partforge 0.134.0 → 0.136.0

package/docs/AUTHORING-PARTS.md

@@ -334,9 +334,10 @@ meta: { title: "…", units: "mm", environment: "studio" },
 - `material` — a preset id from the table below. Without one (or with one the
   library does not know) the sub-part keeps the CAD view's look — its `color`,
   else the viewer's blue-grey — and **realistic mode shows it as a PLA print**
-  (`pla-print`'s finish and layer lines) in that same colour. So an untouched
-  part looks printed in realistic mode; name a material when it is made some
-  other way. The PLA look is realistic-only: the CAD view, export colours and
+  (`pla-print`'s finish and layer lines) in that same colour — except a laser
+  `sheetPart`, which shows its stock instead (below). So an untouched part looks
+  printed in realistic mode; name a material when it is made some other way. The
+  PLA look is realistic-only: the CAD view, export colours and
   `declaresMaterials` are unaffected, and a part that names no material is not
   treated as declaring one.
 - `color` — the base colour (`0xRRGGBB`). With a preset it is the TINT. Presets
@@ -349,6 +350,23 @@ 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
+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):
+
+| A word of the stock label starts with | Realistic look |
+| --- | --- |
+| `acryl`, `perspex`, `plexi`, `pmma`, `methacryl`, `polycarb`, `lexan`, `makrolon`, `lucite` | `clear-acrylic` |
+| 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
+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
+PLA look, this is realistic-only and never makes a part declare a material.
+
 **Where it shows.** The CAD view (with feature lines) shows each material's
 colour, flattened so dark materials stay readable. **Realistic** mode — the
 viewer's toggle — shows the full material under environment lighting, with a
@@ -365,6 +383,15 @@ displayed. If the lines run the wrong way, fix the export pose with `place()`
 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
+`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
+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 its own `place` shows plain wood. The CAD view and every export are
+unchanged.
+
 **`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):
@@ -373,7 +400,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` | size of one texture tile (the grain repeats every this many mm) | 250 (`oak`), 400 (`walnut`) |
+| wood | `oak`, `walnut`, `plywood` | size of one texture tile (the grain repeats every this many mm) | 250 (`oak`), 400 (`walnut`), 150 (`plywood`) |
 | carbon weave | `carbon-fiber` | size of one texture tile | 48 |
 
 Presets without a pattern ignore it.
@@ -409,6 +436,7 @@ 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. |
 | `carbon-fiber` | Carbon fibre | — | 2x2 twill carbon fibre under clear coat. |
 
 **Environments** (`meta.environment`, default `studio`; viewers can switch):
@@ -1808,8 +1836,8 @@ needing the kernel is `(k, p, d) => …`; a plain value is a literal or `(p, d)
 `material`, `thickness` and `profile` are required; `score`, `engrave`, `pose`,
 `process` (default `"laser"`) are optional; `label`, `views`, `display`, `export`,
 `enabled`, `exportable`, `reference` pass through; your own `place` runs after the
-pose. `build` is supplied — passing one throws, as do `kerf`, `outline`/`cut` (use
-`profile`) and `quantity` (the kit counts identical pieces).
+pose. `build` is supplied — passing one throws, as do `kerf`, `outline`/`cut` and
+`quantity`; each error names the fix.
 
 ### Cut, score and engrave
 
@@ -1898,7 +1926,7 @@ PRINT pose, `place` it for display, and cut the slot where the tongue lands:
 | `verify-process-sheets-only` | warning | `verify.process` is set but every exportable part is a sheet part |
 | `laser-thickness-range` | warning | a laser sheet is thinner than 0.5 mm or thicker than 12 mm |
 
-**Verify** runs the laser checks on every sheet part. They are
+**Verify** runs the laser checks on every sheet part, as
 *volunteered* warnings: none counts toward `declared`/`evaluated`, so none makes
 `verify.ok` true on its own. Declare one in `expect` to make it count:
 
