forgecad 0.10.3 → 0.10.5

package/examples/api/extrude-up-to-face.forge.js

@@ -0,0 +1,47 @@
+/**
+ * Reference-based extrude end conditions.
+ *
+ * Instead of guessing a numeric height, terminate an extrusion against a real
+ * reference: a face on another part, an arbitrary plane, or a vertex. The extent
+ * collapses to a numeric distance before the solid is built, so this works on
+ * every backend.
+ *
+ * - `extrude({ upToFace })`  — flush with another shape's planar face.
+ * - `extrude({ upToPlane, offset })` — to a plane, then a margin past it.
+ */
+
+scene({
+  camera: { position: [120, -140, 90], target: [0, 0, 25], fov: 32 },
+});
+
+// A lid sitting above the build plate; its bottom face is the termination target.
+const lid = box(60, 60, 6).translate(0, 0, 40).color('#9aa7b4');
+
+// Boss grown from the plate exactly up to the lid's underside (z = 40).
+const boss = circle2d(10).extrude({ upToFace: lid.face('bottom') }).color('#d98c5f');
+
+// A post that rises to a plane at z = 30, then 4 mm past it (a press-fit stub).
+const post = rect(10, 10)
+  .translate(22, 0)
+  .extrude({ upToPlane: { normal: [0, 0, 1], offset: 30 }, offset: 4 })
+  .color('#5f9ed9');
+
+// A pin that stops at the plane through a vertex.
+const pin = circle2d(4)
+  .translate(-22, 0)
+  .extrude({ upToVertex: [0, 0, 18] })
+  .color('#6fb86f');
+
+verify.notEmpty('boss is a solid', boss);
+verify.boundingBoxSize('boss reaches the lid underside (height 40)', boss, [20, 20, 40], 1);
+verify.boundingBoxSize('post stops 4 mm past the z=30 plane', post, [10, 10, 34], 1);
+verify.boundingBoxSize('pin stops at the z=18 vertex plane', pin, [8, 8, 18], 1);
+
+return [
+  { name: 'extrude up-to references', group: [
+    { name: 'Lid', shape: lid },
+    { name: 'Boss (upToFace)', shape: boss },
+    { name: 'Post (upToPlane + offset)', shape: post },
+    { name: 'Pin (upToVertex)', shape: pin },
+  ] },
+];

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

