partforge 0.134.0 → 0.135.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.135.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/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 };

package/src/framework/materials/sheet-look.js

@@ -0,0 +1,204 @@
+// src/framework/materials/sheet-look.js
+// How a laser-cut sheet part looks in realistic mode — plain data and pure math, three-free
+// and DOM-free like resolve.js, so the viewer, mount, lint and the tests all read ONE
+// statement of it. patterns.js turns it into GLSL; nothing here knows about three.
+//
+// A laser sheetPart in a wood shows its burns: charred cut walls, scorched engrave and
+// score floors, faces untouched. The shader tells those surfaces apart in the sheet's
+// CANONICAL frame — profile in XY, material over z ∈ [0, t], laser face at z = t — but the
+// viewer holds the DELIVERED display mesh. With no author `place`, sheetPart's generated
+// place is exactly the rigid steps poseSteps(pose, t) (and there is no place at all with no
+// pose), so the delivered mesh is that motion applied to the canonical solid and the frame
+// is its inverse: computed from data, with no pose probe and no geometry. A sheet with an
+// 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
+// (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.
+import { isSheetPart, sheetMeta, MARK_DEPTH } from "../sheet/constants.js";
+import { poseSteps, validatePose } from "../sheet/pose.js";
+import { composePose, invertRigid } from "../geometry/pose.js";
+import { resolveMaterial } from "./resolve.js";
+import { PRESETS } from "./presets.js";
+
+const IDENTITY = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+
+// The burn's numbers, ONE statement: patterns.js templates the GLSL from them, and the JS
+// twins below (classifySheetSurface, burnAlbedo) read the same object.
+//   wallNz      a surface whose canonical |n.z| is below this band is a cut wall (the
+//               shader blends across the band; the JS twin splits at its middle). Creased
+//               normals are hard at a sheet's 90° arris, so real walls sit at n.z = 0.
+//   floorDepth  an up-facing surface at least this far below the laser face is an engrave
+//               or score floor: half the preview's MARK_DEPTH, so the laser face (z = t) is
+//               never one and a mark's floor (z = t − MARK_DEPTH) always is.
+// Char is RELATIVE to the face, all in linear RGB. A cut wall is the face's average colour
+// mixed toward a char TARGET by k — kThin at ≤ tThin mm, kThick at ≥ tThick (thick stock takes
+// a longer dwell) — plus up to `exit` more toward the exit side (z = 0); an engrave or score
+// floor mixes `engraveLess` less. The target is PER CHANNEL: min(charcoal_i, charOfDark ·
+// face_i) (burnAlbedo's `target`). For oak and plywood that is `charcoal` itself; charOfDark
+// 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.
+//   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
+//               average is unchanged and no texel comes out lighter; burnTexel is the twin).
+//   relief      the share of the wood's surface relief (its normal map) that char and
+//               scorched floors keep; the rest fades to the geometric normal.
+//
+// The numbers were tuned by eye on the contact sheet in all four environments, inside the
+// calibration floors test/framework/sheet-look.test.js holds them to. The twins see only the
+// albedo. The render adds specular reflection — the same at every thickness — which no albedo
+// can take away, and on walnut, whose char is near black, it is most of what a lit wall shows.
+// So judge a retune on captures (scripts/capture-contact-sheet.mjs) compared at the SAME place
+// on the sheet, never on the twins alone: swatches in different places reflect different
+// light. The design spec records the measurements.
+export const BURN = Object.freeze({
+  wallNz: Object.freeze([0.35, 0.65]),
+  floorDepth: MARK_DEPTH / 2,
+  charcoal: 0x262220,
+  kThin: 0.74,
+  kThick: 0.97,
+  tThin: 3,
+  tThick: 9,
+  exit: 0.1,
+  engraveLess: 0.1,
+  charOfDark: 0.37,
+  roughness: 0.68,
+  crossPly: 0.78,
+  grain: 1,
+  relief: 0.35,
+});
+
+// sRGB 0xRRGGBB → linear [r, g, b]: the conversion three applies to a colour uniform.
+export function srgbToLinear(hex) {
+  return [(hex >> 16) & 255, (hex >> 8) & 255, hex & 255].map((c) => {
+    const s = c / 255;
+    return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  });
+}
+
+// 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]]);
+export function plyCount(t) {
+  for (const [below, plies] of PLY_STEPS) if (t < below) return plies;
+  return 9;
+}
+
+// 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
+// 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
+// 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",
+  ]) }),
+]);
+export const DEFAULT_STOCK_LOOK = "plywood";
+
+const labelWords = (label) => {
+  const lower = label.toLowerCase();
+  return [...lower.split(/[^\p{L}]+/u), ...lower.replace(/-/g, "").split(/[^\p{L}]+/u)].filter(Boolean);
+};
+
+export function stockLook(stock) {
+  if (typeof stock !== "string") return DEFAULT_STOCK_LOOK;
+  const words = labelWords(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).
+export function sheetStockLook(sp) {
+  return isSheetPart(sp) && sp.sheet.process === "laser" ? stockLook(sp.sheet.material) : null;
+}
+
+// The display realistic mode draws: sp.display itself, except that a laser 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).
+export function realisticDisplay(sp) {
+  const display = sp?.display;
+  const look = sheetStockLook(sp);
+  if (!look) return display;
+  if (typeof display?.material === "string" && Object.hasOwn(PRESETS, display.material)) return display;
+  return { ...(display && typeof display === "object" ? display : {}), material: look };
+}
+
+// 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
+  try { return lookOf(sp).params.pattern === "wood"; } catch { return false; }
+}
+
+// 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
+// the pose or thickness cannot be read (the build reports those).
+export function sheetFrameFor(sp, { p, d } = {}) {
+  if (!burnsFor(sp)) return null;
+  const meta = sheetMeta(sp, p, d);
+  if (!meta) return null;
+  const t = meta.thickness;
+  let pose;
+  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 = pose == null ? [...IDENTITY] : invertRigid(composePose(poseSteps(pose, t)));
+  return { frame, t, plies: lookOf(sp).preset.laminated ? plyCount(t) : 0 };
+}
+
+// The shader's surface classification, in JS: the frame tests hold real geometry to it.
+// `pos` and `normal` are canonical (after the frame); `t` is the thickness.
+export function classifySheetSurface(pos, normal, t) {
+  if (Math.abs(normal[2]) < (BURN.wallNz[0] + BURN.wallNz[1]) / 2) return "wall";
+  if (normal[2] < 0) return "back";
+  return pos[2] <= t - BURN.floorDepth ? "floor" : "face";
+}
+
+const clamp01 = (x) => Math.min(1, Math.max(0, x));
+
+// The shader's burnt albedo, in JS (the calibration test's twin — same numbers, same
+// formula): `face` is the unburnt face's average colour in linear RGB (the preset's texture
+// average times any tint), `t` the sheet thickness (mm), `kind` "edge" — a cut wall, `zFrac`
+// of the way from the exit side (0) up to the laser face (1) — or "engrave", a mark's floor.
+// Ply bands are left out: they only modulate an edge. It returns the AVERAGE char — what the
+// face's average colour burns to. The shader then multiplies that by each texel's ratio to
+// the face average (texel ÷ face, blended by BURN.grain), so the grain shows through;
+// burnTexel below is that step's twin.
+export function burnAlbedo(face, t, { kind = "edge", zFrac = 1 } = {}) {
+  const charcoal = srgbToLinear(BURN.charcoal);
+  // The mix target, PER CHANNEL: whichever is darker of raw charcoal or charOfDark of this
+  // channel's own face value — never one colour for the whole vector, which a channel darker
+  // than that colour would be pulled UP toward (the BURN comment above). Multiplicative in the
+  // channel that governs it, so charring a face darker than charcoal in that channel still
+  // only ever removes light from it.
+  const target = charcoal.map((c, i) => Math.min(c, BURN.charOfDark * face[i]));
+  const k = BURN.kThin + (BURN.kThick - BURN.kThin) * clamp01((t - BURN.tThin) / (BURN.tThick - BURN.tThin));
+  const amount = kind === "engrave" ? k - BURN.engraveLess : Math.min(1, k + BURN.exit * (1 - clamp01(zFrac)));
+  return face.map((f, i) => f + (target[i] - f) * amount);
+}
+
+// One texel's burnt albedo, in JS — the shader's pfGrain step on top of burnAlbedo: `texel`
+// is the unburnt texel in linear RGB (the wood texture times any tint), the rest is
+// burnAlbedo's. The average char times mix(1, texel ÷ face, BURN.grain), per channel, with
+// the shader's 1e-4 floor under the divide. At grain 1 that is texel × (char ÷ face).
+export function burnTexel(texel, face, t, opts) {
+  return burnAlbedo(face, t, opts).map((c, i) => c * (1 + (texel[i] / Math.max(face[i], 1e-4) - 1) * BURN.grain));
+}

