forgecad 0.10.1 → 0.10.3

package/dist-skill/docs/CLI.md

@@ -78,7 +78,7 @@ Direct `.stl`/`.obj`/`.3mf`/`.step`/`.stp` inputs are imported automatically; ST
 
 ```bash
 forgecad run model.forge.js
-forgecad run model.forge.js --details --history
+forgecad run model.forge.js other-model.forge.js --quality live
 ```
 
 ### `forgecad ls`
@@ -104,7 +104,7 @@ Without a target, `show` renders the whole scene and behaves like a shorter, int
 
 ```bash
 forgecad show model.forge.js
-forgecad show model.forge.js Bench
+forgecad show model.forge.js --target Bench
 ```
 
 ### Object Filtering: `--focus` and `--hide`
@@ -112,7 +112,7 @@ forgecad show model.forge.js Bench
 `render 3d`, `render wireframe`, `inspect <family> <mode>`, `capture`, and `check print` can filter the visible object set without changing model code. Use `forgecad ls model.forge.js` to list exact object paths, then pass names or globs:
 
 ```bash
-forgecad render 3d model.forge.js bench.png --focus "Bench.*"
+forgecad render 3d model.forge.js --output bench.png --focus "Bench.*"
 forgecad inspect visual objects model.forge.js --hide "Bench.Slat0,Bench.Slat1" --camera iso
 ```
 
@@ -200,7 +200,7 @@ Runs the script headlessly and prints every named render view with an exact came
 
 ```bash
 forgecad render views model.forge.js
-forgecad render views model.forge.js --json
+forgecad render views model.forge.js reference.step
 ```
 
 ### `forgecad render wireframe`
@@ -224,7 +224,7 @@ Exports the scene to Blender and renders with Cycles (path tracer); requires Ble
 
 ```bash
 forgecad render hq model.forge.js
-forgecad render hq model.forge.js hero.png --preset dramatic --samples 1024
+forgecad render hq model.forge.js --output hero.png --preset dramatic --samples 1024
 ```
 
 ### `forgecad capture gif|mp4` **\[Pro\]**
@@ -235,18 +235,22 @@ Renders an animated sequence: `--capture orbit` (default) for a turntable, `--ca
 
 ```bash
 forgecad capture gif model.forge.js
-forgecad capture gif model.forge.js out/sweep.gif --capture section-sweep --sweep-plane YZ
+forgecad capture gif model.forge.js other-model.forge.js
 ```
 
 ### `forgecad render section`
 
 Render a 2D cross-section of a 3D model (cut by a plane) to SVG or PNG.
 
-Cuts all shapes with an axis-aligned plane (default XY at Z=0; `--plane XZ|YZ` reorients, `--offset` shifts the cut) and writes a 2D cross-section drawing. The file extension picks the format: `.svg` (default, vector) or `.png` (rasterized at `--size` pixels); `--edges=<off|thin|bold>` sets the outline stroke. Useful for verifying internal geometry, wall thicknesses, and fits that aren't visible in 3D renders.
+Cuts all shapes in the scene with an axis-aligned plane and produces a 2D cross-section drawing. The default plane is XY at Z=0. Use `--plane XZ` or `--plane YZ` for other orientations, and `--offset` to shift the cut position.
+
+Output defaults to `.svg`; pass `--format png` or a single-input `--output *.png` path for a rasterized PNG at `--size` pixels. Use `--edges=<off|thin|bold>` to control the outline stroke on cut shapes.
+
+Useful for verifying internal geometry, wall thicknesses, and fit checks that aren't visible in 3D renders.
 
 ```bash
 forgecad render section model.forge.js
