partforge 0.156.0 → 0.157.0

package/docs/AUTHORING-PARTS.md

@@ -2037,7 +2037,7 @@ the assembled view, and `minWall` and the overhang check skip sheet parts.
 
 ### The kit
 
-A host downloads sheet parts as one ZIP, the **cut & print kit** (`format: "bundle"`): `README.txt`, `parts.csv`, laid-out `sheets/`, one `parts/` file per distinct piece (plus a `-marks.dxf` for a cutting service) and `print/` for printed parts. Identical pieces merge into one `-xN` file named from `export: { name }`, else the key. Destination (`"own-laser"`, `"service"` or `"cnc-router"`), kerf and stock size are chosen at download, so draw nominal and bind `thickness` to the measured control. A choice the kit cannot honour fails with `cut kit options:`.
+Sheet parts download as one ZIP, the **cut & print kit** (`format: "bundle"`): `README.txt`, `parts.csv`, laid-out `sheets/`, a `parts/` file per distinct piece (plus `-marks.dxf` for a cutting service), `print/` for printed parts. Identical pieces share one `-xN` file named from `export: { name }`, else the key. Destination (`"own-laser"`, `"service"`, `"cnc-router"`), kerf, stock size and a two-sided routed piece's flip and file count are chosen at download: draw nominal, bind `thickness` to the measured control. A choice it cannot honour fails with `cut kit options:`.
 
 ### Limits
 
@@ -2179,8 +2179,8 @@ renders and STEP all come from the one declaration — so model it once.
 
 ### When a sub-part is a routed part
 
-When it is machined from one face of a flat board: an outline, pockets with flat floors,
-holes, all straight down. A sculpted surface, a part machined from both faces, or
+When it is machined from one or both faces of a flat board: an outline, pockets with
+flat floors, holes, all straight down from whichever face. A sculpted surface or
 anything that is not flat stock is an ordinary `build` (export it as STEP). A laser-cut
 plate is `sheetPart`.
 
