partforge 0.150.1 → 0.152.0

package/src/framework/export/svg.js

@@ -22,6 +22,7 @@ export const SVG_STROKE_MM = 0.025;   // a hairline: laser software cuts it as a
 // The group order is the cut order — the same list as drawing.js's LAYER_ORDER, which
 // this leaf cannot import (drawing.js reaches paper); test/kit-svg.test.js pins them equal.
 const ORDER = Object.keys(SVG_COLORS);
+const SVG_HEX = /^#[0-9A-F]{6}$/i;
 
 const num = (x) => { const v = Number(x.toFixed(4)); return String(v === 0 ? 0 : v); };   // -0 → "0"
 const escapeXml = (s) => String(s)
@@ -74,13 +75,24 @@ export function renderSvg(doc) {
     `<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="${num(W)}mm" height="${num(H)}mm" viewBox="0 0 ${num(W)} ${num(H)}">`,
     `<title>${escapeXml(doc.title)}</title>`,
   ];
-  for (const id of ORDER) {
+  // Group order mirrors dxf.js: engrave, score, every custom (named) layer in first-seen
+  // order across the placements, then cut-inner and cut-outer.
+  const custom = [];
+  for (const placement of doc.placements) for (const layer of placement.drawing.layers)
+    if (layer.name !== undefined && !custom.includes(layer.id)) custom.push(layer.id);
+  const ids = [...ORDER.filter((id) => !id.startsWith("cut")), ...custom, ...ORDER.filter((id) => id.startsWith("cut"))];
+  for (const id of ids) {
     const paths = [];
     for (const placement of doc.placements) {
       const layer = placement.drawing.layers.find((l) => l.id === id);
       if (!layer || layer.paths.length === 0) continue;
       const place = placer(placement);
-      if (id === "engrave") {
+      if (layer.name !== undefined) {
+        // a routed layer: stroked in its own colour, never filled
+        if (!SVG_HEX.test(layer.svgColor ?? "")) throw new Error(`renderSvg: layer ${JSON.stringify(layer.id)} needs an svgColor`);
+        for (const p of layer.paths)
+          paths.push(`<path d="${pathData(p, place, H)}" fill="none" stroke="${layer.svgColor}" stroke-width="${SVG_STROKE_MM}"/>`);
+      } else if (id === "engrave") {
         // one filled path per piece: all its engrave rings, even-odd, so a glyph's
         // counter stays open whatever the rings' winding
         const d = layer.paths.map((p) => pathData(p, place, H)).join(" ");

package/src/framework/geometry/polygon.js

@@ -625,5 +625,6 @@ export { translateProfile, rotateProfile, scaleProfile, mirrorProfile,
 // the drawing ↔ world converters. Plain JS over the contour IR — not kernel ops, so
 // they add nothing to the kernel contract's op lists.
 export { sheetPart } from "../sheet/part.js";
+export { routedPart } from "../sheet/routed.js";
 export { fingers, tabs, tSlots, sheetPanel, matchingSlots, fingerBox, printedTab, sheetHole, JOINERY_SCREWS } from "../sheet/joinery.js";
 export { sheetToWorld, worldToSheet } from "../sheet/pose.js";

package/src/framework/lint/rules-materials.js

@@ -27,10 +27,27 @@ export const MATERIAL_RULES = [
       const fallback = stock ? `in realistic mode \`${stock}\`${why}` : "a PLA print in realistic mode";
       return warn("unknown-material",
         `sub-part "${name}" names material ${JSON.stringify(value)}, which is not in the library`,
-        `${near ? `Did you mean "${near}"? ` : ""}The viewer draws it as if it named no material instead (${fallback}). Known materials: ${listedPresets().join(", ")}.`,
+        `${near ? `Did you mean "${near}"? ` : ""}It is drawn as if it named none (${fallback}). Known materials: ${listedPresets().join(", ")}.`,
         `parts.${name}.display.material`);
     }),
   },
+  {
+    // A `color` on a scanned-texture preset that is not tintable MULTIPLIES the scan
+    // (physical.js), so the grain goes muddy — usually an agent "helping" a wood look
+    // with a brown. A warning, not an error: a deliberate stain is legitimate.
+    id: "material-tint-textured",
+    run: ({ part }) => subParts(part).flatMap(([name, sp]) => {
+      const d = sp.display;
+      if (!d || typeof d !== "object" || d.color == null || typeof d.material !== "string") return [];
+      if (!Object.hasOwn(PRESETS, d.material)) return [];
+      const preset = PRESETS[d.material];
+      if (!preset.textures || preset.tintable) return [];
+      return [warn("material-tint-textured",
+        `sub-part "${name}" sets display.color on "${d.material}", a textured material: the colour multiplies the scanned ${preset.label.toLowerCase()} and dulls its grain`,
+        `Drop display.color to show ${d.material}'s own colour and grain — the preset already carries it, in the CAD view too. Keep color only for a deliberate stain.`,
+        `parts.${name}.display.color`)];
+    }),
+  },
   {
     id: "unknown-environment",
     run: ({ part }) => {

package/src/framework/materials/assets/SOURCES.md

@@ -69,6 +69,9 @@ the sliced primary and gain-map buffers now start with SOI (`FF D8`) and end wit
 | `pattern-plywood-color.jpg` | Poly Haven `plywood` (colour; API key `Diffuse`) | https://polyhaven.com/a/plywood — file https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/plywood/plywood_diff_1k.jpg | 2026-09-30 | 1K JPG, sRGB colour -> `node scripts/bake-environments.mjs --texture plywood_diff_1k.jpg pattern-plywood-color.jpg --modulate 1.85,0.9 --flatten 0.55 --quality 85` (lightened 1.85x and saturation 0.9 from the scan's mid brown to a pale birch; grain contrast 0.55, since lightening doubles it). One continuous veneer, fine even grain running across the image (`grain: "u"`). Chosen 2026-09-30 from five approved CC0 candidates: ambientCG Wood090A, Wood090B, Wood091A and Wood091B (https://ambientcg.com/a/<id>) are edge-glued strip panels with visible parallel joints, not a veneer face; Wood087/088/089 (checked earlier the same day) show plywood edges. |
 | `pattern-plywood-normal.jpg` | Poly Haven `plywood` (OpenGL normal map; API key `nor_gl`) | https://polyhaven.com/a/plywood — file https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/plywood/plywood_nor_gl_1k.jpg | 2026-09-30 | 1K JPG, OpenGL (+Y up) tangent normals, kept as data -> `node scripts/bake-environments.mjs --texture plywood_nor_gl_1k.jpg pattern-plywood-normal.jpg --data --quality 95` (4:4:4 chroma, no grayscale/tint). The map leans slightly (mean red 118/255, a ~4° tilt along the grain) as the source does; kept as authored. |
 | `pattern-plywood-rough.jpg` | Poly Haven `plywood` (roughness; API key `Rough`) | https://polyhaven.com/a/plywood — file https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/plywood/plywood_rough_1k.jpg | 2026-09-30 | 1K JPG, grayscale data -> `node scripts/bake-environments.mjs --texture plywood_rough_1k.jpg pattern-plywood-rough.jpg --gray` (mean 191/255 = 0.749, the preset's `roughnessMean`). |
+| `pattern-pine-plywood-color.jpg` | ambientCG "Wood 048" (Color, `Wood048_1K-JPG_Color.jpg` from the 1K-JPG zip) | https://ambientcg.com/a/Wood048 — file https://ambientcg.com/get?file=Wood048_1K-JPG.zip | 2026-10-15 | 1K JPG, sRGB colour -> `node scripts/bake-environments.mjs --texture Wood048_1K-JPG_Color.jpg pattern-pine-plywood-color.jpg --modulate 1.25,1.3 --flatten 0.9 --quality 85` (lightened 1.25x and saturation 1.3 from the scan's dull olive-tan toward a sanded pine/fir sheet's warm yellow; grain contrast 0.9 keeps the bold figure). Mean `224,183,125` (`0xe0b77d`, the preset's `color`). Scanned tile 800 x 800 mm (ambientCG `dimensionX/Y`). One continuous softwood face with bold cathedral/flame figure running across the image (`grain: "u"`), seamless. Chosen 2026-10-15 as the hardware-store sheet look (the birch `plywood` set is pale and fine-grained). Rejected: ambientCG Wood047 (closest rotary-fir figure, but an 80 x 40 cm 2:1 scan the square bake would crop in half), Wood050 (same family, pinkish cast), Wood096 and Wood031 (knotty board, not a sanded face); Poly Haven `coated_pine`/`coated_pine_02` (glossy varnished knotty pine), `kitchen_wood` (grey, fine), `okoume_veneer`/`angli_veneer` (pink-brown, near-featureless hardwood); the plywood/Chipboard rows ambientCG tags `plywood` show plywood edges or particle board, not a face. |
+| `pattern-pine-plywood-normal.jpg` | ambientCG "Wood 048" (NormalGL, `Wood048_1K-JPG_NormalGL.jpg`) | https://ambientcg.com/a/Wood048 — file https://ambientcg.com/get?file=Wood048_1K-JPG.zip | 2026-10-15 | 1K JPG, OpenGL (+Y up) tangent normals, kept as data -> `node scripts/bake-environments.mjs --texture Wood048_1K-JPG_NormalGL.jpg pattern-pine-plywood-normal.jpg --data --quality 88` (4:4:4 chroma, no grayscale/tint). q88, not the other wood sets' q95: this map carries about twice birch's relief (stdev 6.8 vs 3.4 /255), so its 8x8 blocks are far below the grain, and q95 (~640 KB) and q90 (~412 KB) both broke the 400 KB pattern budget; q88 is 37.7 dB PSNR against the source. |
+| `pattern-pine-plywood-rough.jpg` | ambientCG "Wood 048" (Roughness, `Wood048_1K-JPG_Roughness.jpg`) | https://ambientcg.com/a/Wood048 — file https://ambientcg.com/get?file=Wood048_1K-JPG.zip | 2026-10-15 | 1K JPG, grayscale data -> `node scripts/bake-environments.mjs --texture Wood048_1K-JPG_Roughness.jpg pattern-pine-plywood-rough.jpg --gray` (mean 141/255 = 0.552, the preset's `roughnessMean`). |
 | `ground-maple-color.jpg` | Poly Haven "Oak Veneer 01" (colour; API key `Diffuse`) | https://polyhaven.com/a/oak_veneer_01 — file https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/oak_veneer_01/oak_veneer_01_diff_1k.jpg | 2026-09-24 | Workshop floor, "unfinished maple": `node scripts/bake-environments.mjs --texture oak_veneer_01_diff_1k.jpg ground-maple-color.jpg --modulate 1.5,0.7 --quality 85` (lightened 1.5x, saturation 0.7). |
 | `ground-maple-normal.jpg` | Poly Haven "Oak Veneer 01" (OpenGL normal map; API key `nor_gl`) | https://polyhaven.com/a/oak_veneer_01 — file https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/oak_veneer_01/oak_veneer_01_nor_gl_1k.jpg | 2026-09-24 | Workshop floor relief: `node scripts/bake-environments.mjs --texture oak_veneer_01_nor_gl_1k.jpg ground-maple-normal.jpg --data --quality 92`. A separate file from `pattern-oak-normal.jpg` so the floor and the oak material never share (and dispose) one texture. |
 | `ground-pei.jpg` | None — procedural | n/a | n/a | Gold-brown fine-grain speckle, no external source. First attempt tinted ambientCG "Plastic 010"'s colour map (near-uniform, stdev < 1/channel — visibly flat, no grain, when actually viewed) gold-brown; that colour map carries no usable grain at all (its roughness map does, which is why `ground-pei-rough.jpg` below is still Plastic010's roughness). Checked ambientCG alternatives (Metal049A — also flat; Granite006A — real speckle but reads as rock, not powder-coat) and found nothing closer. Generated in-baker instead, same procedural precedent as `pattern-carbon.jpg`: per-pixel triangular-distributed noise around a `168,134,82` bronze-gold base (asymmetric per channel so flecks warm rather than grey), then a 0.5px blur to turn single-pixel noise into soft grains -> `node scripts/bake-environments.mjs --speckle ground-pei.jpg --tint 168,134,82`. (Re-baked 2026-09-24 from `196,154,82`: darker and less saturated, closer to a Bambu textured-PEI plate's muted bronze-gold.) |
@@ -80,7 +83,8 @@ the sliced primary and gain-map buffers now start with SOI (`FF D8`) and end wit
 
 ambientCG publishes every asset under CC0 (https://ambientcg.com/, "CC0 Public Domain
 license", checked 2026-09-24; https://ambientcg.com/license, "Creative Commons CC0 1.0
-Universal License", checked again 2026-09-30 for the plywood candidates). The wood sets
+Universal License", checked again 2026-09-30 for the plywood candidates and 2026-10-15 for
+`pattern-pine-plywood-*`, Wood048). The wood sets
 (`pattern-oak-*`, `pattern-walnut-*`, `pattern-plywood-*`, `ground-maple-*`) are Poly Haven
 textures, CC0 like its HDRIs above (https://polyhaven.com/license, checked 2026-09-24, and
 again 2026-09-30 for `plywood`); the exact 1K JPG URLs came
@@ -92,5 +96,5 @@ The presets tile them smaller than the scanned size — see the comment on `oak`
 
 Environments stay under 1.5 MB (largest: `env-workshop.jpg` at ~398 KB); ground/pattern
 textures stay under 400 KB (largest: `ground-concrete-normal.jpg` at ~380 KB; the largest
-pattern map is `pattern-plywood-normal.jpg` at ~337 KB). All committed
+pattern map is `pattern-pine-plywood-normal.jpg` at ~353 KB). All committed
 outputs are well inside both ceilings — see `test/framework/materials-assets.test.js`.

package/src/framework/materials/assets.js

@@ -28,6 +28,9 @@ const URLS = {
   "pattern-plywood-color.jpg": new URL("./assets/pattern-plywood-color.jpg", import.meta.url).href,
   "pattern-plywood-normal.jpg": new URL("./assets/pattern-plywood-normal.jpg", import.meta.url).href,
   "pattern-plywood-rough.jpg": new URL("./assets/pattern-plywood-rough.jpg", import.meta.url).href,
+  "pattern-pine-plywood-color.jpg": new URL("./assets/pattern-pine-plywood-color.jpg", import.meta.url).href,
+  "pattern-pine-plywood-normal.jpg": new URL("./assets/pattern-pine-plywood-normal.jpg", import.meta.url).href,
+  "pattern-pine-plywood-rough.jpg": new URL("./assets/pattern-pine-plywood-rough.jpg", import.meta.url).href,
   "pattern-carbon.jpg": new URL("./assets/pattern-carbon.jpg", import.meta.url).href,
 };
 

package/src/framework/materials/presets.js

@@ -90,6 +90,14 @@ export const PRESETS = {
   plywood: P("plywood", "Birch plywood", "natural", "Birch plywood sheet: a pale, fine-grained face; its plies show on laser-cut edges.",
     { color: 0xe1c1a1, metalness: 0, roughness: 0.6, pattern: "wood", textureScale: 150, laminated: true,
       textures: { color: "pattern-plywood-color.jpg", normal: "pattern-plywood-normal.jpg", roughness: "pattern-plywood-rough.jpg", roughnessMean: 0.749, normalScale: 1, grain: "u" } }),
+  // Hardware-store 4 x 8 sheet plywood, sanded pine/fir face (ambientCG Wood048). Its
+  // textureScale is set for whole sheets, not hand-sized parts: one tile per metre, so the
+  // bold cathedral figure does not visibly repeat across a 1220 mm panel (the scan itself
+  // is 800 mm; 1000 is the top of OVERRIDE_RANGES.textureScale). Plies show on laser-cut
+  // walls only — the ply bands ride the laser burn pass (sheet-look.js burnsFor).
+  "pine-plywood": P("pine-plywood", "Sanded pine plywood", "natural", "Hardware-store 4 × 8 sheet plywood (sanded pine/fir face): warm, bold grain; plies show on laser-cut edges.",
+    { color: 0xe0b77d, metalness: 0, roughness: 0.6, pattern: "wood", textureScale: 1000, laminated: true,
+      textures: { color: "pattern-pine-plywood-color.jpg", normal: "pattern-pine-plywood-normal.jpg", roughness: "pattern-pine-plywood-rough.jpg", roughnessMean: 0.552, normalScale: 1, grain: "u" } }),
   "carbon-fiber": P("carbon-fiber", "Carbon fibre", "natural", "2x2 twill carbon fibre under clear coat.",
     { color: 0x1b1c1e, metalness: 0.2, roughness: 0.35, clearcoat: 1, clearcoatRoughness: 0.05, pattern: "carbon", textureScale: 48 }),
 };

package/src/framework/oracle/measure.js

@@ -166,7 +166,7 @@ function sheetRowFacts(kernel, part, name, view, { p, d }, budget, volume) {
   const expected = f.area * f.thickness - MARK_DEPTH * (f.marksArea ?? 0);
   return {
     ...f,
-    at: { bridge: lift(f.at2d.bridge), gap: lift(f.at2d.gap), marks: lift(f.at2d.marks) },
+    at: { bridge: lift(f.at2d.bridge), gap: lift(f.at2d.gap), marks: lift(f.at2d.marks), outside: lift(f.at2d.outside ?? null) },
     solidMatchPct: f.customBuild && f.marksArea != null && expected > 1e-9
       ? (100 * Math.abs(volume - expected)) / expected
       : null,
@@ -192,7 +192,7 @@ function unknownProcessFacts(kernel, sp, p, d) {
     process: sp.sheet.process, material: meta?.material ?? null, thickness: meta?.thickness ?? null, group: meta?.group ?? null,
     flat, area, pieces, customBuild: sp.build !== sp.sheet.generatedBuild,
     marksArea: null, bridge: null, bridgeCapped: false, gap: null, gapCapped: false, marksOutside: null, solidMatchPct: null,
-    at2d: { bridge: null, gap: null, marks: null }, at: { bridge: null, gap: null, marks: null },
+    at2d: { bridge: null, gap: null, marks: null, outside: null }, at: { bridge: null, gap: null, marks: null, outside: null },
     readErrors: { bridge: null, gap: null, marks: null, marksArea: null },
     evaluated: false,
   };

package/src/framework/process/cnc-router/descriptor.js

@@ -0,0 +1,174 @@
+// CNC routing — process module #2. Flat stock machined from ONE face: through cuts
+// (profile), flat-floored pockets at a depth, drilled holes at a depth, and `extra`
+// operations the operator does with another tool after the flat milling. The
+// drawing is one layered DXF per piece, depth on the layer name and colour.
+//
+// Import-free apart from sheet/constants.js and lint/finding.js (test/sheet-layering):
+// lint and the oracle read the registry. The resolver that turns pockets/drills/extra
+// into shapes lives in sheet/routed-resolve.js (it may import geometry); the writer in
+// process/cnc-router/export.js (it reaches paper), loaded only by the kit.
+import {
+  EMPTY_MARK_RE, MARK_DEPTH, MARK_OVERCUT, ROUTED_DOC_ID, ROUTED_KEYS, LOSS_TOL_MM2, isSheetPart, sheetMeta, fmtMm,
+} from "../../sheet/constants.js";
+import { err } from "../../lint/finding.js";
+
+// The preview: the profile extruded to the thickness, each pocket cut `depth` down from
+// the machined face (z = t), each drill as a cylinder from the face to its depth —
+// through holes and through pockets (depth = thickness) clear BOTH faces by MARK_OVERCUT so no cap is coplanar with a face
+// (OCCT's coplanar booleans are fragile) — each extra solid subtracted as given, and
+// the reference grooves cut like a laser score. A tool whose region turned out empty
+// (EMPTY_MARK_RE) is dropped, never a build failure; matched by message, never by
+// asking the shape, so this stays probe-safe.
+function orEmpty(make) {
+  try { return make(); } catch (e) { if (EMPTY_MARK_RE.test(e?.message ?? "")) return null; throw e; }
+}
+function routedPreview(k, s) {
+  const t = s.thickness;
+  const body = s.profile.extrude({ h: t });
+  const { pockets, drills, extra } = s.routed;
+  const tools = [
+    ...pockets.map((pk) => orEmpty(() => (pk.depth >= t
+      ? pk.region.extrude({ h: t + 2 * MARK_OVERCUT }).translate([0, 0, -MARK_OVERCUT])
+      : pk.region.extrude({ h: pk.depth + MARK_OVERCUT }).translate([0, 0, t - pk.depth])))),
+    ...drills.map((dr) => (dr.through
+      ? k.cylinder({ d: dr.d, h: t + 2 * MARK_OVERCUT }).translate([dr.at[0], dr.at[1], -MARK_OVERCUT])
+      : k.cylinder({ d: dr.d, h: dr.depth + MARK_OVERCUT }).translate([dr.at[0], dr.at[1], t - dr.depth]))),
+    ...extra.map((x) => x.solid),
+    ...s.grooves.map((g) => orEmpty(() => g.extrude({ h: MARK_DEPTH + MARK_OVERCUT }).translate([0, 0, t - MARK_DEPTH]))),
+  ].filter(Boolean);
+  return tools.length ? body.cutAll(tools) : body;
+}
+
+// ── facts: the operations table ───────────────────────────────────────────────
+// In the laser facts' shape (the laser-only readings null), so oracle/measure.js's
+// sheetRowFacts reads a routed row unchanged; `routed` carries what the router does.
+// `at2d.outside` is the 2-D spot of the first region found outside the profile;
+// `at.outside` (its 3-D place) is left null here — measure.js's sheetRowFacts lifts it.
+const round2 = (x) => Math.round(x * 100) / 100;
+const sizeOf = (shape) => { const { min, max } = shape.boundingBox(); return [max[0] - min[0], max[1] - min[1]]; };
+// The centre of the bounding box of `shape`'s largest region; null when empty.
+function centreOfLargest(shape) {
+  if (shape.isEmpty()) return null;
+  let best = null, bestArea = -Infinity;
+  for (const region of shape.regions()) { const a = region.area(); if (a > bestArea) { best = region; bestArea = a; } }
+  const { min, max } = best.boundingBox();
+  return [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2];
+}
+// Does `shape` leave the profile? Its part outside, when it has an area.
+function outsideOf(shape, profile) {
+  const off = shape.cut(profile);
+  return off.isEmpty() || off.area() <= LOSS_TOL_MM2 ? null : off;
+}
+
+function routedFacts(s) {
+  const { profile, thickness: t } = s;
+  const pieces = profile.toContours().length;
+  const area = pieces ? profile.area() : 0;
+  const flat = pieces ? sizeOf(profile) : [0, 0];
+  const { pockets, drills, extra } = s.routed;
+
+  let outside = 0, empty = 0, outsideAt = null;
+  const noteOutside = (shape) => { const off = outsideOf(shape, profile); if (off) { outside++; outsideAt ??= centreOfLargest(off); } };
+
+  const pocketRows = [];
+  for (const pk of pockets) {
+    if (pk.region.isEmpty()) { empty++; continue; }
+    const [w, h] = sizeOf(pk.region);
+    pocketRows.push({ label: pk.label, depth: pk.depth, w: round2(w), h: round2(h), area: round2(pk.region.area()) });
+    noteOutside(pk.region);
+  }
+  // Drills grouped by (d, depth, through): one row per tool setting, labels joined.
+  const drillGroups = new Map();
+  for (const dr of drills) {
+    const key = `${dr.d}|${dr.depth}|${dr.through}`;
+    const g = drillGroups.get(key) ?? { labels: [], d: dr.d, depth: dr.depth, through: dr.through, count: 0 };
+    g.count++;
+    if (dr.label && !g.labels.includes(dr.label)) g.labels.push(dr.label);
+    drillGroups.set(key, g);
+    noteOutside(dr.shape);
+  }
+  const drillRows = [...drillGroups.values()].map(({ labels, d, depth, through, count }) =>
+    ({ label: labels.length ? labels.join(", ") : null, d, depth, through, count }));
+  // An extra op whose footprint resolved to nothing draws nothing: counted under
+  // `empty` with the empty pockets, never a row (its size has no bounding box).
+  const extraRows = [];
+  for (const x of extra) {
+    if (x.footprint.isEmpty()) { empty++; continue; }
+    const [w, h] = sizeOf(x.footprint);
+    noteOutside(x.footprint);
+    // How deep the op reaches below the machined face (z = t), within the stock. An
+    // empty solid has no bounding box and reaches nothing.
+    const bb = x.solid.boundingBox();
+    const bottom = bb?.min?.[2];
+    const reach = Number.isFinite(bottom) ? t - bottom : 0;
+    extraRows.push({ label: x.label, method: x.method, w: round2(w), h: round2(h), maxDepth: round2(Math.max(0, Math.min(t, reach))) });
+  }
+
+  return {
+    process: s.process, material: s.material, thickness: t, group: s.group,
+    flat, area, pieces, customBuild: s.customBuild,
+    marksArea: null, bridge: null, bridgeCapped: false, gap: null, gapCapped: false, marksOutside: null, solidMatchPct: null,
+    at2d: { bridge: null, gap: null, marks: null, outside: outsideAt },
+    at: { bridge: null, gap: null, marks: null, outside: null },
+    readErrors: { bridge: null, gap: null, marks: null, marksArea: null },
+    evaluated: true,
+    routed: { profile: { w: round2(flat[0]), h: round2(flat[1]) }, pockets: pocketRows, drills: drillRows, extra: extraRows, outside, empty },
+  };
+}
+
+// ── verify metrics: all warnings, volunteered by checks() ─────────────────────
+// None is `budgeted` and none has a `readError`: a routed part's facts are taken
+// whole, so nothing is budget-withheld.
+const METRICS = {
+  routedOutside: { kind: "warn", doc: ROUTED_DOC_ID,
+    extract: (s) => s.sheet?.routed?.outside ?? null,
+    locate: (s) => s.sheet?.at?.outside ?? null,
+    hint: "a pocket, drill or extra-op footprint of this routed part lies partly outside its profile — the router would cut air or the next piece; move it inside the outline, or widen the profile" },
+  routedEmpty: { kind: "warn", doc: ROUTED_DOC_ID,
+    extract: (s) => s.sheet?.routed?.empty ?? null,
+    hint: "a pocket or extra-op footprint of this routed part resolved to an empty region at these parameters, so nothing is drawn for it — check the region's size and position, or drop the entry" },
+  routedPieces: { kind: "warn", doc: ROUTED_DOC_ID,
+    extract: (s) => s.sheet?.pieces ?? null,
+    hint: "the profile is not exactly one piece — a routed part must cut out as one region; join the pieces or split them into separate routedPart sub-parts" },
+};
+
+// ── lint ──────────────────────────────────────────────────────────────────────
+const DRILL_DEPTH_HINT = "A drill's depth is measured from the machined face; a depth at or past the stock thickness is a through hole. Lower the depth, raise the stock thickness control, or set depth to the thickness to drill through.";
+const ROUTER_RULES = [{
+  id: "routed-drill-depth",
+  run: ({ part, p, d, deriveError }) => {
+    if (deriveError || !part?.parts || typeof part.parts !== "object") return [];
+    return Object.entries(part.parts).flatMap(([name, sp]) => {
+      if (!isSheetPart(sp) || sp.sheet.process !== "cnc-router" || typeof sp.sheet.drills !== "function") return [];
+      const meta = sheetMeta(sp, p, d);
+      if (!meta) return [];
+      let drills;
+      try { drills = sp.sheet.drills(p, d); } catch { return []; }   // a throwing drills() is the build rules' business
+      if (!Array.isArray(drills)) return [];
+      return drills.flatMap((dr, i) => {
+        if (!dr || typeof dr.depth !== "number" || !(dr.depth > meta.thickness)) return [];
+        const who = typeof dr.label === "string" && dr.label.trim() ? `drill "${dr.label.trim()}"` : `drill ${i + 1}`;
+        return [err("routed-drill-depth", `sub-part "${name}": ${who} is ${fmtMm(dr.depth)} mm deep in ${fmtMm(meta.thickness)} mm stock`,
+          DRILL_DEPTH_HINT, `parts.${name}.sheet.drills`, ROUTED_DOC_ID)];
+      });
+    });
+  },
+}];
+
+export const ROUTER = {
+  id: "cnc-router",
+  label: "CNC routing",
+  stock: "sheet",
+  docId: ROUTED_DOC_ID,
+  // profile = the through cut; reference = vector lines (centerlines); pockets,
+  // drills and extra footprints = filled regions at a depth.
+  layers: { profile: "region", reference: "line", pockets: "region", drills: "region", extra: "region" },
+  keys: ROUTED_KEYS,
+  reservedKeys: [],
+  preview: routedPreview,
+  destinations: [{ id: "cnc-router", cutFormat: "dxf" }],
+  facts: routedFacts,
+  checks: () => ({ routedOutside: "0", routedEmpty: "0", routedPieces: "1" }),
+  metrics: METRICS,
+  lintRules: ROUTER_RULES,
+};

package/src/framework/process/cnc-router/export.js

@@ -0,0 +1,74 @@
+// The cnc-router exporter: one resolved routed piece → one Drawing whose layers carry
+// their own DXF name and colour (drawing.js ROUTED_COLORS). Loaded only through
+// process/exporters.js. Kerf never applies: the CAM offsets for the tool, and
+// validateKitOptions has already refused a kerf for this destination — the check here
+// is the belt for a laser destination carrying a routed piece.
+//
+// Colours: `ctx.palette` (drawing.js routedPalette, built by the kit over EVERY routed
+// piece) when given, so one depth is one colour across the kit; without it — a direct
+// call — the piece ranks its own depths. Each named layer also carries its `depth` (mm,
+// two decimals) and drills `through`, which the README's layer legend reads.
+import {
+  refitRing, ringsOf, cutRings, drawingBounds, routedLayerName, depthToken, drillKey, ROUTED_COLORS,
+} from "../../export/drawing.js";
+import { KIT_OPTIONS_ERROR } from "../../export/formats.js";
+
+const closedPath = (ring) => ({ start: ring.start, segments: ring.segments, closed: true });
+const refitRegions = (regions) => regions.map((rg) => ({ outer: refitRing(rg.outer), holes: rg.holes.map(refitRing) }));
+const allRings = (regions) => { const r = ringsOf(regions); return [...r.outer, ...r.holes]; };
+const ringsOfShape = (shape) => allRings(refitRegions(shape.toContours())).map(closedPath);
+
+function drawing(s, o, k, ctx = {}) {
+  const label = ctx.label ?? s.label ?? "routed part";
+  if (o?.kerf > 0) throw new Error(`${KIT_OPTIONS_ERROR} kerf does not apply to a CNC router — the CAM applies the tool offset; set kerf to 0 ("${label}")`);
+  const nominal = refitRegions(s.profile.toContours());
+  if (nominal.length === 0) throw new Error(`cut kit: "${label}" has an empty profile — nothing to cut`);
+  const cut = cutRings(nominal);
+  const { pockets, drills, extra } = s.routed;
+
+  const layers = [];
+  const reference = [
+    ...s.score.lines.map(([a, b]) => ({ start: [a[0], a[1]], segments: [{ to: [b[0], b[1]] }], closed: false })),
+    ...s.score.shapes.flatMap(ringsOfShape),
+  ];
+  if (reference.length) layers.push({ id: "reference", name: "REFERENCE", ...ROUTED_COLORS.reference, paths: reference });
+  const secondary = extra.flatMap((x) => ringsOfShape(x.footprint));
+  if (secondary.length) layers.push({ id: "secondary", name: "SECONDARY", ...ROUTED_COLORS.secondary, paths: secondary });
+
+  // Drills grouped by (d, depth, through) in first-seen order; each hole a closed ring
+  // of two exact arcs, which dxf.js writes as a CIRCLE.
+  const palette = ctx.palette ?? null;
+  const drillGroups = new Map();
+  drills.forEach((dr) => {
+    const key = drillKey(dr);
+    const colour = palette?.drill.get(key) ?? ROUTED_COLORS.drill[drillGroups.size % ROUTED_COLORS.drill.length];
+    const g = drillGroups.get(key) ?? { id: `drill-${key}`, name: routedLayerName("drill", dr), ...colour,
+      depth: Number(depthToken(dr.depth)), through: dr.through, paths: [] };
+    g.paths.push(...ringsOfShape(dr.shape));
+    drillGroups.set(key, g);
+  });
+  layers.push(...drillGroups.values());
+
+  // Pockets grouped by two-decimal depth, shallowest layer first; an empty region draws nothing.
+  const pocketGroups = new Map();
+  for (const pk of pockets) {
+    const paths = ringsOfShape(pk.region);
+    if (paths.length === 0) continue;
+    const key = depthToken(pk.depth);
+    const g = pocketGroups.get(key) ?? { id: `pocket-${key}`, name: routedLayerName("pocket", pk), depth: Number(key), paths: [] };
+    g.paths.push(...paths);
+    pocketGroups.set(key, g);
+  }
+  [...pocketGroups.values()].sort((a, b) => a.depth - b.depth).forEach((g, i) => {
+    const colour = palette?.pocket.get(depthToken(g.depth)) ?? ROUTED_COLORS.pocket[i % ROUTED_COLORS.pocket.length];
+    layers.push({ ...g, ...colour });
+  });
+
+  if (cut.inner.length) layers.push({ id: "cut-inner", paths: cut.inner.map(closedPath) });
+  layers.push({ id: "cut-outer", paths: cut.outer.map(closedPath) });
+
+  const nb = drawingBounds([{ id: "cut-outer", paths: ringsOf(nominal).outer.map(closedPath) }]);
+  return { layers, bounds: drawingBounds(layers), nominal: [nb.max[0] - nb.min[0], nb.max[1] - nb.min[1]], kerf: 0 };
+}
+
+export default { drawing };

package/src/framework/process/exporters.js

@@ -8,6 +8,7 @@
 // test/kit-export-guards.test.js fails until the two id lists agree.
 export const EXPORTER_LOADERS = Object.freeze({
   laser: () => import("./laser/export.js"),
+  "cnc-router": () => import("./cnc-router/export.js"),
 });
 
 // The process's ProcessExporter ({ drawing(s, o, k, ctx) }), loaded on first use.

package/src/framework/process/registry.js

@@ -6,8 +6,9 @@
 // the descriptors are: lint and the oracle read this file.
 import { isSheetPart } from "../sheet/constants.js";
 import { LASER } from "./laser/descriptor.js";
+import { ROUTER } from "./cnc-router/descriptor.js";
 
-export const PROCESSES = [LASER];
+export const PROCESSES = [LASER, ROUTER];
 export const PROCESS_IDS = PROCESSES.map((d) => d.id);
 
 export const processById = (id) => PROCESSES.find((d) => d.id === id) ?? null;

package/src/framework/sheet/constants.js

@@ -17,6 +17,13 @@
 // lint finding and DFM check carries it as `pattern`, which survives the host's
 // truncation of message/hint.
 export const SHEET_DOC_ID = "sheet-parts";
+// The routed-parts guide section id ("## Routed parts" in docs/AUTHORING-PARTS.md):
+// every cnc-router lint finding and check carries it as `pattern`.
+export const ROUTED_DOC_ID = "routed-parts";
+// The keys only routedPart() admits, on top of SHEET_KEYS. `reference` is stored on
+// the sheet record as `score` (same array shape, same preview groove) and drawn on
+// the REFERENCE layer; the other three are resolved by sheet/routed.js.
+export const ROUTED_KEYS = Object.freeze(["pockets", "drills", "extra", "reference"]);
 
 // The six axis words a SheetPose names its face and up with.
 export const AXIS_WORDS = Object.freeze(["+X", "-X", "+Y", "-Y", "+Z", "-Z"]);

package/src/framework/sheet/part.js

@@ -26,8 +26,8 @@ import { applyPose, resolveSheet, sheetPreview } from "./resolve.js";
 import { PROCESSES, PROCESS_IDS, processById } from "../process/registry.js";
 
 const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
-const KNOWN = [...SHEET_KEYS, ...SUBPART_PASSTHROUGH_KEYS];
-const KEY_LIST = `${SHEET_KEYS.join(", ")}, plus the sub-part keys ${SUBPART_PASSTHROUGH_KEYS.join(", ")}`;
+const KNOWN_BASE = [...SHEET_KEYS, ...SUBPART_PASSTHROUGH_KEYS];
+const keyList = (processKeys) => `${[...SHEET_KEYS, ...processKeys].join(", ")}, plus the sub-part keys ${SUBPART_PASSTHROUGH_KEYS.join(", ")}`;
 const optionalFn = (v) => v === undefined || v === null || typeof v === "function";
 
 // Every mistake throws here, at module load, naming the fix — in the order a reader
@@ -43,11 +43,21 @@ function checkSpec(spec) {
   const reservedKeys = [...RESERVED_KEYS, ...PROCESSES.flatMap((proc) => proc.reservedKeys ?? [])];
   const reserved = keys.find((key) => reservedKeys.includes(key));
   if (reserved) throw new Error(`sheetPart: "${reserved}" is reserved for a future process and not supported yet`);
-  const unknown = keys.find((key) => !KNOWN.includes(key));
-  if (unknown) throw new Error(`sheetPart: unknown key "${unknown}" — the keys are ${KEY_LIST}`);
-
   const process = spec.process ?? "laser";
-  if (!processById(process)) throw new Error(`sheetPart: unknown process ${JSON.stringify(process)} — valid: ${PROCESS_IDS.join(", ")}`);
+  const desc = processById(process);
+  if (!desc) {
+    throw new Error(`sheetPart: unknown process ${JSON.stringify(process)} — valid: ${PROCESS_IDS.join(", ")}; for CNC-routed stock with pockets and drills at depth use routedPart()`);
+  }
+  // A process's own declaration keys (sheet/constants.js ROUTED_KEYS for cnc-router).
+  // `reference` is routedPart's name for the score layer and arrives here already
+  // mapped onto `score`, so it is not admitted on the record itself.
+  const processKeys = (desc.keys ?? []).filter((key) => key !== "reference");
+  const unknown = keys.find((key) => !KNOWN_BASE.includes(key) && !processKeys.includes(key));
+  if (unknown) throw new Error(`sheetPart: unknown key "${unknown}" — the keys are ${keyList(processKeys)}`);
+  for (const key of processKeys) {
+    if (!optionalFn(spec[key])) throw new Error(`sheetPart: ${key} must be a function (k, p, d) => …, or omitted`);
+  }
+
   const { material: m, thickness: t } = spec;
   if (!(typeof m === "function" || (typeof m === "string" && m.trim() !== "")))
     throw new Error('sheetPart: material must be a non-empty string or a (p, d) => string function — a stock label like "birch plywood"');
@@ -63,11 +73,11 @@ function checkSpec(spec) {
     if (reason) throw new Error(`sheetPart: ${reason}`);
   }
   if (spec.place !== undefined && typeof spec.place !== "function") throw new Error("sheetPart: place must be a function (solid, ctx) => solid");
-  return process;
+  return { process, processKeys };
 }
 
 export function sheetPart(spec) {
-  const process = checkSpec(spec);
+  const { process, processKeys } = checkSpec(spec);
   const sub = {};
   for (const key of SUBPART_PASSTHROUGH_KEYS)
     if (key !== "place" && spec[key] !== undefined) sub[key] = spec[key];
@@ -109,6 +119,7 @@ export function sheetPart(spec) {
     place: authorPlace,
     generatedBuild,
     generatedPlace,
+    ...Object.fromEntries(processKeys.map((key) => [key, spec[key] ?? null])),
   });
   sub.build = generatedBuild;
   if (generatedPlace) sub.place = generatedPlace;

package/src/framework/sheet/resolve.js

@@ -12,6 +12,7 @@
 import { EMPTY_MARK_RE, MARK_DEPTH, MARK_OVERCUT, SCORE_WIDTH, sheetGroup } from "./constants.js";
 import { poseSteps, validatePose } from "./pose.js";
 import { recoverArcs } from "../geometry/arc-fit.js";
+import { resolveRouted } from "./routed-resolve.js";
 
 const fail = (sp, problem) => new Error(`sheet part${sp.label ? ` "${sp.label}"` : ""}: ${problem}`);
 const isNum = (v) => typeof v === "number" && Number.isFinite(v);
@@ -45,8 +46,16 @@ function shapeGroove(shape) {
   return orEmpty(() => outer.cut(shape.offset(-SCORE_WIDTH / 2))) ?? outer;
 }
 
+// A process's own resolver, keyed by id, producing the `routed`-style field its
+// descriptor's facts/preview and its exporter read. The laser has none. Lives here,
+// not on the descriptor, because a descriptor may import nothing but constants and
+// finding.js, and a resolver lifts shapes with the kernel.
+const PROCESS_RESOLVERS = Object.freeze({ "cnc-router": resolveRouted });
+
 // → ResolvedSheet: { process, material, thickness, group, label, pose, profile,
-//   score: { lines, shapes }, engrave, grooves, customBuild, trustedShape2d, recoverArcs }.
+//   score: { lines, shapes }, engrave, grooves, customBuild, trustedShape2d, recoverArcs,
+//   routed? } — `routed` ({ pockets, drills, extra }, sheet/routed-resolve.js) only for the
+//   cnc-router process; a laser sheet has no such field.
 //   Throws a `sheet part "<label>": …` error for a field that resolves to something
 //   unusable. `trustedShape2d` is the kernel's lift for machine-produced regions (no
 //   profile validation, arcs kept), or null where the kernel has none (a probe): the
@@ -98,13 +107,15 @@ export function resolveSheet(k, sp, p, d) {
     ...shapes.map(shapeGroove),
   ];
 
-  return {
+  const base = {
     process: s.process, material, thickness, group: sheetGroup(material, thickness),
     label: sp.label ?? null, pose, profile, score: { lines, shapes }, engrave, grooves,
     customBuild: sp.build !== s.generatedBuild,
     trustedShape2d: typeof k.shape2d?.trusted === "function" ? k.shape2d.trusted : null,
     recoverArcs,
   };
+  const resolveProcess = PROCESS_RESOLVERS[s.process];
+  return resolveProcess ? { ...base, routed: resolveProcess(k, sp, p, d, base) } : base;
 }
 
 // The default preview: the profile extruded to the thickness, the engrave pocketed and

package/src/framework/sheet/routed-resolve.js

@@ -0,0 +1,62 @@
+// Resolve a routed part's pockets, drills and extra ops at (p, d) — the cnc-router
+// process's half of resolveSheet (sheet/resolve.js dispatches here by process id).
+//
+// PROBE-SAFE like sheet/resolve.js: kernel and Shape2D METHODS only, no geometry
+// queries, no branching on geometry. The exact circle for a drill is written as the
+// contract's two-arc ring (sheetHole's form) rather than imported from joinery.js, which
+// the oracle's closure may not reach.
+const isNum = (v) => typeof v === "number" && Number.isFinite(v);
+const isPoint = (q) => Array.isArray(q) && q.length === 2 && isNum(q[0]) && isNum(q[1]);
+const isSolid = (v) => !!v && typeof v === "object" && typeof v.cutAll === "function" && typeof v.translate === "function";
+const circleRing = ([x, y], r) => ({ start: [x + r, y], segments: [{ to: [x - r, y], via: [x, y + r] }, { to: [x + r, y], via: [x, y - r] }] });
+
+const fail = (sp, problem) => new Error(`routed part${sp.label ? ` "${sp.label}"` : ""}: ${problem}`);
+const name = (entry, i, kind) => (typeof entry.label === "string" && entry.label.trim() ? `${kind} "${entry.label}"` : `${kind} ${i + 1}`);
+const depthOf = (sp, entry, who) => {
+  if (!isNum(entry.depth) || entry.depth <= 0) throw fail(sp, `${who} depth must be a finite number > 0 (mm), got ${JSON.stringify(entry.depth)}`);
+  return entry.depth;
+};
+const labelOf = (entry) => (typeof entry.label === "string" && entry.label.trim() ? entry.label.trim() : null);
+const list = (sp, fn, args, what, shape) => {
+  if (!fn) return [];
+  const out = fn(...args);
+  if (out === null || out === undefined) return [];
+  if (!Array.isArray(out)) throw fail(sp, `${what} must return an array of ${shape}`);
+  return out.filter((e) => e !== null && e !== undefined);
+};
+
+// `base` is resolveSheet's ResolvedSheet so far (profile, thickness, score…); the
+// return value is merged onto it as `routed`.
+export function resolveRouted(k, sp, p, d, base) {
+  const s = sp.sheet;
+  const t = base.thickness;
+
+  const pockets = list(sp, s.pockets, [k, p, d], "pockets(k, p, d)", "{ region, depth, label? }").map((e, i) => {
+    const who = name(e, i, "pocket");
+    if (!e || typeof e !== "object" || e.region === null || e.region === undefined) throw fail(sp, `${who} needs a region (a Shape2D or profile)`);
+    const depth = depthOf(sp, e, who);
+    if (depth > t) throw fail(sp, `${who} is ${e.depth} mm deep in ${t} mm stock — a pocket may be at most the thickness; make it a through cut in \`profile\` if it should go through`);
+    return { region: k.shape2d(e.region), depth, label: labelOf(e) };
+  });
+
+  const drills = list(sp, s.drills, [p, d], "drills(p, d)", "{ at, d, depth }").map((e, i) => {
+    const who = name(e, i, "drill");
+    if (!e || typeof e !== "object" || !isPoint(e.at)) throw fail(sp, `${who} needs at: [x, y]`);
+    if (!isNum(e.d) || e.d <= 0) throw fail(sp, `${who} d must be a finite number > 0 (mm), got ${JSON.stringify(e.d)}`);
+    const depth = depthOf(sp, e, who);
+    const through = depth >= t;
+    return { shape: k.shape2d(circleRing(e.at, e.d / 2)), at: [e.at[0], e.at[1]], d: e.d, depth: through ? t : depth, through, label: labelOf(e) };
+  });
+
+  const extra = list(sp, s.extra, [k, p, d], "extra(k, p, d)", "{ solid, footprint, label, method }").map((e, i) => {
+    const label = labelOf(e);
+    if (!label) throw fail(sp, `extra op ${i + 1} needs a label — say what it is ("12° domino slot")`);
+    const who = `extra op "${label}"`;
+    if (typeof e.method !== "string" || !e.method.trim()) throw fail(sp, `${who} needs a method — say how the operator makes it ("table saw, blade tilted 12°")`);
+    if (!isSolid(e.solid)) throw fail(sp, `${who} needs a solid — the geometry it removes, for the preview and the STEP`);
+    if (e.footprint === null || e.footprint === undefined) throw fail(sp, `${who} needs a footprint — its outline on the machined face, for the drawing`);
+    return { solid: e.solid, footprint: k.shape2d(e.footprint), label, method: e.method.trim() };
+  });
+
+  return { pockets, drills, extra };
+}