-forgecad render section model.forge.js out/section.svg --plane XZ --offset 10
+forgecad render section model.forge.js --output out/section.svg --plane XZ --offset 10
 ```
 
 | Command | Description |
@@ -261,7 +265,7 @@ forgecad render section model.forge.js out/section.svg --plane XZ --offset 10
 
 ### Cross-cutting flags
 
-These flags work across run / render / capture / inspect commands:
+These flags work across script-backed run, render, export, capture, inspect, and check commands that evaluate `.forge.js` files. Use `--param Key=Value` for parameter overrides; repeat it for multiple parameters.
 
 | Option | Description |
 |--------|-------------|
@@ -272,8 +276,8 @@ These flags work across run / render / capture / inspect commands:
 | `--camera <front\|back\|side\|right\|top\|iso\|az:el\|az:el:dist\|spec>` | Camera preset, spherical (az:el), or full spec such as `proj=perspective;pos=x,y,z;target=x,y,z;up=x,y,z;fov=45`. Repeatable. |
 | `--view <name>` | Named camera view declared by the model with scene({ views }) |
 | `--size <px>` | Image size in pixels |
+| `--backend <manifold\|occt\|truck\|sdf>` | Geometry backend (default: manifold; STEP inputs default to OCCT) |
 | `--quality <default\|live\|high>` | Mesh quality preset |
-| `--backend <manifold\|occt\|truck>` | Geometry backend (default: manifold; STEP inputs default to OCCT) |
 | `--json` | Print machine-readable JSON |
 
 Every command has more — Blender-only `render hq` flags (`--preset`, `--samples`, `--engine`, `--hdri`, `--transparent`, `--video`) and capture-only flags (`--capture`, `--animation`, `--cut-plane`, `--sweep-*`, `--fps`) among them. Run `forgecad <command> --help` for the full list.
@@ -295,43 +299,53 @@ Export to every format you need.
 | `export sdf` **\[Production\]** | SDF package | Gazebo robot simulation |
 | `export mjcf` **\[Production\]** | MJCF package | MuJoCo / MJX robot simulation |
 | `export urdf` **\[Production\]** | URDF package | ROS / PyBullet / MuJoCo |
+| `export usd` **\[Production\]** | USD package | Isaac Sim / OpenUSD simulation |
 | `export report` **\[Production\]** | PDF report | Multi-view report with BOM and dimensions |
 | `export cutting-layout` **\[Production\]** | PDF/DXF | Sheet cutting layout with cut sequence |
 | `link` | URL | Share link from a GitHub Gist URL or ID (copied to clipboard) |
 
 ```bash
 # Sheet material
-forgecad cut-list shelf.forge.js
+forgecad cut-list shelf.forge.js --param Material=plywood
 forgecad export cutting-layout shelf.forge.js --sheet-width 420 --sheet-height 594 --kerf 3
+forgecad export cutting-layout shelf.forge.js --output out/layout.dxf
 
 # 3D printing
 forgecad check print bracket.forge.js
-forgecad export stl bracket.forge.js
+forgecad export stl bracket.forge.js --param Width=42
 forgecad export 3mf bracket.forge.js --quality high
 
 # CAD interchange
-forgecad export step bracket.forge.js
+forgecad export step bracket.forge.js --param Width=42
 
 # Technical drawings
-forgecad export report bracket.forge.js out/report.pdf
+forgecad export report bracket.forge.js --output out/report.pdf
 
 # Robot simulation
 forgecad export sdf rover.forge.js --output out/forge_scout
