forgecad 0.10.1 → 0.10.3

package/dist-skill/website/skills/forgecad-spec-by-walking-through-it.md

@@ -0,0 +1,145 @@
+<!-- Generated by scripts/build-forgecad-skill.mjs — do not edit. Edit agent-skill-library/forgecad-spec-by-walking-through-it/SKILL.md instead. -->
+
+# forgecad-spec-by-walking-through-it
+
+Design a ForgeCAD model, mechanism, or assembly by fixing WHAT before HOW in a git-reviewed design document, validated by mentally operating the thing step by step. Covers fuzzy-request intake and process choice, high-level design (HLD), and low-level design (LLD). Use on "spec this out", "plan the design", "write the HLD/LLD", a vague build request that needs concrete decisions, or any moment the right move is a reviewable spec before code.
+
+| Field | Value |
+| --- | --- |
+| Installed by | `forgecad skill install` |
+| Source | `agent-skill-library/forgecad-spec-by-walking-through-it/SKILL.md` |
+
+---
+
+## Spec by Walking Through It
+
+The design document — a git-committed, diff-reviewed markdown file — is the source of truth. Not the code, not the chat, not your head. You iterate it by commit-and-review, and the `git diff` is the review artifact.
+
+**Validate the design by mentally operating the thing, step by step.** Walk it as someone assembles, uses, or moves it. The step with no answer — *"how does the servo get inside the housing?"* — is the real design gap. A spec that reads complete on the page can still hide a hole that only surfaces when you try to put it together in your head. State each gap falsifiably: not "tolerances might be tight" but "the 12mm arm cantilevers under gripping load, may flex >0.5mm."
+
+**Every number has a reason; the narrative comes before the numbers.** Describe the object as if over the phone, then derive each value and show its math: `wallThickness = 2.4mm = 6 × 0.4mm nozzle`. The design is **implementation-blind** — shaped by the object, never by what the ForgeCAD API makes easy. **Manufacturing process is one of those reasons** — a design decision you weigh, never a default you inherit (never assume FDM/printing).
+
+**A vague request is a set of decisions you make honestly, not information to extract.** No placeholders ("appropriate motor"); choose a defensible value, show why, continue. The Decisions table fills only after user review, so the loop stays in the document.
+
+### Altitude — three phases, one document trail
+
+| Phase | When | Output |
+|-------|------|--------|
+| Intake | request is fuzzy / process unspecified | engineering brief + master prompt |
+| HLD | design is wrong in *approach*, alternatives exist | `<name>-hld.md` |
+| LLD | decisions locked, or a simple single-body part | `<name>-lld.md` |
+
+The HLD carries only decision-driving dimensions and genuinely-different alternatives; the LLD carries enough that someone builds from it alone. Speccing every tolerance in an HLD, or revisiting locked decisions in an LLD, is an altitude error — back up. Simple parts skip straight from HLD to code, or from a request to an LLD.
+
+---
+
+### Phase 1 — Intake (fuzzy request → concrete brief)
+
+Use when the user wants something physically real but the ask is vague ("make me a robot gripper", "make it production ready", "pick sensible numbers"). This phase owns intake; once the brief is concrete, continue to HLD or hand off to the `forgecad` skill.
+
+**Manufacturing is a design decision, not a default.** Derive the process stack from artifact family, load path, scale, safety expectations, material, production intent, and operating story — never assume printing/plastic. If the user names a process, honor it but warn when it is unsafe or dishonest for the duty. Family→process anchors live in `references/default-profiles.md`.
+
+**Default posture: manufacture-realistic prototype** — real materials, purchased-part boundaries, assembly logic, validation; no claims of production tooling or certification. Other postures only when justified: `production-realistic`, `printable`, `visual-CAD`, or a specific process posture (`sheet-metal`, `CNC-machined`, `laser-cut`, `welded-tube`, `injection-molded`, `cast`, `hybrid purchased-hardware`). Pick the posture honest for the artifact, not the easiest CAD surface.
+
+**Family-scoped numbers.** Every starter assumption is scoped to one artifact family; never reuse numbers across families.
+
+Workflow:
+1. **Normalize the ask** into plain mechanism language ("6 DOF gripper" → standalone gripper, wrist+gripper, or arm+gripper).
+2. **Build a specific operating story** — invented (non-famous) org, named program, prototype revision, review moment, mission pressure (pilot gate, demo date, investor milestone), and the generic failure mode to avoid. Prefer bold high-agency stories over modest lab exercises. Never assert the user works for a named real company; use real products only as public comparison anchors; never clone proprietary designs.
+3. **Classify the artifact family** (`references/default-profiles.md`); use the no-family-fits escape rather than forcing one. Rideables route to human-vehicles, never chassis.
+4. **Choose the process posture** per the taxonomy above.
+5. **Pick qualitative levers** — duty (`light`/`general`/`sturdy`), scale (`compact`/`medium`/`large`), cost (`cheapest`/`balanced`/`performance-first`) — and translate to family-scoped starter assumptions.
+6. **Close only critical gaps** — at most 3 grouped questions, always choice menus, never raw engineering inputs unless the architecture truly depends on them. Good: "light desk demo, useful hobby tool, or sturdier bench mechanism?" Bad: "What payload mass?"
+7. **Write the engineering brief**: artifact + family + normalized interpretation; operating story + production reason + test setting + failure mode to avoid; output posture; intended loads, size envelope, motion/DOF; process stack + material defaults; purchased-part (BOM) boundary; validation standard; variant policy (versions are selectable params, one rendered at a time); file organization (`main.forge.js` entry for multi-file); explicit uncertainty policy.
+8. **Emit one master prompt** — fill `references/master-prompt.md`; return the finished prompt, not notes about it. It must demand exactly `BUILD-READY` or `BEST-EFFORT BUILD CANDIDATE` (human-bearing furniture and rideables usually end the latter).
+
+Defaults if the user stays vague: `general-duty` / `medium` / `balanced`, invent the operating story, use family starter assumptions.
+
+---
+
+### Phase 2 — High-Level Design (HLD)
+
+Aligns user and agent on *what* to build before *how*. Brevity is a readability tool, not a metric — include whatever evidence, diagrams, and dimensions a good decision needs. Write the sections top to bottom; the order is the workflow.
+
+```markdown
+# [Name] — High-Level Design
+
+## Problem
+What must this do? Hard requirements (grip 40-90mm objects, fit a 60mm
+housing, use purchased bearings). State the problem without implying a
+solution. Unspecified process choice is an open design dimension.
+
+## Approach
+How it works conceptually. ASCII diagram of key elements and their
+spatial relationships — diagram labels stay in this markdown, never
+carried into CAD geometry unless the real artifact needs markings.
+
+## Key Interfaces
+Every point where this touches another part or the outside world:
+mating surfaces, shared dimensions, coordination points. These are the
+contracts that constrain the design.
+
+## Dictionary
+| Term | What it is |
+Define every domain term in plain words, with dimensions where relevant.
+Write for a developer without a mechanical-engineering background.
+
+## Alternatives
+| Option | Description | Tradeoff |
+2-3 genuinely different strategies, not minor variations. Mark one
+recommended and say why. If there is honestly one approach, say so.
+
+## Usage Guide
+Work backwards from how someone uses, assembles, or operates the thing,
+step by step. If a step doesn't make sense ("how does the servo get
+inside?"), flag it inline with ⚠️ and promote it to Concerns.
+
+## Concerns
+1. Numbered, falsifiably specific — a reviewer must be able to say "real
+   problem" or "fine, because…".
+
+## Decisions
+| # | Decision | Rationale |
+Filled ONLY after user review — never pre-decide. Each row resolves a
+concern or alternative.
+```
+
+Rules: if you're speccing every part, formula, and tolerance, you're writing an LLD — back up. If you can't draw it, you don't understand it yet.
+
+---
+
+### Phase 3 — Low-Level Design (LLD)
+
+Implements the HLD's locked Decisions table; it never revisits those decisions. Simple single-body parts skip the HLD and start here. Complex assemblies split into a numbered directory: overview, global constraints, per-component files, assembly, verification.
+
+An LLD is **narrative-first** (reads like describing the object over the phone), **authoritative** (the single source code implements), **implementation-blind**, and shows **every number's rationale**.
+
+Required structure:
+1. **Narrative** — what it is, how it behaves and interacts, why it exists. Concrete comparisons ("about the size of a deck of cards"); no ungrounded vague terms.
+2. **Technical** — typed parameter table (length / angle / count / boolean / choice / ratio / clearance — design-document vocabulary, not the runtime `Param.*` API), always with units (mm, degrees default) and a rationale for every default and range; derived dimensions shown as math; geometry and constraints, each constraint with a rationale.
+3. **Verification** — mandatory checklist: dimensional, functional, printability/process checks.
+
+Don'ts: never open with a parameter list (story before numbers), never leave a constraint implicit, never skip verification. Completeness gate before presenting: can someone build from this alone? Does it implement every HLD decision? Is every constraint explicit with a rationale?
+
+---
+
+### Review via git
+
+HLDs and LLDs iterate through git, not conversation:
+- **Commit every version.** No drafts floating in chat. After writing, commit and tell the user it's ready for review.
+- **Feedback arrives as file edits (inline comments, strikethroughs) or chat — check both.** Read `git diff`: the diff is the review artifact.
+- **Update, commit, repeat** until the Decisions table is filled and the user says "go."
+
+### Pipeline
+
+| Stage | This skill's phase | Output | Next |
+|-------|--------------------|--------|------|
+| Explore a fuzzy ask | Intake | engineering brief + master prompt | HLD |
+| Decide *what* to build | HLD | `*-hld.md` (Decisions filled) | LLD |
+| Detail *how* to build | LLD | `*-lld.md` | `forgecad-make-a-model` + `forgecad` → `.forge.js` |
+
+
+## Bundled Files
+
+- `references/default-profiles.md`
+- `references/master-prompt.md`

