partforge 0.151.0 → 0.153.0

package/docs/AUTHORING-PARTS.md

@@ -393,7 +393,9 @@ meta: { title: "…", units: "mm", environment: "studio" },
   marked tintable are normally coloured this way (anodizing, plastic, paint);
   the others have an intrinsic colour (brass) but still accept one. (A viewer
   user PICKING an untintable preset drops an authored tint for that pick — see
-  the runtime section below.)
+  the runtime section below.) On a TEXTURED preset (`oak`, `walnut`, `plywood`,
+  `pine-plywood`) `color` multiplies the scanned wood and dulls its grain — leave
+  it unset unless you mean a stain (lint warns: `material-tint-textured`).
 - Overrides — each clamped to its range: `roughness` (0–1), `metalness` (0–1),
   `clearcoat` (0–1), `clearcoatRoughness` (0–1), `anisotropy` (0–1), `textureScale` (0.01–1000).
   Transmission, index of refraction, sheen and iridescence come only from a preset.
@@ -401,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):
@@ -409,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
@@ -434,15 +440,25 @@ modelled in its print orientation, not the material. Wood, carbon fibre and SLS
 fixed to the sub-part, so they never slide when the camera or an animation
 moves.
 
-**Laser-cut wood.** In realistic mode a laser `sheetPart` in a wood — `plywood`, `oak` or
+**Laser-cut wood.** In realistic mode a laser `sheetPart` in a wood — `plywood`, `pine-plywood`, `oak` or
 `walnut`, named or its stock's default (so a plywood sheet that names no material burns too)
 — shows what the laser did: its cut edges are charred, darker on thicker stock (on
-`plywood` the plies show through), and its engraving and score lines are scorched, while its
+`plywood` and `pine-plywood` the plies show through), and its engraving and score lines are scorched, while its
 faces stay wood. There is nothing to set, and it is still one material: the char follows
 from the sheet and the wood it is drawn in. It needs the sheet's own frame, so a sheet part
 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):
@@ -451,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` | size of one texture tile (the grain repeats every this many mm) | 250 (`oak`), 400 (`walnut`), 150 (`plywood`) |
+| 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.
@@ -487,7 +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. |
+| `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):
@@ -2173,8 +2190,8 @@ plate is `sheetPart`.
 import { routedPart, roundedRectProfile } from "partforge/geometry";
 
 plinth: routedPart({
-  label: "Hardwood base", views: { assembly: true, base: true }, display: { color: 0x6e3d23 },
-  material: "walnut",                           // stock label: groups pieces in the kit
+  label: "Plywood base", views: { assembly: true, base: true }, display: { material: "pine-plywood" },
+  material: "pine plywood",                     // stock label: groups pieces in the kit
   thickness: (p) => p.baseThickness,            // the MEASURED board, from a control
   profile: (k, p) => k.shape2d(roundedRectProfile(p.baseLength, p.baseWidth, 10)),   // the THROUGH cut
   pockets: (k, p, d) => [
@@ -3960,12 +3977,15 @@ 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
 or one of the six overrides; ignored), `material-override-clamped` (an override
-outside its range, or not a number; clamped).
+outside its range, or not a number; clamped), `material-tint-textured` (a
+`display.color` on a textured preset that is not tintable — `oak`, `walnut`,
+`plywood`, `pine-plywood`: the colour multiplies the scanned wood and dulls its
+grain; drop it unless a stain is intended).
 
 **Geometry imports** — `import-unknown-name` (a build calls `k.import` with a
 name the part's `imports` field doesn't declare — this throws at build time;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.151.0",
+  "version": "0.153.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/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);
@@ -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/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,17 +79,26 @@ 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). 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.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

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;
@@ -32,11 +33,11 @@ const withHole = (k) =>
 // can diff them pixel for pixel — and one row of sheets that name no material, drawn as
 // their stock (sheet-look.js STOCK_LOOKS).
 const SW = 30;
-const WOODS = ["plywood", "oak", "walnut"];
+const WOODS = ["plywood", "pine-plywood", "oak", "walnut"];
 const CONTROLS_Y = -WOODS.length * PITCH;
 const LASER_SWATCHES = [
   ...WOODS.flatMap((material, row) => [3, 6, 9].map((t, col) => ({
-    key: `${material}_${t}`, label: `${PRESETS[material].label}, ${t} mm`, at: [col * PITCH, -row * PITCH], t, display: { material },
+    key: `${material.replaceAll("-", "_")}_${t}`, label: `${PRESETS[material].label}, ${t} mm`, at: [col * PITCH, -row * PITCH], t, display: { material },
   }))),
   { key: "acrylic_3", label: "Clear acrylic, 3 mm", at: [0, CONTROLS_Y], t: 3, display: { material: "clear-acrylic" }, stock: "clear acrylic" },
   { key: "oak_standing", label: "Oak, 3 mm, standing", at: [PITCH, CONTROLS_Y], t: 3, display: { material: "oak" }, standing: true },
@@ -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,
   },
 };