-forgecad export mjcf rover.forge.js --output out/forge_scout_mjcf
+forgecad export mjcf rover.forge.js --param Wheelbase=180 --output out/forge_scout_mjcf
+forgecad export usd rover.forge.js --output out/forge_scout_usd
 ```
 
+Script-backed exports accept repeatable `--param Key=Value` overrides before the model is evaluated. The MuJoCo/MJX package export command is `export mjcf`.
+
 <details>
 <summary>Export flags</summary>
 
 | Option | Description |
 |--------|-------------|
+| `--param <Key=Value>` | Override a parameter value (Key=Value). Repeatable. |
+| `-p <Key=Value>` | Shorthand for --param |
 | `--joint <JointName=Value>` | Override a Motion tab joint value (JointName=Value). Repeatable. |
-| `--output <path>` | Output STEP path |
+| `--output <path>` | Output SVG path for a single input |
 | `--backend <occt\|truck>` | Exact BREP exporter: occt (default) or truck (native analytic kernel) |
 | `--quality <default\|live\|high>` | Forge quality preset |
 | `-o <path>` | Shorthand for --output |
+| `--format <json\|webgpu-brick>` | Implicit artifact format |
+| `-q <live\|default\|high>` | Shorthand for --quality |
+| `--workgroup-size <x>x<y>x<z>` | WebGPU compute workgroup size |
 | `--dim-angle-tol <deg>` | Dimension routing tolerance in degrees |
-| `--format <pdf\|dxf>` | Output format |
+| `--out <path>` | Alias for --output |
 | `--sheet-width <mm>` | Stock sheet width in mm |
 | `--sheet-height <mm>` | Stock sheet height in mm |
 | `--kerf <mm>` | Cutting clearance (saw blade width) in mm |
@@ -478,7 +492,7 @@ Checks include script `verify.*` results, exact positive-volume object collision
 
 ```bash
 forgecad check print model.forge.js
-forgecad check print model.forge.js --json
+forgecad check print model.forge.js other-model.forge.js
 ```
 
 ### `forgecad check simready`
@@ -489,7 +503,7 @@ Runs a Forge script and checks the returned `assembly(...).withSimulation(...)`
 
 ```bash
 forgecad check simready model.forge.js
-forgecad check simready robot.forge.js --json
+forgecad check simready model.forge.js other-model.forge.js
 ```
 
 ### `forgecad inspect mechanical-integrity`
@@ -529,7 +543,7 @@ The CLI is free for personal non-commercial use. Pro covers human-operated comme
 
 | Free | Production outputs | Pro | Enterprise |
 |------|--------------------|-----|------------|
-| `run`, `dev`, `studio`, `render 3d`, `export stl`, `export 3mf`, `export svg`, `compare 3d`, `check print`, `inspect fit interference`, `inspect mechanical-integrity` for personal non-commercial use | `cut-list`, `export sketch-pdf`, `export step`, `export brep`, `export gcode`, `export sdf`, `export mjcf`, `export urdf`, `export report`, `export cutting-layout` are free to run for personal non-commercial use; Pro covers human-operated commercial CAD work | `render hq`, `capture gif`, `capture mp4` plus commercial coverage for client/customer work | Backend, hosted, embedded, or application workflows that call ForgeCAD automatically |
+| `run`, `dev`, `studio`, `render 3d`, `export stl`, `export 3mf`, `export svg`, `compare 3d`, `check print`, `inspect fit interference`, `inspect mechanical-integrity` for personal non-commercial use | `cut-list`, `export sketch-pdf`, `export step`, `export brep`, `export gcode`, `export implicit`, `export sdf`, `export mjcf`, `export urdf`, `export usd`, `export report`, `export cutting-layout` are free to run for personal non-commercial use; Pro covers human-operated commercial CAD work | `render hq`, `capture gif`, `capture mp4` plus commercial coverage for client/customer work | Backend, hosted, embedded, or application workflows that call ForgeCAD automatically |
 
 ```bash
 forgecad license                    # Check local license status

package/dist-skill/docs/generated/assembly.md