package/src/framework/mount.js

@@ -13,6 +13,7 @@ import { attachViewStyleControls } from "./view-style-controls.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 { buildControls } from "./controls.js";
 import { relevantParamKeys } from "./param-deps.js";
 import { createMeshCache } from "./mesh-cache.js";
@@ -863,6 +864,12 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
     // to its own worker in parallel, so a mixed part previews its plain sub-parts at
     // Manifold speed while only the OCCT-routed ones wait. The return value is
     // the job count — the loop holds the cycle open until every group has replied.
+    // Each dispatched sub-part remembers the { view, params } its job was sent with
+    // (`dispatched`): the frames the realistic look reads must describe the geometry
+    // that job builds, and a delivery shown during playback was built at params the
+    // live ones have already left (see recordFrames). One cycle is in flight at a time,
+    // so a sub-part's entry is its in-flight job's until the cycle's last reply.
+    const dispatched = new Map(); // sub-part -> { view, params } its latest job was sent with
     const loop = createRegenLoop({
       missingParts,
       send: (missing) => {
@@ -870,6 +877,8 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
         // for the overlay; this build reports the poses repaired in its own cycle.
         lastGen = { skipped: needed.length - missing.length, rebuilt: missing.length, posed: pendingPosed.size };
         pendingPosed.clear(); // consumed — never counted against a second build
+        const at = { view: view(), params: { ...params } };
+        for (const n of missing) dispatched.set(n, at);
         ui.showBusy("generating");
         const backends = backendPolicy.backendsFor(params);
         let jobs = 0;
@@ -951,44 +960,58 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
       }
     }
 
-    // Print frames for the layer-line pattern: the display → export map of the
-    // geometry just delivered, so layers run the way the part is printed rather
-    // than the way it is displayed. Each frame describes the delivered mesh
-    // (which a later pose-only repair only moves), and only sub-parts whose
-    // material draws layer lines have one — which includes every
-    // sub-part naming no material, since realistic mode shows those as PLA
-    // (resolve.js). One without a place() is identity at once; one with it
-    // costs two geometry-free probe builds.
+    // Frames the realistic look reads, for the geometry just delivered:
+    //  - print frames for the layer-line pattern: the display → export map, so layers run
+    //    the way the part is printed rather than the way it is displayed. Only sub-parts
+    //    whose material draws layer lines have one — which includes every sub-part naming
+    //    no material, since realistic mode shows those as PLA (resolve.js) — except a laser
+    //    sheet part, which it shows as its stock (sheet-look.js realisticDisplay). One
+    //    without a place() is identity at once; one with it costs two geometry-free probe
+    //    builds.
+    //  - sheet frames for the burn pass (materials/sheet-look.js): a laser sheet in a wood,
+    //    mapped back into its canonical frame — from data, no probe.
+    // Each describes the delivered mesh (which a later pose-only repair only moves).
     const layerLined = new Set(Object.keys(part.parts).filter((n) => {
-      try { return resolveMaterial(part.parts[n].display).params.pattern === "layer-lines"; } catch { return false; }
+      try { return resolveMaterial(realisticDisplay(part.parts[n])).params.pattern === "layer-lines"; } catch { return false; }
     }));
-    // LAZY: a delivery only records the view and params it was built at; the
-    // viewer pulls the frames (computePrintFrames) when it is about to draw the
-    // realistic look — live, loading, or borrowed by a capture — so a CAD-only
-    // session never probes (viewer.js setPrintFrameSource). The snapshot keeps
-    // a late computation describing the mesh actually delivered.
+    const burning = new Set(Object.keys(part.parts).filter((n) => burnsFor(part.parts[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)
+    // when it is about to draw the realistic look — live, loading, or borrowed by a
+    // capture — so a CAD-only session computes nothing (viewer.js setFrameSource). The
+    // snapshot keeps a late computation describing the mesh actually delivered.
     const printFrames = {};
-    const undrawnFrames = new Map(); // sub-part -> { view, params } at its delivery
-    function recordPrintFrames(names) {
-      const wanted = names.filter((n) => layerLined.has(n));
+    const sheetFrames = {};
+    const undrawnFrames = new Map(); // sub-part -> { view, params } its delivered mesh was built at
+    function recordFrames(names) {
+      const wanted = names.filter((n) => layerLined.has(n) || burning.has(n));
       if (!wanted.length) return;
-      const at = { view: view(), params: { ...params } };
-      for (const n of wanted) undrawnFrames.set(n, at);
-      viewer.invalidatePrintFrames?.();
+      for (const n of wanted) undrawnFrames.set(n, dispatched.get(n) ?? null); // null: built at params nobody recorded
+      viewer.invalidateFrames?.();
     }
-    function computePrintFrames() {
+    function computeFrames() {
       const resolvedFor = new Map(); // one resolveParams per delivery, not per sub-part
       for (const [n, at] of undrawnFrames) {
-        if (!resolvedFor.has(at)) {
+        if (at && !resolvedFor.has(at)) {
           try { resolvedFor.set(at, resolveParams(part, at.params)); } catch { resolvedFor.set(at, null); } // diagnosed by the build
         }
-        const resolved = resolvedFor.get(at);
-        if (resolved) printFrames[n] = printFrameMatrix(part.parts[n], { view: at.view, ...resolved });
+        const resolved = at ? resolvedFor.get(at) : null;
+        // No params to frame this mesh by: a burning sheet draws plain wood rather than
+        // keep a frame that describes other geometry — a sub-millimetre lag along its
+        // normal is enough to char a whole face. A print frame keeps its last value (the
+        // worst it can do is run layer lines the wrong way).
+        if (!resolved) { delete sheetFrames[n]; continue; }
+        if (layerLined.has(n)) printFrames[n] = printFrameMatrix(part.parts[n], { view: at.view, ...resolved });
+        if (burning.has(n)) {
+          const f = sheetFrameFor(part.parts[n], resolved);
+          if (f) sheetFrames[n] = f; else delete sheetFrames[n];
+        }
       }
       undrawnFrames.clear();
-      return { ...printFrames };
+      return { print: { ...printFrames }, sheet: { ...sheetFrames } };
     }
-    viewer.setPrintFrameSource?.(computePrintFrames);
+    viewer.setFrameSource?.(computeFrames);
 
     // Sub-parts whose latest fresh delivery had zero triangles (see the `meshes` case).
     const emptySubParts = new Set();
@@ -1051,7 +1074,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
               // delivered, which buildDone() true guarantees is at the live params.
               fastPath.recordDelivered(m.name);
             }
-            recordPrintFrames(data.meshes.map((m) => m.name));
+            recordFrames(data.meshes.map((m) => m.name));
             // A split dispatch answers in two meshes replies; the busy spinner
             // stays up until the view has everything (the other worker's job may
             // still be running — often OCCT, the slow one).
@@ -1082,10 +1105,14 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
           } else if (lastAnimApplyVersion === loop.version()) {
             // Stale ONLY because animation frames kept bumping the version:
             // show the delivered meshes anyway — that IS best-effort playback —
-            // but record NOTHING. Cache and fast-path stamps must describe
-            // geometry built at the live params, and this delivery wasn't; the
-            // fast-path stamp is dropped too, so a later pose-only repair can
-            // never re-pose this newer geometry off an older delivery's stamp.
+            // but record nothing about the LIVE params. Cache and fast-path stamps
+            // must describe geometry built at the live params, and this delivery
+            // wasn't; the fast-path stamp is dropped too, so a later pose-only
+            // repair can never re-pose this newer geometry off an older delivery's
+            // stamp. Its material frames are the exception: those are recorded
+            // against the params its job was dispatched with, which is what it was
+            // built at — keeping the last fresh delivery's frame instead would lay a
+            // sheet's burn over geometry that has moved along its normal.
             // A user edit mid-play pauses playback and bumps the version WITHOUT
             // touching lastAnimApplyVersion, so a genuinely user-stale result
             // fails this test and is discarded exactly as before.
@@ -1093,6 +1120,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
               viewer.setSubGeometry(m.name, m);
               fastPath.forget(m.name);
             }
+            recordFrames(data.meshes.map((m) => m.name));
             ui.hideBusy();
             refreshView();
           }

package/src/framework/sheet/part.js

@@ -9,6 +9,11 @@
 // `sp.sheet.generatedBuild` is the build made here; an author who replaces `build`
 // afterwards is detectable as `sp.build !== sp.sheet.generatedBuild`.
 //
+// Likewise `sp.sheet.generatedPlace` is the place made here (the pose, then the author's
+// own) and `sp.sheet.place` the author's own place, or null: the realistic look
+// (materials/sheet-look.js) trusts a sheet's canonical frame only with no author place
+// and `sp.place === sp.sheet.generatedPlace`.
+//
 // Placement (decision 10): the pose applies for display AND export, then the author's
 // own `place` — so STEP/3MF/STL files of a sheet forge come out assembled.
 import { RENAMED_KEYS, RESERVED_KEYS, SHEET_KEYS, SUBPART_PASSTHROUGH_KEYS } from "./constants.js";
@@ -67,32 +72,42 @@ export function sheetPart(spec) {
     const s = resolveSheet(k, sub, p, d);
     return (processById(s.process).preview ?? sheetPreview)(k, s);
   };
+
+  // Placement (decision 10): the pose applies for display AND export, then the author's own
+  // place. Made BEFORE the record is frozen, so the record can name it. Everything the
+  // place reads is taken NOW, into the same values the record freezes — never read off
+  // `spec` later, which an author may reuse and change for the next panel: the build and
+  // the burn's frame both read the frozen record, and a place that read the spec live would
+  // move the panel away from them.
+  const pose = spec.pose ?? null;
+  const thickness = spec.thickness;
+  const authorPlace = spec.place ?? null;
+  const generatedPlace = pose !== null || authorPlace ? (solid, ctx) => {
+    const resolved = typeof pose === "function" ? pose(ctx.p, ctx.d) : pose;
+    let posed = solid;
+    if (resolved !== null) {
+      const reason = validatePose(resolved);
+      if (reason) throw new Error(`sheet pose: ${reason}`);
+      const t = typeof thickness === "function" ? thickness(ctx.p, ctx.d) : thickness;
+      posed = applyPose(solid, resolved, t);
+    }
+    return authorPlace ? authorPlace(posed, ctx) : posed;
+  } : null;
+
   const sheet = Object.freeze({
     process,
     material: spec.material,
-    thickness: spec.thickness,
+    thickness,
     profile: spec.profile,
     score: spec.score ?? null,
     engrave: spec.engrave ?? null,
-    pose: spec.pose ?? null,
+    pose,
+    place: authorPlace,
     generatedBuild,
+    generatedPlace,
   });
   sub.build = generatedBuild;
-
-  const authorPlace = spec.place;
-  if (sheet.pose !== null || authorPlace) {
-    sub.place = (solid, ctx) => {
-      const pose = typeof sheet.pose === "function" ? sheet.pose(ctx.p, ctx.d) : sheet.pose;
-      let posed = solid;
-      if (pose !== null) {
-        const reason = validatePose(pose);
-        if (reason) throw new Error(`sheet pose: ${reason}`);
-        const t = typeof sheet.thickness === "function" ? sheet.thickness(ctx.p, ctx.d) : sheet.thickness;
-        posed = applyPose(solid, pose, t);
-      }
-      return authorPlace ? authorPlace(posed, ctx) : posed;
-    };
-  }
+  if (generatedPlace) sub.place = generatedPlace;
   sub.sheet = sheet;
   return sub;
 }

package/src/framework/viewer.js

@@ -12,6 +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 { neutralToneMapToSrgb8 } from "./materials/tonemap-readback.js";
 import { createCutaway } from "./cutaway.js";
 import { CUTAWAY_OVERLAY_RENDER_ORDER } from "./cutaway-render.js";
@@ -591,9 +592,11 @@ export function createViewer(container, part) {
   const textureCache = new Map();    // asset file name -> Texture
   const textureLoader = new THREE.TextureLoader();
   let pmrem = null;
-  let printFrames = {};
-  let printFrameSource = null;       // () => frames; mount's lazy provider (setPrintFrameSource)
-  let printFramesStale = false;      // the source has frames the materials have not seen
+  let printFrames = {};              // name -> mat4 array: layer lines' display → export map
+  let sheetFrames = {};              // name -> { frame, t, plies }: a burning sheet's canonical frame (sheet-look.js)
+  let frameSource = null;            // () => { print, sheet }; mount's lazy provider (setFrameSource)
+  let framesStale = false;           // the source has frames the materials have not seen
+  const IDENTITY_MAT4 = new THREE.Matrix4().toArray();
   const modeListeners = new Set();
   const envListeners = new Set();
   const SHADOW_LOWRES_MS = 100;      // at most one low-res shadow per this, while a part moves
@@ -728,9 +731,14 @@ export function createViewer(container, part) {
   function physicalFor(name) {
     let m = physicalMats.get(name);
     if (!m) {
-      m = cloneKeepsPattern(buildPhysicalMaterial(part.parts[name].display, { printFrame: printFrames[name], loadTexture }));
+      const sp = part.parts[name];
+      // `burn` is decided once per sub-part (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).
+      m = cloneKeepsPattern(buildPhysicalMaterial(realisticDisplay(sp), { printFrame: printFrames[name], burn: burnsFor(sp), loadTexture }));
       physicalMats.set(name, m);
       syncGrain(name);
+      applySheetFrame(m, sheetFrames[name]);
     }
     return m;
   }
@@ -859,7 +867,7 @@ export function createViewer(container, part) {
   // ground only moves on showAssembly, never because a capture happened.
   function enterRealistic(rig, { live = true, reground = true } = {}) {
     try {
-      syncPrintFrames(); // before the swap: the first realistic frame has the export-pose layers
+      syncFrames(); // before the swap: the first realistic frame has the export-pose layers and the sheets' burns
       renderMode = "realistic";
       // A regen can land between the proxy compile and here, while the mode
       // was still CAD, so setSubGeometry skipped the UVs. Idempotent.
@@ -929,7 +937,7 @@ export function createViewer(container, part) {
   // target bound — each only for the synchronous compile() inside
   // compileAsync, so the view on screen is untouched while it waits.
   function compileRealistic(rig, { forCapture = false } = {}) {
-    syncPrintFrames();
+    syncFrames();
     const proxy = new THREE.Scene();
     proxy.environment = rig.envMap;
     for (const n of names) {
@@ -1030,30 +1038,45 @@ export function createViewer(container, part) {
     for (const [n, m] of physicalMats) m.userData.patternUniforms?.pfPrintFrame.value.fromArray(printFrames[n] ?? identity);
   }
 
-  // The lazy form mount uses. Computing a frame runs the sub-part's pose probe
-  // (two geometry-free builds for a placed sub-part), and every sub-part with
-  // no material draws layer lines, so frames are PULLED only when something is
-  // about to draw the realistic look: the live view (or a switch loading),
-  // and any capture that borrows it — compileRealistic and enterRealistic are
-  // the two doors every such path goes through. A delivery just marks them
-  // stale (invalidatePrintFrames); in CAD nothing is computed.
-  function setPrintFrameSource(source) {
-    printFrameSource = typeof source === "function" ? source : null;
-    invalidatePrintFrames();
-  }
-  function invalidatePrintFrames() {
-    printFramesStale = true;
-    if (renderMode === "realistic" || realisticPending) syncPrintFrames();
-  }
-  function syncPrintFrames() {
-    if (!printFrameSource || !printFramesStale) return;
-    printFramesStale = false;
+  // 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) {
+    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;
+  }
+  function setSheetFrames(frames) {
+    sheetFrames = frames ?? {};
+    for (const [n, m] of physicalMats) applySheetFrame(m, sheetFrames[n]);
+  }
+
+  // The lazy form mount uses. Frames are PULLED only when something is about to draw the
+  // realistic look: the live view (or a switch loading), and any capture that borrows it —
+  // compileRealistic and enterRealistic are the two doors every such path goes through. A
+  // delivery just marks them stale (invalidateFrames); in CAD nothing is computed. One
+  // source carries both kinds: `print` (layer lines; a placed sub-part's costs two
+  // geometry-free probe builds, and every sub-part with no material draws layer lines) and
+  // `sheet` (a burning sheet's canonical frame, from data).
+  function setFrameSource(source) {
+    frameSource = typeof source === "function" ? source : null;
+    invalidateFrames();
+  }
+  function invalidateFrames() {
+    framesStale = true;
+    if (renderMode === "realistic" || realisticPending) syncFrames();
+  }
+  function syncFrames() {
+    if (!frameSource || !framesStale) return;
+    framesStale = false;
     let frames;
-    try { frames = printFrameSource(); } catch (e) {
-      console.warn("partforge: computing print frames failed", e);
+    try { frames = frameSource(); } catch (e) {
+      console.warn("partforge: computing material frames failed", e);
       return;
     }
-    setPrintFrames(frames);
+    setPrintFrames(frames?.print);
+    setSheetFrames(frames?.sheet);
   }
 
   // Resolves once the current environment's rig is loaded (captures wait on it).
@@ -2735,8 +2758,9 @@ export function createViewer(container, part) {
     isRealisticPending: () => realisticPending,
     onEnvironmentChange: (cb) => { envListeners.add(cb); return () => envListeners.delete(cb); },
     setPrintFrames,
-    setPrintFrameSource,
-    invalidatePrintFrames,
+    setSheetFrames,
+    setFrameSource,
+    invalidateFrames,
     whenRealisticReady,
     dispose,
   }, () => requestRender(API_GRACE_MS));

package/src/parts/laser-box.js

@@ -42,7 +42,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

package/src/parts/material-swatches.js

@@ -1,7 +1,10 @@
 // Dev-only contact sheet for the material library: one 30 mm sample per preset,
 // laid out in a grid, so a change to a preset or the pattern shader can be
-// judged by eye in every environment (materials.html). Not a reference part.
+// judged by eye in every environment (materials.html). The "Laser-cut" views
+// (below) do the same for the laser burn. Not a reference part.
 import { PRESETS } from "../framework/materials/presets.js";
+import { sheetPart } from "../framework/sheet/part.js";
+import { sheetHole } from "../framework/sheet/joinery.js";
 
 const ids = Object.keys(PRESETS);
 const COLS = 6, PITCH = 40;
@@ -19,10 +22,59 @@ const FILAMENT_COLOURS = [
 const withHole = (k) =>
   k.box({ size: [30, 30, 12] }).fillet({ r: 3 }).cut(k.cylinder({ r: 5, h: 20 }).translate([0, 0, -4]));
 
+// The "Laser-cut" view: sheet swatches as the laser burn draws them — each 30 × 30 with a
+// cut hole, an engraved label (its thickness) and a score line — in every wood at 3, 6 and
+// 9 mm; one oak panel standing on edge (posed, so its frame is not the identity); and the
+// looks that must NOT burn: a clear-acrylic sheet and an oak block that is not a sheet part.
+// "Laser-cut, unburnt" is its twin: the same swatches with an identity author `place`,
+// which shows plain wood (materials/sheet-look.js) — same geometry, same place, same
+// material — so the two views differ ONLY by the burn and scripts/capture-contact-sheet.mjs
+// 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 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: "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 },
+  { key: "oak_block", label: "Oak block (not a sheet part)", at: [2 * PITCH, CONTROLS_Y], t: 3, display: { material: "oak" }, block: true },
+  { key: "stock_plywood", label: "No material, \"birch plywood\" stock", at: [0, CONTROLS_Y - PITCH], t: 3, stock: "birch plywood" },
+  { key: "stock_acrylic", label: "No material, \"clear acrylic\" stock", at: [PITCH, CONTROLS_Y - PITCH], t: 3, stock: "clear acrylic" },
+  { key: "stock_stained", label: "A bare colour on \"birch plywood\" stock", at: [2 * PITCH, CONTROLS_Y - PITCH], t: 3, stock: "birch plywood", display: { color: 0x2e8b3d } },
+];
+
+function laserSwatch(s, unburnt) {
+  const [x, y] = s.at;
+  const common = {
+    label: unburnt ? `${s.label} (unburnt)` : s.label,
+    views: [unburnt ? "unburnt" : "laser"],
+    ...(s.display ? { display: s.display } : {}),
+  };
+  if (s.block) {
+    return { ...common, build: (k) => k.box({ min: [x, y, 0], max: [x + SW, y + SW, s.t] })
+      .cut(k.cylinder({ d: 8, h: s.t + 2 }).translate([x + 21, y + 21, -1])) };
+  }
+  // A standing swatch is drawn at the drawing origin; its pose stands it on edge at `at`.
+  const [u, v] = s.standing ? [0, 0] : [x, y];
+  return sheetPart({
+    ...common,
+    material: s.stock ?? "birch plywood",
+    thickness: s.t,
+    profile: (k) => k.shape2d([[u, v], [u + SW, v], [u + SW, v + SW], [u, v + SW]]).cut(sheetHole({ d: 8, at: [u + 21, v + 21] })),
+    engrave: (k) => k.text2d(String(s.t), { size: 10, align: "center", valign: "middle" }).translate([u + 9, v + 20]),
+    score: () => [[[u + 3, v + 7], [u + SW - 3, v + 7]]],
+    ...(s.standing ? { pose: { face: "-Y", up: "+Z", at: [x, y, 0] } } : {}),
+    ...(unburnt ? { place: (solid) => solid } : {}),
+  });
+}
+
 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" } },
+  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" } },
   parts: {
     ...Object.fromEntries(ids.map((id, i) => [id.replaceAll("-", "_"), {
       label: PRESETS[id].label,
@@ -65,5 +117,9 @@ export default {
       build: (k) => k.box({ size: [30, 12, 40] }).translate([50, 0, 0]),
       display: { material: "pla-print", color: 0xe0592a },
     },
+    ...Object.fromEntries(LASER_SWATCHES.flatMap((s) => [
+      [`laser_${s.key}`, laserSwatch(s, false)],
+      [`unburnt_${s.key}`, laserSwatch(s, true)],
+    ])),
   },
 };

package/types/part.d.ts

@@ -441,6 +441,10 @@ export interface SheetDeclaration<P = ResolvedParams, D = Derived> {
   pose: SheetPose | ((p: P, d: D) => SheetPose | null) | null;
   /** The build `sheetPart` made; `sub.build !== sub.sheet.generatedBuild` is a custom build. */
   generatedBuild: (k: GeometryKernel, p: P, d: D) => Solid;
+  /** The author's own `place` (the spec's), run after the pose; `null` when there is none. */
+  place: ((solid: Solid, ctx: PlaceContext<P, D>) => Solid) | null;
+  /** The `place` `sheetPart` installed (the pose, then the author's own), or `null`; `sub.place !== sub.sheet.generatedPlace` is a replaced place. */
+  generatedPlace: ((solid: Solid, ctx: PlaceContext<P, D>) => Solid) | null;
 }
 
 export interface ViewDefinition {