@@ -1928,12 +1956,13 @@ A host downloads sheet parts as one ZIP, the **cut & print kit** (`format: "bund
 
 - One thickness per joint: fingers, tabs and T-slots join panels cut from the
   same sheet.
-- Poses are rigid and axis-aligned: `face` and `up` are the six axis words. A
-  panel at an angle is an author `place` after the pose, or a printed part.
+- Poses are rigid and axis-aligned: `face` and `up` are the six axis words. An
+  angled panel is an author `place` after the pose (realistic mode then shows
+  no laser burns), or a printed part.
 - No bends, folds, living hinges or grain direction: `folds`, `bends` and
   `grain` are reserved keys and throw.
-- Cut and score are vector lines; engraving is filled regions. There is no raster
-  image engraving.
+- Cut and score are vector lines; engraving is filled regions, never a raster
+  image.
 - The laser checks are warnings. Sharp-corner shrinking can over-report at acute
   tips, and a web within 0.05 mm of the floor can read as passing.
 
@@ -1986,7 +2015,7 @@ const hingeSlots = (k, p, d, pose, z) => d.hingeX.flatMap((hx) =>
   [hx - HINGE.tongueX, hx + HINGE.tongueX].map((x) =>
     k.shape2d(tab(p).slot).translate(worldToSheet(pose, [x, p.depth / 2, z]))));
 
-const PLY = { views: ["box"], display: { material: "oak" }, material: "birch plywood", thickness: (p) => p.t };
+const PLY = { views: ["box"], display: { material: "plywood" }, material: "birch plywood", thickness: (p) => p.t };
 const panel = (name, label, extra = {}) => sheetPart({
   ...PLY, label,
   profile: (k, p, d) => d.box[name].outline,       // drawn as seen from outside
@@ -3177,7 +3206,8 @@ addition to) the generated view style button above:
   revert too.
 - `runtime.declaresMaterials` — `true` when any sub-part names a
   `display.material`. A part with none still supports realistic mode (every
-  sub-part renders as a PLA print in its CAD colour), so use this to decide
+  sub-part renders as a PLA print in its CAD colour, a laser sheet part as its
+  stock — "Sheet parts default to their stock"), so use this to decide
   whether to surface your own realistic control at all, not whether it works.
   Feature lines are not a preference: they draw whenever `runtime.renderMode`
   reads `"cad"` and never while it reads `"realistic"` — there is no switch
@@ -3665,7 +3695,8 @@ trust handling.
 
 **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), `unknown-environment`
+in realistic mode, or for a laser 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.134.0",
+  "version": "0.136.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/app-materials.js

@@ -12,7 +12,9 @@ import { mount } from "./framework/index.js";
 // open /materials.html. Not part of the production build — check materials.html
 // by eye after any preset or shader change (see AGENTS.md "Architecture").
 // Dev-only: the handle is stashed on window so scripts/check-app.mjs can drive
-// the embedding contract (runtime.captureCurrent) the way an embedder would.
+// the embedding contract (runtime.captureCurrent) the way an embedder would, and
+// scripts/capture-contact-sheet.mjs can switch views and environments and call
+// runtime.renderViews — removing it breaks both.
 window.__pfRuntime = mount(materialSwatchesPart, {
   createWorker: (name) =>
     new Worker(new URL("./materials-worker.js", import.meta.url), { type: "module", name }),

package/src/framework/fonts.js

@@ -31,3 +31,11 @@ export async function resolveFonts(fontsDecl) {
   }
   return resolveDecl(fontsDecl, resolveOne);
 }
+
+// Drop one source's memo entry. jobs.js calls this once a font is PARSED: the
+// parsed Font is what the kernel keeps (kernel._fontsBySource, bounded), so
+// holding the raw ArrayBuffer here as well doubled the cost of every font a
+// session ever auditioned and released none of it (spec 2026-10-01 §3).
+export function forgetFontSource(source) {
+  cache.delete(source);
+}

package/src/framework/jobs.js

@@ -6,7 +6,7 @@ import { meshTo3MF } from "./geometry/threemf.js";
 import { printColor } from "./materials/resolve.js";
 import { exportablePartNames } from "./export-select.js";
 import { fontControlAllows, fontSourceAllowed, isNoFontSource } from "./font-source.js";
-import { fontsFor, resolveFonts } from "./fonts.js";
+import { fontsFor, resolveFonts, forgetFontSource } from "./fonts.js";
 import { normalizeOpentype, parseFont } from "./geometry/opentype-interop.js";
 import { imageControlAllows, imageSourceAllowed, isNoImageSource } from "./image-source.js";
 import { imagesFor, ensureImages } from "./images.js";
@@ -16,6 +16,8 @@ import { vectorControlAllows, vectorSourceAllowed, isNoVectorSource } from "./ve
 import { vectorsFor, ensureVectors } from "./vectors.js";
 import { exportSubParts, resolveParams, buildPosed } from "./part-model.js";
 
+export const FONT_SOURCE_CACHE_MAX = 4;
+
 // The oracle loads LAZILY, per job family, never at worker boot. It is the largest
 // JS payload in the worker's graph (measure/verify/build and silhouette/match), and
 // only the `inspect` job runs any of it — the generate/export hot path touches none.
@@ -264,26 +266,51 @@ export async function handle(kernel, part, msg, post, opts = {}) {
     if (part.fonts && kernel._fonts) {
       const declared = fontsToResolve ?? {};
       if (Object.keys(declared).length) {
-        onProgress("resolving fonts");
-        const opentype = normalizeOpentype(await import("opentype.js"));
-        const bufs = await resolveFonts(declared);
         // Keyed on the SOURCE, not the name. A name is not a font identity: one
         // worker outlives many parts (worker-rebind) and, once a font can come
         // from a param, many picks — all of which reuse the same declared name.
         // The old `if (!_fonts.has(name))` made the first bytes ever seen under a
         // name permanent for the life of the worker.
         //
-        // The source, not the resolved buffer: the two agree only because the
-        // resolver's own memo is unbounded and hands back the identical object
-        // every time. Key on that and this memo silently degrades to per-fetch
-        // identity — a re-parse per build — the day eviction is added there.
+        // The parse cache keys on the source and is the ONLY holder of a font:
+        // the resolver's memo is transient (forgotten once a font is parsed).
         kernel._fontsBySource ??= new Map();
-        for (const [name, buf] of bufs) {
-          const source = declared[name];
+        // Resolve only what this kernel has not parsed yet: a source already in
+        // the parse cache needs no bytes at all, which is what lets the resolver
+        // forget a buffer the moment its font is parsed (below).
+        const unparsed = Object.fromEntries(
+          Object.entries(declared).filter(([, src]) => !kernel._fontsBySource.has(src)),
+        );
+        let bufs = new Map();
+        if (Object.keys(unparsed).length) {
+          onProgress("resolving fonts");
+          bufs = await resolveFonts(unparsed);
+        }
+        const opentype = bufs.size ? normalizeOpentype(await import("opentype.js")) : null;
+        for (const [name, source] of Object.entries(declared)) {
           let font = kernel._fontsBySource.get(source);
-          if (!font) { font = parseFont(opentype, buf, name); kernel._fontsBySource.set(source, font); }
+          if (font) {
+            kernel._fontsBySource.delete(source);              // re-insert = most recent
+          } else {
+            font = parseFont(opentype, bufs.get(name), name);
+            forgetFontSource(source);                           // the parsed Font is what we keep
+          }
+          kernel._fontsBySource.set(source, font);
           kernel._fonts.set(name, font);
         }
+        // Bounded (spec 2026-10-01 §3): auditioning fonts in the picker
+        // otherwise kept every face ever tried, per kernel, for the worker's
+        // life. Map order is recency (re-inserted on use above), so eviction
+        // takes the oldest. A source THIS build declared is never evicted — a
+        // part declaring more than the bound would otherwise evict its own
+        // fonts and refetch/reparse them on every build — so the bound is
+        // max(FONT_SOURCE_CACHE_MAX, this build's distinct sources).
+        const keep = new Set(Object.values(declared));
+        const limit = Math.max(FONT_SOURCE_CACHE_MAX, keep.size);
+        for (const src of kernel._fontsBySource.keys()) {
+          if (kernel._fontsBySource.size <= limit) break;
+          if (!keep.has(src)) kernel._fontsBySource.delete(src);
+        }
       }
       // Drop every name this build's declaration does not supply. `_fonts` is
       // the kernel's, and the kernel outlives the job: without this, a face the

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

@@ -1,12 +1,13 @@
 // src/framework/lint/rules-materials.js
 // Appearance findings. All WARNINGS by design: a misspelled material must never
 // block geometry, and the viewer already falls back (resolve.js). Pure — imports
-// only the three-free materials data (test/lint-purity.test.js).
+// only three-free materials and sheet data (test/lint-purity.test.js).
 import { warn } from "./finding.js";
 import { PRESETS } from "../materials/presets.js";
 import { ENVIRONMENTS } from "../materials/environments.js";
 import { resolveMaterial, resolveEnvironmentId, OVERRIDE_RANGES } from "../materials/resolve.js";
 import { suggest } from "../geometry/op-options.js";
+import { sheetStockLook } from "../materials/sheet-look.js";
 
 const listedPresets = () => Object.keys(PRESETS);
 const subParts = (part) => Object.entries(part?.parts ?? {}).filter(([, sp]) => sp && typeof sp === "object");
@@ -18,9 +19,15 @@ 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) —
+      // 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);
+      const why = typeof sp.sheet?.material === "string" ? ", from its stock label" : ": its stock label is a function";
+      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 (a PLA print in realistic mode). Known materials: ${listedPresets().join(", ")}.`,
+        `${near ? `Did you mean "${near}"? ` : ""}The viewer draws it as if it named no material instead (${fallback}). Known materials: ${listedPresets().join(", ")}.`,
         `parts.${name}.display.material`);
     }),
   },

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