@@ -356,7 +356,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[] }`
 
@@ -567,4 +567,4 @@ 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.

package/dist-skill/docs/generated/core.md

@@ -24,6 +24,10 @@ skill-order: 100
 - [SurfacePattern](#surfacepattern)
 - [Pattern2D](#pattern2d)
 - [Pattern2DBuilder](#pattern2dbuilder)
+- [Sheet](#sheet)
+- [CurveNetBuilder](#curvenetbuilder)
+- [MatchEdgeBuilder](#matchedgebuilder)
+- [BridgeBuilder](#bridgebuilder)
 - [ShapeRef](#shaperef)
 - [ANCHOR3D_NAMES](#anchor3d-names)
 - [verify](#verify)
@@ -155,7 +159,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
@@ -708,7 +712,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
@@ -1333,6 +1337,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.

package/dist-skill/docs/generated/curves.md

@@ -426,7 +426,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.
 
@@ -1165,16 +1169,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.

package/dist-skill/docs/generated/lib.md

@@ -63,7 +63,7 @@ Pre-built fasteners, gears, pipes, structural profiles, and utility shapes. Acce
 
 Pre-built parametric parts available in user scripts as `lib.*`.
 
-exposed to `.forge.js` scripts — see the member list below for the catalog. Sizes outside the supported ranges throw at runtime with a descriptive error.
+Every key in this object becomes a method or namespace on the `lib` object exposed to `.forge.js` scripts — see the member list below for the catalog. Sizes outside the supported ranges throw at runtime with a descriptive error.
 
 - `fastenerHole(opts: FastenerHoleOptions): Shape` — ISO metric fastener hole cutter with optional counterbore or countersink.
 

package/dist-skill/docs/generated/output.md

@@ -58,70 +58,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/docs/generated/runtime-names.md

@@ -24,12 +24,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.

package/dist-skill/docs/generated/sdf.md

@@ -53,7 +53,7 @@ An immutable SDF expression. Supports SDF-specific operations (smooth booleans,
 
 #### `clone(): SdfShape` — Clone this SDF expression and its visual metadata.
 
-#### `toShape(options?: SdfToShapeOptions): Shape` — Mesh this SDF into a ForgeCAD Shape through ForgeCAD's Surface Nets pipeline. Once converted, the result is a regular Shape — booleans, transforms, export all work.
+#### `toShape(options?: SdfToShapeOptions): Shape` — Mesh this SDF into a ForgeCAD Shape. Typed SDF trees materialize through Rust Manifold Dual Contouring; dynamic trees (custom/noise/voronoi/displace/blend callbacks) mesh through the Surface Nets pipeline. Once converted, the result is a regular Shape — booleans, transforms, export all work.
 
 #### `color(value: string | undefined): SdfShape` — Set the display color for this implicit leaf.
 
@@ -230,7 +230,7 @@ return {
 - `basketWeave(options?: BasketWeaveOptions): SurfacePattern` — Basket weave surface pattern — threads with over-under crossings in UV space. Returns a SurfacePattern for use with `.surfaceDisplace()`.
 - `pattern2d(): Pattern2DBuilder` — Create typed, composable 2D surface patterns for `.surfaceDisplace()`.
 - `SurfacePattern: typeof SurfacePattern` — A 2D surface pattern — a heightmap function for use with `.surfaceDisplace()`.
-- `fromFunction(fn: SdfFunctionSource, options: SdfFunctionOptions): SdfShape` — Create a custom SDF from one expression; shader-safe expressions raymarch directly.
+- `fromFunction(fn: SdfFunctionSource, options: SdfFunctionOptions): SdfShape` — Create a custom SDF from one expression; shader-safe expressions keep shader metadata for tooling.
 - `combine(value: unknown, options?: CombineOptions): SdfShape` — Collapse a plain object/array tree of SDF leaves into one continuous implicit field. Per-leaf color/material identity is intentionally discarded — the result is one scalar field. Use plain object returns for multi-material SDF preview, and `sdf.combine(...)` only when you want one implicit body. Explicit shape lists are covered by `a.union(b, c)`; pass `{ op: 'intersection' }` to intersect instead.
 
   ```js

package/dist-skill/docs/generated/viewport.md

@@ -79,7 +79,7 @@ return b;
 
 #### `scene(options: SceneOptions): void` — Configure the scene environment for the current script execution.
 