package/dist-skill/website/skills/forgecad-visual-spec.md

@@ -15,7 +15,7 @@ Turn a concrete ForgeCAD artifact, build brief, HLD, or existing model into buil
 
 ### Scope
 
-Only for artifacts already concrete enough to visualize (a specific `.forge.js` model, build brief, or HLD); route vague briefs to `forgecad-prepare-prompt` first. Read minimum context — entry `.forge.js`, one key helper if it delegates geometry, brief/HLD — and capture what must survive the image model: artifact type and scale, major subassemblies, actuation style, visible mechanisms, material and color cues.
+Only for artifacts already concrete enough to visualize (a specific `.forge.js` model, build brief, or HLD); route vague briefs to `forgecad-spec-by-walking-through-it` first. Read minimum context — entry `.forge.js`, one key helper if it delegates geometry, brief/HLD — and capture what must survive the image model: artifact type and scale, major subassemblies, actuation style, visible mechanisms, material and color cues.
 
 ### Core Rule
 

package/dist-skill/website/skills/forgecad.md

@@ -1,4 +1,4 @@
-<!-- Generated by scripts/build-forgecad-skill.mjs — do not edit. Edit docs/permanent/ instead. -->
+<!-- Generated by scripts/build-forgecad-skill.mjs — do not edit. Edit docs/skill/ instead. -->
 
 # forgecad
 
