forgecad 0.10.5 → 0.11.0

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

@@ -13,12 +13,12 @@ Manage hosted ForgeCAD project sync from the CLI: init, clone, pull, push, file
 
 ## Project Sync
 
-forgecad.io is the hosted ForgeCAD platform; a project is a local folder linked to the server by `forgecad.json`. The full command inventory (project, file, member, share, token commands and flags) lives in `forgecad project --help` and the forgecad skill's `docs/CLI.md` — do not relearn it here.
+forgecad.io is the hosted ForgeCAD platform; a project is a local folder marked by `forgecad.json`, and linked to the server after its first push. The full command inventory (project, file, member, share, token commands and flags) lives in `forgecad project --help` and the forgecad skill's `docs/CLI.md` — do not relearn it here.
 
 - **One studio process.** Run a single long-running `forgecad studio <folder> [<folder> ...]` naming every active project folder. The user opens the one printed localhost port once; create and edit files only under those folders so the browser live-updates. Never spawn extra servers per project.
 - **studio vs dev.** `forgecad studio` is for users and agents; `forgecad dev` is only for developing ForgeCAD itself.
-- **Login only for hosted commands.** `forgecad login` before any `project`/`publish` command; local work (run, render, studio) needs no auth.
-- **init creates, push syncs.** `project init "Name"` creates the remote project, writes `forgecad.json`, and pushes existing local files. `push` only syncs an already-initialized project. `clone <slug>` is the inverse: remote → new local folder.
+- **Login only for hosted commands.** `project init` plus local work (run, render, studio) need no auth. Run `forgecad login` before hosted sync/admin commands such as `project push`, `project pull`, `project file *`, members, shares, and `publish`.
+- **init is local, push creates remote.** `project init "Name"` writes local project metadata to `forgecad.json` without contacting the server. The first `project push` creates the hosted project if `forgecad.json` has no project ID yet, uploads existing local files, and records server file IDs. Later pushes sync the already-linked project. `clone <slug>` is the inverse: remote → new local folder.
 - **Sync is content-hash based.** `status`/`push`/`pull` compare file content hashes — no timestamps, no git; a file is "modified" purely by content difference. Loop: edit → `project status` → `project push`.
 - **Sync vs single-file ops.** Use `status`/`pull`/`push` for normal sync; use `project file <read|save|delete|...>` only for one hosted-file operation without a full push/pull cycle.
 - **Project context required.** All `project file *` and `publish` commands must run inside a folder containing `forgecad.json`.

package/dist-skill/website/skills/forgecad-reconstruct-cad-file.md

@@ -15,7 +15,7 @@ Reconstruct a readable parametric ForgeCAD model from an existing CAD or mesh fi
 
 The reference asset is evidence, not the deliverable. The deliverable is a readable, parametric `.forge.js` model that runs, renders, and scores well against the source. Never return `Import.mesh()`/`Import.step()` of the source as the final model unless the user explicitly asks for an import wrapper — imports are for measurement, rendering, and scoring only.
 
-Routing: user wants to KEEP the file as a live component and design around it (bracket, enclosure, mating assembly) → `forgecad-build-model` (Imported Parts section), not this skill; prepared benchmark/RL episodes → use the task-local benchmark instructions, not the public skill library; inspection-bundle interpretation → `forgecad-inspect-model`; independent grading after reconstruction → `forgecad-grade-model`; API and command reference → `forgecad` skill + CLI.md.
+Routing: user wants to KEEP the file as a live component and design around it (bracket, enclosure, mating assembly) → `forgecad-build-model`, not this skill; prepared benchmark/RL episodes → use the task-local benchmark instructions, not the public skill library; inspection-bundle interpretation → `forgecad-build-model/references/inspection-feedback.md`; readiness review → `forgecad-build-model/references/readiness-review.md`; API and command reference → `forgecad` skill + CLI.md.
 
 ### Workflow
 
@@ -50,7 +50,7 @@ Faceted sources: decide whether tessellation itself is evidence. Matching low-po
 
 ### Done Criteria
 
-The final model must run, render, re-compare at `--samples 5000`, and pass an `inspect compare overlay`. Add targeted inspects (`forgecad-inspect-model`) when the object is multi-part, hollow, thin-walled, or surface-sensitive. Report: source and candidate paths, score JSON path, final metrics, and every known mismatch classified as intentional simplification or remaining work.
+The final model must run, render, re-compare at `--samples 5000`, and pass an `inspect compare overlay`. Add targeted inspects using `forgecad-build-model`'s inspection feedback reference when the object is multi-part, hollow, thin-walled, or surface-sensitive. Report: source and candidate paths, score JSON path, final metrics, and every known mismatch classified as intentional simplification or remaining work.
 
 
 ## Bundled Files

