forgecad 0.10.1 → 0.10.3

package/dist-cli/{forgecad_geometry-QOQIIP53.js → forgecad_geometry-2IMYCUWW.js}

@@ -31,13 +31,6 @@ function geometry_chamfer_edges(handle, spec_json) {
   }
   return ret[0] >>> 0;
 }
-function geometry_clone(handle) {
-  const ret = wasm.geometry_clone(handle);
-  if (ret[2]) {
-    throw takeFromExternrefTable0(ret[1]);
-  }
-  return ret[0] >>> 0;
-}
 function geometry_create_box(width, depth, height) {
   const ret = wasm.geometry_create_box(width, depth, height);
   return ret >>> 0;
@@ -154,6 +147,25 @@ function geometry_create_revolved_regions(regions_json, degrees, segments) {
   }
   return ret[0] >>> 0;
 }
+function geometry_create_sdf_mesh(abi_version, opcodes, arg_a, arg_b, arg_c, constants, output, slot_count, options_json) {
+  const ptr0 = passArray8ToWasm0(opcodes, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArray32ToWasm0(arg_a, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passArray32ToWasm0(arg_b, wasm.__wbindgen_malloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ptr3 = passArray32ToWasm0(arg_c, wasm.__wbindgen_malloc);
+  const len3 = WASM_VECTOR_LEN;
+  const ptr4 = passArrayF64ToWasm0(constants, wasm.__wbindgen_malloc);
+  const len4 = WASM_VECTOR_LEN;
+  const ptr5 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len5 = WASM_VECTOR_LEN;
+  const ret = wasm.geometry_create_sdf_mesh(abi_version, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, output, slot_count, ptr5, len5);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return ret[0] >>> 0;
+}
 function geometry_create_side_profile_cut(spec_json) {
   const ptr0 = passStringToWasm0(spec_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
   const len0 = WASM_VECTOR_LEN;
@@ -249,6 +261,9 @@ function geometry_delete_nurbs_curve(handle) {
 function geometry_delete_nurbs_surface(handle) {
   wasm.geometry_delete_nurbs_surface(handle);
 }
+function geometry_delete_sdf_mesh(handle) {
+  wasm.geometry_delete_sdf_mesh(handle);
+}
 function geometry_export_step(handle) {
   let deferred2_0;
   let deferred2_1;
@@ -509,6 +524,47 @@ function geometry_sample_nurbs_surface(handle, u_samples, v_samples) {
     wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
   }
 }
+function geometry_sdf_mesh_metadata(handle) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ret = wasm.geometry_sdf_mesh_metadata(handle);
+    var ptr1 = ret[0];
+    var len1 = ret[1];
+    if (ret[3]) {
+      ptr1 = 0;
+      len1 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred2_0 = ptr1;
+    deferred2_1 = len1;
+    return getStringFromWasm0(ptr1, len1);
+  } finally {
+    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+  }
+}
+function geometry_sdf_mesh_tri_verts(handle) {
+  const ret = wasm.geometry_sdf_mesh_tri_verts(handle);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+  return v1;
+}
+function geometry_sdf_mesh_vert_properties(handle) {
+  const ret = wasm.geometry_sdf_mesh_vert_properties(handle);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+  return v1;
+}
+function geometry_sdf_mesher_abi_version() {
+  const ret = wasm.geometry_sdf_mesher_abi_version();
+  return ret >>> 0;
+}
 function geometry_select_edges(handle, query_json) {
   let deferred3_0;
   let deferred3_1;
@@ -621,9 +677,38 @@ function __wbg_get_imports() {
     "./forgecad_geometry_bg.js": import0
   };
 }
+function getArrayF32FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+function getArrayU32FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+var cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+  if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+    cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+  }
+  return cachedFloat32ArrayMemory0;
+}
+var cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+  if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+    cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+  }
+  return cachedFloat64ArrayMemory0;
+}
 function getStringFromWasm0(ptr, len) {
   return decodeText(ptr >>> 0, len);
 }
+var cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+  if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+    cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+  }
+  return cachedUint32ArrayMemory0;
+}
 var cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
   if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -631,6 +716,24 @@ function getUint8ArrayMemory0() {
   }
   return cachedUint8ArrayMemory0;
 }