@@ -7,7 +7,7 @@ ForgeCAD model authoring, editing, debugging, and execution guidance for .forge.
 | Field | Value |
 | --- | --- |
 | Installed by | `forgecad skill install` |
-| Source | Generated from `docs/permanent/` by `scripts/build-forgecad-skill.mjs` |
+| Source | Generated from `docs/skill/` by `scripts/build-forgecad-skill.mjs` |
 
 ---
 
@@ -18,9 +18,9 @@ Author or modify ForgeCAD models, sketches, assemblies, and CLI workflows. Prefe
 ### Workflow
 
 1. Identify the artifact: `.forge.js`, SVG asset, or CLI/export task.
-2. **If the model has any moving parts, load the `assembly` group and `docs/permanent/guides/joint-design.md` upfront** — do not defer the kinematic structure to a refactor pass.
+2. **If the model has any moving parts, load the `assembly` group and `docs/skill/guides/joint-design.md` upfront** — do not defer the kinematic structure to a refactor pass.
 3. Load only the docs the task needs (see Source Map below). Start from the top group, add others as needed, and prefer these docs and recipes over ad-hoc repo examples.
-4. If any two parts are intended to touch or mate in the final model, load `docs/permanent/guides/positioning.md` immediately and default to connectors + `matchTo()`.
+4. If any two parts are intended to touch or mate in the final model, load `docs/skill/guides/positioning.md` immediately and default to connectors + `matchTo()`.
 5. Default to a concrete first pass — easy iteration beats speculative design review.
 6. If an existing model is broken, replace the weak structure rather than preserving bad architecture.
 7. Validate with `forgecad run <file>` (add `--debug-imports` for import chain issues; pass `--backend manifold|occt|truck` when the backend matters).
@@ -46,77 +46,77 @@ Load groups top-to-bottom, stopping when you have what the task needs.
 
 Execution model, colors, coordinate system, primitives, booleans, patterns, imports, parameters, topology, edge queries.
 
-- `docs/permanent/API/core/concepts.md`
-- `docs/permanent/generated/runtime-names.md`
-- `docs/permanent/generated/core.md`
+- `docs/skill/API/core/concepts.md`
+- `docs/skill/generated/runtime-names.md`
+- `docs/skill/generated/core.md`
 
 #### 2. Static Assembly and Positioning (for any multi-part model)
 
 Axis conventions, winding rules, and placement strategy. If parts should touch in the final model, read this group before writing placement code. Connectors + `matchTo()` are the default for mating interfaces; raw `translate()` and `rotate()` are for free offsets, not assembly contracts.
 
-- `docs/permanent/guides/coordinate-system.md`
-- `docs/permanent/guides/positioning.md`
+- `docs/skill/guides/coordinate-system.md`
+- `docs/skill/guides/positioning.md`
 
 #### 3. Sketch APIs
 
 2D construction, transforms, booleans, paths, on-face sketching, extrusion, anchors, text, regions.
 
-- `docs/permanent/generated/sketch.md`
+- `docs/skill/generated/sketch.md`
 
 #### 4. Curves and Surfacing (for lofts, sweeps, splines)
 
 Smooth curves, Hermite splines, lofted and swept solids. For straps, inlays, guards, brace members, vents, or physical bands that live on a carrier surface, use `Carrier` + `SurfaceBody` surface-member primitives before reaching for `variableSweep`, SDF sculpting, or manual boolean overlap recipes.
 
