partforge 0.133.2 → 0.134.0

package/src/framework/export/layout.js

@@ -0,0 +1,92 @@
+// The kit's sheet layout: one stock group's pieces packed onto sheets of one stock size.
+// Deterministic first-fit decreasing-height SHELVES over each piece's bounding box of ALL
+// its layers, kerf included — a stray engrave or score mark must never land on a
+// neighbour — turned 0° or 90°, `margin` in from every sheet edge and `spacing` apart,
+// so no two pieces share a cut line. v1 packs rectangles only: no nesting into holes,
+// grain ignored; the README says so (design spec D.5).
+//
+// Coordinates are the sheet frame: mm, y up, origin at the sheet's corner. A placement's
+// `at` is where the (turned) drawing's bounds.min lands (contract §5.6).
+import { fmtMm } from "../sheet/constants.js";
+import { KIT_OPTIONS_ERROR } from "./formats.js";
+
+const EPS = 1e-9;
+const sizeOf = ({ min, max }) => [max[0] - min[0], max[1] - min[1]];
+const byKey = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
+// Throws when `margin` leaves a stock sheet with no inside at all — the options' fault,
+// for either destination, not a "stock too small" quoting a negative size, nor a service
+// kit with every piece oversized. `label` is the group's `${material} ${fmtMm(t)} mm`.
+// The options allow a 50 mm margin and a 10 mm stock side, which together can trigger
+// this. Exported so buildBundle can check every stock group right after resolveStock —
+// before any piece is drawn (spec D.3: a bad option must not wait behind a build) —
+// rather than only once a group finally reaches layoutGroup below, which calls this too
+// so a caller that skips the early check (or a future one) still gets it.
+export function marginFitsStock(stock, margin, label) {
+  const [W, H] = stock;
+  const innerW = W - 2 * margin, innerH = H - 2 * margin;
+  if (innerW <= EPS || innerH <= EPS)
+    throw new Error(`${KIT_OPTIONS_ERROR} a ${fmtMm(W)} × ${fmtMm(H)} mm sheet has no room inside a ${fmtMm(margin)} mm margin on every side (${label}) — lower margin or use larger stock`);
+  return [innerW, innerH];
+}
+
+// `pieces`: [{ key, label, drawing, qty }] — `key` names the piece in `oversized` and
+// breaks sort ties; `label` is what an error quotes. The `label` argument is the group's
+// `${material} ${fmtMm(t)} mm`; `group` is accepted and not needed here. `strict` (own
+// laser): a piece that fits the sheet in neither orientation is an options error;
+// otherwise (a cutting service, whose sheets are reference only) its key is listed in
+// `oversized` and it is left out. The sheets-per-group cap belongs to the caller — this
+// only packs.
+export function layoutGroup({ label, pieces, stock, margin, spacing, strict }) {
+  const [W, H] = stock;
+  const [innerW, innerH] = marginFitsStock(stock, margin, label);
+  const items = [];
+  const oversized = [];
+  for (const pc of pieces) {
+    const [w, h] = sizeOf(pc.drawing.bounds);
+    const fits = [];
+    if (w <= innerW + EPS && h <= innerH + EPS) fits.push({ rotated: false, w, h });
+    if (h <= innerW + EPS && w <= innerH + EPS) fits.push({ rotated: true, w: h, h: w });
+    if (fits.length === 0) {
+      if (strict)
+        throw new Error(`${KIT_OPTIONS_ERROR} stock too small — "${pc.label}" is ${w.toFixed(1)} × ${h.toFixed(1)} mm; a ${fmtMm(W)} × ${fmtMm(H)} mm sheet leaves ${fmtMm(innerW)} × ${fmtMm(innerH)} after its ${fmtMm(margin)} mm margin (${label})`);
+      oversized.push(pc.key);
+      continue;
+    }
+    // The orientation with the smaller height packs shelves tighter; 0° wins a tie.
+    const pick = fits.length === 2 && fits[1].h < fits[0].h - EPS ? fits[1] : fits[0];
+    for (let i = 0; i < pc.qty; i++) items.push({ key: pc.key, drawing: pc.drawing, ...pick });
+  }
+  items.sort((a, b) => b.h - a.h || b.w - a.w || byKey(a.key, b.key));
+
+  // Each sheet: shelves bottom-up ({ y, h, x: used width, n: pieces }), `top` = the last
+  // shelf's upper edge, `area` = placed bounding-box area.
+  const sheets = [];
+  const place = (sh, shelf, it) => {
+    const x = shelf.n ? shelf.x + spacing : 0;
+    sh.placements.push({ drawing: it.drawing, at: [margin + x, margin + shelf.y], rotated: it.rotated });
+    shelf.x = x + it.w; shelf.n++; sh.area += it.w * it.h;
+  };
+  for (const it of items) {
+    // 1. the first shelf, on any sheet, with room left along it
+    const onShelf = (() => {
+      for (const sh of sheets) for (const shelf of sh.shelves) {
+        const x = shelf.n ? shelf.x + spacing : 0;
+        if (x + it.w <= innerW + EPS && it.h <= shelf.h + EPS) return [sh, shelf];
+      }
+      return null;
+    })();
+    if (onShelf) { place(onShelf[0], onShelf[1], it); continue; }
+    // 2. a new shelf on the first sheet with height left; 3. else a new sheet
+    let sh = sheets.find((s) => s.top + spacing + it.h <= innerH + EPS);
+    if (!sh) { sh = { placements: [], shelves: [], top: -spacing, area: 0 }; sheets.push(sh); }
+    const shelf = { y: sh.top + spacing, h: it.h, x: 0, n: 0 };
+    sh.shelves.push(shelf);
+    sh.top = shelf.y + it.h;
+    place(sh, shelf, it);
+  }
+  return {
+    sheets: sheets.map((sh) => ({ placements: sh.placements, used: (100 * sh.area) / (W * H) })),
+    oversized,
+  };
+}