@@ -2197,8 +2197,12 @@ plinth: routedPart({
   pockets: (k, p, d) => [
     { region: k.shape2d(roundedRectProfile(d.vaultW, d.vaultL, 2)).translate([0, -9]), depth: 11.43, label: "peg vault" },
     { region: k.shape2d(roundedRectProfile(d.pocketW, d.pocketL, 4)).translate([-58, -10]), depth: p.inlayThickness, label: "inlay pocket" },
+    { region: k.shape2d(roundedRectProfile(40, 20, 3)).translate([60, 0]), depth: 4, face: "far", label: "felt recess" },
+  ],
+  drills: (p, d) => [
+    ...d.pegHoles.map(([x, y]) => ({ at: [x, y], d: p.pegHoleDia, depth: 10 })),
+    { at: [-60, 30], d: 8, depth: 6, face: "far", label: "foot socket" },   // from the underside
   ],
-  drills: (p, d) => d.pegHoles.map(([x, y]) => ({ at: [x, y], d: p.pegHoleDia, depth: 10 })),
   extra: (k, p, d) => [{
     solid: k.box({ size: [d.rackL, 12, 14] }).rotateX(-p.rackTilt).at([0, d.rackY, p.baseThickness - 9.5]),
     footprint: k.shape2d(roundedRectProfile(d.rackL, 12, 2)).translate([0, d.rackY]),
@@ -2213,21 +2217,22 @@ plinth: routedPart({
 `exportable` pass through. A field needing the kernel is `(k, p, d) => …`; `drills` is
 `(p, d) => …`. `build` is supplied — passing one throws, as do `kerf`, `score`,
 `engrave` and `process`; each error names the fix. The drawing is in XY with the
-machined face at z = `thickness`; `pose` places it exactly as a sheet part's does.
+near face at z = `thickness` and the far face at z = 0; `pose` places it exactly as a
+sheet part's does.
 
 ### Pockets, drills, extra ops and reference lines
 
-- **`pockets`** — `[{ region, depth, label? }]`: a Shape2D or profile machined `depth`
-  mm down from the machined face, flat-floored. `depth` may equal `thickness` (a
+- **`pockets`** — `[{ region, depth, label?, face? }]`: a Shape2D or profile machined
+  `depth` mm into the stock from its face, flat-floored. `depth` may equal `thickness` (a
   through pocket); deeper is a build error naming the pocket. Pockets whose depths agree to
   two decimals share a DXF layer.
-- **`drills`** — `[{ at: [x, y], d, depth, label? }]`: a round hole of diameter `d`.
+- **`drills`** — `[{ at: [x, y], d, depth, label?, face? }]`: a round hole of diameter `d`.
   Set `depth` to the thickness to drill through — deeper is a `routed-drill-depth`
   lint error. Written as a DXF `CIRCLE`, which is what lets
   the CAM offer a drilling toolpath instead of a profile cut.
-- **`extra`** — `[{ solid, footprint, label, method }]`: an operation the router cannot
-  do straight down — a tilted slot, a scooped thumb hold, an undercut. `solid` is cut in
-  the preview and the STEP; `footprint` (its outline on the machined face) is drawn on
+- **`extra`** — `[{ solid, footprint, label, method, face? }]`: an operation the router
+  cannot do straight down — a tilted slot, a scooped thumb hold, an undercut. `solid` is
+  cut in the preview and the STEP; `footprint` (its outline on its face) is drawn on
   the `SECONDARY` layer; `label` and `method` are REQUIRED and go in the README's
   operations table so the operator knows what to make and how ("core box bit, 20 mm
   radius"). Do not put a flat-floored pocket here to avoid stating its depth.
@@ -2248,10 +2253,27 @@ and depth (colours 3, 4, 2, 140, 170); `SECONDARY` (6) the extra ops' footprints
 `REFERENCE` (8) layout lines. Depth rides both the layer name and the colour, and colours
 are assigned per kit — pockets shallowest depth first, drills in the order they appear —
 so one layer name has one colour in every file. A palette cycles past five depths; the
-README's LAYERS legend (layer, colour, depth) is the authority. Kerf
+README's LAYERS legend (layer, face, colour, depth) is the authority. Kerf
 never applies — the CAM applies the tool offset, and the kit refuses a kerf for this
 destination. The README's ROUTER OPERATIONS table lists every pocket, drill group and
-extra op with its depth and method.
+extra op with its face, depth and method.
+
+### Both faces
+
+Every pocket, drill and extra op takes `face`: `"near"` (the default, machined down
+from z = `thickness`) or `"far"` (machined up from z = 0 — the board turned over); any
+other value is a build error. `depth` is measured from the op's own face. Model the part
+in place, as assembled; the kit does the flipping. Far ops go on their own layers —
+`FAR_POCKET_<depth>MM`, `FAR_DRILL_D<dia>_…`, `FAR_SECONDARY` — mirrored about the
+piece's centre so they read as the router sees the far face. Two kit options apply to a
+piece with far work: `flip` — `"left-right"` (the default, VCarve's Flip Direction =
+Horizontal) or `"end-over-end"` (Vertical) — sets the mirror axis; `twoSided` —
+`"one-file"` (the default: both faces' layers in the piece's one DXF) or `"two-files"`
+(the far layers in `parts/<name>-far.dxf`, behind the mirrored outline on `REFERENCE`
+for alignment). In the CAM, line the far vectors' outline up on the piece's outline as
+seen from the bottom; the README says so and orders the work far side first, through
+cut last. `routedBreakthrough` counts a near and a far pocket that overlap and together
+go deeper than the stock.
 
 ### What lint and verify check
 
@@ -2259,14 +2281,17 @@ Lint: `routed-drill-depth` (error) — a drill deeper than the stock at the defa
 Every sheet rule applies too (`sheet-thickness-literal`, `sheet-custom-build`, …); the
 laser's thickness range does not. A pocket deeper than the stock is a build error.
 
-Verify volunteers three warnings on every routed part, none counting toward
+Verify volunteers four warnings on every routed part, none counting toward
 `declared`/`evaluated`: `routedOutside` (pocket, drill or footprint regions outside the
-profile, `0`), `routedEmpty` (pockets that resolved empty, `0`), `routedPieces` (`1`).
+profile, `0`), `routedEmpty` (pockets that resolved empty, `0`), `routedPieces` (`1`),
+`routedBreakthrough` (a near-face and a far-face pocket that overlap and together go
+deeper than the stock, `0`).
 Each measured row carries `sheet.routed` — the operations table — beside the stock facts.
 
 ### Limits
 
-- One machined face. A part worked from both faces is two routed parts or a `build`.
+- Far-side `reference` lines and far-side work in the sheets/ layouts are not drawn;
+  two-sided jobs are per-piece files.
 - No tool-radius, dogbone or inside-corner checks: the CAM owns those.
 - No depth per extra op beyond its footprint and the solid's deepest point; the
   `method` text is where the operator's instructions go.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.156.0",
+  "version": "0.157.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/export/bundle.js

@@ -19,15 +19,17 @@ import { resolveSheet } from "../sheet/resolve.js";
 import { processById, SHEET_METRICS } from "../process/registry.js";
 import { loadExporter } from "../process/exporters.js";
 import { validateKitOptions, resolveStock, KIT_OPTIONS_ERROR, KIT_LIMITS } from "./formats.js";
-import { canonicalDrawingKey, routedPalette } from "./drawing.js";
+import { canonicalDrawingKey, routedPalette, splitFaces } from "./drawing.js";
 import { renderSvg } from "./svg.js";
 import { renderDxf } from "./dxf.js";
 import { layoutGroup, marginFitsStock } from "./layout.js";
 import { renderReadme, renderPartsCsv, cleanLabel } from "./readme.js";
 
 // Every entry name the kit may write (spec D.10). test/kit-bundle.test.js pins every
-// kit it builds against it, and buildBundle asserts it again before zipping.
-export const KIT_ENTRY_RE = /^(README\.txt|parts\.csv|sheets\/[a-z0-9][a-z0-9._-]*\/sheet-\d+-of-\d+\.(svg|dxf)|parts\/[a-z0-9][a-z0-9._-]*(-x\d+)?(-marks)?\.(svg|dxf)|print\/[a-z0-9][a-z0-9._-]*(-x\d+)?\.(stl|3mf))$/;
+// kit it builds against it, and buildBundle asserts it again before zipping. A piece's
+// files are `<name>[-x<n>]` plus `-far` (a two-sided routed piece's far-face file, in
+// the two-files mode) or `-marks` (a laser piece's score and engrave lines).
+export const KIT_ENTRY_RE = /^(README\.txt|parts\.csv|sheets\/[a-z0-9][a-z0-9._-]*\/sheet-\d+-of-\d+\.(svg|dxf)|parts\/[a-z0-9][a-z0-9._-]*(-x\d+)?(-far)?(-marks)?\.(svg|dxf)|print\/[a-z0-9][a-z0-9._-]*(-x\d+)?\.(stl|3mf))$/;
 
 // A path segment from an author string. safeName already lowercases, collapses runs and
 // refuses a leading dot or dash; folding every run of dots on top means no entry name
@@ -192,27 +194,32 @@ function sheetMetaOrThrow(kernel, sp, p, d, name) {
   throw new Error(`sheet part "${name}": its material or thickness could not be evaluated`);
 }
 
-// The README's layer legend: every routed layer name in the kit, once, with its colour
-// (ACI in a DXF kit, hex in an SVG one) and depth — REFERENCE, SECONDARY, then drills in
-// palette order, then pockets shallowest first. The palette is kit-wide, so a name has
-// one colour; the legend is the authority when a palette cycles.
-const LEGEND_RANK = { reference: 0, secondary: 1, drill: 2, pocket: 3 };
-const legendKind = (l) => (l.id.startsWith("drill-") ? "drill" : l.id.startsWith("pocket-") ? "pocket" : l.id);
+// The README's layer legend: every routed layer name in the kit, once, with its face,
+// colour (ACI in a DXF kit, hex in an SVG one) and depth — REFERENCE, SECONDARY, then
+// drills in palette order, then pockets shallowest first; the far face's layers follow
+// in the same order. The palette is kit-wide, so a name has one colour; the legend is
+// the authority when a palette cycles. It reads each piece's whole drawing, so the
+// far file's alignment outline (splitFaces' `far-outline`) is never listed.
+const LEGEND_RANK = { reference: 0, secondary: 1, drill: 2, pocket: 3, "far-secondary": 4, "far-drill": 5, "far-pocket": 6 };
+const legendKind = (l) => {
+  const m = /^(far-)?(drill|pocket)-/.exec(l.id);
+  return m ? `${m[1] ?? ""}${m[2]}` : l.id;
+};
 function routedLegend(pieces, cutExt) {
   const rows = new Map();
   for (const pc of pieces) {
     for (const l of pc.drawing.layers) {
       if (l.name === undefined || rows.has(l.name)) continue;
       const kind = legendKind(l);
-      rows.set(l.name, { name: l.name, kind, order: rows.size,
+      rows.set(l.name, { name: l.name, kind, face: l.face === "far" ? "far" : "near", order: rows.size,
         colour: cutExt === "svg" ? l.svgColor : String(l.color),
         depth: l.through ? "through" : typeof l.depth === "number" ? `${l.depth.toFixed(2)} mm` : "—", mm: l.depth ?? 0 });
     }
   }
   return [...rows.values()]
     .sort((a, b) => (LEGEND_RANK[a.kind] ?? 9) - (LEGEND_RANK[b.kind] ?? 9)
-      || (a.kind === "pocket" ? a.mm - b.mm : 0) || a.order - b.order)
-    .map(({ name, colour, depth }) => ({ name, colour, depth }));
+      || (a.kind.endsWith("pocket") ? a.mm - b.mm : 0) || a.order - b.order)
+    .map(({ name, face, colour, depth }) => ({ name, face, colour, depth }));
 }
 
 // One export-bundle job's kit. `names` is the job's selected() — exportable, enabled, in
@@ -292,11 +299,14 @@ export async function buildBundle({ kernel, part, msg, p, d, posed, label, expor
   // and the op labels, are not in its drawing — only the README carries them, so two
   // pieces that draw alike but machine differently must stay two files.
   const sameOps = (a, b) => JSON.stringify(a.facts?.routed ?? null) === JSON.stringify(b.facts?.routed ?? null);
+  // A routed piece with far-face work is two-sided: its sheets carry the near face only
+  // (`faces.near`), and the two-files mode writes its far face to a file of its own.
   const pieces = dedupe(drawn, (x) => h(x.key), (a, b) => a.key === b.key && a.group === b.group && sameOps(a, b))
-    .map(({ item, members }) => ({
-      ...item, labels: members.map((m) => m.label), qty: members.length * o.sets,
-      hasMarks: item.drawing.layers.some((l) => l.id === "score" || l.id === "engrave"),
-    }));
+    .map(({ item, members }) => {
+      const faces = splitFaces(item.drawing);
+      return { ...item, labels: members.map((m) => m.label), qty: members.length * o.sets, faces, twoSided: faces.far !== null,
+        hasMarks: item.drawing.layers.some((l) => l.id === "score" || l.id === "engrave") };
+    });
 
   // Names, in definition order. A name that was taken moves to name-2; the README's
   // RENAMED FILES says which file it was and who held the name (spec D.10). A piece
@@ -321,10 +331,12 @@ export async function buildBundle({ kernel, part, msg, p, d, posed, label, expor
     const sx = pc.qty > 1 ? `-x${pc.qty}` : "";
     // A routed piece is never split: its depths are one layered file for the CAM.
     const marks = (service || router) && pc.hasMarks && !pc.routed;
-    const name = claim(kitName(pc.fileKey),
-      (n) => [`parts/${n}${sx}.${cutExt}`, ...(marks ? [`parts/${n}${sx}-marks.dxf`] : []), `parts/${n}/`], pc.labels);
+    const far = pc.twoSided && o.twoSided === "two-files";
+    const name = claim(kitName(pc.fileKey), (n) => [`parts/${n}${sx}.${cutExt}`, ...(marks ? [`parts/${n}${sx}-marks.dxf`] : []),
+      ...(far ? [`parts/${n}${sx}-far.${cutExt}`] : []), `parts/${n}/`], pc.labels);
     pc.file = `parts/${name}${sx}.${cutExt}`;
     pc.marksFile = marks ? `parts/${name}${sx}-marks.dxf` : null;
+    pc.farFile = far ? `parts/${name}${sx}-far.${cutExt}` : null;
   }
 
   // Lay out each stock group. An own laser needs every piece to fit (layoutGroup
@@ -339,7 +351,7 @@ export async function buildBundle({ kernel, part, msg, p, d, posed, label, expor
     const stock = stockFor.get(g.group);
     const laid = layoutGroup({
       group: g.group, label: g.label, stock, margin: o.margin, spacing: o.spacing, strict: !(service || router),
-      pieces: inGroup.map((pc) => ({ key: pc.file, label: pc.labels[0], drawing: pc.drawing, qty: pc.qty })),
+      pieces: inGroup.map((pc) => ({ key: pc.file, label: pc.labels[0], drawing: pc.faces.near, qty: pc.qty })),
     });
     if (laid.sheets.length > KIT_LIMITS.sheetsPerGroup) {
       throw new Error(`${KIT_OPTIONS_ERROR} ${g.material} ${fmtMm(g.thickness)} mm needs ${laid.sheets.length} sheets — at most ${KIT_LIMITS.sheetsPerGroup} per material; use larger stock or fewer sets`);
@@ -394,7 +406,8 @@ export async function buildBundle({ kernel, part, msg, p, d, posed, label, expor
   // The files (spec D.8): own laser — an SVG per sheet and per piece; service and CNC
   // router — a cut-only DXF per laser piece, a -marks.dxf where it has marks, and
   // reference DXF sheets. A routed piece is one file with every layer, whatever the
-  // destination.
+  // destination — or, two-sided in the two-files mode, its near face and its far face
+  // (behind a REFERENCE outline) as two.
   say("writing cut files");
   const title = cleanLabel(part.meta?.title ?? fileBase);
   const files = [];
@@ -404,8 +417,11 @@ export async function buildBundle({ kernel, part, msg, p, d, posed, label, expor
     put(sh.file, cutExt === "dxf" ? renderDxf(doc) : renderSvg(doc));
   }
   for (const pc of pieces) {
-    const doc = { title: pc.labels.join(", "), size: sizeOf(pc.drawing.bounds),
-      placements: [{ drawing: pc.drawing, at: [0, 0], rotated: false }] };
+    const docOf = (drawing) => ({ title: pc.labels.join(", "), size: sizeOf(drawing.bounds),
+      placements: [{ drawing, at: [0, 0], rotated: false }] });
+    const render = cutExt === "svg" ? renderSvg : renderDxf;
+    if (pc.farFile) { put(pc.file, render(docOf(pc.faces.near))); put(pc.farFile, render(docOf(pc.faces.far))); continue; }
+    const doc = docOf(pc.drawing);
     if (cutExt === "svg") { put(pc.file, renderSvg(doc)); continue; }
     if (pc.routed) { put(pc.file, renderDxf(doc)); continue; }       // every layer, one file
     put(pc.file, renderDxf(doc, { include: ["cut"] }));
@@ -416,15 +432,17 @@ export async function buildBundle({ kernel, part, msg, p, d, posed, label, expor
   const controls = collectControls(part.parameters);
   const readme = renderReadme({
     title, destination: o.destination, cutFormat: o.cutFormat, kerf: o.kerf,
+    flip: o.flip, twoSided: o.twoSided, anyTwoSided: pieces.some((pc) => pc.twoSided),
     stockNotes: [...groups.values()].map((g) => ({ material: g.material, thickness: g.thickness,
       control: thicknessControlLabel(controls, part.parts[g.first], p, d) })),
     scale: pieces.map((pc) => ({ label: pc.labels.join(", "), nominal: pc.drawing.nominal, drawn: sizeOf(pc.drawing.bounds) })),
     sheets: sheets.map((sh) => ({ file: sh.file, material: sh.group.material, thickness: sh.group.thickness,
       size: sh.stock, pieces: sh.placements.length, used: sh.used })),
-    pieces: pieces.map((pc) => ({ file: pc.file, marksFile: pc.marksFile, labels: pc.labels, material: groups.get(pc.group).material,
+    pieces: pieces.map((pc) => ({ file: pc.file, marksFile: pc.marksFile, farFile: pc.farFile, labels: pc.labels, material: groups.get(pc.group).material,
       thickness: groups.get(pc.group).thickness, size: pc.drawing.nominal, quantity: pc.qty })),
     router: pieces.filter((pc) => pc.routed && pc.facts?.routed).map((pc) => ({
-      labels: pc.labels, material: groups.get(pc.group).material, thickness: groups.get(pc.group).thickness, ...pc.facts.routed })),
+      labels: pc.labels, material: groups.get(pc.group).material, thickness: groups.get(pc.group).thickness, ...pc.facts.routed,
+      twoSided: pc.twoSided, farFile: pc.farFile })),
     layers: routedLegend(pieces.filter((pc) => pc.routed), cutExt),
     printed: prints.map((pp) => ({ file: pp.file, labels: pp.labels, quantity: pp.qty })),
     clearances: controls.filter(isClearance)
@@ -434,8 +452,11 @@ export async function buildBundle({ kernel, part, msg, p, d, posed, label, expor
     oversized, renamed,
   });
   const csv = renderPartsCsv([
-    ...pieces.map((pc) => ({ file: pc.file, kind: "sheet", labels: pc.labels, material: groups.get(pc.group).material,
-      thickness: groups.get(pc.group).thickness, width: pc.drawing.nominal[0], height: pc.drawing.nominal[1], quantity: pc.qty })),
+    ...pieces.flatMap((pc) => {
+      const row = { file: pc.file, kind: "sheet", labels: pc.labels, material: groups.get(pc.group).material,
+        thickness: groups.get(pc.group).thickness, width: pc.drawing.nominal[0], height: pc.drawing.nominal[1], quantity: pc.qty };
+      return pc.farFile ? [row, { ...row, file: pc.farFile, kind: "far" }] : [row];
+    }),
     ...prints.map((pp) => ({ file: pp.file, kind: "print", labels: pp.labels, material: pp.material, thickness: null,
       width: pp.size[0], height: pp.size[1], quantity: pp.qty })),
   ]);

package/src/framework/export/drawing.js

@@ -359,11 +359,44 @@ export function applyKerf(regions, kerf, { label = "sheet part", gap = null } =
 // Depth in millimetres as a layer-name token: up to two decimals, trailing zeros
 // dropped (11.43 → "11.43", 3 → "3"). Two depths that round alike share a layer.
 export const depthToken = (mm) => String(Number(mm.toFixed(2)));
+// A far-face op's layer carries a FAR_ prefix; near names are unchanged.
 export function routedLayerName(kind, op) {
-  if (kind === "pocket") return `POCKET_${depthToken(op.depth)}MM`;
-  if (kind === "drill") return op.through ? `DRILL_D${depthToken(op.d)}_THRU` : `DRILL_D${depthToken(op.d)}_${depthToken(op.depth)}MM`;
+  const far = op.face === "far" ? "FAR_" : "";
+  if (kind === "pocket") return `${far}POCKET_${depthToken(op.depth)}MM`;
+  if (kind === "drill") return far + (op.through ? `DRILL_D${depthToken(op.d)}_THRU` : `DRILL_D${depthToken(op.d)}_${depthToken(op.depth)}MM`);
   throw new Error(`routedLayerName: unknown kind ${JSON.stringify(kind)}`);
 }
+// How a piece is turned over to cut its far face, as the mirror axis of its drawing.
+export const FLIP_AXIS = Object.freeze({ "left-right": "x", "end-over-end": "y" });
+// A ring mirrored about the line `axis = c` ("x": x -> 2c - x; "y": y -> 2c - y), every
+// point mapped (start, to, via, c1, c2), then walked backwards so a CCW ring stays CCW:
+// an arc keeps its mirrored via, a cubic swaps its mirrored c1/c2. Other fields (closed)
+// carry over. Returns a new ring; the input is not touched.
+export function mirrorRing(ring, axis, c) {
+  const m = axis === "x" ? ([x, y]) => [2 * c - x, y] : ([x, y]) => [x, 2 * c - y];
+  const pts = [ring.start, ...ring.segments.map((s) => s.to)].map(m);
+  const segments = [];
+  for (let i = ring.segments.length - 1; i >= 0; i--) {
+    const s = ring.segments[i], to = pts[i];
+    if (s.via) segments.push({ to, via: m(s.via) });
+    else if (s.c1) segments.push({ to, c1: m(s.c2), c2: m(s.c1) });
+    else segments.push({ to });
+  }
+  return { ...ring, start: pts[pts.length - 1], segments };
+}
+export const mirrorRings = (rings, axis, c) => rings.map((r) => mirrorRing(r, axis, c));
+// A two-sided piece's drawing split by face. `near` keeps every layer not marked
+// face "far" (the input itself for a one-sided piece); `far` is null for a one-sided
+// piece, else the far layers behind a REFERENCE layer of `drawing.farOutline` (the
+// mirrored outer rings the exporter sets), both with the input's bounds/nominal/kerf.
+export function splitFaces(drawing) {
+  const farLayers = drawing.layers.filter((l) => l.face === "far");
+  if (farLayers.length === 0) return { near: drawing, far: null };
+  const { bounds, nominal, kerf } = drawing;
+  const near = { layers: drawing.layers.filter((l) => l.face !== "far"), bounds, nominal, kerf };
+  const outline = { id: "far-outline", name: "REFERENCE", ...ROUTED_COLORS.reference, face: "far", paths: drawing.farOutline };
+  return { near, far: { layers: [outline, ...farLayers], bounds, nominal, kerf } };
+}
 // A drill's tool setting as a key: diameter and depth (or THRU), two-decimal tokens —
 // one layer per key, and the kit-wide palette's drill key.
 export const drillKey = (dr) => `D${depthToken(dr.d)}-${dr.through ? "THRU" : depthToken(dr.depth)}`;

package/src/framework/export/formats.js

@@ -44,9 +44,10 @@ export const KIT_LIMITS = Object.freeze({
 export const KIT_DEFAULTS = Object.freeze({
   destination: "own-laser", kerf: 0, colors: "lightburn", stock: null,
   margin: 5, spacing: 3, printFormat: "stl", sets: 1,
+  flip: "left-right", twoSided: "one-file",
 });
 
-const OPTION_KEYS = ["destination", "cutFormat", "kerf", "colors", "stock", "margin", "spacing", "printFormat", "sets"];
+const OPTION_KEYS = ["destination", "cutFormat", "kerf", "colors", "stock", "margin", "spacing", "printFormat", "sets", "flip", "twoSided"];
 
 const fail = (message) => new Error(`${KIT_OPTIONS_ERROR} ${message}`);
 const isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v)
@@ -91,7 +92,14 @@ export function validateKitOptions(o) {
   if (!Number.isInteger(sets) || sets < KIT_LIMITS.sets[0] || sets > KIT_LIMITS.sets[1])
     throw fail(`sets must be a whole number from ${KIT_LIMITS.sets[0]} to ${KIT_LIMITS.sets[1]}, got ${JSON.stringify(sets)}`);
 
-  return { destination, cutFormat, kerf, colors, stock, margin, spacing, printFormat, sets };
+  const flip = pick("flip");
+  if (flip !== "left-right" && flip !== "end-over-end")
+    throw fail(`flip must be "left-right" or "end-over-end", got ${JSON.stringify(flip)}`);
+  const twoSided = pick("twoSided");
+  if (twoSided !== "one-file" && twoSided !== "two-files")
+    throw fail(`twoSided must be "one-file" or "two-files", got ${JSON.stringify(twoSided)}`);
+
+  return { destination, cutFormat, kerf, colors, stock, margin, spacing, printFormat, sets, flip, twoSided };
 }
 
 // null/undefined → null ("every group gets DEFAULT_STOCK_SIZE"); otherwise fresh

package/src/framework/export/readme.js

@@ -15,7 +15,16 @@ export const CSV_HEADER = "file,kind,labels,material,thickness_mm,width_mm,heigh
 
 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 ROUTER_LEGEND = "DXF layers: CUT (colour 1) is the through cut; POCKET_<depth>MM and DRILL_D<dia>_<depth>MM / _THRU carry one depth each; SECONDARY outlines operations done with another tool (see ROUTER OPERATIONS); REFERENCE is layout only. Laser pieces keep CUT/SCORE/ENGRAVE.";
+const ROUTER_LEGEND = "DXF layers: CUT (colour 1) is the through cut; POCKET_<depth>MM and DRILL_D<dia>_<depth>MM / _THRU carry one depth each; SECONDARY outlines operations done with another tool (see ROUTER OPERATIONS); REFERENCE is layout only. FAR_* layers are the same operations on the far face, drawn mirrored (see the flip note under each two-sided piece). Laser pieces keep CUT/SCORE/ENGRAVE.";
+// A two-sided routed piece: how its far layers were mirrored, how to line them up, and
+// where its through cut is made.
+const FLIP_NOTE = {
+  "left-right": "Far-side layers (FAR_*) are drawn as seen after flipping the board left-right, matching a VCarve two-sided job with Flip Direction = Horizontal.",
+  "end-over-end": "Far-side layers (FAR_*) are drawn as seen after flipping the board end over end, matching a VCarve two-sided job with Flip Direction = Vertical.",
+};
+const ALIGN_NOTE = "On the bottom side, move the imported far-side vectors so their outline sits on the piece's outline as the CAM shows it from that side. Shortcut: make the job's material the piece's size, then centre the imported vectors on the material (VCarve: Align Selected Objects → Centre); because the far layers are mirrored about the piece's own centre, they then land exactly.";
+const ONE_FILE_NOTE = "On the bottom side the CUT outline is for alignment only — cut the piece out from the near side.";
+const TWO_SIDED_ORDER = "Two-sided pieces: machine the far side first, flip, then the near side and the through cut last, so the board holds the piece until the end. Sheet layouts in sheets/ carry near-side work only; far-side work is in the per-piece files.";
 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
@@ -48,6 +57,7 @@ function settingValue(v) {
 
 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 faceOf = (op) => (op.face === "far" ? "far" : "near");
 const labelsOf = (labels) => labels.map(cleanLabel).join(", ");
 
 export function renderReadme(m) {
@@ -72,6 +82,7 @@ export function renderReadme(m) {
       ...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)"}`),
       router ? ROUTER_LEGEND : m.cutFormat === "dxf" ? DXF_LEGEND : SVG_LEGEND,
+      ...(m.anyTwoSided ? [TWO_SIDED_ORDER] : []),
       ...(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."] : []),
@@ -83,16 +94,18 @@ export function renderReadme(m) {
     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)])),
     "ROUTER OPERATIONS": [...(m.router ?? []).flatMap((r) => [
-      `${labelsOf(r.labels)} (${cleanLabel(r.material)} ${r.thickness.toFixed(2)} mm) — depths from the machined face:`,
-      ...table(["op", "label", "size", "depth", "method"], [
-        ...r.pockets.map((pk) => ["pocket", pk.label ? cleanLabel(pk.label) : "—", mm2([pk.w, pk.h]), `${pk.depth.toFixed(2)} mm`, "mill"]),
-        ...r.drills.map((dr) => ["drill", dr.label ? cleanLabel(dr.label) : "—", `Ø${fmtMm(dr.d)} mm × ${dr.count}`, dr.through ? "through" : `${dr.depth.toFixed(2)} mm`, "drill"]),
-        ...r.extra.map((x) => ["extra", cleanLabel(x.label), mm2([x.w, x.h]), `to ${x.maxDepth.toFixed(2)} mm`, cleanLabel(x.method)]),
+      `${labelsOf(r.labels)} (${cleanLabel(r.material)} ${r.thickness.toFixed(2)} mm) — depths from each op's own face:`,
+      ...table(["op", "face", "label", "size", "depth", "method"], [
+        ...r.pockets.map((pk) => ["pocket", faceOf(pk), pk.label ? cleanLabel(pk.label) : "—", mm2([pk.w, pk.h]), `${pk.depth.toFixed(2)} mm`, "mill"]),
+        ...r.drills.map((dr) => ["drill", faceOf(dr), dr.label ? cleanLabel(dr.label) : "—", `Ø${fmtMm(dr.d)} mm × ${dr.count}`, dr.through ? "through" : `${dr.depth.toFixed(2)} mm`, "drill"]),
+        ...r.extra.map((x) => ["extra", faceOf(x), cleanLabel(x.label), mm2([x.w, x.h]), `to ${x.maxDepth.toFixed(2)} mm`, cleanLabel(x.method)]),
       ]),
+      ...(r.twoSided ? [FLIP_NOTE[m.flip] ?? FLIP_NOTE["left-right"], ALIGN_NOTE,
+        r.farFile ? `Far-side work is in ${r.farFile}; its REFERENCE outline is for alignment, not cutting.` : ONE_FILE_NOTE] : []),
     ]),
     // The layer legend: one colour per layer name across the whole kit.
     ...((m.router ?? []).length && (m.layers ?? []).length
-      ? ["LAYERS (one colour per layer across the kit):", ...table(["layer", "colour", "depth"], m.layers.map((l) => [l.name, l.colour, l.depth]))]
+      ? ["LAYERS (one colour per layer across the kit):", ...table(["layer", "face", "colour", "depth"], m.layers.map((l) => [l.name, faceOf(l), l.colour, l.depth]))]
       : [])],
     "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) =>

package/src/framework/process/cnc-router/descriptor.js

@@ -1,4 +1,5 @@
-// CNC routing — process module #2. Flat stock machined from ONE face: through cuts
+// CNC routing — process module #2. Flat stock machined from either face — the near
+// face (z = t, the default) or the far face (z = 0, per op `face: "far"`): through cuts
 // (profile), flat-floored pockets at a depth, drilled holes at a depth, and `extra`
 // operations the operator does with another tool after the flat milling. The
 // drawing is one layered DXF per piece, depth on the layer name and colour.
@@ -12,8 +13,9 @@ import {
 } from "../../sheet/constants.js";
 import { err } from "../../lint/finding.js";
 
-// The preview: the profile extruded to the thickness, each pocket cut `depth` down from
-// the machined face (z = t), each drill as a cylinder from the face to its depth —
+// The preview: the profile extruded to the thickness, each pocket cut `depth` into the
+// stock from its face (down from z = t on the near face, up from z = 0 on the far
+// face), each drill as a cylinder from its face to its depth —
 // through holes and through pockets (depth = thickness) clear BOTH faces by MARK_OVERCUT so no cap is coplanar with a face
 // (OCCT's coplanar booleans are fragile) — each extra solid subtracted as given, and
 // the reference grooves cut like a laser score. A tool whose region turned out empty
@@ -29,10 +31,14 @@ function routedPreview(k, s) {
   const tools = [
     ...pockets.map((pk) => orEmpty(() => (pk.depth >= t
       ? pk.region.extrude({ h: t + 2 * MARK_OVERCUT }).translate([0, 0, -MARK_OVERCUT])
-      : pk.region.extrude({ h: pk.depth + MARK_OVERCUT }).translate([0, 0, t - pk.depth])))),
+      : pk.face === "far"
+        ? pk.region.extrude({ h: pk.depth + MARK_OVERCUT }).translate([0, 0, -MARK_OVERCUT])
+        : pk.region.extrude({ h: pk.depth + MARK_OVERCUT }).translate([0, 0, t - pk.depth])))),
     ...drills.map((dr) => (dr.through
       ? k.cylinder({ d: dr.d, h: t + 2 * MARK_OVERCUT }).translate([dr.at[0], dr.at[1], -MARK_OVERCUT])
-      : k.cylinder({ d: dr.d, h: dr.depth + MARK_OVERCUT }).translate([dr.at[0], dr.at[1], t - dr.depth]))),
+      : dr.face === "far"
+        ? k.cylinder({ d: dr.d, h: dr.depth + MARK_OVERCUT }).translate([dr.at[0], dr.at[1], -MARK_OVERCUT])
+        : k.cylinder({ d: dr.d, h: dr.depth + MARK_OVERCUT }).translate([dr.at[0], dr.at[1], t - dr.depth]))),
     ...extra.map((x) => x.solid),
     ...s.grooves.map((g) => orEmpty(() => g.extrude({ h: MARK_DEPTH + MARK_OVERCUT }).translate([0, 0, t - MARK_DEPTH]))),
   ].filter(Boolean);
@@ -74,21 +80,21 @@ function routedFacts(s) {
   for (const pk of pockets) {
     if (pk.region.isEmpty()) { empty++; continue; }
     const [w, h] = sizeOf(pk.region);
-    pocketRows.push({ label: pk.label, depth: pk.depth, w: round2(w), h: round2(h), area: round2(pk.region.area()) });
+    pocketRows.push({ label: pk.label, depth: pk.depth, w: round2(w), h: round2(h), area: round2(pk.region.area()), face: pk.face });
     noteOutside(pk.region);
   }
-  // Drills grouped by (d, depth, through): one row per tool setting, labels joined.
+  // Drills grouped by (d, depth, through, face): one row per tool setting, labels joined.
   const drillGroups = new Map();
   for (const dr of drills) {
-    const key = `${dr.d}|${dr.depth}|${dr.through}`;
-    const g = drillGroups.get(key) ?? { labels: [], d: dr.d, depth: dr.depth, through: dr.through, count: 0 };
+    const key = `${dr.d}|${dr.depth}|${dr.through}|${dr.face}`;
+    const g = drillGroups.get(key) ?? { labels: [], d: dr.d, depth: dr.depth, through: dr.through, face: dr.face, count: 0 };
     g.count++;
     if (dr.label && !g.labels.includes(dr.label)) g.labels.push(dr.label);
     drillGroups.set(key, g);
     noteOutside(dr.shape);
   }
-  const drillRows = [...drillGroups.values()].map(({ labels, d, depth, through, count }) =>
-    ({ label: labels.length ? labels.join(", ") : null, d, depth, through, count }));
+  const drillRows = [...drillGroups.values()].map(({ labels, d, depth, through, count, face }) =>
+    ({ label: labels.length ? labels.join(", ") : null, d, depth, through, count, face }));
   // An extra op whose footprint resolved to nothing draws nothing: counted under
   // `empty` with the empty pockets, never a row (its size has no bounding box).
   const extraRows = [];
@@ -96,12 +102,25 @@ function routedFacts(s) {
     if (x.footprint.isEmpty()) { empty++; continue; }
     const [w, h] = sizeOf(x.footprint);
     noteOutside(x.footprint);
-    // How deep the op reaches below the machined face (z = t), within the stock. An
-    // empty solid has no bounding box and reaches nothing.
+    // How deep the op reaches into the stock from its face — below z = t on the near
+    // face, above z = 0 on the far face — within the stock. An empty solid has no
+    // bounding box and reaches nothing.
     const bb = x.solid.boundingBox();
-    const bottom = bb?.min?.[2];
-    const reach = Number.isFinite(bottom) ? t - bottom : 0;
-    extraRows.push({ label: x.label, method: x.method, w: round2(w), h: round2(h), maxDepth: round2(Math.max(0, Math.min(t, reach))) });
+    const bound = x.face === "far" ? bb?.max?.[2] : bb?.min?.[2];
+    const reach = Number.isFinite(bound) ? (x.face === "far" ? bound : t - bound) : 0;
+    extraRows.push({ label: x.label, method: x.method, w: round2(w), h: round2(h), maxDepth: round2(Math.max(0, Math.min(t, reach))), face: x.face });
+  }
+
+  // Breakthrough: a near pocket and a far pocket whose regions overlap and whose depths
+  // together exceed the stock — the router breaks through between them. Depths adding
+  // up to exactly the thickness are a deliberate opening and never counted.
+  const live = pockets.filter((pk) => !pk.region.isEmpty());
+  const near = live.filter((pk) => pk.face !== "far"), far = live.filter((pk) => pk.face === "far");
+  let breakthrough = 0;
+  for (const a of near) {
+    for (const b of far) {
+      if (a.depth + b.depth > t + 1e-6 && a.region.intersect(b.region).area() > LOSS_TOL_MM2) breakthrough++;
+    }
   }
 
   return {
@@ -112,7 +131,7 @@ function routedFacts(s) {
     at: { bridge: null, gap: null, marks: null, outside: null },
     readErrors: { bridge: null, gap: null, marks: null, marksArea: null },
     evaluated: true,
-    routed: { profile: { w: round2(flat[0]), h: round2(flat[1]) }, pockets: pocketRows, drills: drillRows, extra: extraRows, outside, empty },
+    routed: { profile: { w: round2(flat[0]), h: round2(flat[1]) }, pockets: pocketRows, drills: drillRows, extra: extraRows, outside, empty, breakthrough },
   };
 }
 
@@ -130,10 +149,13 @@ const METRICS = {
   routedPieces: { kind: "warn", doc: ROUTED_DOC_ID,
     extract: (s) => s.sheet?.pieces ?? null,
     hint: "the profile is not exactly one piece — a routed part must cut out as one region; join the pieces or split them into separate routedPart sub-parts" },
+  routedBreakthrough: { kind: "warn", doc: ROUTED_DOC_ID,
+    extract: (s) => s.sheet?.routed?.breakthrough ?? null,
+    hint: "a pocket on the near face and one on the far face overlap and together go deeper than the stock, so the router breaks through between them — make the overlap a through cut in `profile`, or lower one depth; if the opening is intended, set the two depths to add up to exactly the thickness" },
 };
 
 // ── lint ──────────────────────────────────────────────────────────────────────
-const DRILL_DEPTH_HINT = "A drill's depth is measured from the machined face; a depth at or past the stock thickness is a through hole. Lower the depth, raise the stock thickness control, or set depth to the thickness to drill through.";
+const DRILL_DEPTH_HINT = "A drill's depth is measured from the op's own face (near or far); a depth at or past the stock thickness is a through hole. Lower the depth, raise the stock thickness control, or set depth to the thickness to drill through.";
 const ROUTER_RULES = [{
   id: "routed-drill-depth",
   run: ({ part, p, d, deriveError }) => {
@@ -168,7 +190,7 @@ export const ROUTER = {
   preview: routedPreview,
   destinations: [{ id: "cnc-router", cutFormat: "dxf" }],
   facts: routedFacts,
-  checks: () => ({ routedOutside: "0", routedEmpty: "0", routedPieces: "1" }),
+  checks: () => ({ routedOutside: "0", routedEmpty: "0", routedPieces: "1", routedBreakthrough: "0" }),
   metrics: METRICS,
   lintRules: ROUTER_RULES,
 };

package/src/framework/process/cnc-router/export.js

@@ -6,10 +6,11 @@
 //
 // Colours: `ctx.palette` (drawing.js routedPalette, built by the kit over EVERY routed
 // piece) when given, so one depth is one colour across the kit; without it — a direct
-// call — the piece ranks its own depths. Each named layer also carries its `depth` (mm,
+// call — routedPalette over the piece alone. Each named layer also carries its `depth` (mm,
 // two decimals) and drills `through`, which the README's layer legend reads.
 import {
   refitRing, ringsOf, cutRings, drawingBounds, routedLayerName, depthToken, drillKey, ROUTED_COLORS,
+  routedPalette, FLIP_AXIS, mirrorRings,
 } from "../../export/drawing.js";
 import { KIT_OPTIONS_ERROR } from "../../export/formats.js";
 
@@ -18,57 +19,79 @@ const refitRegions = (regions) => regions.map((rg) => ({ outer: refitRing(rg.out
 const allRings = (regions) => { const r = ringsOf(regions); return [...r.outer, ...r.holes]; };
 const ringsOfShape = (shape) => allRings(refitRegions(shape.toContours())).map(closedPath);
 
-function drawing(s, o, k, ctx = {}) {
-  const label = ctx.label ?? s.label ?? "routed part";
-  if (o?.kerf > 0) throw new Error(`${KIT_OPTIONS_ERROR} kerf does not apply to a CNC router — the CAM applies the tool offset; set kerf to 0 ("${label}")`);
-  const nominal = refitRegions(s.profile.toContours());
-  if (nominal.length === 0) throw new Error(`cut kit: "${label}" has an empty profile — nothing to cut`);
-  const cut = cutRings(nominal);
-  const { pockets, drills, extra } = s.routed;
-
+// One face's operation layers: SECONDARY, then drills grouped by (d, depth, through) in
+// first-seen order, then pockets grouped by two-decimal depth, shallowest first. `place`
+// maps each layer's paths (identity for the near face, the flip's mirror for the far);
+// a far layer's id is prefixed `far-` and it carries `face: "far"` — a near layer has
+// no face key, so a one-sided piece draws exactly as before two-sided parts existed.
+function opLayers({ pockets, drills, extra }, palette, place) {
+  const tag = place ? { face: "far" } : {};
+  const id = (base) => (place ? `far-${base}` : base);
+  const at = place ?? ((paths) => paths);
   const layers = [];
-  const reference = [
-    ...s.score.lines.map(([a, b]) => ({ start: [a[0], a[1]], segments: [{ to: [b[0], b[1]] }], closed: false })),
-    ...s.score.shapes.flatMap(ringsOfShape),
-  ];
-  if (reference.length) layers.push({ id: "reference", name: "REFERENCE", ...ROUTED_COLORS.reference, paths: reference });
   const secondary = extra.flatMap((x) => ringsOfShape(x.footprint));
-  if (secondary.length) layers.push({ id: "secondary", name: "SECONDARY", ...ROUTED_COLORS.secondary, paths: secondary });
+  if (secondary.length) layers.push({ id: id("secondary"), name: place ? "FAR_SECONDARY" : "SECONDARY", ...ROUTED_COLORS.secondary, ...tag, paths: at(secondary) });
 
-  // Drills grouped by (d, depth, through) in first-seen order; each hole a closed ring
-  // of two exact arcs, which dxf.js writes as a CIRCLE.
-  const palette = ctx.palette ?? null;
+  // Each hole a closed ring of two exact arcs, which dxf.js writes as a CIRCLE.
   const drillGroups = new Map();
   drills.forEach((dr) => {
     const key = drillKey(dr);
-    const colour = palette?.drill.get(key) ?? ROUTED_COLORS.drill[drillGroups.size % ROUTED_COLORS.drill.length];
-    const g = drillGroups.get(key) ?? { id: `drill-${key}`, name: routedLayerName("drill", dr), ...colour,
-      depth: Number(depthToken(dr.depth)), through: dr.through, paths: [] };
-    g.paths.push(...ringsOfShape(dr.shape));
+    const g = drillGroups.get(key) ?? { id: id(`drill-${key}`), name: routedLayerName("drill", dr), ...palette.drill.get(key),
+      depth: Number(depthToken(dr.depth)), through: dr.through, ...tag, paths: [] };
+    g.paths.push(...at(ringsOfShape(dr.shape)));
     drillGroups.set(key, g);
   });
   layers.push(...drillGroups.values());
 
-  // Pockets grouped by two-decimal depth, shallowest layer first; an empty region draws nothing.
+  // An empty region draws nothing.
   const pocketGroups = new Map();
   for (const pk of pockets) {
     const paths = ringsOfShape(pk.region);
     if (paths.length === 0) continue;
     const key = depthToken(pk.depth);
-    const g = pocketGroups.get(key) ?? { id: `pocket-${key}`, name: routedLayerName("pocket", pk), depth: Number(key), paths: [] };
-    g.paths.push(...paths);
+    const g = pocketGroups.get(key) ?? { id: id(`pocket-${key}`), name: routedLayerName("pocket", pk), depth: Number(key), ...tag, paths: [] };
+    g.paths.push(...at(paths));
     pocketGroups.set(key, g);
   }
-  [...pocketGroups.values()].sort((a, b) => a.depth - b.depth).forEach((g, i) => {
-    const colour = palette?.pocket.get(depthToken(g.depth)) ?? ROUTED_COLORS.pocket[i % ROUTED_COLORS.pocket.length];
-    layers.push({ ...g, ...colour });
-  });
+  [...pocketGroups.values()].sort((a, b) => a.depth - b.depth)
+    .forEach((g) => layers.push({ ...g, ...palette.pocket.get(depthToken(g.depth)) }));
+  return layers;
+}
+
+function drawing(s, o, k, ctx = {}) {
+  const label = ctx.label ?? s.label ?? "routed part";
+  if (o?.kerf > 0) throw new Error(`${KIT_OPTIONS_ERROR} kerf does not apply to a CNC router — the CAM applies the tool offset; set kerf to 0 ("${label}")`);
+  const nominal = refitRegions(s.profile.toContours());
+  if (nominal.length === 0) throw new Error(`cut kit: "${label}" has an empty profile — nothing to cut`);
+  const cut = cutRings(nominal);
+  const { pockets, drills, extra } = s.routed;
+
+  const layers = [];
+  const reference = [
+    ...s.score.lines.map(([a, b]) => ({ start: [a[0], a[1]], segments: [{ to: [b[0], b[1]] }], closed: false })),
+    ...s.score.shapes.flatMap(ringsOfShape),
+  ];
+  if (reference.length) layers.push({ id: "reference", name: "REFERENCE", ...ROUTED_COLORS.reference, paths: reference });
+  // Near ops as they are; far ops (cut after the piece is turned over by the kit's flip)
+  // on their own `far-` layers, every ring mirrored about the piece's centre so the far
+  // face is drawn as the router sees it. One palette for both faces: a depth or drill
+  // setting is one colour whichever face it is on.
+  const palette = ctx.palette ?? routedPalette([s]);
+  const nb = drawingBounds([{ id: "cut-outer", paths: ringsOf(nominal).outer.map(closedPath) }]);
+  const axis = FLIP_AXIS[o?.flip ?? "left-right"];
+  const centre = axis === "x" ? (nb.min[0] + nb.max[0]) / 2 : (nb.min[1] + nb.max[1]) / 2;
+  const isFar = (op) => op.face === "far";
+  const near = opLayers({ pockets: pockets.filter((op) => !isFar(op)), drills: drills.filter((op) => !isFar(op)), extra: extra.filter((op) => !isFar(op)) }, palette);
+  const far = opLayers({ pockets: pockets.filter(isFar), drills: drills.filter(isFar), extra: extra.filter(isFar) }, palette,
+    (paths) => mirrorRings(paths, axis, centre));
+  layers.push(...near, ...far);
 
   if (cut.inner.length) layers.push({ id: "cut-inner", paths: cut.inner.map(closedPath) });
   layers.push({ id: "cut-outer", paths: cut.outer.map(closedPath) });
 
-  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: 0 };
+  const out = { layers, bounds: drawingBounds(layers), nominal: [nb.max[0] - nb.min[0], nb.max[1] - nb.min[1]], kerf: 0 };
+  if (far.length) out.farOutline = mirrorRings(ringsOf(nominal).outer, axis, centre).map(closedPath);
+  return out;
 }
 
 export default { drawing };

package/src/framework/sheet/routed-resolve.js

@@ -16,6 +16,13 @@ const depthOf = (sp, entry, who) => {
   if (!isNum(entry.depth) || entry.depth <= 0) throw fail(sp, `${who} depth must be a finite number > 0 (mm), got ${JSON.stringify(entry.depth)}`);
   return entry.depth;
 };
+// Which face an op is machined from: "near" (z = thickness, the default) or "far" (z = 0).
+const faceOf = (sp, entry, who) => {
+  const f = entry.face;
+  if (f === undefined || f === null) return "near";
+  if (f === "near" || f === "far") return f;
+  throw fail(sp, `${who} face must be "near" or "far", got ${JSON.stringify(f)}`);
+};
 const labelOf = (entry) => (typeof entry.label === "string" && entry.label.trim() ? entry.label.trim() : null);
 const list = (sp, fn, args, what, shape) => {
   if (!fn) return [];
@@ -26,7 +33,9 @@ const list = (sp, fn, args, what, shape) => {
 };
 
 // `base` is resolveSheet's ResolvedSheet so far (profile, thickness, score…); the
-// return value is merged onto it as `routed`.
+// return value is merged onto it as `routed`. Every op carries `face`: "near" (machined
+// from z = thickness, the default) or "far" (from z = 0, the stock flipped over); depth
+// is measured from that face either way.
 export function resolveRouted(k, sp, p, d, base) {
   const s = sp.sheet;
   const t = base.thickness;
@@ -35,8 +44,9 @@ export function resolveRouted(k, sp, p, d, base) {
     const who = name(e, i, "pocket");
     if (!e || typeof e !== "object" || e.region === null || e.region === undefined) throw fail(sp, `${who} needs a region (a Shape2D or profile)`);
     const depth = depthOf(sp, e, who);
+    const face = faceOf(sp, e, who);
     if (depth > t) throw fail(sp, `${who} is ${e.depth} mm deep in ${t} mm stock — a pocket may be at most the thickness; make it a through cut in \`profile\` if it should go through`);
-    return { region: k.shape2d(e.region), depth, label: labelOf(e) };
+    return { region: k.shape2d(e.region), depth, label: labelOf(e), face };
   });
 
   const drills = list(sp, s.drills, [p, d], "drills(p, d)", "{ at, d, depth }").map((e, i) => {
@@ -44,18 +54,20 @@ export function resolveRouted(k, sp, p, d, base) {
     if (!e || typeof e !== "object" || !isPoint(e.at)) throw fail(sp, `${who} needs at: [x, y]`);
     if (!isNum(e.d) || e.d <= 0) throw fail(sp, `${who} d must be a finite number > 0 (mm), got ${JSON.stringify(e.d)}`);
     const depth = depthOf(sp, e, who);
+    const face = faceOf(sp, e, who);
     const through = depth >= t;
-    return { shape: k.shape2d(circleRing(e.at, e.d / 2)), at: [e.at[0], e.at[1]], d: e.d, depth: through ? t : depth, through, label: labelOf(e) };
+    return { shape: k.shape2d(circleRing(e.at, e.d / 2)), at: [e.at[0], e.at[1]], d: e.d, depth: through ? t : depth, through, label: labelOf(e), face };
   });
 
   const extra = list(sp, s.extra, [k, p, d], "extra(k, p, d)", "{ solid, footprint, label, method }").map((e, i) => {
     const label = labelOf(e);
     if (!label) throw fail(sp, `extra op ${i + 1} needs a label — say what it is ("12° domino slot")`);
     const who = `extra op "${label}"`;
+    const face = faceOf(sp, e, who);
     if (typeof e.method !== "string" || !e.method.trim()) throw fail(sp, `${who} needs a method — say how the operator makes it ("table saw, blade tilted 12°")`);
     if (!isSolid(e.solid)) throw fail(sp, `${who} needs a solid — the geometry it removes, for the preview and the STEP`);
     if (e.footprint === null || e.footprint === undefined) throw fail(sp, `${who} needs a footprint — its outline on the machined face, for the drawing`);
-    return { solid: e.solid, footprint: k.shape2d(e.footprint), label, method: e.method.trim() };
+    return { solid: e.solid, footprint: k.shape2d(e.footprint), label, method: e.method.trim(), face };
   });
 
   return { pockets, drills, extra };

package/types/geometry.d.ts

@@ -338,12 +338,14 @@ export function sheetPart<P = ResolvedParams, D = Derived>(spec: SheetPartSpec<P
 
 // --- routed parts (docs/AUTHORING-PARTS.md "Routed parts") --------------------
 
-/** A flat-floored pocket machined `depth` mm down from the machined face. */
-export interface RoutedPocket { region: Shape2D | ProfileInput; depth: number; label?: string }
+/** Which face of the stock an op is machined from: `"near"` (z = thickness, the default) or `"far"` (z = 0). */
+export type RoutedFace = "near" | "far";
+/** A flat-floored pocket machined `depth` mm into the stock from its face. */
+export interface RoutedPocket { region: Shape2D | ProfileInput; depth: number; label?: string; face?: RoutedFace }
 /** A drilled hole; `depth` equal to the stock thickness drills through — deeper is a `routed-drill-depth` lint error. */
-export interface RoutedDrill { at: Point2; d: number; depth: number; label?: string }
+export interface RoutedDrill { at: Point2; d: number; depth: number; label?: string; face?: RoutedFace }
 /** An operation done with another tool after the flat milling: the solid is cut in the preview and the STEP, the footprint is drawn, label and method go in the README. */
-export interface RoutedExtra { solid: Solid; footprint: Shape2D | ProfileInput; label: string; method: string }
+export interface RoutedExtra { solid: Solid; footprint: Shape2D | ProfileInput; label: string; method: string; face?: RoutedFace }
 
 /**
  * What `routedPart` accepts: `sheetPart`'s stock, profile and pose, plus pockets,

package/types/index.d.ts

@@ -67,6 +67,10 @@ export interface KitOptions {
   printFormat?: "stl" | "3mf";
   /** Whole number, 1–20. Default 1. */
   sets?: number;
+  /** Which way a two-sided board is turned over between sides — the axis far-side layers are mirrored about. Default `"left-right"`. */
+  flip?: "left-right" | "end-over-end";
+  /** Two-sided pieces: one layered file per piece (`"one-file"`, default), or a near file plus a `-far` file (`"two-files"`). */
+  twoSided?: "one-file" | "two-files";
 }
 
 /**
@@ -830,6 +834,8 @@ export const KIT_DEFAULTS: Readonly<{
   spacing: number;
   printFormat: "stl";
   sets: number;
+  flip: "left-right";
+  twoSided: "one-file";
 }>;
 
 /** Normalise kit options — defaults filled, `cutFormat` derived — or throw a `"cut kit options: …"` error. */

package/types/part.d.ts

@@ -576,6 +576,8 @@ export interface SubPartExpectations {
   routedEmpty?: Expectation;
   /** Routed parts only: separate regions in the cut profile (volunteered check: `1`). */
   routedPieces?: Expectation;
+  /** Routed parts only: overlapping near- and far-face pocket pairs whose depths together exceed the stock (volunteered check: `0`). */
+  routedBreakthrough?: Expectation;
 }
 
 /**