@@ -0,0 +1,148 @@
+/**
+ * Spoon — v4 smooth-clamp metal bowl + full-tang polymer handle.
+ *
+ * Built like a full-tang kitchen knife, in two materials:
+ *  - METAL HEAD: the smooth-clamp dished bowl (see the spoon tutorial / step5_v4),
+ *    flowing into a flat steel TANG that runs the whole length of the handle.
+ *  - POLYMER GRIP: a comfortable rounded handle (variableSweep) that is SPLIT by the
+ *    tang into a top + bottom scale, so the steel tang reads as a liner line around
+ *    the handle's equator — the classic full-tang look.
+ *  - Exposed steel BOLSTER where the bowl meets the handle, a steel BUTT at the end,
+ *    and three steel RIVETS pinning the scales to the tang.
+ *
+ * Two materials are returned as a colored group (steel + dark polymer).
+ *
+ * The bowl recipe is the key idea from the build: a smooth-clamped parabola
+ *   f(s) = s / sqrt(1 + (s/S)^2),   s = (y/hw)^2
+ * which is a pure (round) parabola in the visible bowl but C-infinity smooth, so the
+ * wall has no kink to ring around — the rim stays glassy, not wavy.
+ */
+
+scene({
+  camera: { position: [95, -260, 250], target: [20, 2, -6], fov: 36 },
+});
+
+// ───────────────────────── 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);
+  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]);
+        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');
+
+function dishZ(x, y) {
+  const hw = hwAt(x);
+  const lz = lowAt(x);
+  if (hw < 1e-6) return lz + (H - lz) * S;
+  const s = (y / hw) * (y / hw);
+  const f = s / Math.sqrt(1 + (s / S) * (s / S)); // smooth-clamp parabola
+  return lz + (H - lz) * f;
+}
+
+const X0 = -97, X1 = 28, Y0 = -40, Y1 = 40;
+const NX = 52, NY = 38;
+const grid = [];
+for (let i = 0; i < NX; i += 1) {
+  const x = X0 + ((X1 - X0) * i) / (NX - 1);
+  const row = [];
+  for (let j = 0; j < NY; j += 1) {
+    const y = Y0 + ((Y1 - Y0) * j) / (NY - 1);
+    row.push([x, y, dishZ(x, y)]);
+  }
+  grid.push(row);
+}
+
+const bowl = Surface.Net()
+  .cage(grid)
+  .degree(3, 3)
+  .toSheet()
+  .thicken(1.2, { resolution: 160 })
+  .trimByPlane([0, 0, -1], -H); // exact level rim
+
+// ───────────────────────── 2. the rounded grip volume ─────────────────────────
+const spine = Curve.Fit(
+  [
+    [16, 0, 4.0],
+    [34, 0, 4.4],
+    [74, 0, 4.2],
+    [110, 0, 3.5],
+  ],
+  { tolerance: 0.02 },
+);
+
+const gripProfile = (width, thickness) => roundedRect(width, thickness, thickness / 2);
+
+const grip = variableSweep(
+  spine,
+  [
+    { t: 0.0, profile: gripProfile(15.0, 7.0) },
+    { t: 0.16, profile: gripProfile(16.6, 9.0) },
+    { t: 0.62, profile: gripProfile(13.6, 9.8) },
+    { t: 1.0, profile: gripProfile(16.2, 9.2) },
+  ],
+  { edgeLength: 0.65, samples: 90, up: [0, 0, 1] },
+);
+
+// ───────────────────────── 3. split into tang + scales ─────────────────────────
+const TANG_Z = 4.0; // grip equator
+const TANG_T = 3.2; // tang thickness
+const tangSlab = box(240, 70, TANG_T).translate(20, 0, TANG_Z); // flat slab at the equator
+
+// Tang = grip ∩ slab (flush to the grip outline), fused into the bowl → metal head.
+const tang = grip.intersect(tangSlab);
+const metalHead = union(bowl, tang);
+
+// Polymer scales = grip − slab, with the bolster (front) and butt (back) trimmed off
+// so the steel shows there.
+const bolsterCut = box(60, 70, 60).translate(2, 0, TANG_Z); // expose metal for x < 32
+const buttCut = box(30, 70, 60).translate(121, 0, TANG_Z); // expose metal for x > 106
+const scales = grip.subtract(tangSlab).subtract(bolsterCut).subtract(buttCut);
+
+// ───────────────────────── 4. rivets ─────────────────────────
+const rivetXs = [46, 72, 96];
+const rivets = rivetXs.map((rx) =>
+  cylinder(14, 1.7).translate(rx, 0, TANG_Z - 7), // cylinder(height, radius); base at 0, along Z
+);
+
+// ───────────────────────── 5. materials & assembly ─────────────────────────
+const steel = (shape) => shape.color('#c9d0d8').material({ roughness: 0.22, metalness: 0.86 });
+const polymer = (shape) => shape.color('#141619').material({ roughness: 0.55, metalness: 0.0 });
+
+const wholeForMeasure = union(metalHead, scales, ...rivets);
+
+verify.notEmpty('metal head (bowl + tang) is solid', metalHead);
+verify.notEmpty('polymer scales are solid', scales);
+verify.boundingBoxSize('full-tang spoon keeps its proportions', wholeForMeasure, [203, 69, 23], 16);
+verify.lessThan('mid-bowl is deeper than the neck', dishZ(-48, 0), dishZ(24, 0) - 8);
+verify.greaterThan('bowl has real spoon width', hwAt(-48) * 2, 50);
+
+return [
+  steel(metalHead),
+  polymer(scales),
+  ...rivets.map(steel),
+];

package/examples/api/surface-boundarynet-dished-bowl.forge.js

