forgecad 0.10.2 → 0.10.4

package/dist/docs-raw/AI/usage.md

@@ -97,7 +97,7 @@ To verify installation, ask the agent:
 What ForgeCAD skills are available?
 ```
 
-You should see `forgecad` plus companion skills such as `forgecad-make-a-model`, `forgecad-render-inspect`, `forgecad-lld`, and `forgecad-project`.
+You should see `forgecad` plus companion skills such as `forgecad-build-model`, `forgecad-inspect-model`, `forgecad-design-spec`, and `forgecad-project-sync`.
 
 If you only want the core modeling skill without companion workflows:
 
@@ -130,16 +130,17 @@ push when the result is ready for the browser.
 ### Mechanism Or Assembly
 
 ```text
-Use forgecad-component-model and forgecad. Parts must build at origin. The
-assembly positions parts with connectors or explicit assembly-level placement.
-Validate with forgecad run, inspect physical components, inspect fit interference and visual objects,
-and run parameter checks before calling it done.
+Use forgecad-build-model and forgecad. For multi-part assemblies, parts must
+build at origin, expose connectors/metadata, and let the parent assembly position
+them with connectors or matchTo(). Validate with forgecad run, inspect physical
+components, inspect fit interference and visual objects, and run parameter
+checks before calling it done.
 ```
 
-### Image Or Product Replication
+### Image Or Product Reconstruction
 
 ```text
-Use the ForgeCAD image-replication workflow. Treat the reference images as
+Use forgecad-reconstruct-from-images. Treat the reference images as
 evidence, infer dimensions explicitly, build real CAD geometry, and compare
 renders against the references. Do not stop at a decorative approximation.
 Validate with forgecad run and targeted forgecad inspect evidence before finalizing.
@@ -205,16 +206,15 @@ For the full command reference, see [ForgeCAD CLI](../CLI.md).
 | Skill | Use it for |
 |---|---|
 | `forgecad` | Core model authoring, editing, debugging, imports, assembly, render/export commands, and CLI validation. |
-| `forgecad-prepare-prompt` | Turning a fuzzy physical-product request into a concrete build brief and modeling prompt. |
-| `forgecad-high-level-spec` | Writing an HLD before modeling: requirements, alternatives, decisions, and open questions. |
-| `forgecad-lld` | Writing the exact low-level model specification: dimensions, constraints, parameters, and verification criteria. |
-| `forgecad-make-a-model` | Creating a new `.forge.js` model in the active ForgeCAD project and validating it. |
-| `forgecad-component-model` | Building or reviewing multi-file assemblies where parts build at origin and the parent assembly positions them through connectors. |
-| `forgecad-blockout-model` | Making rough concept geometry to explore proportions, layout, motion envelope, or spatial intuition before detailed modeling. |
-| `forgecad-image-replicator` | Recreating an object from reference images as real ForgeCAD geometry through camera-calibrated render/compare/iterate loops. |
-| `forgecad-render-inspect` | Generating and interpreting `forgecad inspect <family> <mode>` bundles for fit interference, wall thickness, connectivity, masks, depth, normals, and sections. |
-| `forgecad-visual-spec` | Producing builder-honest image prompts from a concrete model, HLD, LLD, or build brief. |
-| `forgecad-project` | Managing forgecad.io projects from the CLI: init, clone, pull, push, file commands, members, publish, and shares. |
+| `forgecad-design-spec` | Designing in a git-reviewed document before code: fuzzy-request intake and process choice, the HLD (requirements, alternatives, decisions), and the LLD (exact dimensions, constraints, parameters, verification). |
+| `forgecad-build-model` | Creating a new `.forge.js` model in the active ForgeCAD project, including multi-part assembly discipline and validation. |
+| `forgecad-reconstruct-cad-file` | Reconstructing a readable parametric ForgeCAD model from an existing STL, OBJ, 3MF, STEP, or STP file. |
+| `forgecad-reconstruct-from-images` | Recreating an object from reference images as real ForgeCAD geometry through camera-calibrated render/compare/iterate loops. |
+| `forgecad-inspect-model` | Generating and interpreting `forgecad inspect <family> <mode>` bundles for fit interference, wall thickness, connectivity, masks, depth, normals, and sections. |
+| `forgecad-grade-model` | Reviewing and scoring a model against a requirement, brief, prompt, reference, or acceptance criteria. |
+| `forgecad-verify-mujoco` | Verifying MJCF exports in MuJoCo with dynamics, contacts, controls, joint travel, and rendered evidence. |
+| `forgecad-image-prompt` | Producing builder-honest image prompts from a concrete model, HLD, LLD, or build brief. |
+| `forgecad-project-sync` | Managing forgecad.io projects from the CLI: init, clone, pull, push, file commands, members, publish, and shares. |
 
 The source prompts for CLI-shipped companion skills live in the repository under `agent-skill-library/`. Public export is controlled by `forgecad-public: true` in each skill's `SKILL.md` frontmatter. Repo-local operational skills live under `.agents/skills/` and are not shipped through the CLI. To list the current public set from a source checkout:
 