-Controls camera, named render views, guided journeys, lighting, background, fog, environment maps, post-processing, capture defaults, and the joint-control helper overlay (`jointOverlay` — axis arrows and arc indicators, renderer-only). Multiple `scene()` calls merge per-key — later values win — so configuration can be split across calls.
+Controls camera, named render views, guided journeys, lighting, background, fog, environment maps, capture defaults, and the joint-control helper overlay (`jointOverlay` — axis arrows and arc indicators, renderer-only). Multiple `scene()` calls merge per-key — later values win — so configuration can be split across calls.
 
 Two behavioral cliffs:
 
@@ -90,7 +90,7 @@ Named views are repeatable cameras checked in with the model code. Canonical sha
 
 Journeys are ordered `steps`, each focusing a returned object by name/tree path with an optional caption and camera. In the viewer they are opt-in (an Explore control; the camera does not move until started). Inspect resolved targets with `forgecad run --journeys`.
 
-Post-processing (`bloom`, `vignette`, `grain`) is browser-only; the CLI applies camera, lights, background, fog, and `toneMappingExposure` but skips shader effects.
+Post-processing is disabled for now while the browser EffectComposer flicker path is being rebuilt. Existing scripts that pass `postProcessing` continue running, but the option is not part of the active scene API.
 
 All numeric values accept `param()` expressions.
 
@@ -109,7 +109,6 @@ scene({
     { type: 'directional', position: [50, -30, 200], color: '#ffd60a', intensity: 1.2 },
   ],
   fog: { color: '#000814', near: 100, far: 450 },
-  postProcessing: { bloom: { intensity: param('bloom', 1.5, 0, 4) } },
   jointOverlay: { axisColor: '#13dfff', arcColor: '#ff7a1a' },
 });
 ```
@@ -120,7 +119,7 @@ scene({
 |--------|------|-------------|
 | `capture?` | `SceneCaptureConfig` | Default capture parameters for `forgecad capture` — CLI flags override these. |
 
-Also: `background?: string | SceneBackgroundGradient`, `camera?: SceneCameraConfig`, `views?: Record<string, SceneViewInputConfig>`, `journeys?: Record<string, SceneJourneyConfig>`, `lights?: SceneLightConfig[]`, `environment?: SceneEnvironmentConfig`, `fog?: SceneFogConfig`, `postProcessing?: ScenePostProcessingConfig`, `ground?: SceneGroundConfig`.
+Also: `background?: string | SceneBackgroundGradient`, `camera?: SceneCameraConfig`, `views?: Record<string, SceneViewInputConfig>`, `journeys?: Record<string, SceneJourneyConfig>`, `lights?: SceneLightConfig[]`, `environment?: SceneEnvironmentConfig`, `fog?: SceneFogConfig`, `ground?: SceneGroundConfig`.
 
 `SceneBackgroundGradient`: `{ top: string, bottom: string }`
 
@@ -174,14 +173,6 @@ Also: `type: SceneLightType`, `color?: string`, `intensity?: number`, `position?
 - `density?: number` — Exponential fog density (if set, uses FogExp2 instead of linear Fog)
 - Also: `color?: string`.
 
-`ScenePostProcessingConfig`: `{ bloom?: SceneBloomConfig, vignette?: SceneVignetteConfig, grain?: SceneGrainConfig, toneMappingExposure?: number }`
-
-`SceneBloomConfig`: `{ intensity?: number, threshold?: number, radius?: number }`
-
-`SceneVignetteConfig`: `{ darkness?: number, offset?: number }`
-
-`SceneGrainConfig`: `{ intensity?: number }`
-
 **`SceneGroundConfig`**
 
 | Option | Type | Description |

package/dist-skill/docs/guides/inspection-bundles.md

@@ -5,7 +5,7 @@ skill-order: 2
 
 # Inspection Bundles — Evidence Contract
 