@@ -0,0 +1,63 @@
+/**
+ * Smooth closed-rim dished bowl built with ONLY the Boundary Surface primitive.
+ *
+ * This is the headline case for `Surface.BoundaryNet()`'s closed/periodic form:
+ * a dished bowl whose around-rim seam must be tangent-continuous (no G0 kink).
+ *
+ * Construction (a class-A "boundary surface" cage):
+ *  - U runs radially, rim -> center (rings of decreasing radius, dishing down).
+ *  - V runs around the rim; the first and last V columns coincide so the loop
+ *    closes in position.
+ *  - `.closedV()` welds those two ends into one smooth seam, so the surface has
+ *    NO crease where the around-rim parameterization wraps.
+ *
+ * The innermost ring is a small non-degenerate disk (not a single pole), so the
+ * floor rounds over cleanly and `.thicken()` stays watertight.
+ */
+
+scene({
+  camera: { position: [140, -150, 120], target: [0, 0, -14], fov: 32 },
+  views: {
+    iso: { position: [140, -150, 120], target: [0, 0, -14], fov: 32 },
+    top: { position: [0, 0, 230], target: [0, 0, -12], fov: 32 },
+  },
+});
+
+const RIM_RADIUS = 60;
+const DEPTH = 22; // dish depth at the floor (down -z)
+const AROUND = 48; // around-rim samples (V); seam wraps here
+const RINGS = 10; // radial rings rim -> center (U)
+const CENTER_SCALE = 0.02; // innermost ring radius as a fraction of the rim (near-closed floor, no hard pole)
+
+// Radial profile: round dished bottom. t = 0 at rim, 1 at center.
+// radius shrinks to the floor; z dips so the rim tangent rolls in and the floor
+// is flat (cosine dish: flat tangent at BOTH the rim and the floor -> no throat).
+function ringRadius(t) {
+  return RIM_RADIUS * (CENTER_SCALE + (1 - CENTER_SCALE) * (1 - t));
+}
+function ringDepth(t) {
+  return -DEPTH * 0.5 * (1 - Math.cos(Math.PI * t));
+}
+
+// Build the (RINGS x AROUND+1) cage. Each row is a ring; columns go around.
+// Column 0 and column AROUND are the SAME point so the V loop closes.
+const cage = [];
+for (let r = 0; r < RINGS; r++) {
+  const t = r / (RINGS - 1);
+  const radius = ringRadius(t);
+  const z = ringDepth(t);
+  const ring = [];
+  for (let a = 0; a <= AROUND; a++) {
+    const angle = (a / AROUND) * 2 * Math.PI; // a=0 and a=AROUND coincide
+    ring.push([radius * Math.cos(angle), radius * Math.sin(angle), z]);
+  }
+  cage.push(ring);
+}
+
+// The Boundary Surface: Gordon fill of the cage, with the around-rim seam welded
+// into a tangent-continuous loop via the closed/periodic form.
+const bowl = Surface.BoundaryNet().cage(cage).degree(3, 3).closedV().thicken(1.2);
+
+bowl.color('#b9c4cc');
+
+return bowl;

package/examples/api/surface-fill-interior-constraints.forge.js

@@ -0,0 +1,59 @@
+/**
+ * n-sided filled surface pulled onto interior features with `Surface.Fill`.
+ *
+ * `Surface.Fill` already fills any closed loop of n >= 3 boundary curves
+ * (energy-minimizing constrained fill on the OCCT backend). Two optional fields
+ * shape the INTERIOR of that fill without changing the rim:
+ *
+ *  - `through` — interior constraint curves the surface must pass through. They
+ *    are NOT part of the boundary loop; they pull the fill onto an internal
+ *    feature line (here, a raised diagonal spine/crease).
+ *  - `points` — isolated interior points the surface must interpolate (here, a
+ *    single pinned bump lifted above the rim plane).
+ *
+ * The result is an open sheet, so `.thicken()` turns it into a thin solid.
+ * (Interior constraints require the default OCCT exact backend.)
+ */
+
+scene({
+  camera: { position: [120, -150, 110], target: [25, 25, 6], fov: 32 },
+  environment: { preset: 'studio' },
+});
+
+// A near-planar pentagon rim at z = 0 (five corners, five exact edges).
+const corners = [
+  [0, 0, 0],
+  [50, 0, 0],
+  [62, 38, 0],
+  [25, 60, 0],
+  [-12, 38, 0],
+];
+
+function edge(a, b) {
+  return Curve.Fit([corners[a], corners[b]]);
+}
+
+const boundaries = [
+  { name: 'a', curve: edge(0, 1) },
+  { name: 'b', curve: edge(1, 2) },
+  { name: 'c', curve: edge(2, 3) },
+  { name: 'd', curve: edge(3, 4) },
+  { name: 'e', curve: edge(4, 0) },
+];
+
+// Interior crease the fill must ride over: a raised diagonal spine.
+const spine = Curve.Fit([
+  [8, 8, 3],
+  [28, 30, 7],
+  [50, 48, 3],
+]);
+
+const skin = Surface.Fill({
+  boundaries,
+  through: [{ curve: spine }], // pull the fill onto the internal feature line
+  points: [[22, 14, 6]], // pin an interior bump above the rim plane
+}).thicken(1.2);
+
+skin.color('#bcd0d8');
+
+return skin;