-- `docs/permanent/guides/surface-members.md`
-- `docs/permanent/generated/curves.md`
+- `docs/skill/guides/surface-members.md`
+- `docs/skill/generated/curves.md`
 
 #### 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.
 
-- `docs/permanent/generated/assembly.md`
+- `docs/skill/generated/assembly.md`
 
 #### 6. Sheet Metal (for bent parts, K-factor, flat patterns)
 
 Bend operations, flat pattern unfolding, K-factor configuration.
 
-- `docs/permanent/generated/sheet-metal.md`
+- `docs/skill/generated/sheet-metal.md`
 
 #### 7. Output and Export (for STL/3MF/STEP, BOM, dimensions)
 
 Mesh export, exact geometry export, bill of materials, dimension annotations.
 
-- `docs/permanent/generated/output.md`
+- `docs/skill/generated/output.md`
 
 #### 8. Toolbox (fasteners and standard parts)
 
 Parametric bolts, nuts, washers, standard hardware, gears, pipes, and structural profiles.
 
-- `docs/permanent/generated/lib.md`
-- `docs/permanent/generated/wood.md`
+- `docs/skill/generated/lib.md`
+- `docs/skill/generated/wood.md`
 
 #### 9. Runtime Viewport APIs (for cut planes, exploded views, hiding, and animation playback)
 
 Viewer-only APIs such as cutPlane, explodeView, render labels, comparison references, and runtime display behavior.
 
-- `docs/permanent/generated/viewport.md`
+- `docs/skill/generated/viewport.md`
 
 #### 10. Recipes and Debugging (for patterns and troubleshooting)
 
 Modeling patterns, debugging tactics, copyable snippets.
 
-- `docs/permanent/guides/scene-presentation.md`
-- `docs/permanent/guides/joint-design.md`
+- `docs/skill/guides/scene-presentation.md`
+- `docs/skill/guides/joint-design.md`
 
 #### 11. CLI (for validation/render/export tasks)
 
 Test-run, export pipelines, debug flags.
 
-- `docs/permanent/CLI.md`
-- `docs/permanent/guides/inspection-bundles.md`
+- `docs/skill/CLI.md`
+- `docs/skill/guides/inspection-bundles.md`
 
 #### SDF Modeling (smooth booleans, TPMS, deformations, fromFunction)
 
 Primitives, smooth booleans, TPMS lattices, twist/bend/displace, morph, custom functions, gotchas. The doc preamble's precision caution applies to every SDF workflow.
 
-- `docs/permanent/generated/sdf.md`
+- `docs/skill/generated/sdf.md`

package/dist-skill/website/skills/index.md

@@ -14,13 +14,12 @@ forgecad skill install
 | [forgecad-3d-reconstruction](/docs/skills/forgecad-3d-reconstruction) | `forgecad skill install` | Reconstruct a parametric ForgeCAD model from an existing 3D CAD or mesh file such as STL, OBJ, 3MF, STEP, or STP; inspect the source asset directly, author real ForgeCAD geometry, and iteratively compare the candidate with `forgecad compare 3d`. |
 | [forgecad-blockout-model](/docs/skills/forgecad-blockout-model) | `forgecad skill install` | Create rough high-level ForgeCAD concept models from simple primitives to explore layout, proportions, motion, and part relationships without production detail. Use when asked for a quick model sketch, blockout, spatial mockup, or intuitive low-detail 3D concept. |
 | [forgecad-component-model](/docs/skills/forgecad-component-model) | `forgecad skill install` | Enforce the ForgeCAD Component Model when building multi-part assemblies. Parts build at origin, connectors position them, data flows down from parent. Use when building or reviewing any multi-file ForgeCAD project. |
-| [forgecad-high-level-spec](/docs/skills/forgecad-high-level-spec) | `forgecad skill install` | Write a high-level design document (HLD) for a model, mechanism, or assembly before detailed specification or coding. Use when starting a new design, rethinking an existing one, or when the user asks to spec out, plan, or think through a model at a high level. Works backwards from requirements — defines the problem, explores alternatives, records decisions. Produces a right-sized design document for review and iteration. |
 | [forgecad-image-replicator](/docs/skills/forgecad-image-replicator) | `forgecad skill install` | Build real ForgeCAD geometry from one or more reference images by treating images as evidence, inferring the object, then validating against both reference-matched and canonical views. |
-| [forgecad-lld](/docs/skills/forgecad-lld) | `forgecad skill install` | Write a Low-Level Design (LLD) for a CAD model — exact dimensions, constraints, parameters, and verification criteria. Use after a High-Level Design (HLD) exists and decisions are locked, or for simple parts that don't need an HLD. The detailed design document that code implements. |
 | [forgecad-make-a-model](/docs/skills/forgecad-make-a-model) | `forgecad skill install` | Create manufacture-realistic prototype ForgeCAD (.forge.js) models in the active CAD project. Handles file placement, invokes the forgecad skill for API guidance, and validates the result. |
 | [forgecad-model-grader](/docs/skills/forgecad-model-grader) | `forgecad skill install` | Analyze, verify, and grade ForgeCAD or CAD-as-code models against a user requirement, design brief, prompt, reference, or acceptance criteria. Use when asked to evaluate, judge, QA, benchmark, score, rate, or compare a CAD model; render it from multiple angles, run targeted inspections when needed, visually verify the evidence, and produce a 0-10 score with concise justification. |