@@ -66,6 +66,9 @@ the sliced primary and gain-map buffers now start with SOI (`FF D8`) and end wit
 | `pattern-walnut-color.jpg` | Poly Haven "Dark Wood" (colour; API key `Diffuse`) | https://polyhaven.com/a/dark_wood — file https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/dark_wood/dark_wood_diff_1k.jpg | 2026-09-24 | 1K JPG, sRGB colour -> `node scripts/bake-environments.mjs --texture dark_wood_diff_1k.jpg pattern-walnut-color.jpg` (q82). Scanned tile 2000 mm (`api.polyhaven.com/info/dark_wood` dimensions). |
 | `pattern-walnut-normal.jpg` | Poly Haven "Dark Wood" (OpenGL normal map; API key `nor_gl`) | https://polyhaven.com/a/dark_wood — file https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/dark_wood/dark_wood_nor_gl_1k.jpg | 2026-09-24 | 1K JPG, OpenGL (+Y up) tangent normals, kept as data -> `node scripts/bake-environments.mjs --texture dark_wood_nor_gl_1k.jpg pattern-walnut-normal.jpg --data --quality 95` (4:4:4 chroma, no grayscale/tint; q95 because the map is nearly flat and the viewer amplifies it, so q90's 8x8 blocks showed). |
 | `pattern-walnut-rough.jpg` | Poly Haven "Dark Wood" (roughness; API key `Rough`) | https://polyhaven.com/a/dark_wood — file https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/dark_wood/dark_wood_rough_1k.jpg | 2026-09-24 | 1K JPG, grayscale data -> `node scripts/bake-environments.mjs --texture dark_wood_rough_1k.jpg pattern-walnut-rough.jpg --gray` (source is neutral grey; channel means unchanged). |