+function passArray32ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 4, 4) >>> 0;
+  getUint32ArrayMemory0().set(arg, ptr / 4);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passArrayF64ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 8, 8) >>> 0;
+  getFloat64ArrayMemory0().set(arg, ptr / 8);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
 function passStringToWasm0(arg, malloc, realloc) {
   if (realloc === void 0) {
     const buf = cachedTextEncoder.encode(arg);
@@ -698,6 +801,9 @@ function __wbg_finalize_init(instance, module) {
   wasmInstance = instance;
   wasm = instance.exports;
   wasmModule = module;
+  cachedFloat32ArrayMemory0 = null;
+  cachedFloat64ArrayMemory0 = null;
+  cachedUint32ArrayMemory0 = null;
   cachedUint8ArrayMemory0 = null;
   wasm.__wbindgen_start();
   return wasm;
@@ -776,7 +882,6 @@ export {
   geometry_boolean,
   geometry_capabilities,
   geometry_chamfer_edges,
-  geometry_clone,
   geometry_create_box,
   geometry_create_cylinder,
   geometry_create_empty,
@@ -791,6 +896,7 @@ export {
   geometry_create_nurbs_surface_handle,
   geometry_create_path_swept_regions,
   geometry_create_revolved_regions,
+  geometry_create_sdf_mesh,
   geometry_create_side_profile_cut,
   geometry_create_sphere,
   geometry_create_surface_grid,
@@ -804,6 +910,7 @@ export {
   geometry_delete,
   geometry_delete_nurbs_curve,
   geometry_delete_nurbs_surface,
+  geometry_delete_sdf_mesh,
   geometry_export_step,
   geometry_export_step_multi,
   geometry_fillet_edges,
@@ -818,6 +925,10 @@ export {
   geometry_nurbs_surface_tessellation,
   geometry_sample_nurbs_curve,
   geometry_sample_nurbs_surface,
+  geometry_sdf_mesh_metadata,
+  geometry_sdf_mesh_tri_verts,
+  geometry_sdf_mesh_vert_properties,
+  geometry_sdf_mesher_abi_version,
   geometry_select_edges,
   geometry_topology,
   geometry_transform,

package/dist-skill/CONTEXT.md

@@ -39,16 +39,16 @@ Author or modify ForgeCAD models, sketches, assemblies, and CLI workflows. Prefe
 ### Validation and export commands (ask the user to run these)
 
 ```bash
-forgecad run <file.forge.js>                        # geometry diagnostics, verify.* results — run after every edit
-forgecad run <file.forge.js> --debug-imports        # trace import-chain failures
-forgecad check print <file.forge.js> --json         # collisions, mesh health, walls, overhangs, bed contact
-forgecad render 3d <file.forge.js>                  # shaded PNG render
-forgecad render wireframe <file.forge.js>           # edges only — internal geometry, edge flow
-forgecad render section <file.forge.js> --plane XZ  # 2D cross-section (SVG/PNG)
-forgecad capture gif <file.forge.js>                # animated orbit or joint-playback GIF
-forgecad export stl <file.forge.js>                 # mesh for 3D printing
-forgecad export 3mf <file.forge.js>                 # mesh + metadata for 3D printing
-forgecad export step <file.forge.js>                # exact B-rep for CAD interchange
+forgecad run <file.forge.js> [file ...]                        # geometry diagnostics, verify.* results — run after every edit
+forgecad run <file.forge.js> --debug-imports                   # trace import-chain failures
+forgecad check print <file.forge.js> [file ...] --json         # collisions, mesh health, walls, overhangs, bed contact
+forgecad render 3d <file.forge.js> [file ...]                  # shaded PNG render
+forgecad render wireframe <file.forge.js> [file ...]           # edges only — internal geometry, edge flow
+forgecad render section <file.forge.js> [file ...] --plane XZ  # 2D cross-section (SVG/PNG)
+forgecad capture gif <file.forge.js> [file ...]                # animated orbit or joint-playback GIF
+forgecad export stl <file.forge.js> [file ...]                 # mesh for 3D printing
+forgecad export 3mf <file.forge.js> [file ...]                 # mesh + metadata for 3D printing
+forgecad export step <file.forge.js> [file ...]                # exact B-rep for CAD interchange
 ```
 
 Add `--param Name=Value` to test a specific parameter value. Pick the export that matches the goal: STL/3MF for printing, STEP for exact CAD interchange.
@@ -114,7 +114,7 @@ Resolve labels with `.face(name)` or `.face(query)` — see the Shape class docs
 
 **No explanatory text inside CAD geometry.** Model the physical artifact; explain the design through names, comments, BOM entries, and docs. Use `text2d()` only when letters are part of the real object (engraving, branding, gauge ticks); use `Viewport.label()` only for temporary review/debug annotation — never to compensate for unclear geometry.
 
-**SDF shapes preview natively** when returned directly; call `.toShape()` only when mesh-backed CAD/export behavior is needed. See [SDF docs](../../generated/sdf.md).
+**SDF shapes preview natively** when returned directly — including plain object/array trees of SDF leaves; call `.toShape()` only when mesh-backed CAD/export behavior is needed. See [SDF docs](../../generated/sdf.md).
 
 ---
 
@@ -141,12 +141,12 @@ lib, Line2D, linearPattern, linearPattern2d, loadFont, loft, Loft, mirrorCopy
 mock, ngon, NurbsCurve3D, NurbsSurface, offsetSolid, param, Param, path
 Point2D, Points, polygon, polygonVertices, port, Product, ProductPanelBuilder, ProductRibbonBuilder
 ProductSkin, ProductSkinBuilder, ProductStationBuilder, ProductSurfaceBuilder, ProductSurfaceRef, projectToPlane, queueMicrotask, rect
-Rectangle2D, robotExport, roundedRect, Route3D, scene, Sculpt, sdf, SdfShape
-selectEdge, selectEdges, self, setActiveBackend, setImmediate, setInterval, setTimeout, Shape
-ShapeGroup, sheetMetal, SheetMetalPart, sheetStock, Sim, Sketch, sketchToDxf, sketchToSvg
-slot, SolvedAssembly, spec, sphere, spline2d, stroke, Surface, SurfaceBody
-SurfaceMembers, sweep, text2d, textWidth, torus, toShape, Transform, union
-union2d, variableSweep, verify, Viewport, window, Wood
+Rectangle2D, roundedRect, Route3D, scene, Sculpt, sdf, SdfShape, selectEdge
+selectEdges, self, setActiveBackend, setImmediate, setInterval, setTimeout, Shape, ShapeGroup
+sheetMetal, SheetMetalPart, sheetStock, Sim, Sketch, sketchToDxf, sketchToSvg, slot
+SolvedAssembly, spec, sphere, spline2d, stroke, Surface, SurfaceBody, SurfaceMembers
+sweep, text2d, textWidth, torus, toShape, Transform, union, union2d
+variableSweep, verify, Viewport, window, Wood
 ```
 
 `showLabels` is also a runtime global, but it is not part of the top-level collision check. Avoid reusing it unless you intentionally want a local value with that name.
@@ -176,6 +176,10 @@ union2d, variableSweep, verify, Viewport, window, Wood
 - [SurfacePattern](#surfacepattern)
 - [Pattern2D](#pattern2d)
 - [Pattern2DBuilder](#pattern2dbuilder)
+- [Sheet](#sheet)
+- [CurveNetBuilder](#curvenetbuilder)
+- [MatchEdgeBuilder](#matchedgebuilder)
+- [BridgeBuilder](#bridgebuilder)
 - [ShapeRef](#shaperef)
 - [ANCHOR3D_NAMES](#anchor3d-names)
 - [verify](#verify)
@@ -307,7 +311,7 @@ chamfer(base, 3, base.edge('vert-br'))
 
 Adds a taper angle to the vertical faces of a solid so that it can be extracted from a mold. The neutral plane is the Z position where the draft angle is zero — faces above and below are tapered symmetrically. Typical values for injection molding are 1–5°.
 
-Truck supports vertical-prism solids with Z-axis pull directions. OCCT uses its native draft operation when available. Manifold throws.
+SDF, Manifold, and Truck lower supported vertical-prism solids with Z-axis pull directions to a tapered loft. OCCT uses its native draft operation when available.
 
 ```ts
 // Add 3° draft to a box for injection molding
@@ -860,7 +864,7 @@ Supports transforms (translate, rotate, scale, mirror, transform, rotateAround,
 
 Returns a new Shape with the specified material properties merged on top of any previously set properties. All properties are optional — omitted keys retain their current value. Material properties survive transforms and boolean operations.
 
-Use `.color()` to set the base diffuse color; `.material()` controls how that color behaves under light (metalness, roughness, clearcoat) and can add emissive glow independent of lighting. Emissive glow pairs naturally with the `postProcessing.bloom` effect in [`scene()`](/docs/viewport#scene).
+Use `.color()` to set the base diffuse color; `.material()` controls how that color behaves under light (metalness, roughness, clearcoat) and can add emissive glow independent of lighting.
 
 ```js
 box(50, 50, 50).material({ metalness: 0.9, roughness: 0.1 }); // polished metal
@@ -1485,6 +1489,71 @@ const bracket = group(
 | `depth?` | `number` | Thread groove depth in millimeters. Default: 0.8. |
 | `underScale?` | `number` | Relative height of the under-crossing thread. Default: 0.15. |
 
+### `Sheet`
+
+A parametric open surface value (control grid + knots + analytic differential geometry).
+
+**Properties:**
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `surface` | `BSplineSurface` | — |
+
+**Methods:**
+
+#### `get frontEdge(): SheetEdge` — Edge naming follows parameter direction (documented): front=v0, rear=v1, left=u0, right=u1.
+
+#### `thicken(wall: number, options?: { resolution?: number; }): Shape` — Offset the sheet along its analytic normals into a watertight solid shell of the given wall thickness. Throws if the wall would self-intersect on a concave region (no silent degenerate solid).
+
+#### `matchEdge(edge: SheetEdge): MatchEdgeBuilder` — Per-edge continuity match against a neighbor (returns a NEW Sheet).
+
+**`SheetEdge`**
+- `fixed: "u" | "v"` — Which parameter is held fixed along this edge.
+- `value: 0 | 1` — The fixed value (0 or 1).
+- Also: `sheet: Sheet`.
+
+- `get rearEdge(): SheetEdge`
+- `get leftEdge(): SheetEdge`
+- `get rightEdge(): SheetEdge`
+- `pointAt(u: number, v: number): Vec3`
+- `normalAt(u: number, v: number): Vec3`
+- `curvatureAt(u: number, v: number): SurfaceCurvature`
+
+### `CurveNetBuilder`
+
+#### `toSheet(): Sheet` — Build (once) and return the Sheet.
+
+- `lengthwise(...curves: CurveInput[]): this`
+- `crosswise(...curves: CurveInput[]): this`
+- `alongRails(railA: CurveInput, railB: CurveInput): this`
+- `sections(...curves: CurveInput[]): this`
+- `cage(grid: Vec3[][]): this`
+- `degree(u: number, v: number): this`
+- `get frontEdge(): SheetEdge`
+- `get rearEdge(): SheetEdge`
+- `get leftEdge(): SheetEdge`
+- `get rightEdge(): SheetEdge`
+- `get surface(): BSplineSurface`
+- `pointAt(u: number, v: number): Vec3`
+- `normalAt(u: number, v: number): Vec3`
+- `curvatureAt(u: number, v: number): SurfaceCurvature`
+- `thicken(wall: number, options?: { resolution?: number; }): Shape`
+- `matchEdge(edge: SheetEdge): MatchEdgeBuilder`
+
+### `MatchEdgeBuilder`
+
+- `toG0(neighbor: SheetEdge): Sheet`
+- `toG1(neighbor: SheetEdge): Sheet`
+- `toG2(neighbor: SheetEdge): Sheet`
+
+### `BridgeBuilder`
+
+#### `bulge(a: number, b: number): this` — Tune the influence of each side (Rhino-style bulge).
+
+- `g0(): Sheet`
+- `g1(): Sheet`
+- `g2(): Sheet`
+
 ### `ShapeRef`
 
 A first-class reference path over a shape's semantic faces and face relationships.
@@ -3025,7 +3094,11 @@ const outlet = route.port("outlet");
 
 #### `pointAt(u: number, v: number): Vec3` — Evaluate the surface at parameters (u, v) ∈ [0, 1]². Uses tensor product evaluation: evaluate basis functions in U and V independently.
 
-#### `normalAt(u: number, v: number): Vec3` — Evaluate the surface normal at (u, v) via cross product of partial derivatives.
+#### `normalAt(u: number, v: number): Vec3` — Evaluate the surface unit normal at (u, v) from analytic first derivatives.
+
+Uses Algorithm A2.3 basis-function derivatives with the rational quotient rule, so the normal is exact (no finite-difference epsilon, no error near the boundary). Constant chain-rule factors from the parameter remap scale Su and Sv positively and cancel under normalization, so they are omitted.
+
+#### `derivativesAt(u: number, v: number): { S: Vec3; Su: Vec3; Sv: Vec3; }` — Analytic first partial derivatives S_u, S_v (rational quotient rule).
 
 #### `tessellate(resU?: number, resV?: number): { positions: Vec3[]; normals: Vec3[]; indices: number[]; }` — Tessellate the surface into a triangle mesh. Returns positions, normals, and triangle indices.
 
@@ -3764,16 +3837,19 @@ Members (full entries under [Curves & Surfacing](#curves-surfacing)): `Curve.Ble
 - `Trim(shape: Shape, tool: Shape | SurfacePlaneOp): Shape`
 - `Split(shape: Shape, tool: Shape | SurfacePlaneOp): [ Shape, Shape ]`
 - `Match(shape: Shape, options: { edge: "u0" | "u1" | "v0" | "v1"; target: EdgeRef; continuity?: SurfaceContinuity; }): Shape`
+- `Net(): CurveNet` — Begin a curve-network (Gordon) surface — the class-A keystone. Chain `.lengthwise(...)/.crosswise(...)` (or `.alongRails(a,b).sections(...)`, or `.cage(grid)`), then `.thicken(wall)` to get a solid Shape. Returns a fluent [`Sheet`](/docs/core#sheet) builder with analytic point/normal/curvature queries and named edges.
 
 ### `Blend`
 
 - `Edge(options: BlendEdgeOptions): Shape`
 - `Surface(options: BlendSurfaceOptions): Shape`
+- `Bridge(edgeA: SheetEdge, edgeB: SheetEdge): BridgeBuilder` — Build a transition strip between two `Surface.Net` sheet edges. Chain `.bulge(a, b)` then `.g0()/.g1()/.g2()` for the continuity order. Returns a [`Sheet`](/docs/core#sheet); verify the seam with `Analysis.EdgeMatch`.
 
 ### `Analysis`
 
 - `EdgeContinuity(shape: Shape, options?: EdgeContinuityThresholds): EdgeContinuityReport`
 - `SurfaceContinuity(shape: Shape, options?: EdgeContinuityThresholds): EdgeContinuityReport`
+- `EdgeMatch(edgeA: SheetEdge, edgeB: SheetEdge, options?: { samples?: number; }): ContinuityReport` — Measure G0/G1/G2 agreement between two `Surface.Net` sheet edges: worst position gap, cross-boundary tangent angle (0 = G1), and normal-curvature mismatch (0 = G2). The reflection/fairness check for matched panel seams.
 - `CurvatureComb(input: NurbsCurve3D | EdgeRef, options?: { samples?: number; }): CurvatureSample[]`
 - `SurfaceHealth(shape: Shape, options?: { tinyEdgeThreshold?: number; sliverThreshold?: number; }): SurfaceHealthReport`
 - `BRepValidity(shape: Shape, options?: BRepValidityOptions): BRepValidityReport` — Validate B-rep/shell/solid structure and return closedness, manifoldness, orientation, and issue diagnostics.
@@ -4226,7 +4302,7 @@ return mech.solve({ theta: 45 });
 
 #### `withSimulation(options: SimAssemblySimulationOptions): Assembly` — Attach the root simulation contract for this assembly.
 
-Use this after adding physical parts and joints. Robot-body profiles require `rootPart`; asset profiles can describe one-part or multi-part physical assets. URDF/SDF exporters and `forgecad check simready` read this contract directly, so model files no longer need a separate `robotExport(...)` side effect.
+Use this after adding physical parts and joints. Robot-body profiles require `rootPart`; asset profiles can describe one-part or multi-part physical assets. URDF/SDF/MJCF/USD exporters and `forgecad check simready` read this contract directly from the returned assembly.
 
 `SimAssemblySimulationOptions`: `{ profile: SimProfileDef, rootPart?: string, controllers?: SimControllerDef[] }`
 
@@ -4437,7 +4513,7 @@ console.log("Collisions", solved.collisionReport());
 
 #### `minClearance(partA: string, partB: string, searchLength?: number): number` — Compute the minimum gap (clearance) between two parts in this solved pose.
 
-Returns `0` if the parts are touching or overlapping. Requires the Manifold backend. `searchLength` bounds the search radius in mm — increase it for widely separated parts.
+Returns `0` if the parts are touching or overlapping. Manifold-backed parts use the exact Manifold gap query. SDF-backed parts use a mesh-derived sampled gap. `searchLength` bounds the Manifold search radius in mm — increase it for widely separated Manifold parts.
 
 ---
 
@@ -4498,70 +4574,6 @@ bom(tubeLen, "rectangular steel tube", {
 | `notes?` | `string` | Free-form notes |
 | `grain?` | `string` | Wood grain direction, e.g. "long", "cross" |
 
-#### `robotExport(options: RobotExportOptions): CollectedRobotExport` — Compatibility shim for SDF/URDF robot package metadata.
-
-Prefer returning `assembly(...).withSimulation(...)` with `Sim.body(...)`, `Sim.drive.*(...)`, and `Sim.controller.*(...)` metadata. The CLI commands `forgecad export sdf` and `forgecad export urdf` now read that assembly simulation contract directly.
-
-`robotExport()` remains available for one compatibility window. It converts the legacy descriptor into the same internal simulation model used by source-authored `Sim` metadata and produces a robot package with:
-
-- Mesh-based inertia tensors (full 6-component, not bounding-box approximations)
-- Separate collision meshes
-- Joint limits, effort/velocity/damping/friction metadata from assembly joints
-
-**Collision mesh modes** (set per-link via `links["PartName"].collision`):
-
-| Mode | Description | Default |
-|------|-------------|---------|
-| `'convex'` | Convex hull (separate `_collision.stl`) | Yes |
-| `'box'` | AABB primitive — fastest physics | |
-| `'visual'` | Same mesh as visual — exact but slow | |
-| `'none'` | No collision geometry | |
-
-**Unit conventions:**
-
-- Revolute `velocity` is in degrees/second in Forge; exporters convert to rad/s.
-- Prismatic distances are in mm in Forge; exported in meters.
-- `massKg` is preferred; `densityKgM3` is used when mass is unknown.
-- Compatibility coupling metadata, when present, maps only the primary term (largest ratio) to `<mimic>` — SDF/URDF support single-leader mimic only. Dropped terms emit a warning.
-
-**Legacy example**
-
-```ts
-robotExport({
-  assembly: rover, // assembly() with parts + revolute wheel joints
-  modelName: "Scout",
-  links: { Chassis: { massKg: 10 }, "Left Wheel": { massKg: 0.8 } },
-  plugins: {
-    diffDrive: {
-      leftJoints: ["leftWheel"], rightJoints: ["rightWheel"],
-      wheelSeparationMm: 280, wheelRadiusMm: 60,
-    },
-  },
-  world: { generateDemoWorld: true },
-});
-```
-
-**Preferred CLI usage**
-
-```bash
-forgecad export sdf model.forge.js   # SDF package (Gazebo/Ignition)
-forgecad export urdf model.forge.js  # URDF package (ROS/PyBullet/MuJoCo)
-```
-
-**`RobotExportOptions`**: `assembly: Assembly`, `modelName?: string`, `state?: JointState`, `static?: boolean`, `selfCollide?: boolean`, `allowAutoDisable?: boolean`, `links?: Record<string, RobotLinkExportOptions>`, `joints?: Record<string, RobotJointExportOptions>`, `plugins?: { diffDrive?: RobotDiffDrivePluginOptions; jointStatePublisher?: RobotJointStatePublisherOptions; }`, `world?: RobotWorldOptions`
-
-`RobotLinkExportOptions`: `{ massKg?: number, densityKgM3?: number, collision?: "visual" | "convex" | "box" | "none" }`
-
-`RobotJointExportOptions`: `{ effort?: number, velocity?: number, damping?: number, friction?: number }`
-
-**`RobotDiffDrivePluginOptions`**: `leftJoints: string[]`, `rightJoints: string[]`, `wheelSeparationMm: number`, `wheelRadiusMm: number`, `topic?: string`, `odomTopic?: string`, `tfTopic?: string`, `frameId?: string`, `odomFrameId?: string`, `maxLinearVelocity?: number`, `maxAngularVelocity?: number`, `linearAcceleration?: number`, `angularAcceleration?: number`
-
-`RobotJointStatePublisherOptions`: `{ enabled?: boolean, joints?: string[], topic?: string, updateRate?: number }`
-
-`RobotWorldOptions`: `{ name?: string, generateDemoWorld?: boolean, spawnPose?: RobotPose6, keyboardTeleop?: RobotWorldKeyboardTeleopOptions }`
-
-`RobotWorldKeyboardTeleopOptions`: `{ enabled?: boolean, linearStep?: number, angularStep?: number }`
-
 #### `dim()` — Add a dimension annotation between two points, or along an entity.
 
 Overloads:

package/dist-skill/SKILL.md

@@ -65,7 +65,7 @@ Smooth curves, Hermite splines, lofted and swept solids. For straps, inlays, gua
 
 ### 5. Assemblies and Mechanisms (for joints or kinematics)
 
-Assembly graph, joint types, couplings, validation, robot export.
+Assembly graph, joint types, couplings, validation, and simulation export.
 
 - `{{SKILL_DIR}}/docs/generated/assembly.md`
 

package/dist-skill/docs/API/core/concepts.md

@@ -48,4 +48,4 @@ Resolve labels with `.face(name)` or `.face(query)` — see the Shape class docs
 
 **No explanatory text inside CAD geometry.** Model the physical artifact; explain the design through names, comments, BOM entries, and docs. Use `text2d()` only when letters are part of the real object (engraving, branding, gauge ticks); use `Viewport.label()` only for temporary review/debug annotation — never to compensate for unclear geometry.
 
-**SDF shapes preview natively** when returned directly; call `.toShape()` only when mesh-backed CAD/export behavior is needed. See [SDF docs](../../generated/sdf.md).
+**SDF shapes preview natively** when returned directly — including plain object/array trees of SDF leaves; call `.toShape()` only when mesh-backed CAD/export behavior is needed. See [SDF docs](../../generated/sdf.md).