Apolo Cad

Simula con FÍSICA (gravedad real, motor MuJoCo) la caída de cajas de 'producto' sobre la escena actual (faja, mesa…) y guarda un GIF animado de la caída en `path`. Cada producto es un dict {w,d,h (mm), x,y,z (mm pose inicial), mass (kg, opcional)}. Devuelve las posiciones de reposo [x,y,z] mm y si el sistema se asentó (settled). Es análisis read-only: NO modifica el modelo.

Corrige o borra la nota número `nota` de la memoria del agente (1 = la primera de get_agent_notes; léelas antes: al borrar, las siguientes bajan un número). Con `text` la reemplaza (hasta 2000 caracteres); con `borrar=true` la quita, p. ej. una nota obsoleta que nombra piezas que ya no existen. Devuelve las notas que quedan.

Edita VARIOS comandos en UN lote ATÓMICO: un solo regenerate y un solo paso de undo (frente a N round-trips + N regenerates de llamar edit_command en bucle). Úsalo al reparametrizar muchas piezas a la vez. edits = [{"command_id": "c38", "params": {...}}, …]. PATCH por defecto (merge=True, superficial: un sub-objeto position/rotation se reemplaza entero); merge=False reemplaza todos los params. Si una edición falla, revierte TODO el lote. `expect` (CONTRATO, V6.5b) = aserciones estilo verify que deben cumplirse tras el lote; si alguna falla, se revierte TODO (doc intacto) — úsalo para reparamet…

Edita los parámetros de un comando pasado y regenera (edición paramétrica del historial). Por defecto hace PATCH (`merge=True`): combina con los params actuales, así que basta enviar los campos a cambiar. Merge SUPERFICIAL: un sub-objeto (position, rotation) se reemplaza entero. `merge=False` reemplaza todos los params (los omitidos vuelven a su default). `detail` como en run_command. Si tarda, recibes un RECIBO {"job": id}: recógelo con get_job(id) y NO reenvíes la edición.