-`forgecad inspect <family> <mode>` writes a deterministic bundle: evidence PNGs under `evidence/<type>/` plus a root `manifest.json`. **The manifest is the authoritative contract** — take file paths, encodings, per-view ranges, thresholds, tolerances, and identity maps from it; never hard-code bundle layout or infer object identity from object order. The PNGs are a visual index for locating findings, not standalone artifacts. Command tree, flags, and `--focus`/`--hide` filtering live in `docs/permanent/CLI.md` and `forgecad inspect evidence`; the inspection workflow lives in the `forgecad-render-inspect` skill. Model-authored `scene()` background, lights, fog, and exposure are ignored for inspection captures so evidence stays stable; named scene views remain available via `--view`.
+`forgecad inspect <family> <mode>` writes a deterministic bundle: evidence PNGs under `evidence/<type>/` plus a root `manifest.json`. **The manifest is the authoritative contract** — take file paths, encodings, per-view ranges, thresholds, tolerances, and identity maps from it; never hard-code bundle layout or infer object identity from object order. The PNGs are a visual index for locating findings, not standalone artifacts. Command tree, flags, and `--focus`/`--hide` filtering live in `docs/skill/CLI.md` and `forgecad inspect evidence`; the inspection workflow lives in the `forgecad-render-inspect` skill. Model-authored `scene()` background, lights, fog, and exposure are ignored for inspection captures so evidence stays stable; named scene views remain available via `--view`.
 
 Manifest evidence keys are evidence-oriented and stable for bundle readers: e.g. `fit interference` writes `manifest.evidence.collisions`, `physical components` writes `manifest.evidence.connectivity`.
 

package/dist-skill/library/README.md

@@ -11,13 +11,12 @@ The installed skill names are namespaced to avoid collisions with a user's exist
 - `forgecad-3d-reconstruction`
 - `forgecad-blockout-model`
 - `forgecad-component-model`
-- `forgecad-high-level-spec`
 - `forgecad-image-replicator`
-- `forgecad-lld`
 - `forgecad-make-a-model`
 - `forgecad-model-grader`
-- `forgecad-prepare-prompt`
+- `forgecad-mujoco-verify`
 - `forgecad-project`
 - `forgecad-reconstruction-benchmark`
 - `forgecad-render-inspect`
+- `forgecad-spec-by-walking-through-it`
 - `forgecad-visual-spec`

package/dist-skill/library/forgecad-blockout-model/SKILL.md

@@ -11,7 +11,7 @@ A blockout is a spatial planning artifact: 3-7 simple masses that answer where p
 | Need | Skill |
 |------|-------|
 | High-level 3D idea using simple masses | `forgecad-blockout-model` |
-| Written concept or architecture before CAD | `forgecad-high-level-spec` |
+| Written concept or architecture before CAD | `forgecad-spec-by-walking-through-it` |
 | Accurate, detailed, parametric ForgeCAD model | `forgecad-make-a-model` |
 
 ## Method

package/dist-skill/library/forgecad-image-replicator/SKILL.md

@@ -11,7 +11,7 @@ The reference image is evidence, not the deliverable. The deliverable is a real
 ## Companion Skills
 
 - `forgecad` — API docs, model authoring, renderer behavior.
-- `forgecad-prepare-prompt` — when the images underdetermine artifact family, process posture, scale, operating story, or validation boundary.
+- `forgecad-spec-by-walking-through-it` — when the images underdetermine artifact family, process posture, scale, operating story, or validation boundary.
 - `forgecad-make-a-model` — file placement, project structure, decomposition, definition of done.
 - `forgecad-render-inspect` — pre-delivery inspection for multi-part, internal, mechanical, thin-wall, or fit-sensitive objects.
 
@@ -23,7 +23,7 @@ Infer the real object before matching any camera — identity, manufacture, scal
 
 1. Stage references in `/tmp/<slug>-replicate/refs`, keeping originals and adding view names where possible (`front`, `side`, `rear-iso`, `top`, `detail`).
 2. Read each image as evidence, recording: visible facts; scale cues; camera cues; unknowns (hidden/occluded geometry); conflicts across images or stylization.