-| [forgecad-prepare-prompt](/docs/skills/forgecad-prepare-prompt) | `forgecad skill install` | Turn a fuzzy physical product, mechanism, or CAD artifact request into a concrete manufacture-realistic prototype ForgeCAD build brief and a single master prompt for the modeling pass. Use when the engineering brief is incomplete, manufacturing/process choice is underspecified, or the work needs a specific operating story to avoid generic toy solutions. |
+| [forgecad-mujoco-verify](/docs/skills/forgecad-mujoco-verify) | `forgecad skill install` | 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-project](/docs/skills/forgecad-project) | `forgecad skill install` | ForgeCAD project CLI workflow — creating, managing, syncing projects and files on forgecad.io. Covers init, push, pull, file operations, member management, publishing, and sharing. |
 | [forgecad-reconstruction-benchmark](/docs/skills/forgecad-reconstruction-benchmark) | `forgecad skill install` | Solve ForgeCAD CAD reconstruction benchmark or RL episodes in a prepared workspace by rebuilding a visible reference asset as readable parametric ForgeCAD in the fixed submission path, using visual and geometric self-checks while respecting sandbox limits. |
 | [forgecad-render-inspect](/docs/skills/forgecad-render-inspect) | `forgecad skill install` | Run and interpret ForgeCAD inspection bundles for model verification. Use when asked to inspect a ForgeCAD model, analyze an inspection bundle, validate collisions, wall thickness, connectivity, floating bodies, sections, masks, depth, normals, or Zebra stripes. |
+| [forgecad-spec-by-walking-through-it](/docs/skills/forgecad-spec-by-walking-through-it) | `forgecad skill install` | Design a ForgeCAD model, mechanism, or assembly by fixing WHAT before HOW in a git-reviewed design document, validated by mentally operating the thing step by step. Covers fuzzy-request intake and process choice, high-level design (HLD), and low-level design (LLD). Use on "spec this out", "plan the design", "write the HLD/LLD", a vague build request that needs concrete decisions, or any moment the right move is a reviewable spec before code. |
 | [forgecad-visual-spec](/docs/skills/forgecad-visual-spec) | `forgecad skill install` | Turn a concrete ForgeCAD artifact, build brief, HLD, or existing model into builder-honest image prompts for AI image models. Use when the user wants visual-spec renders that show the final product while keeping mechanisms, seams, hardware, and build cues visible instead of drifting into concept art. |

package/examples/analysis/clearance-fit.forge.js

@@ -0,0 +1,31 @@
+/**
+ * Shaft-in-bushing clearance fit — a tolerance stack-up closed-loop demo.
+ *
+ * The diametral clearance must land in [0.10, 0.50] mm. With the default
+ * (loose) manufacturing ranges the clearance varies too much to hold that spec,
+ * so the stack-up reports a low Cpk and names the dominant dimension:
+ *
+ *   1. forgecad sim tolerance examples/analysis/clearance-fit.forge.js --json
+ *        → Cpk(Clearance) well below 1.33, yield ~84%, contributions split
+ *          between BoreDia and ShaftDia.
+ *   2. Act on the feedback — tighten both bores:
+ *        forgecad sim tolerance examples/analysis/clearance-fit.forge.js \
+ *          --tol BoreDia=±0.05 --tol ShaftDia=±0.05 --json
+ *        → Cpk comfortably above 1.33, exit 0.
+ *
+ * The response is an ordinary verify.inRange call and the inputs are ordinary
+ * params — no special tolerance API is needed.
+ */
+
+const BoreDia = Param.number('BoreDia', 10.0, { min: 9.7, max: 10.3, unit: 'mm' });
+const ShaftDia = Param.number('ShaftDia', 9.7, { min: 9.4, max: 10.0, unit: 'mm' });
+
+// Diametral clearance is the measured response; its spec limits come from this call.
+const clearance = BoreDia - ShaftDia;
+verify.inRange('Clearance', clearance, 0.1, 0.5);
+
+const length = 20;
+const bushing = difference(cylinder(length, BoreDia / 2 + 3), cylinder(length, BoreDia / 2));
+const shaft = cylinder(length + 5, ShaftDia / 2).translate(0, 0, -2.5);
+
+return union(bushing, shaft);

package/examples/analysis/lever-arm-actuator.forge.js

