partforge 0.152.0 → 0.154.0

package/docs/AUTHORING-PARTS.md

@@ -403,7 +403,7 @@ meta: { title: "…", units: "mm", environment: "studio" },
 - **One material per sub-part.** Something that needs two finishes (a knurled
   grip in rubber on an aluminium body) is two sub-parts.
 
-**Sheet parts default to their stock.** A laser `sheetPart` that names no material (or
+**Sheet parts default to their stock.** A laser `sheetPart` or a `routedPart` that names no material (or
 one the library does not know) is not drawn as a PLA print: realistic mode shows it as the
 sheet its stock label names — the first row with a stem that starts a word of the label,
 ignoring case (so `Plexiglas`, `Acrylite` and `poly-carbonate` match; `perplexing` does not):
@@ -411,10 +411,14 @@ ignoring case (so `Plexiglas`, `Acrylite` and `poly-carbonate` match; `perplexin
 | A word of the stock label starts with | Realistic look |
 | --- | --- |
 | `acryl`, `perspex`, `plexi`, `pmma`, `methacryl`, `polycarb`, `lexan`, `makrolon`, `lucite` | `clear-acrylic` |
+| `pine`, `douglas` | `pine-plywood` |
+| `walnut` | `walnut` |
+| `oak` | `oak` |
 | anything else — plywood, birch, basswood, poplar, MDF, hardboard — or no readable label | `plywood` |
 
 Stock that is neither wood nor acrylic — felt, leather, card, cork — takes the `plywood`
-look too, charred edges and all. A `color` tints the look, as it tints any preset (a
+look too (charred edges and all, on a laser sheet), and a species-faced ply — `walnut
+plywood`, `oak ply` — takes that species' solid look, without plies. A `color` tints the look, as it tints any preset (a
 stained plywood, a coloured acrylic); the CAD view still shows the `color` itself. Only a
 string label is read: a stock written as a `(p, d)` function counts as unreadable. Name
 `display.material` to choose the look yourself — for such stock, or any other. Like the
@@ -445,6 +449,16 @@ from the sheet and the wood it is drawn in. It needs the sheet's own frame, so a
 with a custom `build` or a `views` pose of its own shows plain wood. The CAD view and every export are
 unchanged.
 
+**Plywood edges.** Anything drawn in `plywood` shows its plies wherever a surface runs across
+them: alternating face-grain and cross plies (side grain on one, darker end grain on the
+other, swapping as the edge turns), each veneer its own tone, with a thin glue line between
+plies. The ply count follows the thickness (3 mm → 3, 6 → 5, 9 → 7, 12 → 9, then one per
+~1.4 mm: 18 mm → 13). A `sheetPart` or `routedPart` stacks them along its own thickness, so a
+CNC-routed plywood board shows clean plies on its profile, pockets and drills, and a laser
+sheet shows them through its char; any other sub-part in plywood stacks them along its
+thinnest bounding-box axis — right for a slab, a guess for a chunky block. Realistic mode
+only, like the burn.
+
 **`textureScale` is millimetres, and what it measures depends on the preset's
 pattern** — so a value copied from one preset family is wrong on another (0.2
 on oak shrinks the grain to a 0.2 mm tile, i.e. invisible noise):
@@ -453,7 +467,7 @@ on oak shrinks the grain to a 0.2 mm tile, i.e. invisible noise):
 | --- | --- | --- | --- |
 | layer lines | `pla-print`, `petg-print` | layer height | 0.2 |
 | SLS grain | `nylon-sls` | grain size | 0.15 |
-| wood | `oak`, `walnut`, `plywood`, `pine-plywood` | size of one texture tile (the grain repeats every this many mm) | 250 (`oak`), 400 (`walnut`), 150 (`plywood`), 1000 (`pine-plywood`, sized for whole 4 × 8 sheets) |
+| wood | `oak`, `walnut`, `plywood`, `pine-plywood` | size of one texture tile (the grain repeats every this many mm) | 250 (`oak`), 400 (`walnut`), 150 (`plywood`), 400 (`pine-plywood`; raise it toward 1000 for a whole 4 × 8 sheet with no visible repeat, at the cost of a softer grain) |
 | carbon weave | `carbon-fiber` | size of one texture tile | 48 |
 
 Presets without a pattern ignore it.
@@ -489,8 +503,8 @@ the viewer's blue-grey.
 | `rubber` | Rubber | yes | Matte elastomer: gaskets, feet, grips; tint with `color`. |
 | `oak` | Oak | — | Light oak with open grain. |
 | `walnut` | Walnut | — | Dark oiled walnut. |
-| `plywood` | Birch plywood | — | Birch plywood sheet: a pale, fine-grained face; its plies show on laser-cut edges. |
-| `pine-plywood` | Sanded pine plywood | — | Hardware-store 4 × 8 sheet plywood (sanded pine/fir face): warm, bold grain; plies show on laser-cut edges. |
+| `plywood` | Birch plywood | — | Birch plywood sheet: a pale, fine-grained face; its plies show on cut edges. |
+| `pine-plywood` | Sanded pine plywood | — | Hardware-store 4 × 8 sheet plywood (sanded pine/fir face): warm, bold grain; plies show on cut edges. |
 | `carbon-fiber` | Carbon fibre | — | 2x2 twill carbon fibre under clear coat. |
 
 **Environments** (`meta.environment`, default `studio`; viewers can switch):
@@ -3963,7 +3977,7 @@ rigid motion — translate/rotate — never a reshape; an error). A pose the pro
 
 **Appearance** (all warnings) — `unknown-material` (a `display.material` the
 library does not know; the viewer draws it as if it named none — a PLA print
-in realistic mode, or for a laser sheet part its stock's look, per "Sheet parts
+in realistic mode, or for a laser or routed sheet part its stock's look, per "Sheet parts
 default to their stock"), `unknown-environment`
 (`meta.environment` not known; realistic mode uses `studio`),
 `material-key-unknown` (a `display` key that is not colour, opacity, material

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.152.0",
+  "version": "0.154.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/gltf/decode-preview.js

@@ -11,6 +11,16 @@
 // rotation; parenting the glTF root under the pivot would turn the part twice.
 // Undoing the root here hands the viewer geometry in the frame it already owns.
 //
+// Feature edges (encoder version 2): a sub-part's mesh may carry a second
+// primitive, mode LINES, holding the kernel's edge segments. GLTFLoader then
+// makes the node a Group of a Mesh and a LineSegments (the node's extras and
+// name on the Group, not the Mesh), so each surface and its lines are matched
+// through the glTF NODE they belong to. Lines go back to model frame through
+// the same matrix as the positions; a node with no line primitive — version 1,
+// or a sub-part whose edges were empty — decodes to an EMPTY Float32Array,
+// which the viewer reads as "no feature edges" (never undefined, which would
+// make it derive lines by angle).
+//
 // Rejects on anything that is not a decodable GLB; the callers (mount's
 // `preview`, mountPreview) decide what a failure means for them.
 import { Matrix3, Matrix4, Vector3 } from "three";
@@ -50,15 +60,50 @@ function metaOf(extras) {
   return Object.keys(out).length ? out : null;
 }
 
+// The object standing for a glTF node: the object itself when its node had one
+// primitive, else the Group GLTFLoader made for a multi-primitive mesh — the
+// one carrying the node's extras / name (a primitive's own Mesh has neither).
+function nodeObjectOf(obj) {
+  const own = obj.userData ?? {};
+  if ("partforgeSubPart" in own || "name" in own) return obj;
+  const parent = obj.parent;
+  return parent?.isGroup && parent.userData && ("partforgeSubPart" in parent.userData || "name" in parent.userData) ? parent : obj;
+}
+
+// Line segments as endpoint pairs in model frame (an indexed LINES primitive —
+// weld() indexes it — expanded back to pairs).
+function readSegments(geometry, matrix) {
+  const position = geometry.getAttribute("position");
+  if (!position || position.count === 0) return null;
+  const points = readVec3(position, matrix, false);
+  if (!geometry.index) return points;
+  const index = geometry.index.array;
+  const out = new Float32Array(index.length * 3);
+  for (let i = 0; i < index.length; i++) out.set(points.subarray(index[i] * 3, index[i] * 3 + 3), i * 3);
+  return out;
+}
+
 export async function decodePreviewGlb(bytes) {
   const data = toArrayBuffer(bytes);
   const loader = new GLTFLoader().setMeshoptDecoder(MeshoptDecoder);
   const gltf = await loader.parseAsync(data, "");
   gltf.scene.updateMatrixWorld(true);
   const meshes = [];
+  const edgesByNode = new Map(); // node object → model-frame segment arrays
+  const meshByNode = new Map(); // node object → its surface payload
   const toModel = new Matrix4();
   const normalMatrix = new Matrix3();
   gltf.scene.traverse((obj) => {
+    if (obj.isLineSegments) {
+      toModel.multiplyMatrices(Y_UP_TO_Z_UP, obj.matrixWorld);
+      const segments = readSegments(obj.geometry, toModel);
+      if (segments) {
+        const node = nodeObjectOf(obj);
+        edgesByNode.set(node, [...(edgesByNode.get(node) ?? []), segments]);
+      }
+      obj.geometry.dispose();
+      return;
+    }
     if (!obj.isMesh) return;
     const geometry = obj.geometry;
     const position = geometry.getAttribute("position");
@@ -67,19 +112,31 @@ export async function decodePreviewGlb(bytes) {
     normalMatrix.getNormalMatrix(toModel);
     const normal = geometry.getAttribute("normal");
     const indices = geometry.index ? Uint32Array.from(geometry.index.array) : null;
-    const { partforgeSubPart, partforgeDisplay, name: originalName } = obj.userData;
-    meshes.push({
+    const node = nodeObjectOf(obj);
+    const { partforgeSubPart, partforgeDisplay, name: originalName } = node.userData;
+    const payload = {
       // The writer's own record of the key, then the unsanitized glTF node name.
-      name: typeof partforgeSubPart === "string" ? partforgeSubPart : (originalName ?? obj.name),
+      name: typeof partforgeSubPart === "string" ? partforgeSubPart : (originalName ?? node.name),
       positions: readVec3(position, toModel, false),
       normals: normal ? readVec3(normal, normalMatrix, true) : null,
       indices,
       triangles: (indices ? indices.length : position.count) / 3,
-      edges: new Float32Array(0), // previews carry no feature edges (v1)
+      edges: new Float32Array(0), // filled below from the node's LINES primitive, if any
       display: partforgeDisplay && typeof partforgeDisplay === "object" ? partforgeDisplay : null,
-    });
+    };
+    meshes.push(payload);
+    if (!meshByNode.has(node)) meshByNode.set(node, payload);
     geometry.dispose();
   });
+  for (const [node, parts] of edgesByNode) {
+    const payload = meshByNode.get(node);
+    if (!payload) continue; // lines with no surface: nothing to draw them on
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const edges = new Float32Array(total);
+    let at = 0;
+    for (const p of parts) { edges.set(p, at); at += p.length; }
+    payload.edges = edges;
+  }
   const extras = gltf.userData ?? {};
   return {
     view: typeof extras.partforgeView === "string" ? extras.partforgeView : null,

package/src/framework/gltf/encode-preview.js

@@ -3,8 +3,15 @@
 // buildView all hold) as a small GLB a viewer can show before the kernel boots.
 //
 // The file, which a reader may rely on:
-//  - one node + mesh + primitive per sub-part, all three named by the sub-part
-//    key; POSITION + NORMAL (+ indices when the kernel sent them)
+//  - one node + mesh per sub-part, both named by the sub-part key; the mesh's
+//    FIRST primitive is the surface (TRIANGLES: POSITION + NORMAL, + indices
+//    when the kernel sent them); a sub-part with feature edges adds a SECOND
+//    primitive, mode LINES, POSITION only and no material — the kernel's edge
+//    segments in the same posed frame. A sub-part whose `edges` is empty or
+//    absent has no line primitive; a reader takes that as "no feature edges"
+//    (never "derive them"). Version-1 files have no line primitives at all.
+//    Both primitives share the mesh, so quantize() gives them ONE quantization
+//    volume and one node transform: the lines dequantize onto the faces.
 //  - every sub-part node under ONE root node, "partforge", rotated −90° about X:
 //    partforge models Z-up in millimetres and glTF is Y-up. Units stay mm — the
 //    file is for partforge's own viewer; metres would only matter for AR.
@@ -14,20 +21,20 @@
 //  - top-level extras { partforgeView, partforgeEncoder, partforgeMeta? }
 //  - weld() → quantize() → meshopt({ level: "medium" }): 5–8 bytes a triangle,
 //    the recipe measured in partforge-cloud's local_glb_benchmark.md
-// Not encoded (v1): feature edges, textures, patterns.
+// Not encoded: textures, patterns. (Feature edges since version 2.)
 //
 // Runs in Node, a page and a Web Worker: no three.js, no DOM, no Blob
 // (test/gltf-layering.test.js). Deterministic: the same input writes the same
 // bytes, and nothing here mutates the input (exportPreview passes the viewer's
 // live buffers). Bump PREVIEW_ENCODER_VERSION whenever the bytes for the same
 // input change — downstream caches key on it.
-import { Document, Logger, WebIO } from "@gltf-transform/core";
+import { Document, Logger, Primitive, WebIO } from "@gltf-transform/core";
 import { EXTMeshoptCompression, KHRMeshQuantization } from "@gltf-transform/extensions";
 import { meshopt, quantize, weld } from "@gltf-transform/functions";
 import { MeshoptEncoder } from "meshoptimizer/encoder";
 import { cadAppearance, DISPLAY_KEYS } from "../materials/resolve.js";
 
-export const PREVIEW_ENCODER_VERSION = 1;
+export const PREVIEW_ENCODER_VERSION = 2; // 2: feature edges as a LINES primitive
 
 // −90° about X as [x, y, z, w]: model (x, y, z) → glTF (x, z, −y), the viewer's pivot.
 const Z_UP_TO_Y_UP = [-Math.SQRT1_2, 0, 0, Math.SQRT1_2];
@@ -72,6 +79,13 @@ function checkMesh(m, seen) {
   if (m.normals != null && m.normals.length > 0 && m.normals.length !== m.positions.length) {
     throw new Error(`encodePreviewGlb: "${m.name}" normals do not match its positions`);
   }
+  // Any zero-length edges (typed or plain) mean "no feature edges": nothing to check.
+  if (m.edges != null && m.edges.length !== 0) {
+    if (!ArrayBuffer.isView(m.edges) && !Array.isArray(m.edges)) {
+      throw new TypeError(`encodePreviewGlb: "${m.name}" edges must be a typed array or an array of numbers`);
+    }
+    if (m.edges.length % 6 !== 0) throw new Error(`encodePreviewGlb: "${m.name}" edges are not whole segments`);
+  }
   if (indexed) {
     const vertexCount = m.positions.length / 3;
     for (let i = 0; i < m.indices.length; i++) {
@@ -126,9 +140,14 @@ export async function encodePreviewGlb({ meshes, part = null, view = null } = {}
       .setMetallicFactor(look.metalness)
       .setRoughnessFactor(look.roughness)
       .setAlphaMode(look.opacity < 1 ? "BLEND" : "OPAQUE"));
+    const mesh = doc.createMesh(m.name).addPrimitive(prim);
+    if (m.edges?.length) {
+      mesh.addPrimitive(doc.createPrimitive().setMode(Primitive.Mode.LINES).setAttribute(
+        "POSITION", doc.createAccessor().setType("VEC3").setArray(Float32Array.from(m.edges)).setBuffer(buffer)));
+    }
     const extras = displayExtras(display);
     root.addChild(doc.createNode(m.name)
-      .setMesh(doc.createMesh(m.name).addPrimitive(prim))
+      .setMesh(mesh)
       .setExtras(extras ? { partforgeSubPart: m.name, partforgeDisplay: extras } : { partforgeSubPart: m.name }));
   }
   if (root.listChildren().length === 0) throw new Error("encodePreviewGlb: every mesh was empty");

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

@@ -19,7 +19,7 @@ export const MATERIAL_RULES = [
     id: "unknown-material",
     run: ({ part }) => issuesOf(part, "unknown-material").map(({ name, value }) => {
       const near = typeof value === "string" ? suggest(value, listedPresets()) : null;
-      // A laser sheet falls back to its stock's look, not to PLA (materials/sheet-look.js) —
+      // A laser or routed sheet falls back to its stock's look, not to PLA (materials/sheet-look.js) —
       // read from a string label only: a label written as a function takes the default look.
       const sp = part.parts[name];
       const stock = sheetStockLook(sp);

package/src/framework/materials/patterns.js

@@ -5,10 +5,11 @@
 // they move with the sub-part under animation and never slide when the camera
 // moves. Layer lines additionally map object space through `pfPrintFrame`
 // (print-frame.js: display→export), so they run the way the part will print.
-// A laser-cut wood sheet's burn (applyBurn) composes over the wood pass in the sheet's
-// canonical frame (sheet-look.js).
+// A laminated wood's plies (applyPlies) compose over the wood pass on its cut walls, and a
+// laser-cut wood sheet's burn (applyBurn) over both, in the sheet's canonical frame
+// (sheet-look.js).
 import * as THREE from "three";
-import { BURN, srgbToLinear } from "./sheet-look.js";
+import { BURN, PLY, srgbToLinear } from "./sheet-look.js";
 
 const VERT_DECL = "varying vec3 vPfObjPos;\nvarying vec3 vPfObjNormal;\nvarying vec3 vPfPrintUpView;\nuniform mat4 pfPrintFrame;\n";
 // Wood's triplanar normal map builds its normal in OBJECT space; the fragment
@@ -358,6 +359,121 @@ export function applyBrushFrame(material) {
   return material;
 }
 
+// --- plies ------------------------------------------------------------------------
+// A laminated wood (presets.js `laminated`: plywood) shows its plies wherever a surface runs
+// across them — laser cut, router pass, or the side of a plain solid. The viewer hands each
+// such sub-part a LAMINATE frame (sheet-look.js: a canonical sheet's own frame, else
+// boxPlyFrame's), with the plies stacked along its z over [0, pfPlyT] and the face grain
+// along pfPlyGrain. On a wall each ply is drawn from scratch — side grain (the colour map
+// laid along the wall, each ply its own stretch of it) or end grain (darker, rougher, a fine
+// mottle), whichever its grain shows that wall — with its own tone, and a glue line at
+// every inner boundary. Injected where the burn's colour body goes, before
+// <normal_fragment_begin>; applyPlies runs first, so the burn (placed after this) chars the
+// plies it finds and keeps them through its grain ratio. Every snippet sits between
+// `// pf-ply {` and `// } pf-ply`. pfPlyT = 0 (no frame yet) draws the plain wood pass.
+//
+// Box-filtered like layer lines must be: the odd/even ply split and the glue lines are each
+// their wave's integral differenced across fwidth, so plies too thin to draw average out
+// instead of shimmering, and the per-ply tone fades out as the plies do. The texture reads
+// use textureGrad on the CONTINUOUS coordinates, so a ply's jump to its own stretch of the
+// map does not drop a seam of the coarsest mip at each boundary.
+// A JS number as a GLSL float literal.
+const glf = (x) => (Number.isInteger(x) ? x.toFixed(1) : String(x));
+const vec3f = (a) => `vec3(${a.map(glf).join(", ")})`;
+const plyBlock = (glsl) => `// pf-ply {\n${glsl}\n// } pf-ply`;
+
+const PLY_FRAG_DECL = plyBlock(`uniform mat4 pfPlyFrame;
+uniform float pfPlyT;
+uniform float pfPlyCount;
+uniform vec2 pfPlyGrain;
+uniform vec3 pfPlyAvg;
+// The fraction of the pixel on odd (cross) plies.
+float pfPlyOddI(float x) { return floor(x * 0.5) + max(0.0, fract(x * 0.5) * 2.0 - 1.0); }
+float pfPlyOdd(float x) {
+  float w = max(fwidth(x), 1e-4);
+  return clamp((pfPlyOddI(x + 0.5 * w) - pfPlyOddI(x - 0.5 * w)) / w, 0.0, 1.0);
+}
+// The fraction of the pixel on a glue line: pulses of half-width h (in plies) on integers.
+float pfGlueI(float x, float h) { float y = x + h; return floor(y) * 2.0 * h + min(fract(y), 2.0 * h); }
+float pfGlue(float x, float h) {
+  float w = max(fwidth(x), 1e-4);
+  return clamp((pfGlueI(x + 0.5 * w, h) - pfGlueI(x - 0.5 * w, h)) / w, 0.0, 1.0);
+}`);
+
+// `uv` is "xy" when the colour map's figure runs along u (presets.js grain "u"), else "yx".
+const plyFragBody = (uv) => plyBlock(`float pfPlyWall = 0.0;
+if (pfPlyT > 0.0 && pfPlyCount > 0.0) {
+  vec3 pfQ = (pfPlyFrame * vec4(vPfObjPos, 1.0)).xyz;
+  vec3 pfQn = normalize(mat3(pfPlyFrame) * vPfObjNormal);
+  pfPlyWall = 1.0 - smoothstep(${glf(PLY.wallNz[0])}, ${glf(PLY.wallNz[1])}, abs(pfQn.z));
+  if (pfPlyWall > 0.0) {
+    float pfX = clamp(pfQ.z / pfPlyT, 0.0, 1.0) * pfPlyCount;  // in plies
+    float pfPly = floor(min(pfX, pfPlyCount - 0.5));
+    vec2 pfWn = normalize(pfQn.xy);
+    // How squarely each ply's grain runs into this wall: 1 is end grain.
+    float pfAlong = abs(dot(pfPlyGrain, pfWn));
+    float pfEndFace = smoothstep(0.25, 0.9, pfAlong);
+    float pfEndCross = smoothstep(0.25, 0.9, sqrt(max(0.0, 1.0 - pfAlong * pfAlong)));
+    // Two wall projections, by which in-plane axis the wall faces (the triplanar rule).
+    vec2 pfW = pow(abs(pfWn), vec2(4.0)); pfW /= (pfW.x + pfW.y);
+    float pfOff = pfPly * 37.0;  // each ply its own stretch of the map
+    vec2 pfSa = vec2(pfQ.y, pfQ.z) / pfPatternScale, pfSb = vec2(pfQ.x, pfQ.z) / pfPatternScale;
+    vec2 pfDx = vec2(dFdx(pfQ.y), dFdx(pfQ.z)) / pfPatternScale, pfDy = vec2(dFdy(pfQ.y), dFdy(pfQ.z)) / pfPatternScale;
+    vec2 pfDxb = vec2(dFdx(pfQ.x), dFdx(pfQ.z)) / pfPatternScale, pfDyb = vec2(dFdy(pfQ.x), dFdy(pfQ.z)) / pfPatternScale;
+    vec2 pfO = vec2(0.0, pfOff / pfPatternScale);
+    vec3 pfSide = textureGrad(pfPatternMap, (pfSa + pfO).${uv}, pfDx.${uv}, pfDy.${uv}).rgb * pfW.x
+                + textureGrad(pfPatternMap, (pfSb + pfO).${uv}, pfDxb.${uv}, pfDyb.${uv}).rgb * pfW.y;
+    // End grain: the same map read ACROSS its figure and finer, kept only as a mottle.
+    float pfE = ${glf(PLY.endScale)};
+    vec3 pfEndT = textureGrad(pfPatternMap, ((pfSa + pfO) * pfE).${uv === "xy" ? "yx" : "xy"}, (pfDx * pfE).${uv === "xy" ? "yx" : "xy"}, (pfDy * pfE).${uv === "xy" ? "yx" : "xy"}).rgb * pfW.x
+                + textureGrad(pfPatternMap, ((pfSb + pfO) * pfE).${uv === "xy" ? "yx" : "xy"}, (pfDxb * pfE).${uv === "xy" ? "yx" : "xy"}, (pfDyb * pfE).${uv === "xy" ? "yx" : "xy"}).rgb * pfW.y;
+    float pfAvgL = max(dot(pfPlyAvg, vec3(0.2126, 0.7152, 0.0722)), 1e-4);
+    float pfMott = mix(1.0, dot(pfEndT, vec3(0.2126, 0.7152, 0.0722)) / pfAvgL, ${glf(PLY.endMottle)});
+    vec3 pfEnd = pfPlyAvg * ${glf(PLY.endTone)} * ${vec3f(PLY.endWarm)} * pfMott;
+    float pfOdd = pfPlyOdd(pfX);
+    float pfEndness = mix(pfEndFace, pfEndCross, pfOdd);
+    vec3 pfCol = diffuse * mix(pfSide, pfEnd, pfEndness);
+    // Each veneer its own tone, fading out as the plies get too thin to tell apart.
+    float pfJ = (pfHash(vec3(pfPly, 7.13, 3.71)) * 2.0 - 1.0) * ${glf(PLY.jitter)};
+    pfCol *= 1.0 + pfJ * (1.0 - smoothstep(0.3, 0.8, fwidth(pfX)));
+    float pfH = 0.5 * ${glf(PLY.glueMm)} * pfPlyCount / pfPlyT;
+    float pfG = pfGlue(pfX, pfH) * step(0.5, pfX) * step(pfX, pfPlyCount - 0.5);
+    pfCol = mix(pfCol, pfCol * ${glf(PLY.glue)} * ${vec3f(PLY.glueTint)}, pfG);
+    diffuseColor.rgb = mix(diffuseColor.rgb, pfCol, pfPlyWall);
+    roughnessFactor = mix(roughnessFactor, clamp(roughnessFactor + ${glf(PLY.endRough)} * pfEndness, 0.0, 1.0), pfPlyWall);
+  }
+}`);
+
+const PLY_FRAG_NORMAL = plyBlock(`normal = normalize(mix(normal, nonPerturbedNormal, pfPlyWall * ${glf(1 - PLY.relief)}));`);
+
+// `faceAvg` is the preset's own colour (0xRRGGBB) — its texture's average, never the tint.
+// Wood only, like the burn; the viewer sets the frame uniforms (viewer.js applyPlyFrame).
+export function applyPlies(material, { faceAvg }) {
+  const uniforms = material.userData.patternUniforms;
+  if (!uniforms?.pfGrainSwap) return material;
+  Object.assign(uniforms, {
+    pfPlyFrame: { value: new THREE.Matrix4() },
+    pfPlyT: { value: 0 },
+    pfPlyCount: { value: 0 },
+    pfPlyGrain: { value: new THREE.Vector2(1, 0) },
+    pfPlyAvg: { value: new THREE.Color(faceAvg) },
+  });
+  const uv = material.userData.pfGrain === "v" ? "yx" : "xy";
+  const prev = material.onBeforeCompile;
+  const prevKey = material.customProgramCacheKey;
+  material.onBeforeCompile = (shader, renderer) => {
+    prev?.call(material, shader, renderer); // applyPattern's hook copies `uniforms` — ply uniforms included
+    shader.fragmentShader = shader.fragmentShader
+      .replace("#include <common>", `#include <common>\n${PLY_FRAG_DECL}`)
+      .replace("#include <normal_fragment_begin>", `${plyFragBody(uv)}\n#include <normal_fragment_begin>`)
+      .replace("#include <emissivemap_fragment>", `${PLY_FRAG_NORMAL}\n#include <emissivemap_fragment>`);
+  };
+  const base = prevKey && prevKey !== THREE.Material.prototype.customProgramCacheKey ? prevKey.call(material) : "";
+  material.customProgramCacheKey = () => `${base}|pf-ply`;
+  material.needsUpdate = true;
+  return material;
+}
+
 // --- laser burns ------------------------------------------------------------------
 // A laser-cut sheet in a wood shows what the laser did to it (sheet-look.js decides which
 // sub-parts, and mount hands the viewer each one's canonical frame): cut walls charred,
@@ -378,22 +494,12 @@ export function applyBrushFrame(material) {
 // vertex stage is untouched — the pass reads the varyings every pattern already has. With
 // pfSheetT = 0 (no frame delivered yet) it draws plain wood. No noise term: an unfiltered
 // striation would shimmer at part scale (the layer-lines lesson above).
-const glf = (x) => (Number.isInteger(x) ? x.toFixed(1) : String(x));
 const CHARCOAL = srgbToLinear(BURN.charcoal);
 const burnBlock = (glsl) => `// pf-burn {\n${glsl}\n// } pf-burn`;
 
 const BURN_FRAG_DECL = burnBlock(`uniform mat4 pfSheetFrame;
 uniform float pfSheetT;
-uniform float pfPlies;
-uniform vec3 pfFaceAvg;
-// 1 on a cross ply (an odd one), 0 on a face-grain ply: the square wave box-filtered over
-// the pixel (its integral, differenced across fwidth), so plies too thin to draw average
-// out instead of shimmering.
-float pfCrossPlyI(float x) { return floor(x * 0.5) + max(0.0, fract(x * 0.5) * 2.0 - 1.0); }
-float pfCrossPly(float x) {
-  float w = max(fwidth(x), 1e-4);
-  return (pfCrossPlyI(x + 0.5 * w) - pfCrossPlyI(x - 0.5 * w)) / w;
-}`);
+uniform vec3 pfFaceAvg;`);
 
 const BURN_FRAG_BODY = burnBlock(`float pfBurnWall = 0.0;
 float pfBurnFloor = 0.0;
@@ -411,11 +517,10 @@ if (pfSheetT > 0.0) {
   // went in.
   vec3 pfChar = min(vec3(${CHARCOAL.map((c) => c.toFixed(6)).join(", ")}), ${glf(BURN.charOfDark)} * pfFace);
   vec3 pfEdge = mix(pfFace, pfChar, min(1.0, pfK + ${glf(BURN.exit)} * (1.0 - pfZ)));
-  if (pfPlies > 0.0) pfEdge *= mix(1.0, ${glf(BURN.crossPly)}, pfCrossPly(pfZ * pfPlies));
   vec3 pfMark = mix(pfFace, pfChar, pfK - ${glf(BURN.engraveLess)});
   // The grain survives the char (sheet-look.js's burnTexel is the twin): pfEdge and pfMark
   // are what the face AVERAGE chars to, and each texel keeps its ratio to that average,
-  // blended in by BURN.grain. At 1, a pure multiply, the average chars exactly as above and
+  // blended in by BURN.grain — the plies too, which applyPlies has already drawn. At 1, a pure multiply, the average chars exactly as above and
   // no texel comes out lighter than it went in.
   vec3 pfGrain = mix(vec3(1.0), diffuseColor.rgb / max(pfFace, vec3(1e-4)), ${glf(BURN.grain)});
   pfEdge *= pfGrain;
@@ -439,7 +544,6 @@ export function applyBurn(material, { faceAvg }) {
   Object.assign(uniforms, {
     pfSheetFrame: { value: new THREE.Matrix4() },
     pfSheetT: { value: 0 },
-    pfPlies: { value: 0 },
     pfFaceAvg: { value: new THREE.Color(faceAvg) },
   });
   const prev = material.onBeforeCompile;

package/src/framework/materials/physical.js

@@ -5,7 +5,7 @@
 // disagree about which preset a sub-part is.
 import * as THREE from "three";
 import { cadAppearance, resolveMaterial, hasAppearance } from "./resolve.js";
-import { applyBrushFrame, applyBurn, applyPattern } from "./patterns.js";
+import { applyBrushFrame, applyBurn, applyPattern, applyPlies } from "./patterns.js";
 import { PATTERN_TEXTURES } from "./assets.js";
 
 export function buildCadMaterial(display, base) {
@@ -22,10 +22,13 @@ export function buildCadMaterial(display, base) {
 // Realistic-mode material. `loadTexture(fileName)` is injected (the viewer owns
 // a caching TextureLoader), so this stays unit-testable without a network.
 // `burn` is the viewer's per-sub-part decision (sheet-look.js burnsFor): it adds the laser
-// burn pass to a wood and changes no other program.
+// burn pass to a wood and changes no other program. A laminated wood (plywood) adds the ply
+// pass first, so the burn chars the plies it draws.
 export function buildPhysicalMaterial(display, opts = {}) {
   let m = buildPhysical(display, opts);
-  if (opts.burn) m = applyBurn(m, { faceAvg: resolveMaterial(display).preset.color });
+  const { preset } = resolveMaterial(display);
+  if (preset.laminated) m = applyPlies(m, { faceAvg: preset.color });
+  if (opts.burn) m = applyBurn(m, { faceAvg: preset.color });
   // brushed metal picks its brush direction per pixel (patterns.js applyBrushFrame)
   return m.userData.pfAnisotropic ? applyBrushFrame(m) : m;
 }

package/src/framework/materials/presets.js

@@ -79,24 +79,25 @@ export const PRESETS = {
   // times that, a sanded face's relief, so it keeps its own. `grain` is the
   // texture axis the scan's figure runs along — oak's runs up the image ("v"),
   // walnut's and plywood's across it ("u") — so patterns.js can lay it along each sub-part's
-  // long axis. `laminated` (plywood) asks the burn pass (patterns.js applyBurn) for ply
-  // bands on laser-cut walls, at sheet-look.js's plyCount(t).
+  // long axis. `laminated` (plywood) adds the ply pass (patterns.js applyPlies): plies on
+  // every cut wall, at sheet-look.js's plyCount(t).
   oak: P("oak", "Oak", "natural", "Light oak with open grain.",
     { color: 0xa17e57, metalness: 0, roughness: 0.65, pattern: "wood", textureScale: 250,
       textures: { color: "pattern-oak-color.jpg", normal: "pattern-oak-normal.jpg", roughness: "pattern-oak-rough.jpg", roughnessMean: 0.53, normalScale: 2.5, grain: "v" } }),
   walnut: P("walnut", "Walnut", "natural", "Dark oiled walnut.",
     { color: 0x5d2a18, metalness: 0, roughness: 0.5, clearcoat: 0.3, clearcoatRoughness: 0.4, pattern: "wood", textureScale: 400,
       textures: { color: "pattern-walnut-color.jpg", normal: "pattern-walnut-normal.jpg", roughness: "pattern-walnut-rough.jpg", roughnessMean: 0.628, normalScale: 3, grain: "u" } }),
-  plywood: P("plywood", "Birch plywood", "natural", "Birch plywood sheet: a pale, fine-grained face; its plies show on laser-cut edges.",
+  plywood: P("plywood", "Birch plywood", "natural", "Birch plywood sheet: a pale, fine-grained face; its plies show on 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,
+  // Hardware-store 4 x 8 sheet plywood, sanded pine/fir face (ambientCG Wood048). One tile
+  // per 400 mm, half the scan's own 800 mm: at the full scan size (1000 here, once) a 1K map
+  // is ~1 mm a texel and a hand-sized part showed a smear, not grain. 400 keeps the bold
+  // cathedral figure reading as a sheet face; the cost is a figure that repeats about three
+  // times across a full 1220 mm sheet. Like plywood it is
+  // `laminated`: the ply pass draws its plies on every cut wall.
+  "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 cut edges.",
+    { color: 0xe0b77d, metalness: 0, roughness: 0.6, pattern: "wood", textureScale: 400, 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/materials/sheet-look.js

@@ -13,7 +13,7 @@
 // author place, a replaced place or a custom build is not trusted with a frame — it draws
 // plain wood, never a frame that could char a face.
 //
-// It also says what a laser sheet part with no usable material looks like: not a PLA print
+// It also says what a sheet part (laser or routed) with no usable material looks like: not a PLA print
 // (resolve.js's default for every other sub-part) but the sheet its stock label names —
 // realisticDisplay, from the ONE keyword table STOCK_LOOKS. Realistic-only, like the PLA
 // default: the CAD view, 3MF colours and declaresMaterials read sp.display itself.
@@ -42,8 +42,9 @@ const IDENTITY = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
 // takes a channel over wherever face_i < charcoal_i / charOfDark — walnut's green and blue —
 // so a dark or strongly tinted face still chars darker in every channel. Mixing toward
 // `charcoal` alone would RAISE walnut's near-black blue, since charcoal's is lighter. Char and
-// scorched floors take `roughness`, a matte finish, and shed any clearcoat; on plywood's cut
-// walls a cross ply is `crossPly` of a face-grain ply.
+// scorched floors take `roughness`, a matte finish, and shed any clearcoat. Plywood's plies
+// are not the burn's: the ply pass (PLY below) draws them first, and the char keeps each
+// texel's ratio to the face (`grain`), so they show through it.
 //   grain       how much of the wood's grain shows through the char: each texel's ratio to
 //               the face average, blended in by `grain`, multiplies the average char (1, a
 //               pure multiply: every texel darkens by the same per-channel factor, so the
@@ -70,7 +71,6 @@ export const BURN = Object.freeze({
   engraveLess: 0.1,
   charOfDark: 0.37,
   roughness: 0.68,
-  crossPly: 0.78,
   grain: 1,
   relief: 0.35,
 });
@@ -83,30 +83,101 @@ export function srgbToLinear(hex) {
   });
 }
 
-// Plies in a birch-plywood sheet t mm thick: 3 mm → 3, 6 → 5, 9 → 7, 12 → 9. Always odd, so
-// both outer plies run with the face grain.
-const PLY_STEPS = Object.freeze([[4.5, 3], [7.5, 5], [10.5, 7]]);
+// Plies in a birch-plywood sheet t mm thick: 3 mm → 3, 6 → 5, 9 → 7, 12 → 9, then one ply
+// per ~1.4 mm (15 → 11, 18 → 13, 24 → 17). Always odd, so both outer plies run with the face
+// grain.
+const PLY_STEPS = Object.freeze([[4.5, 3], [7.5, 5], [10.5, 7], [13.3, 9]]);
 export function plyCount(t) {
   for (const [below, plies] of PLY_STEPS) if (t < below) return plies;
-  return 9;
+  return 2 * Math.round((t / PLY.thickPly - 1) / 2) + 1;
+}
+
+// How a laminated wood's cut wall looks (patterns.js applyPlies): what any `laminated`
+// preset shows wherever a surface runs across its plies — a laser cut, a router pass, or
+// the side of a plain solid in plywood. In a LAMINATE frame like the sheet's canonical one
+// (plies stacked along z over [0, t]), each ply's grain alternates: the outer plies run
+// with the face grain, every other one across it. On a wall, a ply whose grain runs along
+// the wall shows SIDE grain — the face texture's long streaks, laid along the wall — and one
+// whose grain runs into it shows END grain: darker and rougher, the pores open.
+//   wallNz    the same wall band as the burn's (BURN.wallNz): below it a surface is a wall.
+//   endTone   end grain's albedo, a multiple of the face average (birch end grain drinks
+//             light); `endWarm` tints it toward amber, per channel.
+//   endMottle how much of the texture's own variation end grain keeps (a fine mottle, not
+//             streaks: its sample runs across the grain, `endScale` times finer).
+//   endRough  added to roughness on end grain.
+//   jitter    each ply's own tone, ± this fraction (a hash of its index): veneers differ.
+//   glueMm    the glue line between two plies, mm wide (none on the outer faces), drawn
+//             at `glue` of the ply colour, tinted toward `glueTint`.
+//   relief    the share of the face's normal map a wall keeps: the face scan's relief laid
+//             across plies reads as noise, so walls are mostly geometric.
+//   thickPly  above 13.3 mm, ply thickness in mm (plyCount).
+// Like BURN, judged by eye on the contact sheet (materials.html, "Plywood edges").
+export const PLY = Object.freeze({
+  wallNz: BURN.wallNz,
+  endTone: 0.74,
+  endWarm: Object.freeze([1.0, 0.93, 0.82]),
+  endMottle: 0.35,
+  endScale: 4,
+  endRough: 0.12,
+  jitter: 0.06,
+  glueMm: 0.12,
+  glue: 0.42,
+  glueTint: Object.freeze([1.0, 0.82, 0.62]),
+  relief: 0.25,
+  thickPly: 1.4,
+});
+
+// Is this sub-part's realistic look a laminated wood (its walls draw plies)? Static — it
+// reads no params — so it decides a PROGRAM, like burnsFor.
+export function laminatedFor(sp) {
+  try {
+    const look = lookOf(sp);
+    return look.params.pattern === "wood" && look.preset.laminated === true;
+  } catch { return false; }
+}
+
+// The laminate frame of a sub-part with no sheet frame: its delivered mesh's thinnest
+// object-space bounding-box axis is the stack, the box's low corner z = 0. `min`/`max` are
+// the box corners ([x, y, z]); `grainAxis` is the wood pass's grain axis (patterns.js
+// grainAxisFor). Returns { frame, t, plies, grain }: a column-major 4×4 that permutes the
+// thin axis onto z (keeping the frame right-handed) and the face grain in that frame, a
+// unit [x, y] (x when the grain axis IS the thin one, a cube's tie). null for an empty box.
+export function boxPlyFrame(min, max, grainAxis = 0) {
+  const s = [0, 1, 2].map((i) => max[i] - min[i]);
+  if (!s.every((v) => Number.isFinite(v)) || Math.max(...s) <= 0) return null;
+  let thin = 2;
+  for (const i of [1, 0]) if (s[i] < s[thin] - Math.max(...s) * 1e-6) thin = i;
+  const a = (thin + 1) % 3, b = (thin + 2) % 3; // cyclic, so (a, b, thin) → (x, y, z) is a rotation
+  const frame = Array(16).fill(0);
+  frame[a * 4 + 0] = 1; frame[b * 4 + 1] = 1; frame[thin * 4 + 2] = 1; frame[15] = 1;
+  frame[12] = -min[a]; frame[13] = -min[b]; frame[14] = -min[thin];
+  const t = s[thin];
+  return { frame, t, plies: plyCount(t), grain: grainAxis === b ? [0, 1] : [1, 0] };
 }
 
 // The material realistic mode draws this sub-part in.
 const lookOf = (sp) => resolveMaterial(realisticDisplay(sp));
 
-// A laser sheet with no usable material takes its look from its stock label: the first row
+// A sheet part (laser or CNC-routed) with no usable material takes its look from its stock label: the first row
 // with a stem that STARTS a word of the label (ignoring case; a hyphenated word is also read
 // joined, so "poly-carbonate" is one word and "clear-acrylic" still has "acrylic"), else
 // DEFAULT_STOCK_LOOK — plywood for birch, basswood, poplar, MDF, hardboard or anything
 // unlabelled. Word starts, not substrings, so "Plexiglas" and "Acrylite" match while
 // "perplexing" does not. A residual, named in the guide: stock that is neither wood nor
-// acrylic (felt, leather, card, cork) takes the plywood look too, burns and all. Only a
+// acrylic (felt, leather, card, cork) takes the plywood look too, burns and all; and a
+// species-faced ply ("walnut plywood", "oak ply") takes that species' SOLID look, with no
+// plies — name display.material to choose otherwise. Only a
 // string label is read: a (p, d) function would make a sub-part's look (and its program)
 // depend on the params it was first drawn at, so it counts as unlabelled.
 export const STOCK_LOOKS = Object.freeze([
   Object.freeze({ look: "clear-acrylic", words: Object.freeze([
     "acryl", "perspex", "plexi", "pmma", "methacryl", "polycarb", "lexan", "makrolon", "lucite",
   ]) }),
+  // The woods the library has a look for, so a board labelled by its species draws in it.
+  // Pine first: "pine plywood" and Douglas-fir sheet are softwood ply, the pine-plywood look.
+  Object.freeze({ look: "pine-plywood", words: Object.freeze(["pine", "douglas"]) }),
+  Object.freeze({ look: "walnut", words: Object.freeze(["walnut"]) }),
+  Object.freeze({ look: "oak", words: Object.freeze(["oak"]) }),
 ]);
 export const DEFAULT_STOCK_LOOK = "plywood";
 
@@ -121,12 +192,15 @@ export function stockLook(stock) {
   return STOCK_LOOKS.find((row) => row.words.some((stem) => words.some((w) => w.startsWith(stem))))?.look ?? DEFAULT_STOCK_LOOK;
 }
 
-// The stock's look for a laser sheet part, else null (lint names it in its fallback hint).
+// The processes whose parts are drawn as their stock: flat stock, cut by a laser or a router.
+const STOCK_LOOK_PROCESSES = new Set(["laser", "cnc-router"]);
+
+// The stock's look for a sheet part, else null (lint names it in its fallback hint).
 export function sheetStockLook(sp) {
-  return isSheetPart(sp) && sp.sheet.process === "laser" ? stockLook(sp.sheet.material) : null;
+  return isSheetPart(sp) && STOCK_LOOK_PROCESSES.has(sp.sheet.process) ? stockLook(sp.sheet.material) : null;
 }
 
-// The display realistic mode draws: sp.display itself, except that a laser sheet part
+// The display realistic mode draws: sp.display itself, except that a sheet part
 // naming no KNOWN material — none, or one the library does not know, the same "no usable
 // material" resolve.js treats as one case — gets its stock's look. A `color` rides along,
 // so a bare colour tints that look (stained plywood, coloured acrylic).
@@ -138,26 +212,43 @@ export function realisticDisplay(sp) {
   return { ...(display && typeof display === "object" ? display : {}), material: look };
 }
 
+// Is this a sheet part (any process) the viewer can trust with a canonical frame: one whose
+// delivered mesh is its canonical solid moved by poseSteps alone? A custom build, an author
+// place, a replaced place or a pose entry in a views map all move it off that pose.
+function canonicalSheet(sp) {
+  if (!isSheetPart(sp)) return false;
+  if (sp.build !== sp.sheet.generatedBuild) return false;                   // a custom build is not the canonical sheet
+  if (sp.sheet.place != null) return false;                                 // an author place moves it off its pose
+  if ((sp.place ?? null) !== (sp.sheet.generatedPlace ?? null)) return false; // place replaced after sheetPart
+  if (isViewsMap(sp.views) && Object.values(sp.views).some((v) => typeof v === "function")) return false; // a pose entry moves it off its pose
+  return true;
+}
+
 // Does this sub-part carry the burn pass at all? Static — it reads no params — so the
 // viewer decides a sub-part's PROGRAM once, and every sub-part that answers false keeps
 // exactly the program it had before the burn existed.
 export function burnsFor(sp) {
   if (!isSheetPart(sp) || sp.sheet.process !== "laser") return false;
-  if (sp.build !== sp.sheet.generatedBuild) return false;                   // a custom build is not the canonical sheet
-  if (sp.sheet.place != null) return false;                                 // an author place moves it off its pose
-  if ((sp.place ?? null) !== (sp.sheet.generatedPlace ?? null)) return false; // place replaced after sheetPart
-  if (isViewsMap(sp.views) && Object.values(sp.views).some((v) => typeof v === "function")) return false; // a pose entry moves it off its pose
+  if (!canonicalSheet(sp)) return false;
   try { return lookOf(sp).params.pattern === "wood"; } catch { return false; }
 }
 
+// Does this sub-part want a canonical sheet frame from mount? A burning laser sheet does
+// (its burn needs one), and so does any canonical sheet part — laser or routed — in a
+// laminated wood, whose plies then stack exactly along its thickness. Everything else that
+// is laminated stacks its plies by its bounding box (boxPlyFrame), in the viewer.
+export function wantsSheetFrame(sp) {
+  return burnsFor(sp) || (canonicalSheet(sp) && laminatedFor(sp));
+}
+
 // At (p, d) — a delivery's params — the frame that maps the delivered display mesh's
 // object space into the canonical sheet frame, the sheet's thickness, and how many plies
-// its cut walls show (0 unless its preset is `laminated`). null when burnsFor says no or
+// its cut walls show (0 unless its look is laminated). null when wantsSheetFrame says no or
 // the pose or thickness cannot be read (the build reports those).
 // `frame` "canonical": the delivered mesh is the sheet's own canonical solid (place() not
 // applied), so no frame maps it — identity, same t and plies.
 export function sheetFrameFor(sp, { p, d, frame: delivered = "posed" } = {}) {
-  if (!burnsFor(sp)) return null;
+  if (!wantsSheetFrame(sp)) return null;
   const meta = sheetMeta(sp, p, d);
   if (!meta) return null;
   const t = meta.thickness;
@@ -165,7 +256,7 @@ export function sheetFrameFor(sp, { p, d, frame: delivered = "posed" } = {}) {
   try { pose = typeof sp.sheet.pose === "function" ? sp.sheet.pose(p, d) : sp.sheet.pose; } catch { return null; }
   if (pose != null && validatePose(pose)) return null;
   const frame = delivered === "canonical" || pose == null ? [...IDENTITY] : invertRigid(composePose(poseSteps(pose, t)));
-  return { frame, t, plies: lookOf(sp).preset.laminated ? plyCount(t) : 0 };
+  return { frame, t, plies: laminatedFor(sp) ? plyCount(t) : 0 };
 }
 
 // The shader's surface classification, in JS: the frame tests hold real geometry to it.

package/src/framework/mount-preview.js

@@ -8,8 +8,9 @@
 // built once the GLB has decoded, from a synthetic part: one sub-part per glTF
 // mesh, carrying the `display` block the writer stored beside it, and the file's
 // background/environment meta. The CAD look is exact; realistic mode uses each
-// sub-part's display only — no sheet stock, no layer-line print frames (a v1
-// residual alongside "no edges"). The decoder loads on demand (it carries the
+// sub-part's display only — no sheet stock, no layer-line print frames (a
+// residual of the format). CAD feature edges come from the file (encoder
+// version 2); a version-1 file decodes with none. The decoder loads on demand (it carries the
 // GLTFLoader and meshopt), so a bundle that never mounts a preview never ships it.
 // Hence `ready`. Every handle method is safe before it resolves.
 import "./app.css";

package/src/framework/mount.js

@@ -14,7 +14,7 @@ import { attachSelectionPopover } from "./selection-popover.js";
 import { ENVIRONMENTS } from "./materials/environments.js";
 import { declaresMaterials, resolveMaterial } from "./materials/resolve.js";
 import { printFrameMatrix } from "./materials/print-frame.js";
-import { burnsFor, realisticDisplay, sheetFrameFor } from "./materials/sheet-look.js";
+import { realisticDisplay, sheetFrameFor, wantsSheetFrame } from "./materials/sheet-look.js";
 import { pruneOverrides } from "./materials/overrides.js";
 import { subPartRows } from "./sub-part-list.js";
 import { buildControls } from "./controls.js";
@@ -1171,7 +1171,8 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
     const isLayerLined = (n) => {
       try { return resolveMaterial(realisticDisplay(effectiveSubPart(n))).params.pattern === "layer-lines"; } catch { return false; }
     };
-    const isBurning = (n) => burnsFor(effectiveSubPart(n));
+    // A burning laser sheet, or a canonical sheet part (laser or routed) in plywood.
+    const isBurning = (n) => wantsSheetFrame(effectiveSubPart(n));
     // LAZY: a delivery only records the view and params its job was DISPATCHED with
     // (`dispatched`, set where the loop sends) — not the live ones, which a delivery shown
     // during playback was never built at; the viewer pulls the frames (computeFrames)

package/src/framework/viewer.js

@@ -12,7 +12,7 @@ import { ensureBoxUVs } from "./materials/uv.js";
 import { loadEnvironmentRig } from "./materials/environment.js";
 import { assetUrl } from "./materials/assets.js";
 import { resolveEnvironmentId } from "./materials/resolve.js";
-import { burnsFor, realisticDisplay } from "./materials/sheet-look.js";
+import { boxPlyFrame, burnsFor, realisticDisplay } from "./materials/sheet-look.js";
 import { effectiveDisplay, mergeOverride, sanitizeDisplayPatch, subPartVisibility, APPEARANCE_OVERRIDE_KEYS, VIEWING_KEYS } from "./materials/overrides.js";
 import { neutralToneMapToSrgb8 } from "./materials/tonemap-readback.js";
 import { createMaterialThumbCache, thumbDisplay } from "./materials/thumb-cache.js";
@@ -844,14 +844,13 @@ export function createViewer(container, part) {
       const sp = part.parts[name];
       // `burn` is decided per sub-part material (sheet-look.js burnsFor): only a laser sheet in
       // a wood compiles the burn pass, so every other program is exactly what it was.
-      // realisticDisplay: a laser sheet with no material draws as its stock (sheet-look.js).
+      // realisticDisplay: a sheet part with no material draws as its stock (sheet-look.js).
       // Both read sp.display, so hand them a sub-part whose display is the EFFECTIVE one
       // (authored + the user's appearance override).
       const eff = { ...sp, display: effectiveDisplayOf(name) };
       m = cloneKeepsPattern(buildPhysicalMaterial(realisticDisplay(eff), { printFrame: printFrames[name], burn: burnsFor(eff), loadTexture }));
       physicalMats.set(name, m);
       syncGrain(name);
-      applySheetFrame(m, sheetFrames[name]);
     }
     return m;
   }
@@ -863,6 +862,7 @@ export function createViewer(container, part) {
     const m = physicalMats.get(name);
     const geo = subCache[name];
     if (m && geo) setGrainAxis(m, grainAxisFor(geo.boundingBox));
+    if (m) applySheetFrame(m, sheetFrames[name], name);
   }
 
   function publishMode(extra = {}) {
@@ -1159,16 +1159,34 @@ export function createViewer(container, part) {
 
   // A burning sheet's canonical frame (sheet-look.js sheetFrameFor). No frame — not yet
   // delivered, or not computable at these params — is pfSheetT = 0: plain wood.
-  function applySheetFrame(m, f) {
+  // The same frame stacks a laminated sheet's plies (patterns.js applyPlies); a laminated
+  // sub-part with no sheet frame stacks them by its own bounding box (boxPlyFrame).
+  function applySheetFrame(m, f, name) {
     const u = m.userData.patternUniforms;
-    if (!u?.pfSheetFrame) return;
-    u.pfSheetFrame.value.fromArray(f?.frame ?? IDENTITY_MAT4);
-    u.pfSheetT.value = f?.t ?? 0;
-    u.pfPlies.value = f?.plies ?? 0;
+    if (u?.pfSheetFrame) {
+      u.pfSheetFrame.value.fromArray(f?.frame ?? IDENTITY_MAT4);
+      u.pfSheetT.value = f?.t ?? 0;
+    }
+    if (u?.pfPlyFrame) applyPlyFrame(u, m, f, name);
+  }
+  function applyPlyFrame(u, m, f, name) {
+    const box = subCache[name]?.boundingBox;
+    const axis = m.userData.pfGrainAxis ?? 0;
+    let ply = f?.plies > 0 ? { frame: f.frame, t: f.t, plies: f.plies, grain: null } : null;
+    if (!ply && box && !box.isEmpty()) ply = boxPlyFrame(box.min.toArray(), box.max.toArray(), axis);
+    if (!ply) { u.pfPlyT.value = 0; return; }
+    u.pfPlyFrame.value.fromArray(ply.frame);
+    u.pfPlyT.value = ply.t;
+    u.pfPlyCount.value = ply.plies;
+    if (ply.grain) { u.pfPlyGrain.value.fromArray(ply.grain); return; }
+    // A sheet frame: the face grain is the wood pass's grain axis carried into it.
+    const g = new THREE.Vector3().setComponent(axis, 1).transformDirection(u.pfPlyFrame.value);
+    if (Math.hypot(g.x, g.y) < 1e-6) u.pfPlyGrain.value.set(1, 0);
+    else u.pfPlyGrain.value.set(g.x, g.y).normalize();
   }
   function setSheetFrames(frames) {
     sheetFrames = frames ?? {};
-    for (const [n, m] of physicalMats) applySheetFrame(m, sheetFrames[n]);
+    for (const [n, m] of physicalMats) applySheetFrame(m, sheetFrames[n], n);
   }
 
   // The lazy form mount uses. Frames are PULLED only when something is about to draw the
@@ -1723,9 +1741,12 @@ export function createViewer(container, part) {
     // draw none rather than falling back. Only a payload with NO edge data at
     // all (edges === undefined; no current backend does this) derives by angle.
     const lg = new LineSegmentsGeometry();
-    if (edges) lg.setPositions(edges); // edges is already a well-formed (possibly zero-length) Float32Array
-    else lg.fromEdgesGeometry(new THREE.EdgesGeometry(out, EDGE_ANGLE));
+    // The raw segment pairs drawn, kept for getSubMeshPayload (reading them back
+    // out of LineSegmentsGeometry's interleaved instance buffer is awkward).
+    const segments = edges ?? new THREE.EdgesGeometry(out, EDGE_ANGLE).getAttribute("position").array;
+    lg.setPositions(segments); // a well-formed (possibly zero-length) Float32Array
     out.userData.edges = lg;
+    out.userData.edgePositions = segments;
     return out;
   }
 
@@ -1772,7 +1793,9 @@ export function createViewer(container, part) {
   // The geometry drawn for one sub-part, as a fresh worker-style payload with its
   // fast-path pose (setSubPose) baked in — the posed mesh a headless buildView
   // would return. Copies: the caller (exportPreview → partforge/gltf) may keep or
-  // transfer them. null when nothing has been delivered under that name.
+  // transfer them. null when nothing has been delivered under that name. Its
+  // `edges` are the lines shown on screen: the kernel's segments, or — when the
+  // delivery carried no edge data at all — the angle-derived fallback lines.
   const _payloadV = new THREE.Vector3();
   const _payloadNormal = new THREE.Matrix3();
   function getSubMeshPayload(name) {
@@ -1793,10 +1816,17 @@ export function createViewer(container, part) {
         _payloadV.fromBufferAttribute(nor, i).applyMatrix3(_payloadNormal).normalize().toArray(normals, i * 3);
       }
     }
+    // Feature edges, posed by the same matrix (an empty array stays empty: "none").
+    const rawEdges = geo.userData.edgePositions ?? new Float32Array(0);
+    const edges = new Float32Array(rawEdges.length);
+    for (let i = 0; i < rawEdges.length; i += 3) {
+      _payloadV.fromArray(rawEdges, i).applyMatrix4(pose).toArray(edges, i);
+    }
     return {
       name,
       positions,
       normals,
+      edges,
       indices: geo.index ? Uint32Array.from(geo.index.array) : null,
       triangles: geo.userData.triangles ?? (geo.index ? geo.index.count : pos.count) / 3,
     };

package/src/parts/material-swatches.js

@@ -5,6 +5,7 @@
 import { PRESETS } from "../framework/materials/presets.js";
 import { sheetPart } from "../framework/sheet/part.js";
 import { sheetHole } from "../framework/sheet/joinery.js";
+import { routedPart } from "../framework/sheet/routed.js";
 
 const ids = Object.keys(PRESETS);
 const COLS = 6, PITCH = 40;
@@ -71,10 +72,56 @@ function laserSwatch(s, unburnt) {
   });
 }
 
+// The "Plywood edges" view: the ply pass (materials/patterns.js applyPlies) on every kind of
+// plywood wall — CNC-routed panels at 6, 12 and 18 mm (a rounded profile, a pocket and a
+// through drill, so straight, curved and inner walls all show), one standing on edge, a
+// routed disc that names no material (drawn as its stock; a wall that turns through every grain direction), an 18 mm pine-plywood panel, a 6 mm laser panel (plies
+// under the char), and two plain solids in plywood that are not sheet parts at all (their
+// plies stack along the thinnest axis).
+const PW = 50;
+const roundedRect = (k, x, y, w, h, r) => k.shape2d([[x, y], [x + w, y], [x + w, y + h], [x, y + h]]).fillet(r);
+const ROUTED = [[6, 0], [12, 1], [18, 2]];
+const plywoodParts = {
+  ...Object.fromEntries(ROUTED.map(([t, col]) => [`ply_routed_${t}`, routedPart({
+    label: `Routed plywood, ${t} mm`, views: ["plywood"], material: "birch plywood", thickness: t, display: { material: "plywood" },
+    profile: (k) => roundedRect(k, col * (PW + 15), 0, PW, 36, 6),
+    pockets: (k) => [{ region: roundedRect(k, col * (PW + 15) + 6, 6, 18, 24, 3), depth: t / 2 }],
+    drills: () => [{ at: [col * (PW + 15) + 37, 18], d: 10, depth: t }],
+  })])),
+  ply_routed_standing: routedPart({
+    label: "Routed plywood, 12 mm, standing", views: ["plywood"], material: "birch plywood", thickness: 12, display: { material: "plywood" },
+    profile: (k) => roundedRect(k, 0, 0, PW, 36, 6),
+    drills: () => [{ at: [25, 18], d: 10, depth: 12 }],
+    pose: { face: "-Y", up: "+Z", at: [0, -30, 0] },
+  }),
+  ply_routed_disc: routedPart({
+    // names no material: drawn as its stock (sheet-look.js realisticDisplay)
+    label: "Routed plywood disc, 18 mm (no material)", views: ["plywood"], material: "birch plywood", thickness: 18,
+    profile: (k) => k.shape2d(Array.from({ length: 96 }, (_, i) => [90 + 22 * Math.cos((i / 96) * 2 * Math.PI), -45 + 22 * Math.sin((i / 96) * 2 * Math.PI)])),
+  }),
+  ply_routed_pine: routedPart({
+    label: "Routed pine plywood, 18 mm", views: ["plywood"], material: "pine plywood", thickness: 18, display: { material: "pine-plywood" },
+    profile: (k) => roundedRect(k, 130, -100, PW, 30, 6),
+    drills: () => [{ at: [165, -85], d: 10, depth: 18 }],
+  }),
+  ply_laser_6: sheetPart({
+    label: "Laser-cut plywood, 6 mm", views: ["plywood"], material: "birch plywood", thickness: 6, display: { material: "plywood" },
+    profile: (k) => k.shape2d([[130, -60], [130 + SW, -60], [130 + SW, -60 + SW], [130, -60 + SW]]).cut(sheetHole({ d: 8, at: [151, -39] })),
+  }),
+  ply_block: {
+    label: "Plywood block (not a sheet part)", views: ["plywood"], display: { material: "plywood" },
+    build: (k) => k.box({ min: [0, -100, 0], max: [40, -70, 18] }).cut(k.cylinder({ d: 10, h: 30 }).translate([28, -85, -5])),
+  },
+  ply_filleted: {
+    label: "Filleted plywood block (not a sheet part)", views: ["plywood"], display: { material: "plywood" },
+    build: (k) => k.box({ min: [60, -100, 0], max: [100, -70, 18] }).fillet({ r: 4 }),
+  },
+};
+
 export default {
   meta: { title: "Material swatches", units: "mm", environment: "studio" },
   defaults: {},
-  views: { all: { label: "All presets", default: true }, colours: { label: "PLA colours" }, petg: { label: "PETG colours" }, print: { label: "Layer lines" }, laser: { label: "Laser-cut" }, unburnt: { label: "Laser-cut, unburnt" } },
+  views: { all: { label: "All presets", default: true }, colours: { label: "PLA colours" }, petg: { label: "PETG colours" }, print: { label: "Layer lines" }, laser: { label: "Laser-cut" }, unburnt: { label: "Laser-cut, unburnt" }, plywood: { label: "Plywood edges" } },
   parts: {
     ...Object.fromEntries(ids.map((id, i) => [id.replaceAll("-", "_"), {
       label: PRESETS[id].label,
@@ -121,5 +168,6 @@ export default {
       [`laser_${s.key}`, laserSwatch(s, false)],
       [`unburnt_${s.key}`, laserSwatch(s, true)],
     ])),
+    ...plywoodParts,
   },
 };

package/types/gltf.d.ts

@@ -20,7 +20,11 @@ export interface PreviewMesh {
   /** Absent for a non-indexed soup (Manifold); OCCT sends indices. */
   indices?: Uint32Array | null;
   triangles?: number;
-  /** Ignored: feature edges are not encoded in this version. */
+  /**
+   * Feature-edge segments, endpoint pairs `[x0,y0,z0, x1,y1,z1, …]` in the same posed
+   * frame as `positions` (encoder version 2+). Written as a LINES primitive on the
+   * sub-part's mesh. Empty or absent writes none, and decodes as "no feature edges".
+   */
   edges?: Float32Array | null;
 }
 
@@ -33,7 +37,7 @@ export interface EncodePreviewInput {
   view?: string | null;
 }
 
-/** Bumped whenever the encoder writes different bytes for the same input. */
+/** Bumped whenever the encoder writes different bytes for the same input (2: feature edges). */
 export const PREVIEW_ENCODER_VERSION: number;
 
 /** Encode one view's posed meshes as a welded, quantized, meshopt-compressed GLB (Y-up, millimetres). Deterministic. */