package/dist/docs-raw/CLI.md

@@ -265,7 +265,7 @@ forgecad render section model.forge.js --output out/section.svg --plane XZ --off
 
 ### 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 |
 |--------|-------------|
@@ -306,39 +306,41 @@ Export to every format you need.
 
 ```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 --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 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 |
-| `--param <Key=Value>` | Override a parameter value (Key=Value). Repeatable. |
-| `-p <Key=Value>` | Shorthand for --param |
 | `--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 |

package/dist/docs-raw/README.md

@@ -1,6 +1,6 @@
 # Generated — do not edit
 
 Everything in `docs/public/` is generated by `scripts/gen-public-docs.ts`:
-docs are copied from `docs/permanent/` per `docs/public-docs.json`, skill pages
+docs are copied from `docs/skill/` and `docs/internal/` per `docs/public-docs.json`, skill pages
 from `dist-skill/website/skills/` (rendered out of `agent-skill-library/`), and
 legal docs by `scripts/gen-legal-docs.ts`. Edit those sources instead.

package/dist/docs-raw/component-model.md

@@ -5,7 +5,7 @@ skill-order: 4
 
 # The Component Model
 
-Long-form rationale for ForgeCAD's multi-part architecture. The enforceable rule sheet — anti-patterns, design gate, file-structure rules — lives in the `forgecad-component-model` skill (`agent-skill-library/forgecad-component-model/SKILL.md`). Connector and joint mechanics (frame semantics, mating, mirrored-revolute handedness) live in the assembly JSDoc, surfaced in `docs/permanent/generated/assembly.md`.
+Long-form rationale for ForgeCAD's multi-part architecture. The public rule sheet is embedded where agents need it: `forgecad-build-model` for authoring and `forgecad-grade-model` for review caps. Connector and joint mechanics (frame semantics, mating, mirrored-revolute handedness) live in the assembly JSDoc, surfaced in `docs/skill/generated/assembly.md`.
 
 ## The Principle
 
@@ -44,4 +44,4 @@ One file per project-specific assembly is the default because it maximizes local
 
 ## Enforcement
 
-The anti-pattern list and the three-question design gate live in the `forgecad-component-model` skill; every multi-part example and agent-built assembly must pass that gate.
+The anti-pattern list and design gate are enforced by the public build and grading skills; every multi-part example and agent-built assembly must pass that gate.

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