@@ -0,0 +1,43 @@
+/**
+ * Lever-arm actuator — a mechanism torque-budget closed-loop demo.
+ *
+ * A 1 kg arm extends horizontally from a revolute shoulder driven by a motor
+ * rated at 4 N·m. The gravity-hold torque is m·g·r, so a longer arm needs more
+ * torque to simply hold position:
+ *
+ *   1. forgecad sim mechanism examples/analysis/lever-arm-actuator.forge.js --json
+ *        → holdTorqueNm.shoulder ≈ 1.47 N·m (1 kg · g · 0.15 m), ~63% budget margin.
+ *   2. Stretch the arm past the motor's reach:
+ *        forgecad sim mechanism examples/analysis/lever-arm-actuator.forge.js \
+ *          --param ArmLength=900 --json
+ *        → ≈ 4.41 N·m needed, MECHANISM.HOLD.OVER_BUDGET — the 4 N·m motor can't hold it.
+ */
+
+const ArmLength = Param.number('ArmLength', 300, { min: 100, max: 1000, unit: 'mm' });
+
+const base = box(40, 40, 30)
+  .translate(0, 0, 15)
+  .withConnectors({
+    pivot: connector({ origin: [0, 0, 30], axis: [0, 1, 0], up: [1, 0, 0], kind: 'revolute' }),
+  });
+
+// A horizontal bar from the pivot (x=0) out to +X; its center of mass sits at ArmLength/2.
+const arm = box(ArmLength, 20, 20)
+  .translate(ArmLength / 2, 0, 0)
+  .withConnectors({
+    pivot: connector({ origin: [0, 0, 0], axis: [0, 1, 0], up: [1, 0, 0], kind: 'revolute' }),
+  });
+
+const mechanism = assembly('Lever Arm Actuator')
+  .addPart('Base', base, { sim: Sim.body({ massKg: 2.0, collider: Sim.collider.boundingBox() }) })
+  .addPart('Arm', arm, { sim: Sim.body({ massKg: 1.0, collider: Sim.collider.boundingBox() }) })
+  .connect('Base.pivot', 'Arm.pivot', {
+    as: 'shoulder',
+    type: 'revolute',
+    min: -90,
+    max: 90,
+    drive: Sim.drive.velocity({ maxTorqueNm: 4, maxSpeedRpm: 30 }),
+  })
+  .withSimulation({ rootPart: 'Base', profile: Sim.profile.robotBodyRunnable() });
+
+return mechanism;

package/examples/analysis/tipping-tripod.forge.js

@@ -0,0 +1,35 @@
+/**
+ * Tipping tripod head — a closed-loop stability demo.
+ *
+ * A heavy camera head sits on a mast, offset in +X over a square base. With the
+ * default base the center of mass projects just outside the support footprint,
+ * so the rig tips over. This is the model→simulate→feedback→optimize loop:
+ *
+ *   1. forgecad check stability examples/analysis/tipping-tripod.forge.js --json
+ *        → STABILITY.TIPS_OVER, tipOverMarginMm ≈ -3, and a comShiftToTargetMm
+ *          hint pointing in −X (move mass inboard / widen the base).
+ *   2. Act on the feedback — widen the base:
+ *        forgecad check stability examples/analysis/tipping-tripod.forge.js \
+ *          --param BaseSpreadMm=90 --json
+ *        → stable, positive margin.
+ *
+ * forgecad sim mass on the same model reports volume, mass, center of mass, and
+ * the inertia tensor (pass --density for a real material).
+ */
+
+const BaseSpreadMm = Param.number('BaseSpreadMm', 50, { min: 20, max: 200, unit: 'mm' });
+const HeadOffsetMm = Param.number('HeadOffsetMm', 70, { min: 0, max: 150, unit: 'mm' });
+
+const baseThickness = 10;
+const mastHeight = 140;
+
+// Square base, footprint ±BaseSpreadMm in X and Y, resting on Z=0.
+const base = box(BaseSpreadMm * 2, BaseSpreadMm * 2, baseThickness);
+
+// Slim mast carrying the head, offset in +X.
+const mast = cylinder(mastHeight, 8).translate(HeadOffsetMm, 0, baseThickness);
+
+// Heavy camera head high up and offset — this dominates the center of mass.
+const head = box(80, 60, 60).translate(HeadOffsetMm, 0, baseThickness + mastHeight);
+
+return union(base, mast, head);

package/examples/api/gyroid-voronoi-blend.forge.js

@@ -1,5 +1,5 @@
 // Gyroid-diamond blend — shader-compatible TPMS fields combined in one form.
-// Return the raw SDF for fast native preview; use toShape(...) when exporting.
+// Return the SDF directly for implicit preview data; use toShape(...) for export tuning.
 
 const bounds = sdf.sphere(22);
 const gyroid = sdf.gyroid({ cellSize: 10, thickness: 1.0 });

package/examples/api/organic-noise-sculpture.forge.js

@@ -1,5 +1,5 @@
 // Organic noise sculpture — natural, coral-like form
