partforge 0.133.3 → 0.135.0

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";
@@ -27,7 +28,7 @@ import { createStatusUi } from "./status-ui.js";
 import { createViewTabs } from "./view-tabs.js";
 import { attachPickToggle, attachHoverLabels, attachPicker, formatSelection } from "./selection/index.js";
 import { createPickRequestClient, resolvePickServerUrl, PICK_SERVER_DEFAULT_URL } from "./pick-request/index.js";
-import { exportablePartNames, partLabel } from "./export-select.js";
+import { exportableRows, exportFormatList } from "./export-rows.js";
 import { createExportController, backendForFormat } from "./export-controller.js";
 import { createCaptureBuild } from "./capture-build.js";
 import { attachAnimationControls } from "./animation-controls.js";
@@ -68,7 +69,7 @@ const IMPORT_MESH_BROKEN_MESSAGE = "STEP import tessellation failed to satisfy t
 // carries the worker's own error text. See the correlated "error" case below.
 const importTessellateFailedMessage = (workerMessage) => `STEP import tessellation failed — ${workerMessage}`;
 
-export function makeHandle({ ready, dispose, viewer, setParams, listExportableParts, exportParts, warmExportKernel, setHostPane, setRailLayout, animation, getView, setView, captureView, attachTooltips, measure, annotate, projection, pickMarker, getPanelState, getPanelErrors, renderMode, environment, declaresMaterials, renderViews }) {
+export function makeHandle({ ready, dispose, viewer, setParams, listExportableParts, listExportFormats, exportParts, warmExportKernel, setHostPane, setRailLayout, animation, getView, setView, captureView, attachTooltips, measure, annotate, projection, pickMarker, getPanelState, getPanelErrors, renderMode, environment, declaresMaterials, renderViews }) {
   return {
     ready, dispose, setParams,
     // Part-declared animation playback (spec 2026-08-02): animations are
@@ -141,6 +142,10 @@ export function makeHandle({ ready, dispose, viewer, setParams, listExportablePa
     // say "the 3D view ran out of memory" instead of showing a dead canvas.
     onContextLost: (listener) => viewer.onContextLost(listener),
     listExportableParts,
+    // What exportParts can write, as { id, label, ext, mime, needsSheet } — the cut &
+    // print kit ("bundle") needs a sheet part checked. A makeHandle caller that wires
+    // no export (a test) lists none.
+    listExportFormats: listExportFormats ?? (() => []),
     exportParts,
     // Pay the exact kernel's cold boot ahead of an export. STEP is pinned to
     // OCCT, whose ~11 MB WASM loads on its first job, so a Manifold-previewed
@@ -251,8 +256,11 @@ function createCleanupStack() {
 //                                         // framing (live camera pose + viewport aspect) at the
 //                                         // given long-edge resolution → JPEG data URL, or null
 //                                         // when disposed / nothing built yet
-//   runtime.listExportableParts();        // [{ name, label }] — every exportable sub-part,
-//                                         // independent of the active view (for an embedder-drawn export UI)
+//   runtime.listExportableParts();        // [{ name, label, sheet? }] — every exportable sub-part,
+//                                         // independent of the active view (for an embedder-drawn export UI);
+//                                         // a sheet part's row adds sheet: { process, material, thickness, group }
+//   runtime.listExportFormats();          // [{ id, label, ext, mime, needsSheet }] — what exportParts writes;
+//                                         // format "bundle" (the cut & print kit) also takes `options`
 //   await runtime.exportParts({ parts: ["base"], format: "stl", onProgress });
 //                                         // headless export of a chosen subset; resolves when the file is
 //                                         // written (handed to your onDownload sink, or downloaded directly
@@ -856,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) => {
@@ -863,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;
@@ -944,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();
@@ -1044,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).
@@ -1075,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.
@@ -1086,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();
           }
@@ -1389,8 +1424,10 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
       captureView,
       getPanelState: () => panelRef?.getState() ?? {},
       getPanelErrors: () => panelRef?.errors() ?? [],
-      listExportableParts: () =>
-        exportablePartNames(part, params).map((name) => ({ name, label: partLabel(part, name) })),
+      // A sheet part's row carries its stock, evaluated here on the main thread at the
+      // live params the way enabled() is, and omitted when it cannot be (export-rows.js).
+      listExportableParts: () => exportableRows(part, params),
+      listExportFormats: exportFormatList,
       exportParts: (opts) => exportCtl.exportParts(opts),
       warmExportKernel: () => exportCtl.warmKernel(),
       animation: animCtl?.runtime ?? null,

package/src/framework/process/exporters.js

@@ -0,0 +1,18 @@
+// One lazy exporter loader per process id, in the registry's order. Besides
+// process/registry.js this is the ONLY module allowed to import process/<id>/*
+// (test/sheet-layering.test.js), and it does so only through literal dynamic imports:
+// an exporter reaches the drawing stage and so paper, which lint, the oracle and
+// partforge/geometry must never load (test/kit-export-guards.test.js).
+//
+// Adding a process: one folder, one line in registry.js, one line here —
+// test/kit-export-guards.test.js fails until the two id lists agree.
+export const EXPORTER_LOADERS = Object.freeze({
+  laser: () => import("./laser/export.js"),
+});
+
+// The process's ProcessExporter ({ drawing(s, o, k, ctx) }), loaded on first use.
+export async function loadExporter(id) {
+  const load = Object.hasOwn(EXPORTER_LOADERS, id) ? EXPORTER_LOADERS[id] : null;
+  if (!load) throw new Error(`no exporter for process "${id}"`);
+  return (await load()).default;
+}

package/src/framework/process/laser/export.js

@@ -0,0 +1,53 @@
+// The laser process's exporter: one resolved sheet piece → one Drawing (contract §5.5).
+// Loaded only through process/exporters.js's dynamic import — it reaches the drawing
+// stage and so paper, which the laser DESCRIPTOR (read by lint and the oracle) must never
+// do; that is why a process is split into descriptor.js and export.js.
+//
+// Layers, from the piece's canonical-frame declaration (the pose is never read):
+//   cut-outer / cut-inner — the profile's outlines / every ring they enclose (holes, and
+//                           an island in a hole), refit, then kerf, in cut order: every
+//                           ring before any ring that encloses it (drawing.js's cutRings)
+//   score — two-point lines as open paths, score shapes' every ring closed
+//   engrave — the engrave shape's rings, a filled region
+// Kerf offsets the cut layer ONLY: a score or engrave line is burned along its centre, so
+// widening the kerf never moves it.
+import { refitRing, ringsOf, cutRings, applyKerf, drawingBounds, LAYER_ORDER } from "../../export/drawing.js";
+import { KIT_DEFAULTS } from "../../export/formats.js";
+
+const closedPath = (ring) => ({ start: ring.start, segments: ring.segments, closed: true });
+const refitRegions = (regions) => regions.map((rg) => ({ outer: refitRing(rg.outer), holes: rg.holes.map(refitRing) }));
+const allRings = (regions) => { const r = ringsOf(regions); return [...r.outer, ...r.holes]; };
+
+// `s` is a ResolvedSheet (sheet/resolve.js), `o` validated KitOptions (only `kerf` is
+// read), `k` the geometry kernel (unused by laser: every layer is already a Shape2D or
+// plain data), `ctx` = { label, facts? } — facts supplies the narrowest gap a kerf error
+// names.
+function drawing(s, o, k, ctx = {}) {
+  const label = ctx.label ?? s.label ?? "sheet part";
+  const kerf = o?.kerf ?? KIT_DEFAULTS.kerf;
+  const nominal = refitRegions(s.profile.toContours());
+  if (nominal.length === 0) throw new Error(`cut kit: "${label}" has an empty profile — nothing to cut`);
+  // A capped gap is the search ceiling, not a measured opening — don't name it.
+  const gap = ctx.facts && !ctx.facts.gapCapped && Number.isFinite(ctx.facts.gap) ? ctx.facts.gap : null;
+  const cut = cutRings(applyKerf(nominal, kerf, { label, gap }));
+
+  const byId = {
+    engrave: s.engrave ? allRings(refitRegions(s.engrave.toContours())).map(closedPath) : [],
+    score: [
+      ...s.score.lines.map(([a, b]) => ({ start: [a[0], a[1]], segments: [{ to: [b[0], b[1]] }], closed: false })),
+      ...s.score.shapes.flatMap((shape) => allRings(refitRegions(shape.toContours())).map(closedPath)),
+    ],
+    "cut-inner": cut.inner.map(closedPath),
+    "cut-outer": cut.outer.map(closedPath),
+  };
+  const layers = LAYER_ORDER.filter((id) => byId[id].length > 0).map((id) => ({ id, paths: byId[id] }));
+  const nb = drawingBounds([{ id: "cut-outer", paths: ringsOf(nominal).outer.map(closedPath) }]);
+  return {
+    layers,
+    bounds: drawingBounds(layers),
+    nominal: [nb.max[0] - nb.min[0], nb.max[1] - nb.min[1]],
+    kerf,
+  };
+}
+
+export default { drawing };