package/examples/api/texture-projection.forge.js

@@ -0,0 +1,75 @@
+// Bitmap Texturing: Projected UV
+//
+// Wrap an imported bitmap onto a surface with `Shape.wrapTexture(image,
+// projection)`. The projection (a `Wrap.*` helper) decides how each point of the
+// surface maps into the image — no UV unwrapping, no Math.sin/cos.
+//
+// The image's colored edges (top=red, right=green, bottom=blue, left=orange) and
+// the dark top-left corner wedge make the mapping orientation easy to read on
+// every shape.
+//
+// Two key properties:
+//   1. AUTO-FIT — a bare `Wrap.flat/box/aroundCylinder` (no width/height/size)
+//      maps ONE copy of the image across the shape's extent. No magic numbers:
+//      the fit is read from the shape's bounding box.
+//   2. WORLD-SPACE & BOOLEAN-SAFE — the UV is derived from each vertex's final
+//      world position at render time, so the texture survives cuts/unions AND so
+//      you must texture a shape *after* positioning it (auto-fit reads the final
+//      world box; see the rightmost part, textured *then* bored).
+
+const tile = Param.number("Tile repeat", 1, { min: 1, max: 6, step: 1 });
+
+const art = Import.image("assets/uv-grid.png");
+
+// Laid out left-to-right in a tidy row on the z = 0 ground plane, ~25 mm gaps so
+// nothing overlaps. box() and sphere() are origin-centered (lift them by half
+// their height to sit on the ground); cylinder(height, radius) already has its
+// base at z = 0, so the can needs no z lift.
+//
+// In every case: build → translate → wrapTexture LAST, so auto-fit reads the
+// final world bounding box.
+
+// 1. FLAT — lay the image onto one axis-aligned face (a logo on a plate's top).
+//    No width/height: auto-fit maps the face span to the image once. `repeat`
+//    tiles that single fitted copy.
+const plate = box(50, 50, 8)
+  .translate(-140, 0, 4)
+  .wrapTexture(art, Wrap.flat({ onto: "top", repeat: [tile, tile] }));
+
+// 2. AROUND A CYLINDER — wrap the image like a can label. `axis` is the cylinder
+//    axis; the seam falls on the -X side (the atan2 wrap at ±π). No height:
+//    auto-fit maps the can's full height to the image once.
+const can = cylinder(55, 20)
+  .translate(-70, 0, 0)
+  .wrapTexture(art, Wrap.aroundCylinder({ axis: "z" }));
+
+// 3. ONTO A SPHERE — longitude/latitude mapping, like a globe. Auto-fit centers
+//    the projection on the sphere wherever it sits.
+const globe = sphere(26)
+  .translate(0, 0, 26)
+  .wrapTexture(art, Wrap.onSphere());
+
+// 4. BOX (cube-map) — the dominant face axis picks one of three planar maps, so
+//    each of the six sides shows one copy of the image. No size: auto-fit reads
+//    the box extent.
+const crate = box(40, 40, 40)
+  .translate(70, 0, 20)
+  .wrapTexture(art, Wrap.box());
+
+// 5. BOOLEAN-SAFE — position the plate, texture it (auto-fit over the solid
+//    plate), THEN subtract a bore. The image keeps flowing across the top and
+//    around the freshly-cut hole because the UV is re-derived from world position
+//    every frame, not baked into the original mesh. (Texture-then-cut, no
+//    translate after — the world-space UV must be locked before the boolean.)
+const bored = box(50, 50, 16)
+  .translate(140, 0, 8)
+  .wrapTexture(art, Wrap.flat({ onto: "top", repeat: [tile, tile] }))
+  .subtract(cylinder(40, 12).translate(140, 0, -12)); // through-hole, centered on the plate
+
+return [
+  { name: "Flat (plate top)", shape: plate },
+  { name: "Cylinder (label)", shape: can },
+  { name: "Sphere (globe)", shape: globe },
+  { name: "Box (cube-map)", shape: crate },
+  { name: "Boolean-safe (bored)", shape: bored },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgecad",
-  "version": "0.10.3",
+  "version": "0.10.5",
   "description": "Code-first parametric CAD for JavaScript/TypeScript, in the browser and CLI.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://forgecad.io",
@@ -44,6 +44,9 @@
       "export": {
         "description": "Export Forge models to manufacturing, simulation, and exchange formats."
       },
+      "fea": {
+        "description": "Run, inspect, render, compare, and check structural FEA studies."
+      },
       "inspect": {
         "description": "Inspect ForgeCAD models with targeted visual, physical, and manufacturing evidence."
       },

package/dist/docs-raw/skills/forgecad-blockout-model.md

@@ -1,49 +0,0 @@
-<!-- Generated by scripts/build-forgecad-skill.mjs — do not edit. Edit agent-skill-library/forgecad-blockout-model/SKILL.md instead. -->
-
-# forgecad-blockout-model
-
-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.
-
-| Field | Value |
-| --- | --- |
-| Installed by | `forgecad skill install` |
-| Source | `agent-skill-library/forgecad-blockout-model/SKILL.md` |
-
----
-
-## Block Out a Model
-
-A blockout is a spatial planning artifact: 3-7 simple masses that answer where parts go, whether a mechanism makes spatial sense, and what the silhouette, footprint, or motion envelope looks like. Not for print-ready geometry, exact fit, tolerances, or detail work.
-
-| Need | Skill |
-|------|-------|
-| High-level 3D idea using simple masses | `forgecad-blockout-model` |
-| Written concept or architecture before CAD | `forgecad-spec-by-walking-through-it` |
-| Accurate, detailed, parametric ForgeCAD model | `forgecad-make-a-model` |
-
-### Method
-
-- Load the `forgecad` skill first; read its Core API and CLI docs. Load nothing else unless the concept demands it.
-- Translate the idea into 3-7 conceptual parts BEFORE writing geometry: masses and zones (base, arm, payload, sweep volume, keep-out, hand access).
-- One primitive stands in for many eventual details. A bounding box beats a fake detailed part. Never add detail as a substitute for clarity — simplify or reposition instead.
-- Use round-number dimensions; "believably shaped" beats numerically correct. Name uncertainty honestly: `armLengthGuess`, `baseWidthApprox`, `clearanceEnvelope`.
-- At most a handful of `param()` values, for comparing proportions. Do not parameterize every dimension.
-- Color by meaning; keep each conceptual part visually distinct via color or opacity. Return named shape objects so the viewer can inspect the concept part-by-part.
-- Ghost geometry: transparent volumes only for REAL physical envelopes — sweep arcs, keep-out volumes, approximate payloads, reach/access zones. Never decorative teaching overlays. Exaggerate tiny clearances when needed for readability.
-- Even a blockout represents the object in its normal assembled state: no labels, legends, cutaways, or permanently exploded layouts (full rule in the `forgecad` skill).
-- Leave out: fasteners and screw holes, wall thicknesses, fillets and blend radii, polished materials, hidden internal structure that does not affect the concept.
-
-### Verify
-
-Rendering is mandatory even for rough models. Run the script, then render from 2-3 angles with the installed `forgecad` CLI (syntax: the `forgecad` skill's CLI docs). Judge by the reader test:
-
-- Can someone unfamiliar with the idea tell what each mass represents?
-- Are proportions believable enough to discuss?
-- Is motion or interference visible where it matters?
-- Are unknowns shown honestly, not hidden behind fake detail?
-
-If any answer is no, simplify or add clearer ghost volumes.
-
-### Handoff
-
-File placement and naming follow `forgecad-make-a-model` conventions; suffix the filename `-blockout` or `-concept` unless the user supplied a clearer name. Once the high-level questions are answered, stop. If the next question is real fit, tunable dimensions, part details, or manufacturing logic, switch to `forgecad-make-a-model` instead of refining the blockout indefinitely.

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

@@ -1,53 +0,0 @@
-<!-- Generated by scripts/build-forgecad-skill.mjs — do not edit. Edit agent-skill-library/forgecad-component-model/SKILL.md instead. -->
-
-# forgecad-component-model
-
-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.
-
-| Field | Value |
-| --- | --- |
-| Installed by | `forgecad skill install` |
-| Source | `agent-skill-library/forgecad-component-model/SKILL.md` |
-
----
-
-## Component Model
-
-The React of CAD: a part is a function from props to `{ shape, connectors, metadata }`, built at origin in local space. Parts never position themselves — the assembly positions them via connectors.
-
-### Rules
-
-1. **Parts build at origin.** Geometry starts at `[0,0,0]` in local coordinates; no assembly-space offsets; internal structure derives from the part's own props only.
-2. **Connectors are the only interface.** Declare via `.withConnectors({})`; axes point outward, mating is face-to-face (exception: prismatic joints share a co-directional slide axis). Mechanics: the forgecad skill's `docs/guides/positioning.md` and `docs/generated/assembly.md`.
-3. **Assembly is pure composition.** Zero `translate()` to position structural parts, zero coordinate math — connect connectors, pass props down, read metadata up.
-4. **Data flows down, never sideways.** Props down via `require('./part.forge.js', { Height: 20 })` overrides; metadata up via the part's return object; siblings NEVER import each other — the assembly mediates all sibling communication.
-5. **Validate with `verify.*`, never `console.log` + `if`.**
-
-### Part return shape
-
-```js
-return { shape, boltPattern, pinionZ }; // shape + metadata the parent may route to siblings
-```
-
-### File structure
-
-Default: ONE file per project-specific assembly — parts as sections, shared data as variables. Split only for cross-project reuse or past ~300 lines. Never split for "organization".
-
-### Anti-patterns (reject on review)
-
-- `shared-dims.js` — a file that only computes derived dimensions; the assembly derives and passes them.
-- Sibling `require()` — e.g. `require('./motor-mount.forge.js')` inside `cover-plate.forge.js`; route through the parent.
-- Assembly-space coordinates inside a part — a part knowing `pinionZ = 14` from a sibling's geometry; receive it as a prop.
-- `translate()` to position a structural part in an assembly — add a connector instead.
-- `console.log` + `if` validation — use `verify.*`.
-- Bare `connector.neutral()` outside a reusable component library with compatibility checking.
-
-### Design gate
-
-Before committing any multi-part assembly:
-
-1. Can you understand each part without reading other files?
-2. Does the assembly contain zero coordinate math?
-3. Do all inter-part relationships flow through connectors and props?
-
-If any answer is no, refactor.

package/dist/docs-raw/skills/forgecad-reconstruction-benchmark.md

@@ -1,60 +0,0 @@
-<!-- Generated by scripts/build-forgecad-skill.mjs — do not edit. Edit agent-skill-library/forgecad-reconstruction-benchmark/SKILL.md instead. -->
-
-# forgecad-reconstruction-benchmark
-
-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.
-
-| Field | Value |
-| --- | --- |
-| Installed by | `forgecad skill install` |
-| Source | `agent-skill-library/forgecad-reconstruction-benchmark/SKILL.md` |
-
----
-
-## ForgeCAD Reconstruction Benchmark
-
-Benchmark adaptation of `forgecad-3d-reconstruction`: same reconstruction loop, but with a fixed submission path, a local CLI wrapper, sandbox limits, and a short wall-clock budget. This sheet owns only those deltas — follow `forgecad-3d-reconstruction` for the reconstruction craft.
-
-### Workspace
-
-Read first: `AGENTS.md`, `task/instructions.md`, this skill, and `agent-home/.agents/skills/forgecad/SKILL.md` (API + CLI reference).
-
-- Reference asset (evidence only): `task/reference/*`
-- Final answer: `submission/main.forge.js`, unless `task/task.json` overrides
-- CLI: the local wrapper `./bin/forgecad`, never global commands
-- Scratch renders/notes: `outputs/`
-- Stay inside the prepared workspace.
-
-```bash
-./bin/forgecad run submission/main.forge.js
-```
-
-### Rules and Done Criteria
-
-- Deliverable is readable parametric ForgeCAD source at the required submission path. A clean parametric approximation beats an unreadable mesh mimic.
-- The final source must not call `Import.mesh`, `Import.step`, `importMesh`, `importStep`, `readFile`, `readFileSync`, or any equivalent asset-embedding trick, and must contain no `compareWith(...)`, external reference paths, base64 payloads, or debug probes.
-- Sandbox: allowed local tools only — no web search, no broad home-directory access, no subagents, no remote services.
-- Before exit: the run command above succeeds; visual/section evidence checked after the last meaningful edit; model recognizable against the reference from the main views.
-
-### Budget Discipline
-
-A runnable first candidate beats a perfect investigation with no model.
-
-1. Run the starter submission once before editing so syntax/runtime problems surface early.
-2. Inspect only the highest-value reference evidence: dimensions, volume, object count, one visual or sectional view. If a reference render/inspect command fails or stalls, continue from task instructions, filename, starter code, and mechanical inference — do not burn the budget retrying.
-3. Write a short reconstruction brief in `outputs/brief.md` (fields per `forgecad-3d-reconstruction`).
-4. Edit the submission early: coarse bbox, orientation, and main masses first, then iterate coarse-to-fine per `forgecad-3d-reconstruction`.
-5. 3MF references: the `forgecad run` source-structure table is evidence — account for every substantial 3MF item in the reconstruction (the final model may be one part or many).
-6. `inspect section` probes are replayable against the candidate via `inspect replay` — the cheap way to verify an exact local measurement transfers. Mechanics: `forgecad-render-inspect`.
-
-### Pointers
-
-- `forgecad-3d-reconstruction` — the evidence → brief → coarse → fine loop and metric diagnosis
-- `forgecad-render-inspect` — inspection bundles, section probes, replay
-- forgecad skill at `agent-home/.agents/skills/forgecad/` — API and CLI syntax
-- `forgecad-make-a-model` — general quality patterns only; its date-based file-placement workflow does not apply in benchmark workspaces
-
-
-## Bundled Files
-
-- `agents/openai.yaml`

package/dist-skill/library/forgecad-3d-reconstruction/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "ForgeCAD 3D Reconstruction"
-  short_description: "Rebuild CAD files as ForgeCAD models"
-  default_prompt: "Use $forgecad-3d-reconstruction to inspect this 3D file, rebuild it as parametric ForgeCAD, and score the result against the source."

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

@@ -1,42 +0,0 @@
----
-name: forgecad-blockout-model
-description: 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-public: true
----
-
-# Block Out a Model
-
-A blockout is a spatial planning artifact: 3-7 simple masses that answer where parts go, whether a mechanism makes spatial sense, and what the silhouette, footprint, or motion envelope looks like. Not for print-ready geometry, exact fit, tolerances, or detail work.
-
-| Need | Skill |
-|------|-------|
-| High-level 3D idea using simple masses | `forgecad-blockout-model` |
-| Written concept or architecture before CAD | `forgecad-spec-by-walking-through-it` |
-| Accurate, detailed, parametric ForgeCAD model | `forgecad-make-a-model` |
-
-## Method
-
-- Load the `forgecad` skill first; read its Core API and CLI docs. Load nothing else unless the concept demands it.
-- Translate the idea into 3-7 conceptual parts BEFORE writing geometry: masses and zones (base, arm, payload, sweep volume, keep-out, hand access).
-- One primitive stands in for many eventual details. A bounding box beats a fake detailed part. Never add detail as a substitute for clarity — simplify or reposition instead.
-- Use round-number dimensions; "believably shaped" beats numerically correct. Name uncertainty honestly: `armLengthGuess`, `baseWidthApprox`, `clearanceEnvelope`.
-- At most a handful of `param()` values, for comparing proportions. Do not parameterize every dimension.
-- Color by meaning; keep each conceptual part visually distinct via color or opacity. Return named shape objects so the viewer can inspect the concept part-by-part.
-- Ghost geometry: transparent volumes only for REAL physical envelopes — sweep arcs, keep-out volumes, approximate payloads, reach/access zones. Never decorative teaching overlays. Exaggerate tiny clearances when needed for readability.
-- Even a blockout represents the object in its normal assembled state: no labels, legends, cutaways, or permanently exploded layouts (full rule in the `forgecad` skill).
-- Leave out: fasteners and screw holes, wall thicknesses, fillets and blend radii, polished materials, hidden internal structure that does not affect the concept.
-
-## Verify
-
-Rendering is mandatory even for rough models. Run the script, then render from 2-3 angles with the installed `forgecad` CLI (syntax: the `forgecad` skill's CLI docs). Judge by the reader test:
-
-- Can someone unfamiliar with the idea tell what each mass represents?
-- Are proportions believable enough to discuss?
-- Is motion or interference visible where it matters?
-- Are unknowns shown honestly, not hidden behind fake detail?
-
-If any answer is no, simplify or add clearer ghost volumes.
-
-## Handoff
-
-File placement and naming follow `forgecad-make-a-model` conventions; suffix the filename `-blockout` or `-concept` unless the user supplied a clearer name. Once the high-level questions are answered, stop. If the next question is real fit, tunable dimensions, part details, or manufacturing logic, switch to `forgecad-make-a-model` instead of refining the blockout indefinitely.