@@ -373,7 +373,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[] }`
 

package/dist/docs-raw/generated/concepts.md

@@ -7,7 +7,7 @@ Every public API function belongs to one of 16 fundamental concepts. This is an
 - **[C1: Primitive Construction](#c1-primitive-construction)** — Create geometry from parameters — no input geometry required. *(66 functions)*
 - **[C2: Boolean Combination](#c2-boolean-combination)** — Combine same-dimension geometry using CSG set operations. *(6 functions)*
 - **[C3: Rigid Transform](#c3-rigid-transform)** — Reposition or reorient geometry without changing its shape. *(0 functions)*
-- **[C4: Dimensional Promotion](#c4-dimensional-promotion)** — Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep). *(47 functions)*
+- **[C4: Dimensional Promotion](#c4-dimensional-promotion)** — Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep). *(50 functions)*
 - **[C5: Topology Query](#c5-topology-query)** — Select or inspect named faces and edges on a shape. *(3 functions)*
 - **[C6: Edge Feature](#c6-edge-feature)** — Modify edges of a solid — fillets, chamfers, draft, offset. *(4 functions)*
 - **[C7: Pattern Replication](#c7-pattern-replication)** — Duplicate geometry in regular arrangements (linear, circular, mirror). *(6 functions)*
@@ -16,8 +16,8 @@ Every public API function belongs to one of 16 fundamental concepts. This is an
 - **[C10: Assembly & Kinematics](#c10-assembly-kinematics)** — Compose parts with joints for kinematic simulation. *(15 functions)*
 - **[C11: Parameterization & UI](#c11-parameterization-ui)** — Declare user-facing controls that drive model geometry. *(6 functions)*
 - **[C12: Dimensional Demotion](#c12-dimensional-demotion)** — Extract 2D geometry from a 3D solid (section, projection). *(3 functions)*
-- **[C13: Export & Output](#c13-export-output)** — Convert geometry to external formats (STL, 3MF, SVG, DXF, G-code, PDF). *(15 functions)*
-- **[C14: Visual & Debugging](#c14-visual-debugging)** — Control viewport appearance and debugging aids. *(35 functions)*
+- **[C13: Export & Output](#c13-export-output)** — Convert geometry to external formats (STL, 3MF, SVG, DXF, G-code, PDF). *(14 functions)*
+- **[C14: Visual & Debugging](#c14-visual-debugging)** — Control viewport appearance and debugging aids. *(39 functions)*
 - **[C15: Import & Composition](#c15-import-composition)** — Bring external geometry or other ForgeCAD modules into the current script. *(1 functions)*
 - **[C16: Part Library](#c16-part-library)** — Pre-built parametric parts accessible via `lib.*`. *(4 functions)*
 
@@ -144,11 +144,13 @@ Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep).
 - `Loft.withGuideRails(stations, rails, options?)` — Loft through profile stations while forcing generated sections to follow guide rails. → [curves](/docs/curves#curves-surfacing)
 - `Analysis.EdgeContinuity(shape, options?)` → [curves](/docs/curves#analysis)
 - `Analysis.SurfaceContinuity(shape, options?)` → [curves](/docs/curves#analysis)
+- `Analysis.EdgeMatch(edgeA, edgeB, options?)` — 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). → [curves](/docs/curves#analysis)
 - `Analysis.CurvatureComb(input, options?)` → [curves](/docs/curves#analysis)
 - `Analysis.SurfaceHealth(shape, options?)` → [curves](/docs/curves#analysis)
 - `Analysis.BRepValidity(shape, options?)` — Validate B-rep/shell/solid structure and return closedness, manifoldness, orientation, and issue diagnostics. → [curves](/docs/curves#analysis)
 - `Blend.Edge(options)` → [curves](/docs/curves#blend)
 - `Blend.Surface(options)` → [curves](/docs/curves#blend)
+- `Blend.Bridge(edgeA, edgeB)` — Build a transition strip between two `Surface.Net` sheet edges. → [curves](/docs/curves#blend)
 - `Surface.Plane(options)` — Create a finite analytic plane sheet that can be trimmed, sewn, thickened, or used as a low-level face. → [curves](/docs/curves#surface)
 - `Surface.Cylinder(options)` — Create a finite analytic cylindrical sheet, optionally bounded by start/end angles. → [curves](/docs/curves#surface)
 - `Surface.Cone(options)` — Create a finite analytic conical or frustum sheet, optionally bounded by start/end angles. → [curves](/docs/curves#surface)
@@ -165,6 +167,7 @@ Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep).
 - `Surface.Trim(shape, tool)` → [curves](/docs/curves#surface)
 - `Surface.Split(shape, tool)` → [curves](/docs/curves#surface)
 - `Surface.Match(shape, options)` → [curves](/docs/curves#surface)
+- `Surface.Net()` — Begin a curve-network (Gordon) surface — the class-A keystone. → [curves](/docs/curves#surface)
 - `loft(profiles, heights, options?)` — Loft between multiple sketches along Z stations. → [curves](/docs/curves#loft)
 - `sweep(profile, path, options?)` → [curves](/docs/curves#sweep)
 - `variableSweep(spine, sections, options?)` — Sweep a variable cross-section along a 3D spine curve. → [curves](/docs/curves#variablesweep)
@@ -286,7 +289,6 @@ Convert geometry to external formats (STL, 3MF, SVG, DXF, G-code, PDF).
 - `Laser.lookupKerf(material, thickness, laserType?)` — Look up kerf for a material + thickness + laser combo in `Laser.COMMON_KERFS`. → [sheet-metal](/docs/sheet-metal#laser)
 - `Laser.COMMON_KERFS` — Common full-kerf values by material, thickness, and laser type. → [sheet-metal](/docs/sheet-metal#laser)
 - `bom(quantity, description, opts?)` — Register a Bill of Materials entry for report export. → [output](/docs/output#bom)
-- `robotExport(options)` — Compatibility shim for SDF/URDF robot package metadata. → [output](/docs/output#robotexport)
 - `sheetMetal(options)` — Create a parametric sheet metal part with flanges, bend allowances, and flat-pattern unfolding. → [sheet-metal](/docs/sheet-metal#sheetmetal)
 - `sketchToDxf(sketch, options?)` — Export a 2D sketch as a DXF string (R12/AC1009 — maximally compatible). → [output](/docs/output#sketchtodxf)
 - `sketchToSvg(sketch, options?)` — Export a 2D sketch as an SVG string. → [output](/docs/output#sketchtosvg)
@@ -299,6 +301,10 @@ Control viewport appearance and debugging aids.
 
 - `Viewport.label(text, at, options?)` — Add a render-only viewport label at a world-space point. → [viewport](/docs/viewport#viewport-runtime)
 - `Viewport.highlight(target, options?)` — Highlight any geometry for visual debugging in the viewport. → [viewport](/docs/viewport#viewport-runtime)
+- `Wrap.flat(opts)` — Project the image flat onto an axis-aligned face — `onto` is one of top/bottom/front/back/left/right. → [core](/docs/core#wrap)
+- `Wrap.aroundCylinder(opts)` — Wrap the image around a cylinder like a can label — `axis` is 'x' | 'y' | 'z'. → [core](/docs/core#wrap)
+- `Wrap.onSphere(opts?)` — Map the image over a sphere like a globe (longitude/latitude). → [core](/docs/core#wrap)
+- `Wrap.box(opts?)` — Cube-map the image onto a box — one copy per face. → [core](/docs/core#wrap)
 - `verify.that(label, check, message?)` — Custom predicate check. → [core](/docs/core#verify)
 - `verify.equal(label, actual, expected, tolerance?, message?)` — Check that two numbers are approximately equal (within tolerance). → [core](/docs/core#verify)
 - `verify.notEqual(label, actual, unexpected, tolerance?, message?)` — Check that two numbers are NOT equal (differ by more than tolerance). → [core](/docs/core#verify)

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

@@ -24,12 +24,17 @@ 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)
 - [Points](#points)
 - [connector](#connector)
 - [Import](#import)
+- [Wrap](#wrap)
 
 ## Functions
 
@@ -708,7 +713,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
@@ -737,6 +742,7 @@ box(100, 100, 10).color('#gold').material({ metalness: 0.95, roughness: 0.05 }).
 | `specularIntensity?` | `number` | Specular highlight intensity (0–1). |
 | `specularColor?` | `string` | Specular highlight tint. |
 | `reflectivity?` | `number` | Reflection strength for supported renderers (0–1). |
+| `texture?` | `{ image: string; projection: UvProjectionSpec; ...` | Projected bitmap texture set by `Shape.wrapTexture`. `image` is a self-contained `data:` URI; `projection` maps each vertex's final world position to (u,v) in the shader, so the texture survives transforms and boolean cuts. `imageWidth`/`imageHeight` are the intrinsic pixel dimensions. |
 
 **Face Topology**
 
@@ -1085,6 +1091,22 @@ Overloads:
 
 **Other**
 
+#### `wrapTexture(image: ImageHandle, projection: UvProjectionSpec): Shape` — Wrap an imported bitmap image around this shape using a projection.
+
+The `image` comes from `Import.image('path.png')`; the `projection` is one of the `Wrap.*` helpers — `Wrap.flat({ onto: 'top' })` lays it flat on a face, `Wrap.aroundCylinder({ axis: 'z' })` wraps it like a can label, `Wrap.onSphere()` maps it like a globe, and `Wrap.box()` cube-maps it onto the six sides.
+
+By default the image **auto-fits** the shape — one copy across the relevant extent, so no `width`/`height`/`size` is needed (pass them only to override). The (u,v) is derived from each vertex's final world position, so the image stays glued to the surface through transforms and boolean cuts with no UV layout to maintain — apply `wrapTexture` *after* positioning the shape. Returns a new Shape; the original is unchanged.
+
+```js
+const logo = Import.image('./logo.png');
+box(80, 80, 10).wrapTexture(logo, Wrap.flat({ onto: 'top' }));            // auto-fits the face
+
+const label = Import.image('./label.jpg');
+cylinder(60, 20).wrapTexture(label, Wrap.aroundCylinder({ axis: 'z' }));  // wraps the side
+```
+
+`ImageHandle`: `{ __forgeImage: true, dataUri: string, width: number, height: number, mimeType: string, byteLength: number }`
+
 #### `clone(): Shape` — Return a new Shape wrapper for explicit duplication in scripts.
 
 #### `geometryInfo(): GeometryInfo` — Inspect which backend/representation produced this solid.
@@ -1333,6 +1355,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.
@@ -1425,3 +1512,11 @@ Namespaced file-format import helpers — the single vocabulary for bringing ext
   const yUpPart = Import.mesh("./part.obj", { sourceFrame: { up: "+Y" } });
   ```
 - `step(fileName: string, options?: StepImportOptions): Shape` — Import a STEP file (.step, .stp) as an exact OCCT-backed Shape. Preserves NURBS curves, B-spline surfaces, and exact topology. Requires running with the OCCT backend. Use `sourceFrame: { up: "+Y" }` to rotate Y-up source files into ForgeCAD's Z-up world.
+- `image(fileName: string): ImageHandle` — Import a bitmap image (PNG, JPEG, or WebP) as an ImageHandle for projected texturing. Reads the pixel dimensions from the file header and embeds the bytes as a data URI. Pass the result to `Shape.wrapTexture(image, projection)` with a `Wrap.*` projection.
+
+### `Wrap`
+
+- `flat(opts: FlatWrapOptions): UvProjectionSpec` — Project the image flat onto an axis-aligned face — `onto` is one of top/bottom/front/back/left/right. Auto-fits the face (no width/height needed).
+- `aroundCylinder(opts: CylinderWrapOptions): UvProjectionSpec` — Wrap the image around a cylinder like a can label — `axis` is 'x' | 'y' | 'z'. Auto-fits one wrap around and the full height.
+- `onSphere(opts?: SphereWrapOptions): UvProjectionSpec` — Map the image over a sphere like a globe (longitude/latitude). Auto-centers on the sphere.
+- `box(opts?: BoxWrapOptions): UvProjectionSpec` — Cube-map the image onto a box — one copy per face. Auto-fits the box (no size needed).

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

@@ -429,7 +429,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.
 
@@ -1169,16 +1173,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/docs-raw/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/docs-raw/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, Wrap
 ```
 
 <!-- forgecad-skill:exclude-start symbol="compatibility runtime names" reason="Compatibility-only renamed runtime globals." -->

package/dist/docs-raw/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/docs-raw/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-inspect-model` 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/docs-raw/simulation-workflow.md

@@ -2,6 +2,64 @@
 
 ForgeCAD should make a robot or simulated asset runnable without making the CAD API own the control algorithm.
 
+## Native Analysis: The Closed Feedback Loop
+
+Some analyses need no external simulator at all — they are computed directly from the model geometry and return a machine-readable feedback report an AI agent (or you) can act on. This is the simulation feedback cycle in its simplest, fastest form: **edit the `.forge.js` → run the analysis → read the metrics → change a parameter → re-run.**
+
+Every native analysis emits the same `forgecad.feedback/v1` contract: name-keyed `metrics` each with a `pass`/`warn`/`fail` status, `findings` that carry an actionable `suggest`, and a `trust` block recording the assumptions behind the numbers.
+
+### Mass properties
+
+```bash
+node dist-cli/forgecad.js sim mass model.forge.js --density 2700 --json
+```
+
+Reports volume, mass, surface area, bounding box, center of mass, the full inertia tensor about the center of mass, principal moments and axes, and a per-object breakdown. Volume, center of mass, and principal axes are exact regardless of material; pass `--density <kg/m3>` (e.g. `2700` aluminium, `7850` steel, `1240` ABS) for accurate mass and inertia magnitude — otherwise it defaults to water and says so.
+
+### Static stability (tip-over)
+
+```bash
+node dist-cli/forgecad.js check stability model.forge.js --min-margin-mm 5 --json
+```
+
+Computes the center of mass, derives the support footprint as the convex hull of the lowest geometry, and reports the **signed tip-over margin** (distance from the CoM projection to the footprint edge — negative means it tips), the tilt angle at which it tips, the critical edge, and the **center-of-mass shift needed** to reach the required margin. Exits non-zero when the margin is below `--min-margin-mm`. Use `--up x|y|z` to set the up axis.
+
+A worked closed loop ships in `examples/analysis/tipping-tripod.forge.js`: at the default base the rig tips by about 3 mm, the report points the fix in −X, and `--param BaseSpreadMm=90` recovers a comfortable positive margin.
+
+### Tolerance / GD&T stack-up
+
+```bash
+node dist-cli/forgecad.js sim tolerance model.forge.js --json
+```
+
+Treats the model's continuous parameters as the varying manufacturing inputs and its numeric `verify.*` results as the measured responses — so ordinary `param(...)` and `verify.inRange(...)` calls already declare the stack-up, with no special API. It builds a finite-difference Jacobian, runs a deterministic Monte Carlo over the linearized surrogate, and reports per-response mean/sigma, Cp/Cpk, yield % and DPMO, worst-case and RSS envelopes, a ranked variance-contribution list (**which dimension to tighten**), and a tolerance-allocation recommendation to reach the target Cpk. A nonlinearity guard errors (pointing you to `--method full-rebuild`) rather than silently reporting a wrong yield; exits non-zero when any response's Cpk is below `--target-cpk` (default 1.33).
+
+A worked closed loop ships in `examples/analysis/clearance-fit.forge.js`: the default (loose) bores hold the clearance spec at only ~84% yield, the report names the dominant dimension, and `--tol BoreDia=±0.05 --tol ShaftDia=±0.05` lifts Cpk above 1.33.
+
+### Mechanism budget (DOF + static-hold torque)
+
+```bash
+node dist-cli/forgecad.js sim mechanism model.forge.js --json
+```
+
+The deterministic budget tier of rigid-body dynamics, computed straight from the assembly joint graph — no external solver, no time-stepping. It reports the actuated degrees of freedom (with a spatial Grübler mobility diagnostic for closed loops) and, for each actuated joint, the gravity-hold torque (revolute) or force (prismatic) it must supply at the current pose, derived from the mass of everything distal to it. When a joint carries a `Sim.drive` effort, the report includes the budget margin and flags over-budget joints. Use `--joint Name=Value` to evaluate a specific pose. The dynamic/contact tier (RL, collisions) is the external Pinocchio/MuJoCo export.
+
+A worked closed loop ships in `examples/analysis/lever-arm-actuator.forge.js`: a 1 kg arm at 0.15 m needs 1.47 N·m (= m·g·r) and holds with ~63% margin against its 4 N·m motor; `--param ArmLength=900` pushes it to 4.4 N·m and trips `MECHANISM.HOLD.OVER_BUDGET`.
+
+### Rigid-body dynamics export (Pinocchio)
+
+```bash
+node dist-cli/forgecad.js export pinocchio model.forge.js --output out/robot_pinocchio
+cd out/robot_pinocchio && uv run --python 3.11 --with pin --with numpy python scripts/run_pinocchio.py
+node dist-cli/forgecad.js sim dynamics out/robot_pinocchio
+```
+
+The dynamic tier. `export pinocchio` reuses the URDF package (per-link inertials computed from the solid) and adds a runnable Pinocchio harness. `run_pinocchio.py` builds the model with `pin.buildModelFromUrdf`, sweeps each joint, computes the gravity-hold torque with `pin.computeGeneralizedGravity`, and writes `feedback.json` in the same `forgecad.feedback/v1` contract; `sim dynamics` reads it back. Pinocchio (BSD-2-Clause) and Coal (BSD-3-Clause) are user-installed — `pip install pin coal` on Linux/macOS, conda-forge on Windows — never bundled.
+
+This closes the same loop as `sim mechanism` and cross-checks it: on the lever-arm example, Pinocchio reports the same 1.47 N·m shoulder hold torque the native tier computes analytically.
+
+The internal simulation feedback cycle strategy doc carries the full cross-category roadmap.
+
 The source `.forge.js` model owns geometry, assembly structure, physical metadata, joints, drive intent, contact hints, and the neutral simulation contract. Exported packages then generate an editable simulator lab with all names and wiring connected. Rewards, policies, perturbation tests, curriculum, and RL libraries stay in simulator-side code.
 
 ## Current Path: ForgeCAD To MuJoCo