package/src/framework/export/placement.js

@@ -0,0 +1,14 @@
+// Shared by the kit's SVG and DXF writers: one Drawing's frame → the sheet frame for one
+// placement. IMPORT-FREE, like formats.js — svg.js and dxf.js are each a "paper-free leaf
+// (arc-math.js only)" on their own, and this tiny third leaf is what lets them share the
+// placement math without either reaching into the other or into drawing.js (which reaches
+// paper).
+
+// Translate so the drawing's bounds.min lands on `at`, after an optional 90° CCW turn (a
+// proper rotation: arcs keep their sense).
+export function placer({ drawing, at, rotated }) {
+  const { min, max } = drawing.bounds;
+  if (!rotated) return ([x, y]) => [x - min[0] + at[0], y - min[1] + at[1]];
+  // (x, y) → (−y, x); the turned bounds' min corner is (−max.y, min.x)
+  return ([x, y]) => [max[1] - y + at[0], x - min[0] + at[1]];
+}

package/src/framework/export/readme.js

@@ -0,0 +1,103 @@
+// The kit's two plain-text files: README.txt, read by a person standing at the laser,
+// and parts.csv, opened in a spreadsheet (spec D.9). Pure string building over a model
+// that export/bundle.js assembles, so both are testable without a kernel.
+//
+// Neither carries a timestamp — the same forge and options always write the same bytes
+// — and neither is Markdown: every label is an author string, and plain text is the one
+// format in which nothing an author writes renders as anything.
+import { fmtMm } from "../sheet/constants.js";
+
+export const README_HEADINGS = Object.freeze([
+  "BEFORE YOU CUT", "SHEETS", "PIECES", "PRINTED PARTS", "CLEARANCES (design fit, not kerf)",
+  "SETTINGS", "CHECKS", "OVERSIZED PIECES", "RENAMED FILES", "LIMITS",
+]);
+export const CSV_HEADER = "file,kind,labels,material,thickness_mm,width_mm,height_mm,quantity";
+
+const SVG_LEGEND = "Colours: engrave = filled black #000000, score = blue #0000FF, cut = red #FF0000 (inner cuts come before outer cuts).";
+const DXF_LEGEND = "DXF layers: CUT (colour 1), SCORE (colour 5), ENGRAVE (colour 7) — set ENGRAVE to fill; R12 has no hatch.";
+const LIMITS_LINE = "Layout packs bounding boxes only: no nesting into holes, and grain direction is ignored.";
+
+// C0 controls, DEL and C1 controls out of an author string, so a label can never ring a
+// bell, move a cursor or smuggle a line break into a table row — and the Unicode line
+// and paragraph separators (U+2028/U+2029, a line break in many editors) and the bidi
+// embeddings, overrides and isolates (U+202A–U+202E, U+2066–U+2069), which reorder the
+// text around them, for the same reason.
+export const cleanLabel = (s) => String(s).replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g, "");
+
+// One RFC 4180 cell. A cell starting with = + - or @ is a formula to Excel, Numbers and
+// Sheets, so it gets a leading ' first — before quoting, so no quote can be closed
+// around it.
+export function csvCell(v) {
+  let s = v == null ? "" : String(v);
+  if (/^[=+\-@]/.test(s)) s = `'${s}`;
+  return /[",\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+const clip = (s, n = 200) => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
+
+// A parameter value the way one README line can hold it: numbers and booleans as
+// written, strings JSON-quoted (so "" and " " stay visible), bytes by size, anything
+// else as clipped JSON.
+function settingValue(v) {
+  if (v === null || v === undefined || typeof v === "number" || typeof v === "boolean") return String(v);
+  if (typeof v === "string") return JSON.stringify(clip(cleanLabel(v)));
+  if (v instanceof ArrayBuffer || ArrayBuffer.isView(v)) return `<${v.byteLength} bytes>`;
+  try { return clip(JSON.stringify(v) ?? String(v)); } catch { return "<unprintable>"; }
+}
+
+const table = (header, rows) => (rows.length ? [header.join(" | "), ...rows.map((r) => r.join(" | "))] : []);
+const mm2 = ([w, h]) => `${w.toFixed(2)} × ${h.toFixed(2)} mm`;
+const labelsOf = (labels) => labels.map(cleanLabel).join(", ");
+
+export function renderReadme(m) {
+  const k = m.kerf;
+  const kerfed = k > 0;
+  // A cutting service gets each piece's score and engrave lines in a separate
+  // -marks.dxf, which neither table lists — so the files are named here, or a service
+  // order built from the cut files alone silently leaves the marks off.
+  const marksFiles = m.pieces.map((pc) => pc.marksFile).filter(Boolean);
+  const body = {
+    "BEFORE YOU CUT": [
+      ...m.stockNotes.map((g) =>
+        `This kit assumes ${g.thickness.toFixed(2)} mm ${cleanLabel(g.material)} — if yours differs, change "${cleanLabel(g.control ?? "the sheet thickness setting")}" and re-download.`),
+      kerfed
+        ? `Kerf: ${k.toFixed(2)} mm applied to the cut lines only. Set kerf in ONE place — these download options, or your laser software / cutting service — never both.`
+        : "Kerf: none applied — your laser software or cutting service must compensate.",
+      ...(kerfed ? [] : ["To have the files adjusted instead, download again with a kerf set, and turn compensation off in your laser software or service."]),
+      "Scale check — measure one cut piece against its line:",
+      ...m.scale.map((s) => `${cleanLabel(s.label)}: nominal ${s.nominal[0].toFixed(2)} × ${s.nominal[1].toFixed(2)} mm; this file draws ${
+        kerfed ? `${s.drawn[0].toFixed(2)} × ${s.drawn[1].toFixed(2)} with ${k.toFixed(2)} mm kerf` : "the same (no kerf applied)"}`),
+      m.cutFormat === "dxf" ? DXF_LEGEND : SVG_LEGEND,
+      ...(marksFiles.length ? [`Score and engrave marks are in their own files, not in the cut files — send them with the cut files if you want the marks made: ${marksFiles.join(", ")}.`] : []),
+      // A service kit whose every piece is oversized writes no sheets/ at all.
+      ...(m.destination === "service" && m.sheets.length ? ["The sheets in sheets/ are for reference only — a cutting service lays out the pieces itself."] : []),
+      "Test-cut one joint first.",
+    ],
+    SHEETS: table(["file", "material", "thickness", "size", "pieces", "used"], m.sheets.map((s) => [
+      s.file, cleanLabel(s.material), `${s.thickness.toFixed(2)} mm`, `${fmtMm(s.size[0])} × ${fmtMm(s.size[1])} mm`,
+      String(s.pieces), `${Math.round(s.used)}%`])),
+    PIECES: table(["file", "labels", "material", "thickness", "size", "quantity"], m.pieces.map((pc) => [
+      pc.file, labelsOf(pc.labels), cleanLabel(pc.material), `${pc.thickness.toFixed(2)} mm`, mm2(pc.size), String(pc.quantity)])),
+    "PRINTED PARTS": table(["file", "labels", "quantity"], m.printed.map((pp) => [pp.file, labelsOf(pp.labels), String(pp.quantity)])),
+    "CLEARANCES (design fit, not kerf)": m.clearances.map((c) =>
+      `${cleanLabel(c.label)}: ${settingValue(c.value)}${c.unit ? ` ${cleanLabel(c.unit)}` : ""}`),
+    SETTINGS: m.settings.map((s) => `${cleanLabel(s.key)} = ${settingValue(s.value)}`),
+    CHECKS: m.checks.length ? m.checks.map(cleanLabel) : ["none"],
+    "OVERSIZED PIECES": m.destination === "service" ? m.oversized.map(cleanLabel) : [],
+    "RENAMED FILES": m.renamed.map(cleanLabel),
+    LIMITS: [LIMITS_LINE],
+  };
+  const out = [`${cleanLabel(m.title)} — cut & print kit`, ""];
+  for (const heading of README_HEADINGS) {
+    if (body[heading].length) out.push(heading, ...body[heading], "");
+  }
+  return out.join("\n");
+}
+
+export function renderPartsCsv(rows) {
+  const line = (cells) => `${cells.map(csvCell).join(",")}\r\n`;
+  return `${CSV_HEADER}\r\n${rows.map((r) => line([
+    r.file, r.kind, r.labels.map(cleanLabel).join("; "), cleanLabel(r.material ?? ""),
+    r.thickness == null ? "" : r.thickness.toFixed(2), r.width.toFixed(2), r.height.toFixed(2), String(r.quantity),
+  ])).join("")}`;
+}

package/src/framework/export/svg.js

@@ -0,0 +1,97 @@
+// The kit's SVG writer: a SheetDoc (placed Drawings on one sheet) → one SVG string,
+// built by hand — paper.js cannot export SVG in a worker (there is no DOM to serialize
+// through), and this module stays a paper-free leaf (arc-math.js only).
+//
+// Written for laser software, which reads styling far more literally than a browser:
+//   - Size is physical: width/height in mm, viewBox in mm, so 1 user unit = 1 mm.
+//   - y is flipped IN THE COORDINATES (svgY = H − y): the Drawing is y-up, SVG is y-down,
+//     and a transform on the root is exactly the kind of inherited state a laser importer
+//     may drop. The flip reverses every arc's sense, hence the sweep flag below.
+//   - Every <path> carries its whole style. Nothing on the root or a group: inherited
+//     style is where importers disagree. Cut and score paths carry fill="none" — an
+//     unfilled SVG path defaults to BLACK FILL, which Glowforge reads as an engrave.
+//   - Colours are LightBurn's convention (SVG_COLORS); groups are written in cut order.
+//   - The only text is the escaped <title>. Escaping is hygiene, not the security
+//     boundary: a hostile part shares the worker with this writer and can post its own
+//     bytes — the host's download allowlist is the boundary (design spec E.1).
+import { arcCenterAndSweep } from "../geometry/arc-math.js";
+import { placer } from "./placement.js";
+
+export const SVG_COLORS = Object.freeze({ engrave: "#000000", score: "#0000FF", "cut-inner": "#FF0000", "cut-outer": "#FF0000" });
+export const SVG_STROKE_MM = 0.025;   // a hairline: laser software cuts it as a vector
+// The group order is the cut order — the same list as drawing.js's LAYER_ORDER, which
+// this leaf cannot import (drawing.js reaches paper); test/kit-svg.test.js pins them equal.
+const ORDER = Object.keys(SVG_COLORS);
+
+const num = (x) => { const v = Number(x.toFixed(4)); return String(v === 0 ? 0 : v); };   // -0 → "0"
+const escapeXml = (s) => String(s)
+  .replace(/[\u0000-\u001f\u007f]/g, "")
+  .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+  .replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+
+// Every IR arc is written as ceil(|dA| / 90°) equal pieces about the IR's own centre.
+// An `A` command carries no centre: a reader rebuilds it from the radius and the two
+// ends (SVG 1.1 F.6.5), at sqrt(r² − (chord/2)²) from the chord — and at 180° that
+// root is of a number near zero, so the 4-decimal rounding of r and both ends moves the
+// centre by ~sqrt(2·r·1e-4): a quarter of a millimetre-scale error on an ordinary hole,
+// and exactly what the refit makes (a faceted circle comes back as two 180° arcs). At
+// 90° or less the rebuild is well conditioned and lands within ~1e-4 mm. The pieces'
+// inner ends come from the centre and angle, never from a rounded neighbour; the last
+// one is the IR's own `to`.
+const QUARTER = Math.PI / 2;
+function arcCommands(from, s, P) {
+  const g = arcCenterAndSweep(from, s.via, s.to);   // drawing frame: the turn keeps dA's sign
+  if (!g) return ` L${P(s.to)}`;                     // collinear "arc": a straight line
+  const n = Math.max(1, Math.ceil(Math.abs(g.dA) / QUARTER - 1e-9));
+  const a0 = Math.atan2(from[1] - g.center[1], from[0] - g.center[0]);
+  const step = g.dA / n;
+  let d = "";
+  for (let i = 1; i <= n; i++) {
+    const t = a0 + step * i;
+    const to = i === n ? s.to : [g.center[0] + g.r * Math.cos(t), g.center[1] + g.r * Math.sin(t)];
+    d += ` A${num(g.r)} ${num(g.r)} 0 ${Math.abs(step) > Math.PI ? 1 : 0} ${step > 0 ? 0 : 1} ${P(to)}`;
+  }
+  return d;
+}
+
+function pathData(path, place, H) {
+  const P = (p) => { const [x, y] = place(p); return `${num(x)} ${num(H - y)}`; };
+  let d = `M${P(path.start)}`;
+  let from = path.start;
+  for (const s of path.segments) {
+    if (s.c1) d += ` C${P(s.c1)} ${P(s.c2)} ${P(s.to)}`;
+    else if (s.via) d += arcCommands(from, s, P);
+    else d += ` L${P(s.to)}`;
+    from = s.to;
+  }
+  return path.closed ? `${d} Z` : d;
+}
+
+export function renderSvg(doc) {
+  const [W, H] = doc.size;
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="${num(W)}mm" height="${num(H)}mm" viewBox="0 0 ${num(W)} ${num(H)}">`,
+    `<title>${escapeXml(doc.title)}</title>`,
+  ];
+  for (const id of ORDER) {
+    const paths = [];
+    for (const placement of doc.placements) {
+      const layer = placement.drawing.layers.find((l) => l.id === id);
+      if (!layer || layer.paths.length === 0) continue;
+      const place = placer(placement);
+      if (id === "engrave") {
+        // one filled path per piece: all its engrave rings, even-odd, so a glyph's
+        // counter stays open whatever the rings' winding
+        const d = layer.paths.map((p) => pathData(p, place, H)).join(" ");
+        paths.push(`<path d="${d}" fill="${SVG_COLORS.engrave}" fill-rule="evenodd" stroke="none"/>`);
+      } else {
+        for (const p of layer.paths)
+          paths.push(`<path d="${pathData(p, place, H)}" fill="none" stroke="${SVG_COLORS[id]}" stroke-width="${SVG_STROKE_MM}"/>`);
+      }
+    }
+    if (paths.length) lines.push(`<g id="${id}">`, ...paths, "</g>");
+  }
+  lines.push("</svg>");
+  return `${lines.join("\n")}\n`;
+}

package/src/framework/export-controller.js

@@ -39,13 +39,18 @@ export function createExportController({ send, currentView, title, defaultBacken
   // other's Promise.
   let nextWarmId = 1;
 
-  function exportParts({ parts, format, quality = "print", onProgress } = {}) {
+  // `options` are the cut & print kit's download options (format "bundle"). They ride
+  // the message for any format when given — the worker's other export branches never
+  // read them — and are left off entirely when not, so every other export's message is
+  // exactly what it always was.
+  function exportParts({ parts, format, quality = "print", onProgress, options } = {}) {
     const jobId = `export-${controller}-${nextId++}`;
     const type = `export-${format}`;
     const backend = backendForFormat(format, defaultBackend);
     return new Promise((resolve, reject) => {
       pending.set(jobId, { resolve, reject, onProgress });
-      send({ type, jobId, parts, view: currentView(), params: currentParams(), name: title(), quality }, backend);
+      send({ type, jobId, parts, view: currentView(), params: currentParams(), name: title(), quality,
+        ...(options !== undefined ? { options } : {}) }, backend);
     });
   }
 

package/src/framework/export-rows.js

@@ -0,0 +1,34 @@
+// The two lists an embedder's export UI is drawn from — the exportable sub-parts and
+// the formats — behind the mount handle's listExportableParts()/listExportFormats().
+//
+// Main-thread only: mount.js imports it. Deliberately NOT part of export-select.js,
+// which jobs.js imports at worker boot — export/formats.js must stay out of the
+// worker's eager closure (test/worker-layering.test.js).
+import { exportablePartNames, partLabel } from "./export-select.js";
+import { resolveDerived } from "./derive.js";
+import { sheetMeta } from "./sheet/constants.js";
+import { EXPORT_FORMATS } from "./export/formats.js";
+
+// A row for every exportable, enabled sub-part, in definition order. A sheet part's row
+// adds `sheet: { process, material, thickness, group }`, evaluated here at the live
+// params the way enabled() already is, so a host can tag it ("Sheet · …") and name its
+// stock group before asking for a kit. The key is OMITTED, never null, when it cannot
+// be evaluated — not a sheet, a material or thickness that throws, or a derive() that
+// throws (nothing about any part's stock is trustworthy then). The kit recomputes its
+// groups in the worker regardless, so a missing tag costs a label, never a wrong file.
+export function exportableRows(part, params) {
+  const p = { ...part.defaults, ...params };
+  let d = null;
+  let derived = true;
+  try { d = resolveDerived(part, p); } catch { derived = false; }
+  return exportablePartNames(part, params).map((name) => {
+    const row = { name, label: partLabel(part, name) };
+    const s = derived ? sheetMeta(part.parts[name], p, d) : null;
+    if (s) row.sheet = { process: s.process, material: s.material, thickness: s.thickness, group: s.group };
+    return row;
+  });
+}
+
+// What exportParts can write in this version, as fresh copies — a host that annotates
+// or sorts its list can never edit the table every later call reads.
+export const exportFormatList = () => EXPORT_FORMATS.map((f) => ({ ...f }));

package/src/framework/jobs.js

@@ -31,6 +31,12 @@ const loadInspect = () => Promise.all([
   import("./oracle/verify.js"),
 ]);
 
+// The cut & print kit loads the same way, on the first export-bundle job: its writers,
+// layout and README (export/*) and the process exporters behind them are dead weight to
+// a session that never downloads a kit. test/worker-layering.test.js keeps every one of
+// them out of worker boot, and test/kit-layering.test.js keeps the kit off ./oracle/*.
+const loadBundle = () => import("./export/bundle.js");
+
 // HOST JOBS — the extension seam. A host registers its own job types with
 // `runWorker(part, { jobs: { <type>: handler } })`, threaded here as `opts.jobs`, and
 // a message whose type matches no built-in below is handed to that handler with the
@@ -47,6 +53,8 @@ const loadInspect = () => Promise.all([
 //   { type:"generate", subparts, view, params } → { type:"meshes", meshes, ms }
 //   { type:"export-stl", view, params }         → { type:"download-parts", ext, mime, parts }
 //   { type:"export-step", view, params }        → { type:"download", data, filename, mime }
+//   { type:"export-bundle", view, params, parts, options }
+//                                               → { type:"download", data, filename, mime }  (the cut & print kit, a ZIP)
 // A generate also accepts `opts.isStale` — a caller-supplied predicate checked at each
 // sub-part boundary — and answers { type:"superseded" } instead of `meshes` when it
 // stops early (a build that ended without meshes, not an error; see KERNEL-CONTRACT.md).
@@ -455,6 +463,14 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       onProgress("writing 3MF file");
       const data = meshTo3MF(meshes);
       post({ type: "download", data, filename: `${fileBase}.3mf`, mime: "model/3mf", jobId: msg.jobId }, [bufferOf(data)]);
+    } else if (msg.type === "export-bundle") {
+      // The cut & print kit: sheet parts drawn flat from their 2-D declaration and laid
+      // out on the user's stock, printed parts as STL/3MF, a README — one ZIP. Every
+      // download-option problem throws a "cut kit options:" error, posted verbatim by the
+      // catch below like any other failed job.
+      const { buildBundle } = await loadBundle();
+      const { data, filename } = await buildBundle({ kernel, part, msg, p, d, posed, label, exportName, names: selected(), onProgress, fileBase });
+      post({ type: "download", data, filename, mime: "application/zip", jobId: msg.jobId }, [bufferOf(data)]);
     } else if (msg.type === "warm-kernel") {
       // Deliberately empty. worker.js awaits kernelFor() before calling handle(),
       // so REACHING this branch is the whole result: the backend this job was

package/src/framework/mount.js

@@ -27,7 +27,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 +68,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 +141,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 +255,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
@@ -1389,8 +1396,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 };

package/src/framework/stale-touch-guard.js

@@ -0,0 +1,77 @@
+// src/framework/stale-touch-guard.js
+// Keeps the camera controls from holding onto a finger that has already left
+// the screen.
+//
+// OrbitControls tracks every pointer that goes down on the canvas and forgets
+// one only on its pointerup or pointercancel. When the page is embedded in a
+// host that runs its own gestures (a chat app's WKWebView, which scrolls the
+// conversation on a vertical drag), the host can take a drag over and the page
+// never hears that finger lift. The controls then keep it as down forever: the
+// next one-finger drag reads as a two-finger pinch (it zooms), and with two
+// stuck, no drag moves the camera at all.
+//
+// Two measures, both on the canvas's document and both passive:
+//
+// 1. Do-nothing touchstart/touchend/touchcancel listeners. WebKit on iOS hands
+//    a touch to the page only where the page listens for TOUCH events, and the
+//    controls listen for pointer events alone, so without these the host's
+//    gesture recognizers could claim a drag the page itself was handling.
+//
+// 2. Stale fingers are cancelled on arrival. A touch pointerdown marked
+//    isPrimary is the first finger of a brand-new gesture, so no other touch
+//    can really be down; every touch id still recorded as down on the canvas is
+//    sent the pointercancel it missed, from a capture listener on the document
+//    (which runs before the controls' own listener on the canvas). A second
+//    finger of the same gesture is never primary, so pinch and two-finger pan
+//    are untouched.
+//
+// The controls release pointer capture for the id they remove, and that call
+// throws for an id the browser has already forgotten, aborting their cleanup
+// half way (the move listeners and the gesture state would stay live). So the
+// canvas's releasePointerCapture is wrapped to ignore that one failure.
+const TOUCH_TYPES = ["touchstart", "touchend", "touchcancel"];
+
+export function guardStaleTouches(element) {
+  const doc = element.ownerDocument;
+  if (!doc) return () => {};
+  const noop = () => {};
+  const touchesDown = new Set();
+
+  const release = element.releasePointerCapture;
+  if (typeof release === "function") {
+    element.releasePointerCapture = function releaseIfHeld(pointerId) {
+      try {
+        release.call(this, pointerId);
+      } catch {
+        // Already released: the finger is gone, which is all the caller wanted.
+      }
+    };
+  }
+
+  const onDown = (event) => {
+    if (event.pointerType !== "touch") return;
+    if (event.isPrimary && touchesDown.size) {
+      for (const pointerId of [...touchesDown]) {
+        if (pointerId === event.pointerId) continue;
+        touchesDown.delete(pointerId);
+        element.dispatchEvent(new PointerEvent("pointercancel", { pointerId, pointerType: "touch", bubbles: true }));
+      }
+    }
+    if (event.target === element) touchesDown.add(event.pointerId);
+  };
+  const onEnd = (event) => { touchesDown.delete(event.pointerId); };
+
+  for (const type of TOUCH_TYPES) doc.addEventListener(type, noop, { capture: true, passive: true });
+  doc.addEventListener("pointerdown", onDown, { capture: true, passive: true });
+  doc.addEventListener("pointerup", onEnd, { capture: true, passive: true });
+  doc.addEventListener("pointercancel", onEnd, { capture: true, passive: true });
+
+  return function dispose() {
+    for (const type of TOUCH_TYPES) doc.removeEventListener(type, noop, { capture: true });
+    doc.removeEventListener("pointerdown", onDown, { capture: true });
+    doc.removeEventListener("pointerup", onEnd, { capture: true });
+    doc.removeEventListener("pointercancel", onEnd, { capture: true });
+    if (typeof release === "function") element.releasePointerCapture = release;
+    touchesDown.clear();
+  };
+}

package/src/framework/viewer.js

@@ -1,5 +1,6 @@
 import * as THREE from "three";
 import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+import { guardStaleTouches } from "./stale-touch-guard.js";
 import { toCreasedNormals } from "three/addons/utils/BufferGeometryUtils.js";
 import { LineSegments2 } from "three/addons/lines/LineSegments2.js";
 import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js";
@@ -231,6 +232,9 @@ export function createViewer(container, part) {
 
   const controls = new OrbitControls(activeCamera, renderer.domElement);
   controls.enableDamping = true;
+  // A finger a host gesture swallowed would otherwise stay "down" in the
+  // controls forever (every later drag zooms) — see stale-touch-guard.js.
+  const disposeTouchGuard = guardStaleTouches(renderer.domElement);
 
   // --- render on demand -------------------------------------------------------
   // The loop ticks every animation frame (controls, tweens, frame listeners —
@@ -2608,6 +2612,7 @@ export function createViewer(container, part) {
     canonicalCaptureHidden.clear();
     camTween.cancel();
     controls.dispose();
+    disposeTouchGuard();
     for (const t of flashTimers) clearTimeout(t);
     flashTimers.clear();
     // A dot whose timer was just cancelled — or one held indefinitely — still