-3. Write a Real Object Brief — a hard gate before modeling: (a) artifact identity + operating story; (b) assumed scale and units; (c) process posture + part/BOM boundary (real geometry vs purchased vs ghost vs omitted); (d) inferred hidden-side geometry + expected canonical front/back/left/right/top/bottom forms; (e) validation views and inspection evidence. Use `forgecad-prepare-prompt` when these are underdetermined.
+3. Write a Real Object Brief — a hard gate before modeling: (a) artifact identity + operating story; (b) assumed scale and units; (c) process posture + part/BOM boundary (real geometry vs purchased vs ghost vs omitted); (d) inferred hidden-side geometry + expected canonical front/back/left/right/top/bottom forms; (e) validation views and inspection evidence. Use `forgecad-spec-by-walking-through-it` when these are underdetermined.
 4. Build a coarse 3D blockout — model the object, not the image: large volumes, axes, symmetry, side depth, rear form, underside, hidden continuations. Render canonical views before any reference-camera comparison. Follow `forgecad-make-a-model` for project structure.
 5. Calibrate one camera per usable reference, only after the blockout makes sense from canonical views. Use the object center as `target`; estimate azimuth/elevation/distance/FOV from visible faces and perspective cues; use orthographic when parallel edges stay parallel with no perspective convergence.
 6. Render comparison boards: render the model from each calibrated reference camera and place it next to the original. Never compare from memory.

