forgecad 0.10.4 → 0.11.0

package/examples/api/blend-full-round.forge.js

@@ -0,0 +1,37 @@
+// Full round and face fillet — two face-driven blends. Both require OCCT.
+const length = param('Length', 90);
+const railWidth = param('Rail Width', 14);
+const height = param('Height', 30);
+const gap = length * 0.75;
+
+// A bar whose narrow top face ("top") sits between the two long side faces.
+function bar() {
+  return box(length, railWidth, height);
+}
+
+// Full round: roll a blend over the narrow top face so the two sides meet
+// tangentially. The radius defaults to half the center-face span.
+const rounded = Blend.FullRound({
+  shape: bar(),
+  centerFace: bar().face('top'),
+})
+  .translate(-gap, 0, 0)
+  .color('#9ed892');
+
+// Face fillet: blend every edge shared by the top face and one side face.
+const seed = bar();
+const faceFilleted = Blend.Face({
+  shape: seed,
+  faces: [seed.face('top'), seed.face('side-right')],
+  radius: 5,
+})
+  .translate(gap, 0, 0)
+  .color('#e8c06a');
+
+verify.noSelfIntersection('Full round is a valid solid', rounded);
+verify.noSelfIntersection('Face fillet is a valid solid', faceFilleted);
+
+return [
+  { name: 'Full Round (top consumed)', shape: rounded },
+  { name: 'Face Fillet (top x side-right)', shape: faceFilleted },
+];

package/examples/api/blend-variable-radius.forge.js

@@ -0,0 +1,51 @@
+// Variable-radius edge fillet — the blend tapers along the edge instead of
+// holding a single radius. Requires the OCCT backend.
+const width = param('Width', 80);
+const depth = param('Depth', 40);
+const height = param('Height', 24);
+const gap = width * 0.95;
+
+function block() {
+  return box(width, depth, height);
+}
+
+// Constant radius — the reference.
+const constant = Blend.Edge({
+  shape: block(),
+  edges: [block().edge('top-right')],
+  radius: 4,
+})
+  .translate(-gap, 0, 0)
+  .color('#8aa0c8');
+
+// Linear taper from 1mm at u=0 to 8mm at u=1 along the same edge.
+const tapered = Blend.Edge({
+  shape: block(),
+  edges: [block().edge('top-right')],
+  variableRadius: { start: 1, end: 8 },
+})
+  .color('#9ed892');
+
+// Station law — a bulge in the middle of the edge.
+const bulged = Blend.Edge({
+  shape: block(),
+  edges: [block().edge('top-right')],
+  variableRadius: {
+    stations: [
+      { at: 0, radius: 1 },
+      { at: 0.5, radius: 7 },
+      { at: 1, radius: 1 },
+    ],
+  },
+})
+  .translate(gap, 0, 0)
+  .color('#e8c06a');
+
+verify.noSelfIntersection('Tapered fillet is a valid solid', tapered);
+verify.noSelfIntersection('Bulged fillet is a valid solid', bulged);
+
+return [
+  { name: 'Constant r=4', shape: constant },
+  { name: 'Linear taper 1->8', shape: tapered },
+  { name: 'Station bulge 1-7-1', shape: bulged },
+];

package/examples/api/curve-project-and-intersect.forge.js

@@ -0,0 +1,59 @@
+// Projected curve & surface-surface intersection curve on Surface.Net sheets.
+//
+// Curve.ProjectOnSurface drapes a planned guide line onto a freeform panel along
+// the surface normal; the foot curve becomes a real on-surface seam bead.
+// Curve.Intersect follows the surface-surface intersection of two sheets and
+// returns the exact NURBS seam where they meet, which we sweep into a weld bead.
+
+const span = param('Span', 120);
+const depth = param('Depth', 100);
+const crown = param('Crown', 22);
+
+// A gently crowned panel.
+const panelCage = [];
+const M = 6;
+const N = 6;
+for (let i = 0; i <= M; i++) {
+  const row = [];
+  for (let j = 0; j <= N; j++) {
+    const x = (i / M) * span - span / 2;
+    const y = (j / N) * depth - depth / 2;
+    const z = Math.sin((i / M) * Math.PI) * crown + Math.cos((j / N) * Math.PI) * (crown * 0.4);
+    row.push([x, y, z]);
+  }
+  panelCage.push(row);
+}
+const panel = Surface.Net().cage(panelCage).degree(3, 3);
+const panelSolid = panel.thicken(2).color('#9fd3ff');
+
+// 1) Project a straight guide onto the crowned panel → on-surface seam.
+const guide = Curve.Line([-span * 0.4, -depth * 0.2, crown * 2], [span * 0.4, depth * 0.2, crown * 2]);
+const seam = Curve.ProjectOnSurface(guide, panel, { samples: 64, maxGap: crown * 3 });
+const seamBead = sweep(circle2d(0.8), seam).color('#ffd166');
+
+// 2) Intersect the panel with a vertical cutting sheet → exact intersection curve.
+const cutCage = [];
+for (let i = 0; i <= 4; i++) {
+  const row = [];
+  for (let j = 0; j <= 4; j++) {
+    const t = i / 4;
+    row.push([(t - 0.5) * span * 0.9, (t - 0.5) * depth * 0.4, (j / 4) * crown * 2]);
+  }
+  cutCage.push(row);
+}
+const cutSheet = Surface.Net().cage(cutCage).degree(3, 1);
+
+const branches = Curve.Intersect(panel, cutSheet, { samples: 40 });
+if (branches.length === 0) throw new Error('Expected the panel and cutting sheet to intersect.');
+const weldBeads = branches.map((branch) => sweep(circle2d(0.9), branch).color('#ef476f'));
+
+scene({
+  background: { top: '#eef3f8', bottom: '#fbfdff' },
+  camera: { position: [0, -260, 150], target: [0, 0, 24], fov: 34 },
+});
+
+return [
+  { name: 'Crowned Panel', shape: panelSolid },
+  { name: 'Projected Seam Bead', shape: seamBead },
+  ...weldBeads.map((shape, index) => ({ name: `Intersection Weld ${index + 1}`, shape })),
+];

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/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

@@ -0,0 +1,188 @@
+/**
+ * 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 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 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(bowlLowZ);
+const hwAt = smoothField(bowlHalfWidth);
+
+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;