-// Noise is still materialized because native preview does not raymarch it yet.
+// Explicit meshing keeps the noisy field on the ordinary mesh preview/export path.
 
 const shell = sdf.sphere(20).shell(4);
 const texture = sdf.noise({ scale: 0.15, amplitude: 3, octaves: 3 });

package/examples/api/sdf-circular-array-knurling.forge.js

@@ -16,4 +16,4 @@ const leftHandGroove = sdf.box(2.4, 1.2, 48)
 return body
   .subtract(rightHandGroove, leftHandGroove)
   .color('#8da2ad')
-  .material({ roughness: 0.38, metalness: 0.18 });
+  .material({ roughness: 0.38, metalness: 0.18 }).toShape({edgeLength: 0.2});

package/examples/api/{sdf-custom-raymarch.forge.js → sdf-custom-field-mesh-preview.forge.js}

@@ -1,8 +1,7 @@
-// Custom SDF native preview — one user-authored expression drives CPU sampling
-// and, when shader-safe, native raymarch preview.
+// Custom SDF implicit preview — one user-authored expression drives the field.
 //
-// This returns a raw SdfShape. Do not call .toShape() here; keeping it implicit
-// proves the custom function can preview through the raymarch shader.
+// Returning SdfShape directly keeps the field implicit. Call .toShape(...) when
+// you need explicit mesh quality for CAD operations or export.
 
 const rippledSphere = sdf.fromFunction(
   (x, y, z, radius, frequency, amplitude) =>

package/examples/api/sdf-materialize-tree.forge.js

@@ -1,4 +1,4 @@
-// Materialize a raw SDF tree when you need mesh-backed CAD/export behavior.
+// Return a plain SDF tree; scene mapping keeps SDF leaves implicit.
 
 const insert = {
   shell: sdf.sphere(18)
@@ -9,4 +9,4 @@ const insert = {
     .color('#ffcf5a'),
 };
 
-return insert;
+return insert;

package/examples/api/sdf-plain-return.forge.js

@@ -1,6 +1,7 @@
-// Plain raw SDF return: no Shape, no .toShape(), no Sculpt facade.
+// Plain SDF return: no explicit Shape, no .toShape(), no Sculpt facade.
 //
-// This should render directly in Studio and the CLI.
+// Direct returns stay as implicit SDF preview data; call .toShape() when you
+// need a mesh-backed Shape for CAD operations or export.
 
 scene(Sculpt.look('soft-studio'));
 

package/examples/api/sdf-shapes.forge.js

@@ -1,6 +1,6 @@
-// SDF native preview — raw SDF leaves render directly by raymarching.
+// SDF implicit preview — SDF leaves stay lazy until .toShape(...).
 //
-// Use .toShape() only when you need mesh-backed CAD operations or export.
+// Use .toShape(...) when you need explicit meshing controls, CAD operations, or export.
 
 const smoothBlob = sdf.smoothUnion(
   sdf.sphere(12),

package/examples/api/sdf-surface-basket-weave.forge.js

@@ -1,5 +1,5 @@
-// Native SDF surface relief — user-composed Pattern2D IR lowers to shader + CPU.
-// These raw SDF leaves raymarch directly; call .toShape() only for export.
+// Native SDF surface relief — user-composed Pattern2D IR lowers to CPU sampling.
+// Direct SDF returns stay implicit; call .toShape(...) for mesh-backed export.
 
 scene({
   background: { top: '#f6fbff', bottom: '#dfe9f3' },

package/examples/generative/twisted-lattice-tower.forge.js

@@ -1,4 +1,4 @@
-// Twisted lattice tower — gyroid field raymarched directly in the viewport.
+// Twisted lattice tower — direct SDF return materializes as a mesh-backed preview.
 
 const column = sdf.cylinder(54, 13);
 

package/examples/generative/voronoi-lampshade.forge.js

@@ -1,5 +1,5 @@
 // Voronoi lampshade — organic cell-wall dome, open at the bottom.
-// Voronoi is still materialized because native preview does not raymarch it yet.
+// Explicit meshing keeps this dense field on the ordinary mesh preview/export path.
 
 const dome = sdf.sphere(30)
   .subtract(sdf.sphere(27))

package/examples/products/sportscar.forge.js

@@ -0,0 +1,77 @@
+// Sports-car body — a showcase of class-A curve-network surfacing (Surface.Net).
+// Two Gordon surfaces compose the car: a near-closed lower body with fender
+// bulges, and an inset fastback greenhouse. Each is thickened to a glassy shell
+// (analytic vertex normals that survive the boolean wheel-arch cuts), then the
+// tyres are tucked into the arches.
+
+// Normalized body cross-section outline (right side, bottom edge -> deck centre).
+// y is a fraction of the half-width, z a fraction of floor..deck height.
+const BODY_OUTLINE = [
+  [0.12, 0.00], [0.60, 0.01], [0.95, 0.10], [1.00, 0.32],
+  [0.99, 0.55], [0.90, 0.78], [0.62, 0.93], [0.00, 1.00],
+];
+
+// Wrap the outline into a full closed-ish section (right bottom -> deck -> left
+// bottom), open only along a narrow underbody seam, so the thickened shell reads
+// as a solid body.
+function bodySection(halfW, floorZ, topZ) {
+  const cols = [];
+  for (let i = 0; i < BODY_OUTLINE.length; i++) {
+    const [yf, zf] = BODY_OUTLINE[i];
+    cols.push([yf * halfW, floorZ + zf * (topZ - floorZ)]);
+  }
+  for (let i = BODY_OUTLINE.length - 2; i >= 0; i--) {
+    const [yf, zf] = BODY_OUTLINE[i];
+    cols.push([-yf * halfW, floorZ + zf * (topZ - floorZ)]);
+  }
+  return cols; // [y, z] columns, right-bottom -> deck -> left-bottom
+}
+
+// A simpler open arch (rocker/deck edge -> spine -> other edge) for the cabin dome.
+function archSection(halfW, baseZ, topZ) {
+  const half = 7;
+  const cols = 2 * half - 1;
+  const out = [];
+  for (let c = 0; c < cols; c++) {
+    const s = c / (cols - 1);
+    const f = 1 - Math.abs(2 * s - 1);
+    const ease = f * f * (3 - 2 * f);
+    out.push([Math.sign(0.5 - s) * halfW * Math.pow(1 - f, 0.8), baseZ + (topZ - baseZ) * ease]);
+  }
+  return out;
+}
+
+// Assemble a cage from per-station section columns.
+function cageFrom(xs, sectionAt) {
+  return xs.map((x, i) => sectionAt(i).map(([y, z]) => [x, y, z]));
+}
+
+// ── Lower body: long & wide, fender bulges over the wheels, low deck ──────────
+const bodyX   = [0,   400, 950, 1500, 2100, 2700, 3250, 3800, 4200];
+const deckZ   = [420, 600, 690, 705,  710,  715,  730,  700,  560];
+const floorZ  = [300, 180, 150, 150,  155,  160,  165,  240,  380];
+const fenderW = [300, 620, 880, 760,  780,  760,  890,  760,  380];
+const body0 = Surface.Net().cage(cageFrom(bodyX, (i) => bodySection(fenderW[i], floorZ[i], deckZ[i]))).degree(3, 3);
+let body = body0.thicken(10).color('#c01622');
+
+// ── Greenhouse / cabin: long, low fastback set back on the deck ───────────────
+const ghX    = [1480, 1950, 2420, 2900, 3450];
+const ghBase = [700,  706,  710,  714,  724];
+const ghRoof = [725,  915,  975,  930,  745]; // windshield -> roof -> long backlight
+const ghW    = [560,  610,  580,  500,  330];
+const cabin = Surface.Net().cage(cageFrom(ghX, (i) => archSection(ghW[i], ghBase[i], ghRoof[i]))).degree(3, 3);
+body = union(body, cabin.thicken(10));
+body = body.color('#c01622').material({ metalness: 0.55, roughness: 0.28, clearcoat: 1 });
+
+// ── Wheel arches + tyres (tucked under the fenders) ──────────────────────────
+const wheelR = 360;
+const archZ = 360; // wheel centre height -> bottom near the ground, top inside the fender
+const axleX = [1000, 3250];
+for (const x of axleX) body = body.subtract(cylinder(2 * 980, wheelR + 30).rotateX(90).translate(x, 980, archZ));
+
+const tyre = (x, side) =>
+  cylinder(240, wheelR).rotateX(90).translate(x, side * 740, archZ).color('#141414').material({ roughness: 0.85 });
+const wheels = [];
+for (const x of axleX) for (const side of [1, -1]) wheels.push(tyre(x, side));
+
+export default group(body, ...wheels);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgecad",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "Code-first parametric CAD for JavaScript/TypeScript, in the browser and CLI.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://forgecad.io",
@@ -204,7 +204,6 @@
     "@fastify/static": "^9.0.0",
     "@fontsource/inter": "^5.2.8",
     "@oclif/core": "^4.11.3",
-    "@react-three/postprocessing": "^3.0.4",
     "argon2": "^0.44.0",
     "chokidar": "^4.0.0",
     "clipper-lib": "^6.4.2",
@@ -213,7 +212,7 @@
     "gifenc": "^1.0.3",
     "jsonwebtoken": "^9.0.3",
     "lz-string": "^1.5.0",
-    "manifold-3d": "^3.4.0",
+    "manifold-3d": "^3.5.1",
     "meshoptimizer": "^1.0.1",
     "mp4-muxer": "^5.2.1",
     "nanoid": "^5.1.7",
@@ -224,7 +223,6 @@
     "pngjs": "^7.0.0",
     "polygon-clipping": "^0.15.7",
     "postgres": "^3.4.8",
-    "postprocessing": "^6.39.0",
     "prom-client": "^15.1.3",
     "puppeteer-core": "^24.37.2",
     "react-router-dom": "^7.13.2",