package/dist-skill/library/forgecad-mujoco-verify/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: forgecad-mujoco-verify
+description: Verify ForgeCAD MJCF exports in MuJoCo with real dynamics, contacts, root behavior, controls, required joint travel, and rendered evidence before calling a model simulation-ready. Use when making a ForgeCAD assembly sim-ready, debugging MJCF contacts, checking why a body falls through the floor, validating actuator motion, or proving a mechanism moved through the intended range.
+forgecad-public: true
+---
+
+# ForgeCAD MuJoCo Verify
+
+Use this when `forgecad export mjcf ...` is part of the deliverable. A model is not sim-ready just because `forgecad check simready` passes or the MJCF file loads: it must be loaded in MuJoCo, stepped under gravity, driven with the intended controls, contact pairs inspected, and rendered from useful views.
+
+Routing: geometry-only visual inspection -> `forgecad-render-inspect`; model authoring/API questions -> `forgecad`; building a new model -> `forgecad-make-a-model`.
+
+## Definition Of Done
+
+1. **Export from the exact source file.**
+   ```bash
+   rm -rf /tmp/forgecad-mjcf && mkdir -p /tmp/forgecad-mjcf
+   forgecad export mjcf path/to/model.forge.js --output /tmp/forgecad-mjcf
+   ```
+2. **Load the generated scene in MuJoCo.** Use `scene.xml`, not only the model XML, so the floor/camera/package context is included.
+3. **Check the root behavior.** If the model has a free root, it needs real support/contact geometry or an explicit fixed-root export path. Do not hide a floor failure by turning the whole shell into a giant bounding box that blocks moving internals.
+4. **Check initial poses numerically.** For mechanisms, compute the expected body/link axes from the design source and compare them to MuJoCo `xmat`/`xpos`. Joint `ref`/default and connector frames can disagree with visual intuition.
+5. **Keep meaningful collisions.** Do not mark moving functional parts `Sim.collider.none(...)` just to make motion pass. If full visual mesh contact is unstable, use a physically defensible simplified collider or proxy and state what physical surface it represents.
+6. **Run the intended control with numeric acceptance criteria.** Define the expected signed post-settle joint travel before running the test: e.g. "this drive should rotate the drum -0.04 to -0.06 cycles, then stop near zero velocity" or "this wheel should move at least +1 cycle and keep spinning". Use cycles for revolute/indexing mechanisms when that is easier to reason about, and radians for direct MuJoCo qpos checks. A controller that only jitters, moves the wrong direction, overshoots through a stop, or eventually jams after skipping the intended state is a failure even when the process exits 0.
+7. **Inspect contact pairs.** Contact names should match the physical story: floor/support, card/card, wheel/ground, stop/follower, etc. Contacts against a filled-in AABB, hidden fixture, or unrelated side plate usually indicate bad collider selection.
+8. **Render evidence.** Save initial, settled, and driven frames from views that actually show the moving parts. If the model orientation is not obvious, generate a labeled camera preview grid first, inspect it, then rerun with the azimuth/elevation that shows the functional face. Do not report GIFs/frames before visually confirming they are not from the back, underside, or an occluded side.
+
+## Helper Script
+
+This skill ships a MuJoCo smoke verifier:
+
+```bash
+uv run --python 3.11 --with mujoco --with pillow \
+  python <this-skill-dir>/scripts/mujoco_verify.py /tmp/forgecad-mjcf \
+  --settle-seconds 2 \
+  --seconds 8 \
+  --actuator drum_velocity=-0.75 \
+  --watch-joint drum_joint \
+  --expect-drive-cycles drum_joint=-0.06:-0.03 \
+  --expect-final-qvel drum_joint=-0.02:0.02 \
+  --render-dir /tmp/forgecad-mjcf/verify \
+  --camera-preview-grid
+```
+
+Use `--actuator name=value` more than once for multi-actuator models. Use `--expect-drive-cycles joint=min:max` to assert signed final-minus-settled revolute travel in cycles/turns. Use `--expect-drive-delta joint=min:max` when you want raw MuJoCo qpos units instead. Use `--expect-final-qvel joint=min:max` to assert terminal velocity when the mechanism should stop or continue at a bounded speed. The script prints JSON with root drift, initial-to-final joint delta, post-settle drive delta, derived cycle counts, final velocities, expectation ranges, and top contact pairs, then writes PNG frames if `--render-dir` is supplied.
+
+Prefer explicit travel envelopes over loose "it moved" checks:
+
+- Stops/latches: assert a signed drive cycle or delta range and a near-zero final velocity range.
+- Continuous drives: assert the signed drive cycle/delta is large enough over the run and final velocity remains in the expected direction/range.
+- Indexing mechanisms: assert the expected cycle step size, not just eventual stall. If the mechanism reaches a stop only after skipping several indices, treat that as failure.
+- Gravity-settling mechanisms: evaluate functional travel with post-settle drive delta, not initial-to-final delta.
+
+When rendered orientation matters, start with `--camera-preview-grid`, open `camera_preview_grid.png`, pick the azimuth that shows the mechanism face or contact interface, then rerun with `--camera-azimuth <deg>` and any needed `--camera-lookat`, `--camera-distance`, or `--camera-elevation` adjustment. For mechanism evidence, prefer front/front-quarter views for user-facing GIFs and add a side/contact view only when it explains a collision better.
+
+## Contact Debugging Rules
+
+- In MuJoCo UI, enable contact visualization with `Rendering` -> `Contact points` and `Contact forces`; use the right-side perturb/visualization panels if available in your build.
+- If rotation is blocked, list contacts during the stall and sort by repeated pairs. The blocker is usually the pair that appears every step while the driven joint velocity trends to zero.
+- If a body falls through the floor, inspect the exported geoms. Visual geoms have `contype="0" conaffinity="0"` and cannot support anything; collision geoms are usually group 3.
+- Bounding boxes are fast but dangerous for hollow frames, windows, handles, and side plates. They collide as the filled AABB, not the visible object.
+- Mesh collision on complex moving parts can be too exact or solver-hostile. Prefer simple physical proxies for contact-critical moving bodies, such as a slab for a flap card or cylinders for rolling contact, but keep them colliding.
+
+## Reporting
+
+Report the exact export command, the MuJoCo command/script, key numeric results, the most important contact pairs, and the rendered image paths. Say what was not verified. Never say "sim-ready" when only `forgecad run`, `forgecad check simready`, or a successful export was executed.