package/dist-skill/website/skills/forgecad-reconstruct-from-images.md

@@ -18,9 +18,8 @@ The reference image is evidence, not the deliverable. The deliverable is a real
 ### Companion Skills
 
 - `forgecad` — API docs, model authoring, renderer behavior.
-- `forgecad-design-spec` — when the images underdetermine artifact family, process posture, scale, operating story, or validation boundary.
-- `forgecad-build-model` — file placement, project structure, decomposition, definition of done.
-- `forgecad-inspect-model` — pre-delivery inspection for multi-part, internal, mechanical, thin-wall, or fit-sensitive objects.
+- `forgecad-build-model` — design stages, file placement, project structure, decomposition, definition of done.
+- `forgecad-build-model/references/inspection-feedback.md` — pre-delivery inspection for multi-part, internal, mechanical, thin-wall, or fit-sensitive objects.
 
 ### Core Rule
 
@@ -30,13 +29,13 @@ 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-design-spec` 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. Follow `forgecad-build-model` design stages 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-build-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.
 7. Iterate one class of change at a time, in order: object hypothesis → major proportions → canonical geometry → camera → details → presentation. If improving one reference view makes another view or a canonical render worse, the object hypothesis is wrong — fix the model, not the camera illusion.
 8. Use every image as a constraint. Never pick one target image and ignore the rest: assign each image a camera, evidence list, and confidence; optimize one shared geometry against the whole set; state how distorted or decorative images were weighted.
-9. Validate the final object: `forgecad run`, reference comparison boards, canonical renders, and targeted inspections via `forgecad-inspect-model`.
+9. Validate the final object: `forgecad run`, reference comparison boards, canonical renders, and targeted inspections via `forgecad-build-model`'s inspection feedback reference.
 
 ### Comparison Boards
 

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

@@ -30,7 +30,8 @@ Author or modify ForgeCAD models, sketches, assemblies, and CLI workflows. Prefe
 
 #### Import and Composition
 
-- Always include the extension in relative imports: `require("./file.forge.js", { Param: value })` for model files, `require("./helpers.js")` for plain helper modules. Extensionless imports such as `require("./file")` do not resolve; ForgeCAD resolves project imports by exact path.
+- Always include the extension in relative imports: `require("./file.forge.js")` for model files, `require("./helpers.js")` for plain helper modules. Extensionless imports such as `require("./file")` do not resolve; ForgeCAD resolves project imports by exact path.
+- Reusable `.forge.js` part files should return builder functions such as `return { buildPart }`; direct-run preview params belong inside `if (require.main === module)`.
 - ForgeCAD APIs are injected globals in `.forge.js` files. Use `bom()`, `box()`, `scene()`, `Shape`, etc. directly; never destructure those names from helpers (`const { bom } = require("./bom.js")`). Import helper files under a project-specific name such as `const bomHelpers = require("./bom.js")`.
 - For static multi-part models, connectors + `matchTo()` are the default way to assemble touching parts.
 - Top-level scripts can return `Assembly` or `SolvedAssembly` directly. Do not call `.toGroup()` just to render an assembly; use it only when you need `ShapeGroup` composition, transforms, or named-child lookup.
@@ -48,6 +49,7 @@ Execution model, colors, coordinate system, primitives, booleans, patterns, impo
 
 - `docs/skill/API/core/concepts.md`
 - `docs/skill/generated/runtime-names.md`
+- `docs/skill/guides/manual-parameters.md`
 - `docs/skill/generated/core.md`
 
 #### 2. Static Assembly and Positioning (for any multi-part model)

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

@@ -11,12 +11,8 @@ forgecad skill install
 | Skill | Installed by | Purpose |
 | --- | --- | --- |
 | [forgecad](/docs/skills/forgecad) | `forgecad skill install` | ForgeCAD model authoring, editing, debugging, and execution guidance for .forge.js, SVG-import, assembly, and CLI workflows. Use when building or modifying ForgeCAD geometry, structuring multi-file projects, validating scripts, or using ForgeCAD export/render tooling. |
-| [forgecad-build-model](/docs/skills/forgecad-build-model) | `forgecad skill install` | Build or edit a manufacture-realistic `.forge.js` model in a project, then validate it with run, render, inspect, and export evidence. |
-| [forgecad-design-spec](/docs/skills/forgecad-design-spec) | `forgecad skill install` | Create a ForgeCAD design brief, HLD, or LLD before coding by walking through use, assembly, interfaces, decisions, and verification. |
-| [forgecad-grade-model](/docs/skills/forgecad-grade-model) | `forgecad skill install` | Grade a ForgeCAD or CAD-as-code model against a requirement, brief, prompt, reference, or acceptance criteria with evidence and a 0-10 score. |
+| [forgecad-build-model](/docs/skills/forgecad-build-model) | `forgecad skill install` | Build or edit `.forge.js` real product models through design, automatic/manual feedback gathering, inspection/simulation/FEA evidence, and iteration until ready. |
 | [forgecad-image-prompt](/docs/skills/forgecad-image-prompt) | `forgecad skill install` | Write builder-honest AI image prompts from a concrete ForgeCAD model, build brief, HLD, or LLD without hiding how the artifact is built. |
-| [forgecad-inspect-model](/docs/skills/forgecad-inspect-model) | `forgecad skill install` | Select, run, and interpret ForgeCAD inspection evidence for collisions, sections, wall thickness, components, masks, depth, normals, surface continuity, and fit. |
 | [forgecad-project-sync](/docs/skills/forgecad-project-sync) | `forgecad skill install` | Manage hosted ForgeCAD project sync from the CLI: init, clone, pull, push, file operations, members, publishing, and shares. |
 | [forgecad-reconstruct-cad-file](/docs/skills/forgecad-reconstruct-cad-file) | `forgecad skill install` | Reconstruct a readable parametric ForgeCAD model from an existing CAD or mesh file such as STL, OBJ, 3MF, STEP, or STP. |
 | [forgecad-reconstruct-from-images](/docs/skills/forgecad-reconstruct-from-images) | `forgecad skill install` | Reconstruct a real parametric ForgeCAD object from reference images by using images as evidence, not as a one-view facade. |
-| [forgecad-verify-mujoco](/docs/skills/forgecad-verify-mujoco) | `forgecad skill install` | Verify a ForgeCAD MJCF export in MuJoCo with dynamics, contacts, controls, joint travel, and rendered evidence before calling it simulation-ready. |

package/examples/api/param-path2d.forge.js

@@ -0,0 +1,65 @@
+// Editable 2D path parameters: closed outlines and open centerlines.
+
+scene({
+  camera: { position: [92, -150, 95], target: [4, 2, 6], fov: 35 },
+});
+
+const thickness = Param.number('Thickness', 5, { min: 2, max: 12, step: 0.5, unit: 'mm' });
+const cornerRadius = Param.number('Corner Radius', 4, { min: 0, max: 12, step: 0.5, unit: 'mm' });
+const railWidth = Param.number('Rail Width', 4, { min: 1, max: 10, step: 0.5, unit: 'mm' });
+
+const outline = Param.path2d(
+  'Bracket Outline',
+  [
+    [-44, -22],
+    [30, -22],
+    [44, -6],
+    [35, 24],
+    [4, 34],
+    [-34, 22],
+    [-52, 0],
+  ],
+  {
+    closed: true,
+    minPoints: 4,
+    maxPoints: 12,
+    unit: 'mm',
+    x: { min: -70, max: 70, step: 0.5 },
+    y: { min: -45, max: 45, step: 0.5 },
+    anchor: Param.anchor.sheetOnXY([0, 0, 10], { label: 'Bracket outline' }),
+  },
+);
+
+const rail = Param.path2d(
+  'Cable Rail Centerline',
+  [
+    [-34, -6],
+    [-10, 8],
+    [18, 10],
+    [34, -2],
+  ],
+  {
+    closed: false,
+    minPoints: 2,
+    maxPoints: 8,
+    unit: 'mm',
+    x: { min: -60, max: 60, step: 0.5 },
+    y: { min: -35, max: 35, step: 0.5 },
+    anchor: Param.anchor.sheetOnXY([0, 0, 14], { label: 'Cable rail centerline', color: '#3c8f83' }),
+  },
+);
+
+const plateSketch = outline
+  .toSketch()
+  .filletCorners(cornerRadius)
+  .subtract(circle2d(4).translate(-30, 0))
+  .subtract(circle2d(4).translate(22, 2));
+
+const plate = plateSketch.extrude(thickness).color('#68737c').material({ roughness: 0.4, metalness: 0.2 });
+const cableRail = rail.toStroke(railWidth, 'Round').extrude(1.6).translate(0, 0, thickness + 0.8).color('#3c8f83');
+
+verify.notEmpty('path2d outline creates a solid plate', plate);
+verify.notEmpty('path2d centerline creates a raised rail', cableRail);
+verify.boundingBoxSize('path2d bracket stays in expected scale', plate, [96, 56, 5], 18);
+
+return [plate, cableRail];

package/examples/api/param-placement2d.forge.js

@@ -0,0 +1,80 @@
+// Editable 2D placement sheets: named semantic blocks inside constrained zones.
+
+scene({
+  camera: { position: [116, -150, 104], target: [0, 0, 9], fov: 35 },
+});
+
+const FRAME_W = 126;
+const FRAME_D = 82;
+const FRAME_RADIUS = 7;
+const RIM_W = 5;
+const RIM_H = 6;
+const FLOOR_H = 2;
+const COMPONENT_H = 3;
+
+const layout = Param.placement2d('Internal Layout', {
+  frame: { size: [FRAME_W, FRAME_D] },
+  zones: [
+    { id: 'electronics', label: 'Electronics', size: [72, 70], center: [-24, 0] },
+    { id: 'service', label: 'Service', size: [42, 70], center: [38, 0] },
+  ],
+  items: [
+    { id: 'pcb', label: 'PCB', footprint: { type: 'rect', size: [48, 30] }, zone: 'electronics', at: [-28, 6] },
+    { id: 'battery', label: 'Battery', footprint: { type: 'rect', size: [38, 18] }, zone: 'electronics', at: [-22, -24], angle: 0 },
+    { id: 'speaker', label: 'Speaker', footprint: { type: 'circle', radius: 12 }, zone: 'service', at: [39, 18] },
+    { id: 'usb', label: 'USB', footprint: { type: 'rect', size: [18, 10] }, zone: 'service', at: [40, -24] },
+  ],
+  rules: { bounds: 'prevent', collisions: 'warn', snap: 1 },
+  unit: 'mm',
+  anchor: Param.anchor.sheetOnXY([0, 0, 14], { label: 'Internal layout', color: '#c77dff' }),
+});
+
+function placeRectItem(itemId, size, color) {
+  const item = layout.item(itemId);
+  return box(size[0], size[1], COMPONENT_H)
+    .rotateZ(item.angle)
+    .translate(item.x, item.y, FLOOR_H)
+    .color(color);
+}
+
+function placeRoundItem(itemId, radius, color) {
+  const item = layout.item(itemId);
+  return cylinder(COMPONENT_H, radius)
+    .translate(item.x, item.y, FLOOR_H)
+    .color(color);
+}
+
+const trayRim = roundedRect(FRAME_W + 2 * RIM_W, FRAME_D + 2 * RIM_W, FRAME_RADIUS + RIM_W)
+  .subtract(roundedRect(FRAME_W, FRAME_D, FRAME_RADIUS))
+  .extrude(RIM_H)
+  .color('#38414a');
+
+const floor = roundedRect(FRAME_W, FRAME_D, FRAME_RADIUS).extrude(FLOOR_H).color('#232a31');
+const pcb = placeRectItem('pcb', [48, 30], '#3f8f5c');
+const battery = placeRectItem('battery', [38, 18], '#5a6470');
+const usb = placeRectItem('usb', [18, 10], '#d69b45');
+const speaker = placeRoundItem('speaker', 12, '#4d93bf');
+const placedItems = [pcb, battery, usb, speaker];
+
+function sitsOnFloor(shape) {
+  return Math.abs(shape.boundingBox().min[2] - FLOOR_H) < 0.001;
+}
+
+function staysInsideFrame(shape) {
+  const bounds = shape.boundingBox();
+  return (
+    bounds.min[0] >= -FRAME_W / 2 &&
+    bounds.max[0] <= FRAME_W / 2 &&
+    bounds.min[1] >= -FRAME_D / 2 &&
+    bounds.max[1] <= FRAME_D / 2
+  );
+}
+
+verify.notEmpty('placement2d tray has rim', trayRim);
+verify.that('placement2d returns named placement data', () => layout.item('pcb').zone === 'electronics');
+verify.that('placement2d components share the floor plane', () => placedItems.every(sitsOnFloor));
+verify.that('placement2d components stay below the tray rim', () => placedItems.every((shape) => shape.boundingBox().max[2] <= RIM_H));
+verify.that('placement2d components stay inside the frame', () => placedItems.every(staysInsideFrame));
+verify.boundingBoxSize('placement2d layout stays in tray scale', union(trayRim, floor, pcb, battery, usb, speaker), [136, 92, 6], 0.5);
+
+return [trayRim, floor, pcb, battery, usb, speaker];

package/examples/api/param-spline2d-g-continuity.forge.js

@@ -0,0 +1,57 @@
+/**
+ * Editable 2D spline parameter with per-node G continuity selection.
+ *
+ * The smooth spine can be emitted as one smooth curve. The groove rail has
+ * a G0 node, so it is emitted as a joined sweep path that preserves the hard
+ * break while keeping neighboring spans smooth.
+ */
+
+scene({
+  camera: { position: [88, -142, 82], target: [32, 0, 8], fov: 36 },
+});
+
+const spine = Param.spline2d(
+  'Handle Spine',
+  [
+    { x: 0, y: 0, g: 'G2' },
+    { x: 24, y: 9, g: 'G2' },
+    { x: 58, y: 7, g: 'G2' },
+    { x: 92, y: -2, g: 'G1' },
+  ],
+  {
+    unit: 'mm',
+    degree: 3,
+    x: { min: -10, max: 110, step: 1 },
+    y: { min: -18, max: 22, step: 0.5 },
+    anchor: Param.anchor.sheetOnXZ([48, -28, 0], { label: 'Handle spine' }),
+  },
+);
+
+const groove = Param.spline2d(
+  'Index Groove Rail',
+  [
+    { x: 10, y: -12, g: 'G2' },
+    { x: 24, y: -4, g: 'G1' },
+    { x: 38, y: -11, g: 'G0' },
+    { x: 56, y: -2, g: 'G1' },
+    { x: 78, y: -8, g: 'G2' },
+  ],
+  {
+    unit: 'mm',
+    degree: 3,
+    x: { min: -10, max: 110, step: 1 },
+    y: { min: -18, max: 22, step: 0.5 },
+    anchor: Param.anchor.sheetOnXY([48, 0, 11], { label: 'Index groove rail', color: '#4d93bf' }),
+  },
+);
+
+const palmPad = roundedRect(108, 22, 11).extrude(4).translate(50, 0, -3).color('#2b3038');
+const raisedSpine = sweep(circle2d(2.2), spine.toCurveOnXZ(0), { samples: 56, up: [0, 0, 1] }).color('#e0a94b');
+const grooveBead = sweep(circle2d(0.9), groove.toPathOnXY(7, { samples: 18 }), { up: [0, 0, 1] }).color('#4d93bf');
+
+verify.notEmpty('spline2d smooth spine creates a raised sweep', raisedSpine);
+verify.notEmpty('spline2d G0 rail creates a groove bead sweep', grooveBead);
+verify.that('spline2d keeps per-point continuity metadata', () => groove.nodes()[2].g === 'G0');
+verify.boundingBoxSize('editable spline handle stays in expected scale', union(palmPad, raisedSpine, grooveBead), [112, 25, 27], 18);
+
+return [palmPad, raisedSpine, grooveBead];

package/examples/api/spoon-full-tang-handle.forge.js

@@ -25,35 +25,75 @@ scene({
 // ───────────────────────── 1. the v4 metal bowl ─────────────────────────
 const H = 5.5; // rim level
 const S = 5.0; // smooth-clamp knee
-const stations = [
-  { x: -92, hw: 0, lowZ: 5.0 },
-  { x: -90.5, hw: 12, lowZ: 2.0 },
-  { x: -88, hw: 17.5, lowZ: -0.5 },
-  { x: -82, hw: 22.5, lowZ: -4.0 },
-  { x: -67, hw: 28, lowZ: -8.5 },
-  { x: -48, hw: 32, lowZ: -10.2 }, // widest & deepest
-  { x: -28, hw: 29, lowZ: -8.4 },
-  { x: -6, hw: 13, lowZ: -2.0 },
-  { x: 12, hw: 8.4, lowZ: 2.5 },
-  { x: 24, hw: 7.1, lowZ: 4.0 }, // neck
-];
 
-function smoothField(key) {
-  const pts = Curve.Fit(stations.map((s) => [s.x, s[key], 0]), { tolerance: 0.0005 }).sample(600);
+const bowlHalfWidth = Param.spline2d(
+  'Bowl Half Width',
+  [
+    { x: -92, y: 0, g: 'G2' },
+    { x: -90.5, y: 12, g: 'G2' },
+    { x: -88, y: 17.5, g: 'G2' },
+    { x: -82, y: 22.5, g: 'G2' },
+    { x: -67, y: 28, g: 'G2' },
+    { x: -48, y: 32, g: 'G2' },
+    { x: -28, y: 29, g: 'G2' },
+    { x: -6, y: 13, g: 'G2' },
+    { x: 12, y: 8.4, g: 'G2' },
+    { x: 24, y: 7.1, g: 'G1' },
+  ],
+  {
+    unit: 'mm',
+    degree: 3,
+    minPoints: 6,
+    maxPoints: 16,
+    x: { min: -100, max: 30, step: 0.5 },
+    y: { min: 0, max: 38, step: 0.5 },
+    anchor: Param.anchor.sheetOnXY([-48, 0, H + 16], { label: 'Bowl width curve', color: '#5da9e9' }),
+  },
+);
+
+const bowlLowZ = Param.spline2d(
+  'Bowl Low Z',
+  [
+    { x: -92, y: 5.0, g: 'G2' },
+    { x: -90.5, y: 2.0, g: 'G2' },
+    { x: -88, y: -0.5, g: 'G2' },
+    { x: -82, y: -4.0, g: 'G2' },
+    { x: -67, y: -8.5, g: 'G2' },
+    { x: -48, y: -10.2, g: 'G2' },
+    { x: -28, y: -8.4, g: 'G2' },
+    { x: -6, y: -2.0, g: 'G2' },
+    { x: 12, y: 2.5, g: 'G2' },
+    { x: 24, y: 4.0, g: 'G1' },
+  ],
+  {
+    unit: 'mm',
+    degree: 3,
+    minPoints: 6,
+    maxPoints: 16,
+    x: { min: -100, max: 30, step: 0.5 },
+    y: { min: -13, max: 6, step: 0.25 },
+    anchor: Param.anchor.sheetOnXZ([-48, -44, 0], { label: 'Bowl depth curve', color: '#46b6a9' }),
+  },
+);
+
+function smoothField(curve) {
+  const pts = curve.toPathOnXY(0, { samples: 600 }).sort((a, b) => a[0] - b[0]);
   return (x) => {
     if (x <= pts[0][0]) return pts[0][1];
     if (x >= pts[pts.length - 1][0]) return pts[pts.length - 1][1];
     for (let i = 1; i < pts.length; i += 1) {
       if (x <= pts[i][0]) {
-        const t = (x - pts[i - 1][0]) / (pts[i][0] - pts[i - 1][0]);
+        const dx = pts[i][0] - pts[i - 1][0];
+        if (Math.abs(dx) < 1e-9) return pts[i][1];
+        const t = (x - pts[i - 1][0]) / dx;
         return pts[i - 1][1] + (pts[i][1] - pts[i - 1][1]) * t;
       }
     }
     return pts[pts.length - 1][1];
   };
 }
-const lowAt = smoothField('lowZ');
-const hwAt = smoothField('hw');
+const lowAt = smoothField(bowlLowZ);
+const hwAt = smoothField(bowlHalfWidth);
 
 function dishZ(x, y) {
   const hw = hwAt(x);

package/examples/api/surface-variable-thickness-panel.forge.js

@@ -0,0 +1,62 @@
+/**
+ * Variable-thickness surface panel.
+ *
+ * `Surface.Net()` builds the carrier sheet. `Thickness.grid()` defines a scalar
+ * UV wall field, so the panel can be thin at one edge, thicker through the load
+ * path, and locally reinforced near one corner without hand-offset geometry.
+ */
+
+scene({
+  background: { top: '#eef4f7', bottom: '#f9fbfd' },
+  camera: { position: [150, -190, 92], target: [0, 0, 8], fov: 34 },
+  environment: { preset: 'studio', intensity: 0.25, background: false },
+  ground: { visible: true, color: '#d6dde3', height: -5, receiveShadow: true },
+});
+
+const panelWidth = param('Panel Width', 128);
+const panelDepth = param('Panel Depth', 82);
+const crownHeight = param('Crown Height', 15);
+
+const uCount = 6;
+const vCount = 5;
+const panelCage = [];
+
+for (let i = 0; i <= uCount; i++) {
+  const u = i / uCount;
+  const x = (u - 0.5) * panelWidth;
+  const row = [];
+
+  for (let j = 0; j <= vCount; j++) {
+    const v = j / vCount;
+    const y = (v - 0.5) * panelDepth;
+    const xProfile = 1 - (2 * u - 1) ** 2;
+    const yProfile = 1 - 0.42 * (2 * v - 1) ** 2;
+    const diagonalBias = 2.8 * u * (1 - v);
+    row.push([x, y, crownHeight * xProfile * yProfile + diagonalBias]);
+  }
+
+  panelCage.push(row);
+}
+
+const panel = Surface.Net()
+  .cage(panelCage)
+  .degree(3, 3)
+  .thickenInsideBy(
+    Thickness.grid(
+      [
+        [1.1, 1.3, 1.5],
+        [1.8, 2.4, 2.9],
+        [2.8, 3.5, 4.2],
+      ],
+      { easing: 'easeInOut' },
+    ),
+    { resolution: 56 },
+  )
+  .color('#5c8fb5')
+  .material({ roughness: 0.62, metalness: 0.04, clearcoat: 0.12 });
+
+verify.notEmpty('Variable-thickness panel produces solid geometry', panel);
+verify.volumeApprox('Variable thickness stays in the expected volume range', panel, panelWidth * panelDepth * 2.55, 6000);
+verify.physicalComponentCount('Variable-thickness panel is one connected component', 1);
+
+return [{ name: 'Variable Thickness Panel', shape: panel }];

package/examples/mechanical/airplane-propeller.forge.js

@@ -16,6 +16,13 @@
 //
 //   Thickness:  24% at root (structural) → 6% at tip (aerodynamic)
 //   Camber:     4% at root → 1.5% at tip (Cl margin at low-speed root)
+//
+//   Skin:       The blade is lofted through the closed airfoil sections with
+//               Shape.fromSlices — an ordered slice loft that keeps a smooth
+//               section-to-section correspondence, so the blade reads class-A
+//               (no spanwise faceting) even on the default Manifold backend.
+//               Run with `--backend truck` (or occt) for an exact kernel-native
+//               NURBS solid — preferred for STEP export.
 
 // ─── Design Parameters ──────────────────────────────────────────
 const diameter    = Param.number("Diameter",       1900, { min: 1200, max: 2600, unit: "mm" });
@@ -171,49 +178,98 @@ function camberAt(rNorm) {
 //   - Zero pitch → chord along tangential (Y in world)
 //   - Positive β → leading edge tilts toward thrust axis (+Z)
 
-const NUM_STATIONS = 24;
-const NACA_PTS     = 40;      // points per airfoil surface (80 total outline)
+const NUM_STATIONS = 28;      // a few more stations than the old loft for a smoother span
+const NACA_PTS     = 48;      // points per airfoil surface (96 total outline)
 const CAMBER_POS   = 0.4;     // max camber at 40% chord (standard for props)
 const rRoot        = rHub * 0.55;  // blade shank starts inside the spinner
 
-// Airfoil section at a given normalized span position (clamped to the
-// aerodynamic range — the shank inside the spinner reuses the hub section).
-function bladeSection(rNorm, r) {
+// Airfoil section as a 2D point list (before it becomes a Sketch), already
+// rotated for twist. The buried shank can blend toward a fuller, rounder cuff:
+//   rNorm  — normalized span for the aerodynamic distributions
+//   r      — true radius (drives the BEMT twist)
+//   fatten — root-cuff blend 0..1: 0 = pure airfoil, 1 = fully rounded fat
+//            shank. Pulls each outline point toward an enclosing ellipse so the
+//            blade meets the spinner with a beefy, non-spindly junction instead
+//            of necking down to a thin stalk (the old root-quality defect).
+function bladeSectionPoints(rNorm, r, fatten) {
   const chord  = chordAt(rNorm);
   const thick  = thicknessRatioAt(rNorm);
   const camber = camberAt(rNorm);
   const twist  = twistAt(Math.max(r, rHub));
 
   let pts = nacaPoints(camber, CAMBER_POS, thick, chord, NACA_PTS);
-  pts = rotate2D(pts, 90 + twist);  // 90° aligns chord with tangential, +twist adds pitch
-  return polygon(pts);
+
+  if (fatten > 0) {
+    // Blend toward an enclosing ellipse centered at the quarter-chord origin —
+    // fills the thin airfoil into a fuller shank without changing the point
+    // count or ordering, so the loft keeps a clean ordered correspondence.
+    const exA = chord * 0.34;                                  // half-length along chord
+    const exB = Math.max(chord * thick * 0.62, chord * 0.16);  // half-thickness, floored fat
+    pts = pts.map(([x, y]) => {
+      const ang = Math.atan2(y, x);
+      const ex = exA * Math.cos(ang);
+      const ey = exB * Math.sin(ang);
+      return [x + (ex - x) * fatten, y + (ey - y) * fatten];
+    });
+  }
+
+  // 90° aligns chord with the tangential direction; +twist adds pitch.
+  return rotate2D(pts, 90 + twist);
 }
 
-const profiles = [];
-const heights  = [];
+function bladeSection(rNorm, r, fatten) {
+  return polygon(bladeSectionPoints(rNorm, r, fatten || 0));
+}
 
-// Shank stations buried inside the spinner — a constant hub section carries
-// the blade to a structural attachment instead of floating at the hub surface.
-for (const r of [rRoot, rHub * 0.92]) {
-  profiles.push(bladeSection(0, rHub));
-  heights.push(r);
+// Ordered station list: span coordinate (world X, radial in the disk) + the
+// closed airfoil section's points. Sections sit perpendicular to X, so the
+// blade extends radially with no post-loft rotation.
+const stationX = [];
+const stationPoints = [];
+
+// Two buried shank stations inside the spinner: the deepest is a fully round
+// cuff, the next blends back toward the airfoil so the aero blade grows
+// smoothly out of the shank instead of pinching at the hub.
+const shankStations = [
+  { x: rRoot,       fatten: 1.0  },
+  { x: rHub * 0.86, fatten: 0.55 },
+];
+for (const { x, fatten } of shankStations) {
+  stationX.push(x);
+  stationPoints.push(bladeSectionPoints(0, rHub, fatten));
 }
 
 // Aerodynamic stations from the hub surface to the tip. Cosine spacing
 // clusters stations at the root (where the BEMT twist gradient is steepest)
-// and at the tip (where the planform rounds off).
+// and at the tip (where the planform rounds off). A light residual cuff on the
+// first aero stations avoids a sudden chord/thickness step at the hub line.
 for (let i = 0; i <= NUM_STATIONS; i++) {
-  const rNorm = 0.5 - 0.5 * Math.cos(Math.PI * i / NUM_STATIONS);
-  const r     = rHub + rNorm * (R - rHub);
-  profiles.push(bladeSection(rNorm, r));
-  heights.push(r);
+  const rNorm  = 0.5 - 0.5 * Math.cos(Math.PI * i / NUM_STATIONS);
+  const r      = rHub + rNorm * (R - rHub);
+  const fatten = rNorm < 0.06 ? 0.25 * (1 - rNorm / 0.06) : 0;
+  stationX.push(r);
+  stationPoints.push(bladeSectionPoints(rNorm, r, fatten));
 }
 
-// Loft all profiles into a smooth blade solid
-const bladeRaw = loft(profiles, heights, { edgeLength: meshRes });
-
-// Rotate blade from Z-axis (span) to X-axis (radial in propeller disk)
-const blade = bladeRaw.rotateY(90);
+// Loft the closed sections into a smooth blade solid. Shape.fromSlices keeps an
+// ordered, smooth section-to-section correspondence (no SDF faceting). On the
+// default Manifold backend edgeLength tunes the mesh; the truck/occt kernel
+// ignores it and builds an exact NURBS solid.
+const blade = Shape.fromSlices(
+  stationX.map((x, i) => Shape.slicePerpendicularToX(x, polygon(stationPoints[i]))),
+  { edgeLength: meshRes },
+);
+
+// Blade-shaped cutouts through the spinner: the same ordered sections grown
+// ~5% for running clearance, lofted the same exact way so the cut tracks the
+// blade skin (keeping the span direction exact).
+const CLEARANCE = 1.05;
+const bladeCutout = Shape.fromSlices(
+  stationX.map((x, i) => Shape.slicePerpendicularToX(
+    x, polygon(stationPoints[i].map(([px, py]) => [px * CLEARANCE, py * CLEARANCE])),
+  )),
+  { edgeLength: meshRes },
+);
 
 // ─── Spinner / Hub ──────────────────────────────────────────────
 //
@@ -269,10 +325,7 @@ const hubBarrel = cylinder(spinnerLen * 0.5, rHub * 0.62)
 
 const bladeAssembly = union(allBlades, hubBarrel);
 
-// Blade-shaped cutouts through the spinner with a small running
-// clearance: the blade cross-section is grown in chord and thickness
-// (x/y before the radial rotation), keeping the span direction exact.
-const bladeCutout = bladeRaw.scale([1.04, 1.04, 1]).rotateY(90);
+// Pattern the blade-shaped cutouts (defined with the blade above) around the disk.
 const spinnerCutouts = circularPattern(bladeCutout, numBlades);
 
 // ─── Optional: Airfoil Section Visualization ────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgecad",
-  "version": "0.10.5",
+  "version": "0.11.0",
   "description": "Code-first parametric CAD for JavaScript/TypeScript, in the browser and CLI.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://forgecad.io",
@@ -115,7 +115,7 @@
     "dev:cli": "npm run build:solver:if-missing && npm run build:geometry:if-missing && tsup cli/forgecad.ts --format esm --platform node --target node20 --out-dir dist-cli --sourcemap --external typescript && node scripts/copy-cli-assets.mjs dist-cli",
     "build:cli": "npm run build:solver:if-missing && npm run build:geometry:if-missing && tsup cli/forgecad.ts --format esm --platform node --target node20 --out-dir dist-cli --clean --external typescript && node scripts/copy-cli-assets.mjs dist-cli",
     "build:native-occt": "node scripts/build-native-occt.mjs",
-    "build:backend": "npm run build:native-occt && tsup apps/backend/src/server.ts apps/backend/src/nativeOcctWorker.ts --format esm --platform node --target node20 --out-dir dist-backend --clean --sourcemap",
+    "build:backend": "npm run build:geometry:if-missing && npm run build:native-occt && tsup apps/backend/src/server.ts apps/backend/src/nativeOcctWorker.ts --format esm --platform node --target node20 --out-dir dist-backend --clean --sourcemap && node scripts/copy-wasm-assets.mjs dist-backend",
     "build:binary": "node scripts/build-binary.mjs",
     "build:binary:all": "node scripts/build-binary.mjs --all",
     "bundle:offline": "node scripts/build-install-bundle.mjs",