+| `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`). |
 | `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.) |
@@ -76,9 +79,11 @@ the sliced primary and gain-map buffers now start with SOI (`FF D8`) and end wit
 | `pattern-carbon.jpg` | None — procedural | n/a | n/a | ambientCG has no CC0 carbon-fiber weave (searched "carbon"; only unrelated fabric hits). Generated in-baker: a 256x256 2x2 twill tile (32 threads/tile, alternating dark/light grey diagonal bands) -> `node scripts/bake-environments.mjs --carbon pattern-carbon.jpg`. No external source/licence to record. |
 
 ambientCG publishes every asset under CC0 (https://ambientcg.com/, "CC0 Public Domain
-license", checked 2026-09-24). The wood sets (`pattern-oak-*`, `pattern-walnut-*`,
-`ground-maple-*`) are Poly Haven textures, CC0 like its HDRIs above
-(https://polyhaven.com/license, checked 2026-09-24); the exact 1K JPG URLs came
+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
+(`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
 from `https://api.polyhaven.com/files/<slug>` (keys `Diffuse`, `nor_gl`, `Rough`).
 The presets tile them smaller than the scanned size — see the comment on `oak` in
 `presets.js` and on `workshop` in `environments.js`.
@@ -86,5 +91,6 @@ The presets tile them smaller than the scanned size — see the comment on `oak`
 ## Budgets
 
 Environments stay under 1.5 MB (largest: `env-workshop.jpg` at ~398 KB); ground/pattern
-textures stay under 400 KB (largest: `pattern-oak-rough.jpg` at ~218 KB). All committed
+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
 outputs are well inside both ceilings — see `test/framework/materials-assets.test.js`.

package/src/framework/materials/assets.js

@@ -25,6 +25,9 @@ const URLS = {
   "pattern-walnut-color.jpg": new URL("./assets/pattern-walnut-color.jpg", import.meta.url).href,
   "pattern-walnut-normal.jpg": new URL("./assets/pattern-walnut-normal.jpg", import.meta.url).href,
   "pattern-walnut-rough.jpg": new URL("./assets/pattern-walnut-rough.jpg", import.meta.url).href,
+  "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-carbon.jpg": new URL("./assets/pattern-carbon.jpg", import.meta.url).href,
 };
 