ERC del tablero eléctrico: cortocircuitos, tensiones cruzadas (una bobina de 24 VDC en 220 VAC), motores sin protección, puesta a tierra, bornes sueltos, colores IEC 60204-1 y parada de emergencia, cada regla con su norma; con tablero armado y cables de campo, sus reglas (canaletas, largos, lo que gira), las piezas de seguridad sin circuito y la altura de los mandos. Devuelve {estado ok|aviso|error|sin_carril, errores, avisos, reglas, revisadas}: `revisadas` = las reglas que corrieron sin hallazgos (no salen en `reglas`). delivery_check lo incluye y, en un lote, el contrato {"erc": "sin_errore…

Valida el modelo con criterio de ingeniería. Devuelve DOS bloques: `ingenieria` (reglas del transportador: apoyo del paquete, capacidad de rodillo, ancho útil, motorización por CONSTRUCCIÓN — CEMA slider-bed si banda sobre cama / ISO 5048-DIN 22101 si banda sobre rodillos —, par + par de arranque, adherencia del tambor motriz Euler-Eytelwein con la T2 mínima que el tensor debe garantizar, flecha del bastidor, flexión del eje) y `estructura` (chequeo UNIVERSAL de cualquier ensamblaje: uniones apernadas vs ISO 898-1, soldaduras, vida L10 de rodamientos, pandeo de patas, vuelco). Sin argumentos u…

Exporta el patrón plano (desplegado) de una chapa metálica a un DXF local para corte láser. feature_id es el id del sólido de la chapa (ver get_scene); debe haberse creado con el comando create_sheet_metal. Soporta las pestañas ricas de V5.5 (multi-pliegue, taladros/recortes en pestañas — proyectados al blank) y K-factor por material (k_factor vacío = tabla según material). ¿DWG? GET /api/sheetmetal/{id}/flat.dwg (V5.9, requiere ODA File Converter).

Exporta el modelo a un archivo STEP en la ruta local indicada.

Exporta los sólidos VISIBLES como UN STL binario (malla) en la ruta local indicada — para impresión 3D, visores de malla o simuladores externos. `tolerance` = desviación máxima de teselado en mm (menor = más fino y pesado). Para CAD/interop usa export_step (B-rep exacto); el STL es malla aproximada.

FEA ESTÁTICO LINEAL BONDED de un SUB-ENSAMBLAJE (V7.4): el bastidor SOLDADO completo (N sólidos PEGADOS, nodos compartidos en las interfaces = sin contacto) bajo la carga de diseño, MULTI-MATERIAL, con σ_vm y FS reportados POR PIEZA (la gobernante es la de menor FS). Pasa `group` (nombre de sub-ensamblaje) o `ids` (piezas sueltas + `name`). El empotramiento se DERIVA de los grounds (base de las patas/placas ancladas a piso) — o pasa `fixed_pieces`; la carga se DERIVA de requirements.carga_kg repartida sobre la cama/mesa (nómbrala cama/mesa/deck) — o `carga_kg`, o `loads` explícitos [{feature_i…

FEA ESTÁTICO LINEAL de UNA pieza (V5.6): malla tet P2 (gmsh) + elasticidad lineal (scikit-fem). Devuelve σ_vm máx (MPa) con su ubicación, desplazamiento máx (mm), FS = σy/σ_vm (criterio: ≥2 estático, <1.2 sobrecargada) y las HIPÓTESIS declaradas; el resumen se GUARDA y entra solo a la memoria de cálculo (con aviso automático si la geometría cambia después). `fixed` y `loads[].selector` son selectores declarativos de CARAS ({mode: cara|direccion|cerca…} — elige con get_topology); para cargar un TALADRO o una cara grande junto a taladros usa cerca con `medir: "superficie"` y un punto SOBRE la ca…

Busca COMANDOS en el log del documento y devuelve filas compactas [{id, type, resumen}] — para encontrar el command_id que quieres editar/borrar SIN deducirlo por aritmética de lotes. Al menos un filtro: - type: tipo exacto ('chamfer', 'create_box', 'add_joint', …). - feature: comandos que CREARON ese sólido o lo REFERENCIAN en sus params (feature/feature_a/b, members, parent/child, selectores…). - name: substring (sin mayúsculas) del nombre; en el carril eléctrico, '-M1', 'NMRV'… Combínalos (type='chamfer', feature='c14' = los chaflanes sobre c14). Read-only.

Lee la memoria de sesión del agente (notas del proyecto; la n.º k es notes[k-1]).

Lista de materiales del modelo actual, agrupada por referencia y longitud (las piezas a-medida idénticas se agrupan e incluyen peso por volumen×densidad). Con `by_group=true` cada fila lleva su sub-ensamblaje y las piezas iguales de grupos distintos salen separadas (subtotales por grupo/instancia — útil a escala).

Catálogo de componentes industriales (perfiles, rodillos, motorreductores, patas, guardas, sensores) con especificaciones y pesos. Es grande (~73 KB); filtra con `category` (p. ej. 'motorreductores', 'tubos_estructurales', 'rodamientos', 'tornilleria', 'tensores_trotadora') y usa `names_only=True` para traer solo ref/name/category (payload ligero).

Circuito del TABLERO ELÉCTRICO declarado (add_device/add_wire/add_cable): dispositivos con la RED de cada borne, redes con su tensión inferida (contactos cerrados), conductores y cables. `designacion` («-Q1», «=Faja1») filtra a esos dispositivos y lo que los toca (lee la designación asignada sola); una ubicación («+TAB1») da lo que está en ella y un cable («-W4»), sus hilos y los aparatos que tocan. `tablero=true` suma `tableros`: lo que la persona ve del tablero armado en el visor (veredicto, ítems, largos, llenado). Read-only.

Devuelve {type, params} del comando indicado (su estado ACTUAL) para editarlo con edit_command. Usa get_scene para ver los ids (campo 'comando' de cada sólido).

Comandos CAD con su JSON Schema de parámetros. Consúltalo antes de run_command/run_batch. Sin argumento lista TODOS (es grande, ~180 KB); pasa `command_type` (p. ej. "create_belt_conveyor") para traer SOLO ese schema. Un campo con refs del catálogo trae `x-catalogo` (categorías) en vez de la lista: búscalas con get_catalog.

Uniones de ensamblaje DECLARADAS (persistidas) del documento: fijadores (a↔b) y anclajes a tierra, con sus nombres (para borrarlas con delete_connection). Read-only. Filtra con `ids` (piezas, NOMBRES DE GRUPO o command_ids: las uniones donde participa alguna) y `kind` (perno | soldadura | pegado | contacto | anclaje). Con más de 40 uniones responde el RESUMEN —conteos por tipo y una fila por tipo y PAR de piezas {kind, a, b, n, ejemplo}—; `resumen=true` lo fuerza y `resumen=false` trae la lista entera.

BOM COSTEADO en USD: cada fila con costo_ud/costo_total y su FUENTE (catálogo referencial / hardware peso×material×3 / a medida peso×material×2.5) + totales por categoría, catálogo vs fabricación y el ÍTEM MÁS COSTOSO: para optimizar costos y como base de la cotización. Si algo se cobra dos veces o no se cobra, trae `avisos` con su `monto_en_riesgo_usd` y la llamada que lo arregla (no se descuentan solos). Precios referenciales: confirmar con proveedor. Read-only.

Criterio de INGENIERÍA que debes aplicar por DEFECTO al diseñar (máquinas, muebles, estructuras, cualquier objeto): el decálogo completo con detalle, CÓMO verificar cada regla en Apolo, cuándo preguntar vs. asumir, y ejemplos por dominio. Las instrucciones del servidor ya traen el resumen; consulta ESTO cuando vayas a diseñar algo no trivial (añadir una guarda, un soporte, un mueble) para no entregar piezas flotantes, sin montaje ni con la forma equivocada. Recuerda: el usuario es el CLIENTE y tú el INGENIERO — lo obvio se asume.

Reporte de GRADOS DE LIBERTAD del ensamblaje (análogo 3D del dof/redundantes del croquis): por sólido, cuántos GDL le quedan tras ground/juntas/mates y su estado (fijo | parcial | libre | sobre_restringido) + qué lo restringe. Conteo Grübler determinista. OJO: el conteo es heurístico (no ve redundancia geométrica); un 'sobre_restringido' puede ser redundancia benigna — los conflictos REALES los rechaza el solver de mates al editar. Útil para responder '¿qué puede moverse y qué está sobre-restringido?'.

Funciones, constantes, operadores permitidos en los campos '=expr' y las variables del proyecto disponibles. Consúltalo antes de escribir expresiones complejas.

Límites y análisis de AJUSTE ISO 286 (V5.4) — consúltalo al DISEÑAR un asiento. Con `hole` (H7/G7/JS7/K7/M7/N7/P7…) y `shaft` (g6/h7/js6/k6/m6/n6/p6…): análisis completo del ajuste — juego/transición/apriete con juego_min/max en µm. Con uno solo: sus límites (ei/es µm, lo/hi mm) sobre el nominal. Criterio de asientos: inserto de chumacera UC → eje h7 (desliza; fijan los prisioneros); rodamiento prensado con anillo interior giratorio → k6. Los taladros llevan `fit` en drill_hole y los ejes la clase en el NOMBRE («Eje motriz Ø35 h7») — el plano rotula "Ø35 h7 (0/-0.025)" y engineering_check veri…

GRUPOS / sub-ensamblajes del documento: nombre, padre (anidación), rol, comandos miembro y members faltantes. Los grupos se CREAN con run_command(type='create_group', params={name, members:[command_ids], parent?, role?}) — la membresía es por COMANDO (estable: las instancias nuevas de un patrón editado entran solas) — y se MUEVEN enteros con run_command(type='transform_group', {group, translate, rotate}). isolate/highlight/fit de render_view, pick_point, drawing y assembly_manual aceptan NOMBRES de grupo directamente. Read-only.

Recoge el resultado de una mutación que devolvió un RECIBO {"job": id} (run_command, edit_command, set_variable, run_batch, edit_batch o remove_commands tardaron más que la espera; también calc_report, assembly_manual, drawing_set y drawing: guarda el archivo en su `path` o en `path`). Espera hasta `wait_s` segundos (long-poll: responde en cuanto el job termina) y devuelve lo MISMO que habría devuelto la tool (sólidos + `contrato`), o `{"estado": "corriendo"}` si aún no acaba — vuelve a llamar. El resultado queda CACHEADO: re-preguntar es SIEMPRE seguro (no re-ejecuta nada). Si falló (p. ej. c…

Juntas cinemáticas del modelo (nombre, tipo, padre/hijo, eje, límites).

Masa (kg), centro de gravedad (mm) y bbox por pieza y del CONJUNTO. Sin `ids` analiza todas las piezas visibles; con ids solo esas (aunque estén ocultas). El catálogo pesa por su ficha (dato de placa); lo a-medida por volumen × densidad del material resuelto. Úsalo para vuelco/equilibrio (¿el COG cae dentro de la base?), repartos de carga y BOM de pesos. Read-only.

Mates de ensamblaje del documento (uniones persistentes entre piezas).

Estudio de movimiento: fotogramas de juntas y duración.

BASES DE DISEÑO del proyecto (requisitos guardados: carga_kg, largo/ancho/ alto_paquete_mm, velocidad_m_s, inclinacion_deg, producto, entorno, normativa…). engineering_check y la memoria de cálculo los usan como defaults. Read-only.

Los escenarios de prueba del proyecto (la FAT virtual) con su estado: sin_correr, pasa, falla, sin_aserciones o vencido (la máquina o el escenario cambiaron desde la última corrida); con `nombre`, ése entero (definición y último resultado). delivery_check da ROJO si uno falla y AMARILLO si hay sin correr o vencidos. Read-only.

Estado del modelo. Sin argumentos: TODA la escena (sólidos con id/nombre/bbox/volumen/ componente + variables + configuraciones) — cuidado en proyectos grandes. Para trabajar a ESCALA (miles de piezas) usa los filtros y NO vuelques la escena entera: - `summary=true`: entra por aquí — resumen por GRUPO (n_piezas, masa, bbox conjunto, sub-grupos) + «(sin grupo)» + totales + variables. La vista de una ojeada del proyecto. - `ids`: feature_ids o NOMBRES DE GRUPO o de subgrupo (se expanden a sus piezas) → sólo esas. - `name`: substring del nombre (case-insensitive), p. ej. "chumacera". - `limit` …

Lee por partes el resultado de una co-simulación (simulate con escenario o test_plc): sin `simulacion`, la lista de las últimas (en memoria; un reinicio las pierde). `parte`: 'resumen' (veredicto, aserciones y los NOMBRES de todas las señales), 'eventos' (paginados), 'final' (valores al final; `senales` filtra) o 'trazas' (pide `senales`: nombres D10 como «-M1.rpm», «-K1.%QX0.0», «-K1.cuenta», o patrones «-M1.*»; ventana `desde_s`–`hasta_s`; discretas por cambio y analógicas a 50 Hz, paginadas con `limite`/`offset`). Read-only.

Evalúa las CADENAS DE COTAS (stack-up, V7.3): por cadena da el cierre nominal, el intervalo por PEOR CASO y por RSS (√Σt²), y el veredicto contra el requisito. Incluye las cadenas auto del patrón de pernos (join_bolted = cerrada por construcción). Verifica que la suma de tolerancias cierra el ajuste declarado SIN encadenar N measure. scope = all | declared | auto. Read-only.

Caras y aristas de un sólido con su geometría descriptiva (tipo plano/cilíndrico, centro, normal/eje, área; longitud, dirección, radio de aristas). Úsalo para ELEGIR el selector declarativo antes de fillet/chamfer/drill/add_mate: caras por orientación (normal) → 'cara'/'direccion'; aristas largas → 'longitud'; cerca de un punto → 'cerca'. Los 'idx' son solo referencia: la selección sigue siendo declarativa, no por id. A ESCALA (piezas con muchos taladros): `only` ∈ {caras|aristas|anclas} trae solo esa familia; `min_mm` omite aristas más cortas que ese valor y caras menores que min_mm² (filtra …

Simula la GRAVEDAD sobre TODA la máquina (cuerpos rígidos + colisión por casco convexo, motor MuJoCo) y reporta qué piezas SE CAEN y cuáles aguantan. A diferencia del chequeo estático, la FÍSICA decide si una pieza no-sujeta REPOSA sobre algo firme (no cae) o cuelga en el aire (cae). Por defecto sujeta SOLO lo DECLARADO (ground/fasten); with_autodetect=True suma el contacto geométrico (exploración). `exclude` trata esas piezas como NO sujetas ('¿y si a esta le falta el tornillo?'). Con `path` guarda además un GIF animado de la caída. Read-only: NO modifica el modelo.

Proyectos guardados (SQLite, con autoguardado).

Lista las revisiones (instantáneas restaurables) del proyecto abierto.

Distancia mínima (mm) y puntos más cercanos entre dos sólidos a y b (ids). El gap real deja de ser ensayo-error. Opcional: face_a/face_b = selector declarativo (mode cara/direccion/ longitud/cerca) para medir contra UNA cara concreta. 0 = se tocan o solapan. Read-only.

GIF animado de un estudio de movimiento, ESCRITO a `path` (las tools no devuelven binarios). Cada fotograma se pinta con el mismo motor VTK que render_view, con la cámara FIJA a la unión de todo el recorrido; `pingpong` añade la vuelta (bucle sin salto). COSTO REAL: el teselado no se cachea entre fotogramas (≈ steps × render de la escena) — en modelos grandes usa steps moderados (24-48) y baja size_px; si supera ~2 min el cliente corta por timeout aunque el servidor termine.

Consulta espacial por caja envolvente, de más cerca a más lejos. Da EXACTAMENTE uno de: - `point` [x,y,z]: '¿qué pieza hay por aquí?' (combínalo con pick_point). - `feature` (id): '¿qué RODEA a X?' — distancia AABB-AABB al resto, excluyendo X. - `box` [[min_x,min_y,min_z],[max_x,max_y,max_z]]: '¿qué hay en esta REGIÓN?'. `radius` mm (radius=0 con box/feature = solo lo que lo toca) + `limit` (def. 20). Read-only.

Optimización de corte (nesting) para minimizar desperdicio. `mode`: "2d" (tableros/ vidrio en planchas stock_w×stock_h) o "1d" (barras/largueros de largo stock_w). `material` filtra (madera/vidrio/acero...). Devuelve nº de planchas/barras y % de desperdicio; el plano del acomodo está en GET /api/nesting.svg|dxf (mismos params). Read-only.

Abre un proyecto por id. Devuelve además un `briefing` compacto (V6.5b) para arrancar la sesión en UNA llamada: resumen por GRUPO (n_piezas/masa/bbox) + variables + requisitos + notas del agente + salud (ok/suprimidos) + variantes de diseño. Ya NO hace falta encadenar get_scene(summary)+get_requirements+get_agent_notes al abrir.

PÍXEL→3D: 'señala' un punto en un render y obtén qué pieza/cara hay ahí. (u,v) son coordenadas NORMALIZADAS [0,1] de la imagen (0,0 = arriba-izquierda). Devuelve la feature/cara cuyo centro proyectado queda más cerca + su coordenada mundo (snap a geometría con la MISMA cámara del render VTK). Así seleccionas/ubicas apuntando en vez de calcular coordenadas. IMPORTANTE: pasa los MISMOS `view`/`azimuth`/`elevation`/`roll`/`pan`/`fit_ids`/`zoom` que usaste en `render_view` para esa imagen → así el píxel coincide con lo que viste (incluido el ángulo libre, el roll y el encuadre desplazado). Si rend…

GHOST: aplica `actions` (mismo formato que run_batch: [{type, params}, …]) sobre una COPIA del documento SIN tocar el modelo real — ensaya una colocación y equivocarte sale gratis (sin escombro de log). Dos modos: - `data=false` (default): devuelve el PNG con los sólidos nuevos resaltados (para VERLO). `labels` rotula ids; `section` ∈ {x,y,z} corta para ver dentro. - `data=true` (V6.5d): devuelve JSON `{fantasmas:[{name,bbox,volumen_mm3}], colisiones_ nuevas:[{a,b,tipo,volumen_mm3}]}` — las colisiones SOLO de los fantasmas (contra la escena y entre sí). Prueba N colocaciones con datos EX…

Propone a la persona un lote ORDENADO de comandos CAD como tarjetas de acción: NO se ejecuta nada hasta que la persona lo acepte. Mismo formato que run_batch ([{type, params, reason}, …]; los parámetros de cada comando, con get_command_schemas(command_type)). '$k' (1-indexado) referencia la pieza creada por la k-ésima acción del lote. Antes de mostrarse se ensaya en seco sobre una copia del documento: si una acción falla recibes el error para corregir y volver a proponer. Manda TODO el lote en una sola llamada.

LA PUERTA DE PUBLICACIÓN: córrela ANTES de dar por terminada una máquina que va a la tienda (después de delivery_check en VERDE). Es más dura que la de entrega: un registro de ítems de calidad (estructura, función, montaje, seguridad, publicado, proceso), cada uno OK | FALLA | SIN_EVALUAR | NO_APLICA con su evidencia; se publica SÓLO si todo ítem aplicable está OK (SIN_EVALUAR bloquea igual que FALLA: «no se pudo ver» no es «está bien»). Corre la gravedad (obligatoria), las interferencias DENTRO de cada super-comando, el agarre de cada perno, el tensor y su carrera, la vida útil (L10 ≥ 20 000 …

Genera la COTIZACIÓN (PDF multipágina) y la guarda en `path` (.pdf): resumen económico (catálogo vs fabricación, desglose por categoría, margen %, impuesto % opcional, PRECIO DE VENTA, notas) + detalle de partidas con la FUENTE de cada precio. Complemento comercial de calc_report. Si algo se cobra dos veces (dispositivo sin ligar a su pieza 3D) o no se cobra (cable 3D sin add_cable), devuelve `avisos` con su `monto_en_riesgo_usd` y cómo arreglarlo; el PDF los lista en su hoja 2. Precios referenciales: confirmar con proveedor.

Rehace la última operación deshecha. `detail` como en undo (`rehecho` = qué rehízo).

Borra comandos del log por command_id (cirugía: quitar una pieza, un sub-ensamblaje o uniones) en UN cambio atómico, deshacible con UN undo. Si queda una referencia rota (un fijador, anclaje, junta o mate que nombra una pieza borrada) no borra NADA y el error dice cuál estorba, lista los dependientes y cuáles arrastraría `con_dependientes=true`. Éste borra además los fasten y ground que nombran las piezas de esos comandos y los quita de sus grupos, sin buscarlos con find_commands; la respuesta los lista en `dependientes` y `grupos_editados` (un grupo que quedaría vacío no se toca: lo dice `avi…

Render del modelo para VERLO. SIEMPRE motor VTK → sombreado SUAVE a color (color real por pieza, igual que el viewport web), normales interpoladas, sin bandas ni cuadrícula: la captura más limpia para auto-revisar tu trabajo. (Si el entorno no tuviera contexto OpenGL, da error claro en vez de degradar a una imagen con rejilla.) view ∈ {iso, frente, lateral, planta} elige el ángulo preset; azimuth/elevation (GRADOS) lo ANULAN para enfocar desde un ÁNGULO LIBRE cuando ningún preset sirve (azimuth = giro alrededor de Z, elevation = altura sobre el plano; override parcial: puedes dar solo uno). is…

Evalúa una expresión (=expr) contra las variables del proyecto SIN modificar nada; devuelve {ok, value} o {ok:false, error}. Para comprobar una fórmula antes de usarla.

Restaura una revisión por id (red de seguridad tras ediciones arriesgadas).

Ejecuta un lote ordenado de comandos [{type, params}, …]. Usa '$k' en los campos de id de feature para referenciar el sólido creado por la k-ésima acción del lote. `detail`: "diff" (def.) devuelve solo los sólidos creados por el lote + `total_solidos`; "full" toda la escena; "summary" solo id/nombre. Un `fasten` por conjuntos suma `uniones_expandidas` (cuántas uniones declaró cada uno). `expect` (CONTRATO, V6.5b) = lista de ASERCIONES estilo verify (distancia/volumen/bbox/ sin_interferencia/existe) que DEBEN cumplirse tras el lote; si alguna falla, el lote se revierte POR COMPLETO (el document…

Ejecuta un comando CAD (ver get_command_schemas). Los campos numéricos aceptan '=expresión' con variables del proyecto. `detail`: "diff" (def.) devuelve solo los sólidos nuevos + `total_solidos`; "full" toda la escena; "summary" solo id/nombre de lo nuevo (con más de 40, "diff" y "summary" resumen `por_comando`). El bloque `variables` solo aparece si la operación tocó alguna (o detail="full"); usa get_scene para verlas siempre. Si tarda, recibes un RECIBO {"job": id}: recógelo con get_job(id) y NO reenvíes el comando.

Guarda una VARIANTE SIN aplicarla: sólo sus COLUMNAS (las variables que la distinguen; lo demás es común). Sin `values` toma el valor ACTUAL de las columnas; la primera variante pide `values` (p. ej. {"largo_total": "4000"}), que crea o edita; una clave nueva entra en todas.

Vuelve una SESIÓN EN VIVO (la persona maneja la máquina en el visor: aprieta el verde, la seta…) en el escenario de prueba `nombre`: sus acciones y eventos con la hora virtual en que entraron, sobre su escenario de base y con la cola de cajas que tuvo la sesión. La corre por lote (las mismas trazas que se vieron) y devuelve `aserciones_sugeridas` con lo que pasó («-M1.rpm >= 1570 dentro_de 1.6 s desde pulsar -S1», «-M1.par_Nm == 0 dentro_de 0.2 s desde presionar -S0»), todas verdes sobre esa corrida: NO quedan en el escenario; acepta las que quieras con set_scenario(nombre, {…el `escenario` de…

Guarda una revisión (instantánea restaurable) del proyecto abierto.

Escanea las COLISIONES de un estudio de movimiento a lo largo del recorrido: muestrea `steps` instantes (FK + interferencia por instante — costo ≈ steps × check_interference posado) y devuelve SOLO los que colisionan, con pares y volumen. Lista vacía = recorrido limpio. Corre esto tras cada cambio del mecanismo; para garantizarlo por CONTRATO en un lote usa `expect` con joint_values. Read-only.

Color de VISUALIZACIÓN de uno o VARIOS sólidos ('#rrggbb'; None = volver al color automático). Pasa `feature` (uno) o `features` (lote — atómico), no ambos. Solo apariencia del viewport/render — no toca material, BOM ni peso.

Fija (anula) el material de uno o VARIOS sólidos para el BOM/peso/rayado de sección. Pasa `feature` (uno) o `features` (lote — N piezas en 1 llamada, atómico: un id inexistente no aplica nada), no ambos. material=None vuelve al automático (catálogo o heurística por nombre). Ej.: 'acero', 'aluminio', 'acero inoxidable', 'laton', 'madera', 'vidrio'.

Define (o borra, con lista vacía) un ESTUDIO DE MOVIMIENTO con nombre — autoría de cinemática sin salir del MCP (V6.8-C). Fotograma: {"t": segundos, "values": {junta: valor}} — los valores van ANIDADOS en "values" (el formato plano se rechaza) y las juntas se validan contra las declaradas (get_kinematics). OJO FK: una junta mueve solo sus HIJOS declarados — completa un cuerpo rígido multi-pieza con juntas 'fija' colgadas del conductor. Verifica el recorrido con scan_motion, míralo con motion_gif; en la UI aparece en el panel Cinemática.

Guarda las BASES DE DISEÑO del proyecto (reemplaza el dict completo; {} borra). Claves numéricas de convención: carga_kg, largo_paquete_mm, ancho_paquete_mm, alto_paquete_mm, velocidad_m_s, inclinacion_deg, temperatura_c. Texto libre: producto, entorno, normativa, notas. Con esto `engineering_check()` y `calc_report()` funcionan SIN argumentos y validan contra LO PEDIDO. Se persisten con el proyecto.

Declara (o reemplaza) un ESCENARIO de prueba de la máquina con tablero; `escenario` null lo borra. Es metadato (no entra al log ni al undo). Forma: {duracion_s, descripcion?, condiciones?: {red_conectada, selectores {"-S5": "I"}, setas_retenidas [], plc_run}, acciones: [{t, accion: pulsar|soltar|presionar|liberar|girar|rearmar|abrir|cerrar| reponer, dispositivo, valor?, durante_s?, actuador?}], eventos: [{t, tipo: atasco (junta, par_Nm) | corte_de_fase (fase) | caida_de_red (factor) | cable_cortado (rama «-W3») | sensor_pegado (dispositivo) | falla | pro…

Declara una CADENA DE COTAS 1D con nombre (metadato del proyecto, se persiste; lista de eslabones vacía → la borra). Cada eslabón es UNO de: - {nombre, nominal_mm, sentido:±1, tol} — cota literal; nominal_mm acepta '=expr' (sigue a las variables → la cadena se re-verifica al cambiarlas). - {id, eje:x|y|z, sentido:±1, tol?} — mide el BBOX VIVO de esa pieza (auto-actualiza). `tol` es UNA fuente: {"pm":0.2} (± mm) · {"fit":"h7"} (ISO 286) · {"iso2768":"m"} (general) · {"lim":[lo,hi]} (límites absolutos). `requisito` de cierre: {min_mm|max_mm|entre:[a,b]}. Devuelve la evaluación inmediata (peor …

Define o actualiza una variable de proyecto (p. ej. L = 2000). Cambiarla regenera todo lo que la usa. Si tarda, recibes un RECIBO {"job": id}: recógelo con get_job(id) y NO la reenvíes.

Define el vertical del proyecto ('metalmecanica' | 'carpinteria'), que fija el material por defecto de las piezas a-medida NO reconocidas (acero | madera).

Muestra u oculta un sólido individual (útil para aislar antes de render_view).

Muestra u oculta varios sólidos a la vez (patrón aislar / mostrar todo).

Simula la máquina EN MARCHA (dinámica MuJoCo): las juntas giran o deslizan movidas por `motores`, los `productos` (cajas) viajan sobre la banda o los rodillos y los `sensores` (fotoceldas) los ven pasar. Lo sujeto a tierra (ground/fasten) es estático; una pieza sin sujeción ni junta queda FUERA con aviso (eso lo prueba gravity_test). Unidades: mm, kg, s. - motores: [{junta, modo: 'velocidad'|'par', ...}]. 'velocidad' pide UNA consigna: `valor` (rpm; mm/s si la junta es prismática), `v_superficie_m_s` (banda o rodillo) o `placa` {potencia_kW, rpm, frecuencia_hz?, polos?, tk_tn?, inercia_rot…

Prueba un programa de PLC en texto estructurado (ST, IEC 61131-3) SIN guardarlo, como test_script. Compila contra los bornes del PLC `plc` («-K1»: %IX0.0 = borne I0.0, %QX0.0 = Q0.0, %IW1 = AI1) y devuelve `compila`, los `errores` con línea y columna («¿quisiste decir…?») y la tabla de `tags`. Con `escenario` (nombre de uno guardado u objeto, como en set_scenario) además CORRE la máquina con este programa en lugar del de ese PLC y devuelve veredicto, aserciones, eventos y las trazas de `senales` (por defecto las del PLC, «-K1.*»). `ciclos` = {PROGRAM: ms}. Cuando funcione, guárdalo con run_com…

Prueba en seco un script build123d en el sandbox: devuelve {ok, volumen_mm3, bbox} o {ok:false, error} SIN tocar el documento. Itera la geometría sin crear/deshacer sólidos.

Prueba en seco un croquis: lo resuelve con el solver (PlaneGCS) y devuelve {ok, residual, diagnostico, dof, redundantes, conflictivas, ...} SIN crear geometría. dof = grados de libertad restantes (0 = totalmente restringido); redundantes/ conflictivas identifican las restricciones culpables por nombre. Soporta tangent/ symmetric/equal_radius/concentric/midpoint/distance_point_line además de los tipos clásicos (el formato completo está en el schema de sketch_extrude). Itera hasta dof=0 sin redundantes antes de extruir/barrer.

Deshace la última operación. `detail`: "diff" (def.) responde lo que cambió el paso —`deshecho` (qué revirtió), comandos quitados/restaurados/editados, piezas y uniones nuevas o borradas, `variables` cambiadas y `total_solidos`—; "full" lista toda la escena.

Verifica en UNA llamada un lote de ASERCIONES numéricas sobre el modelo (READ-ONLY) — declara tus INVARIANTES y compruébalas de golpe en vez de encadenar N measure + aritmética mental. Devuelve {ok, resultados:[{check, ok, actual, esperado}]}. Cada aserción es un dict con `tipo` (y un `nombre` opcional para etiquetarla): - {tipo:"distancia", a, b, min?|max?|entre?:[lo,hi]} — gap OCCT entre dos sólidos. - {tipo:"volumen", id?|grupo?|ids?, min?|max?|entre?} — volumen (suma si son varios). - {tipo:"bbox", id?|grupo?|ids?, eje:"x"|"y"|"z", min?|max?|entre?} — tamaño de la caja conjunta. - {tipo:"s…