package/src/framework/materials/patterns.js

@@ -5,7 +5,10 @@
 // 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).
 import * as THREE from "three";
+import { BURN, 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
@@ -354,3 +357,103 @@ export function applyBrushFrame(material) {
   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,
+// engrave and score floors scorched, faces untouched. Composes over the wood pass the way
+// applyBrushFrame does, injecting at three points in three's meshphysical order:
+//   (a) colour + roughness, before <normal_fragment_begin>: after wood's body (injected
+//       after <roughnessmap_fragment>) and <metalnessmap_fragment>. A second replace of
+//       <roughnessmap_fragment> would land IN FRONT of wood's body, so it is not reused.
+//       pfBurnWall / pfBurnFloor are declared at main() scope, like pfLayer, for (b), (c).
+//   (b) the normal, before <emissivemap_fragment>: after wood's normal map and the
+//       clearcoat normals. Char flattens the wood's relief: the wood normal fades toward
+//       the geometric one (nonPerturbedNormal, set by <normal_fragment_begin>), keeping
+//       BURN.relief of it.
+//   (c) clearcoat, after <lights_physical_fragment>, which assigns material.clearcoat:
+//       walnut's lacquer comes off the char.
+// Every snippet sits between `// pf-burn {` and `// } pf-burn` lines: that is how the tests
+// prove a burning program is the plain wood program plus these and nothing else. The
+// 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;
+}`);
+
+const BURN_FRAG_BODY = burnBlock(`float pfBurnWall = 0.0;
+float pfBurnFloor = 0.0;
+if (pfSheetT > 0.0) {
+  vec3 pfC = (pfSheetFrame * vec4(vPfObjPos, 1.0)).xyz;
+  vec3 pfCn = normalize(mat3(pfSheetFrame) * vPfObjNormal);
+  pfBurnWall = 1.0 - smoothstep(${glf(BURN.wallNz[0])}, ${glf(BURN.wallNz[1])}, abs(pfCn.z));
+  pfBurnFloor = step(0.5, pfCn.z) * step(pfC.z, pfSheetT - ${glf(BURN.floorDepth)});
+  float pfK = mix(${glf(BURN.kThin)}, ${glf(BURN.kThick)}, clamp((pfSheetT - ${glf(BURN.tThin)}) / ${glf(BURN.tThick - BURN.tThin)}, 0.0, 1.0));
+  float pfZ = clamp(pfC.z / pfSheetT, 0.0, 1.0);
+  vec3 pfFace = diffuse * pfFaceAvg;
+  // Per channel, not the vector scaled by one luminance ratio (sheet-look.js's burnAlbedo,
+  // this shader's twin, explains why): a channel where charOfDark·face is already below raw
+  // charcoal chars toward ITS OWN darker value, so no channel can come out lighter than it
+  // 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
+  // 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;
+  pfMark *= pfGrain;
+  diffuseColor.rgb = mix(diffuseColor.rgb, pfEdge, pfBurnWall);
+  diffuseColor.rgb = mix(diffuseColor.rgb, pfMark, pfBurnFloor);
+  roughnessFactor = mix(roughnessFactor, ${glf(BURN.roughness)}, max(pfBurnWall, pfBurnFloor));
+}`);
+
+const BURN_FRAG_NORMAL = burnBlock(`normal = normalize(mix(normal, nonPerturbedNormal, max(pfBurnWall, pfBurnFloor) * ${glf(1 - BURN.relief)}));`);
+
+const BURN_FRAG_CLEARCOAT = burnBlock(`#ifdef USE_CLEARCOAT
+material.clearcoat *= 1.0 - max(pfBurnWall, pfBurnFloor);
+#endif`);
+
+// `faceAvg` is the preset's own colour (0xRRGGBB) — its texture's average, never the tint:
+// the tint arrives as `diffuse`, so the shader's face colour is diffuse · pfFaceAvg.
+export function applyBurn(material, { faceAvg }) {
+  const uniforms = material.userData.patternUniforms;
+  if (!uniforms?.pfGrainSwap) return material; // wood only: the burn draws over the wood pass
+  Object.assign(uniforms, {
+    pfSheetFrame: { value: new THREE.Matrix4() },
+    pfSheetT: { value: 0 },
+    pfPlies: { value: 0 },
+    pfFaceAvg: { value: new THREE.Color(faceAvg) },
+  });
+  const prev = material.onBeforeCompile;
+  const prevKey = material.customProgramCacheKey;
+  material.onBeforeCompile = (shader, renderer) => {
+    prev?.call(material, shader, renderer); // applyPattern's hook copies `uniforms` — burn uniforms included
+    shader.fragmentShader = shader.fragmentShader
+      .replace("#include <common>", `#include <common>\n${BURN_FRAG_DECL}`)
+      .replace("#include <normal_fragment_begin>", `${BURN_FRAG_BODY}\n#include <normal_fragment_begin>`)
+      .replace("#include <emissivemap_fragment>", `${BURN_FRAG_NORMAL}\n#include <emissivemap_fragment>`)
+      .replace("#include <lights_physical_fragment>", `#include <lights_physical_fragment>\n${BURN_FRAG_CLEARCOAT}`);
+  };
+  const base = prevKey && prevKey !== THREE.Material.prototype.customProgramCacheKey ? prevKey.call(material) : "";
+  material.customProgramCacheKey = () => `${base}|pf-burn`;
+  material.needsUpdate = true;
+  return material;
+}

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 } from "./resolve.js";
-import { applyBrushFrame, applyPattern } from "./patterns.js";
+import { applyBrushFrame, applyBurn, applyPattern } from "./patterns.js";
 import { PATTERN_TEXTURES } from "./assets.js";
 
 const APPEARANCE_KEYS = ["color", "opacity", "material", "roughness", "metalness", "clearcoat", "clearcoatRoughness", "anisotropy", "textureScale"];
@@ -24,8 +24,11 @@ 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.
 export function buildPhysicalMaterial(display, opts = {}) {
-  const m = buildPhysical(display, opts);
+  let m = buildPhysical(display, opts);
+  if (opts.burn) m = applyBurn(m, { faceAvg: resolveMaterial(display).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

@@ -13,7 +13,8 @@ const P = (id, label, category, use, fields) => ({ id, label, category, use, tin
 export const PRESETS = {
   // Every record here is a documented, nameable material. A sub-part that names
   // none is drawn by resolve.js (the blue-grey CAD look; a PLA print in that
-  // colour in realistic mode) — there is no hidden "default" record any more.
+  // colour in realistic mode, or a laser sheet part's stock look — sheet-look.js
+  // realisticDisplay) — there is no hidden "default" record any more.
 
   "machined-aluminum": P("machined-aluminum", "Machined aluminium", "aluminium", "Bare CNC-milled aluminium, fine tool marks, satin sheen.",
     { color: 0xf5f6f6, metalness: 1, roughness: 0.32 }),
@@ -73,17 +74,22 @@ export const PRESETS = {
   // mode the texture carries the colour itself; an explicit `color` tints it.
   // `roughnessMean` is the roughness map's mean, so the preset `roughness` (or an
   // override) sets the AVERAGE roughness and the map only varies it. `normalScale`
-  // strengthens the normal map: these scans' tangent normals barely leave +Z (a
-  // ~1% tilt), which reads as flat under an environment map. `grain` is the
+  // strengthens the normal map: the oak and walnut scans' tangent normals barely leave +Z (a
+  // ~1% tilt), which reads as flat under an environment map; plywood's carries about three
+  // 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 across it ("u") — so patterns.js can lay it along each sub-part's
-  // long axis.
+  // 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).
   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.",
+    { 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" } }),
   "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/resolve.js

@@ -27,8 +27,10 @@ const isColor = (v) => Number.isInteger(v) && v >= 0 && v <= 0xffffff;
 // material and threemf.js's uncoloured-object colour are the same literal).
 // Realistic mode draws it as a PLA print — the pla-print finish, layer lines
 // and all — in that same colour, or the part's own `color`, so a part is the
-// same colour in both views, just printed. `declaresMaterials` still counts
-// only a NAMED material: this default never makes a part "declare" one.
+// same colour in both views, just printed — except a laser sheet part, which
+// realistic mode draws as its stock instead (sheet-look.js realisticDisplay,
+// applied before this resolves). `declaresMaterials` still counts only a NAMED
+// material: this default never makes a part "declare" one.
 export const NO_MATERIAL_COLOR = 0x9fb4cc;
 export const NO_MATERIAL_PRESET_ID = "pla-print";
 const NO_MATERIAL_CAD = { color: NO_MATERIAL_COLOR, metalness: 0.25, roughness: 0.55 };