makeables 0.10.0 → 0.12.0

package/dist/cli.js

@@ -1,4 +1,16 @@
 #!/usr/bin/env node
+import "./chunk-BYXBJQAS.js";
+import {
+  addBrandKit,
+  addBrandLogo,
+  brandFromUrl,
+  brandView,
+  checkKitAgainstBrand,
+  newBrand,
+  prepareBrand,
+  readBrand,
+  writeBrand
+} from "./chunk-YOGNQAYJ.js";
 import {
   addKitMember,
   addToSheet,
@@ -13,41 +25,28 @@ import {
   readSheet,
   sheetPreviewPng,
   sheetReport
-} from "./chunk-TRIRNJSG.js";
+} from "./chunk-7A4TRTVE.js";
 import {
   getSkill,
   skills,
   version
-} from "./chunk-SZTWKHNA.js";
+} from "./chunk-WEPC5LJ7.js";
 import {
   CloudError,
   InputError,
-  PACKAGE_LIMIT,
   addBadgeSticker,
-  badgeDesignObjectSchema,
-  badgeDesignSchema,
   cardStyles,
-  checkSubmittedSvg,
   connectAccount,
   createStickerDesign,
-  defaultStickerMaterial,
   designCatalog,
-  designProfile,
-  draftFromPackage,
   findCardStyle,
   findDesign,
-  hashBytes,
-  jsonBytes,
-  kitDocumentSchema,
   listCardDesigns,
   logout,
   newBadge,
   newCard,
   openBrowser,
-  packageJson,
   readBadge,
-  readPackageJson,
-  readPackageZip,
   readSubmission,
   removeBadgeLayer,
   renderBadge,
@@ -57,33 +56,2107 @@ import {
   startStudio,
   stickerCut,
   stickerCutSvg,
-  stickerMaterialSchema,
   stickerStyles,
   studioRequest,
   submitDesign,
   summarizeBadgeLayers,
-  svgNodeSchema,
-  svgNodeXml,
   writeAtomic
-} from "./chunk-G6OTYITI.js";
+} from "./chunk-MXT43NAQ.js";
+import {
+  PACKAGE_LIMIT,
+  badgeDesignObjectSchema,
+  badgeDesignSchema,
+  checkSubmittedSvg,
+  defaultStickerMaterial,
+  designProfile,
+  draftFromPackage,
+  hashBytes,
+  jsonBytes,
+  kitDocumentSchema,
+  packageJson,
+  readPackageJson,
+  readPackageZip,
+  stickerMaterialSchema,
+  svgNodeSchema,
+  svgNodeXml
+} from "./chunk-KLJRRHMY.js";
 
 // src/cli.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 import { constants as constants4 } from "fs";
-import { access, lstat as lstat4, open as open4, readFile as readFile7 } from "fs/promises";
-import { dirname as dirname5, extname as extname4, resolve as resolve7 } from "path";
+import { access, lstat as lstat4, open as open4, readFile as readFile8 } from "fs/promises";
+import { dirname as dirname5, extname as extname4, resolve as resolve8 } from "path";
 import { parseArgs } from "util";
-import sharp8 from "sharp";
-import { ZodError } from "zod";
+import sharp9 from "sharp";
+import { ZodError as ZodError2 } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
+// src/brick.ts
+import { existsSync, readFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
+
+// ../bricks/dist/index.js
+var GRID_MM = 42;
+var GRIDFINITY_UNIT_MM = 10;
+var CELL_UNITS = GRID_MM / GRIDFINITY_UNIT_MM;
+var HEIGHT_UNIT_MM = 7;
+var BASE_PROFILE = [
+  [2.95, 0],
+  [2.15, 0.8],
+  [2.15, 2.6],
+  [0, 4.75]
+];
+var BASE_TOP_MM = 41.5;
+var BASE_TOP_RADIUS_MM = 3.75;
+var GAP_MM = 0.25;
+var WALL_MM = 0.95;
+var FUSE_MM = 0.5;
+var CORNER_SEGMENTS = 6;
+function rounded(cx, cz, w, d, r) {
+  const out = [];
+  const corners = [
+    [cx + w / 2 - r, cz + d / 2 - r, 0],
+    [cx - w / 2 + r, cz + d / 2 - r, 90],
+    [cx - w / 2 + r, cz - d / 2 + r, 180],
+    [cx + w / 2 - r, cz - d / 2 + r, 270]
+  ];
+  for (const [x, z5, start] of corners)
+    for (let k = 0; k <= CORNER_SEGMENTS; k++) {
+      const t = (start + 90 * k / CORNER_SEGMENTS) * Math.PI / 180;
+      out.push([x + r * Math.cos(t), z5 + r * Math.sin(t)]);
+    }
+  return out;
+}
+function squareFor(ring, cx, cz, half) {
+  return ring.map(([x, z5]) => {
+    const dx = x - cx;
+    const dz = z5 - cz;
+    const s = half / Math.max(Math.abs(dx), Math.abs(dz));
+    return [cx + dx * s, cz + dz * s];
+  });
+}
+var Mesh = class {
+  triangles = [];
+  /**
+   * Counter-clockwise seen from outside. Zero-area triangles along the knife
+   * edge between baseplate cells are kept: they stitch the seam closed.
+   */
+  tri(a, b, c) {
+    this.triangles.push(...a, ...b, ...c);
+  }
+  /** Side wall between two rings; `outward` faces away from the ring centre. */
+  wall(lower, yl, upper, yu, outward, keep = () => true) {
+    for (let i = 0; i < lower.length; i++) {
+      if (!keep(i)) continue;
+      const j = (i + 1) % lower.length;
+      const a = [lower[i][0], yl, lower[i][1]];
+      const b = [lower[j][0], yl, lower[j][1]];
+      const c = [upper[j][0], yu, upper[j][1]];
+      const d = [upper[i][0], yu, upper[i][1]];
+      if (outward) {
+        this.tri(a, c, b);
+        this.tri(a, d, c);
+      } else {
+        this.tri(a, b, c);
+        this.tri(a, c, d);
+      }
+    }
+  }
+  /** Flat convex cap; `up` faces +Y. */
+  cap(ring, y, up) {
+    const [cx, cz] = ring.reduce(
+      ([sx, sz], [x, z5]) => [sx + x / ring.length, sz + z5 / ring.length],
+      [0, 0]
+    );
+    for (let i = 0; i < ring.length; i++) {
+      const j = (i + 1) % ring.length;
+      const c = [cx, y, cz];
+      const a = [ring[i][0], y, ring[i][1]];
+      const b = [ring[j][0], y, ring[j][1]];
+      if (up) this.tri(c, b, a);
+      else this.tri(c, a, b);
+    }
+  }
+  /** Flat annulus between two stitched rings; `up` faces +Y. */
+  annulus(outer, inner, y, up) {
+    for (let i = 0; i < outer.length; i++) {
+      const j = (i + 1) % outer.length;
+      const a = [outer[i][0], y, outer[i][1]];
+      const b = [outer[j][0], y, outer[j][1]];
+      const c = [inner[j][0], y, inner[j][1]];
+      const d = [inner[i][0], y, inner[i][1]];
+      if (up) {
+        this.tri(a, c, b);
+        this.tri(a, d, c);
+      } else {
+        this.tri(a, b, c);
+        this.tri(a, c, d);
+      }
+    }
+  }
+};
+var profileRing = (cx, cz, size, radius, inset) => rounded(cx, cz, size - 2 * inset, size - 2 * inset, Math.max(0.01, radius - inset));
+var toUnits = (mm) => mm.map((v) => v / GRIDFINITY_UNIT_MM);
+function part(id, name, mesh, connectors, height, w, d) {
+  return {
+    id,
+    name,
+    connectors,
+    triangles: toUnits(mesh.triangles),
+    colors: new Array(mesh.triangles.length / 9).fill(16),
+    body: {
+      min: [-w / 2 * CELL_UNITS, 0, -d / 2 * CELL_UNITS],
+      max: [w / 2 * CELL_UNITS, height / GRIDFINITY_UNIT_MM, d / 2 * CELL_UNITS]
+    }
+  };
+}
+var cellCentres = (w, d) => Array.from({ length: w * d }, (_, n) => [n % w - (w - 1) / 2, Math.floor(n / w) - (d - 1) / 2]);
+function gridfinityBin(w, d, h) {
+  if (![w, d, h].every((n) => Number.isInteger(n) && n >= 1))
+    throw new Error("Bin size must be whole cells and height units, at least 1.");
+  const mesh = new Mesh();
+  const top = h * HEIGHT_UNIT_MM;
+  for (const [ux, uz] of cellCentres(w, d)) {
+    const [cx, cz] = [ux * GRID_MM, uz * GRID_MM];
+    const rings = BASE_PROFILE.map(
+      ([inset]) => profileRing(cx, cz, BASE_TOP_MM, BASE_TOP_RADIUS_MM, inset)
+    );
+    mesh.cap(rings[0], 0, false);
+    for (let k = 0; k + 1 < rings.length; k++)
+      mesh.wall(rings[k], BASE_PROFILE[k][1], rings[k + 1], BASE_PROFILE[k + 1][1], true);
+    const crown = BASE_PROFILE[BASE_PROFILE.length - 1][1];
+    const last = rings[rings.length - 1];
+    mesh.wall(last, crown, last, crown + FUSE_MM, true);
+    mesh.cap(last, crown + FUSE_MM, true);
+  }
+  const outerW = w * GRID_MM - 2 * GAP_MM;
+  const outerD = d * GRID_MM - 2 * GAP_MM;
+  const outer = rounded(0, 0, outerW, outerD, BASE_TOP_RADIUS_MM);
+  const inner = rounded(
+    0,
+    0,
+    outerW - 2 * WALL_MM,
+    outerD - 2 * WALL_MM,
+    BASE_TOP_RADIUS_MM - WALL_MM
+  );
+  const base = BASE_PROFILE[BASE_PROFILE.length - 1][1];
+  mesh.cap(outer, base, false);
+  mesh.wall(outer, base, outer, top, true);
+  mesh.annulus(outer, inner, top, true);
+  mesh.wall(inner, HEIGHT_UNIT_MM, inner, top, false);
+  mesh.cap(inner, HEIGHT_UNIT_MM, true);
+  const feet = cellCentres(w, d).map(
+    ([x, z5]) => ({
+      kind: "foot",
+      p: [x * CELL_UNITS, 0, z5 * CELL_UNITS],
+      a: [0, -1, 0]
+    })
+  );
+  return part(`bin-${w}x${d}x${h}`, `Gridfinity bin ${w} x ${d} x ${h}`, mesh, feet, top, w, d);
+}
+function gridfinityBaseplate(w, d) {
+  if (![w, d].every((n) => Number.isInteger(n) && n >= 1))
+    throw new Error("Baseplate size must be whole cells, at least 1.");
+  const mesh = new Mesh();
+  const height = BASE_PROFILE[BASE_PROFILE.length - 1][1];
+  for (const [ux, uz] of cellCentres(w, d)) {
+    const [cx, cz] = [ux * GRID_MM, uz * GRID_MM];
+    const pocket = BASE_PROFILE.map(
+      ([inset]) => profileRing(cx, cz, BASE_TOP_MM + 2 * GAP_MM, BASE_TOP_RADIUS_MM + GAP_MM, inset)
+    );
+    const square = squareFor(pocket[0], cx, cz, GRID_MM / 2);
+    const edge = (i) => {
+      const j = (i + 1) % square.length;
+      const mx = (square[i][0] + square[j][0]) / 2;
+      const mz = (square[i][1] + square[j][1]) / 2;
+      return Math.abs(Math.abs(mx) - w * GRID_MM / 2) < 1e-6 || Math.abs(Math.abs(mz) - d * GRID_MM / 2) < 1e-6;
+    };
+    mesh.wall(square, 0, square, height, true, edge);
+    mesh.annulus(square, pocket[pocket.length - 1], height, true);
+    mesh.annulus(square, pocket[0], 0, false);
+    for (let k = 0; k + 1 < pocket.length; k++)
+      mesh.wall(pocket[k], BASE_PROFILE[k][1], pocket[k + 1], BASE_PROFILE[k + 1][1], false);
+  }
+  const pockets = cellCentres(w, d).map(
+    ([x, z5]) => ({
+      kind: "pocket",
+      p: [x * CELL_UNITS, 0, z5 * CELL_UNITS],
+      a: [0, 1, 0]
+    })
+  );
+  return part(
+    `baseplate-${w}x${d}`,
+    `Gridfinity baseplate ${w} x ${d}`,
+    mesh,
+    pockets,
+    height,
+    w,
+    d
+  );
+}
+var IDENTITY = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+var add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+var sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+var scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+var length = (a) => Math.hypot(a[0], a[1], a[2]);
+function apply(m, v) {
+  return [
+    m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
+    m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
+    m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
+  ];
+}
+function mul(a, b) {
+  const r = new Array(9).fill(0);
+  for (let i = 0; i < 3; i++)
+    for (let j = 0; j < 3; j++)
+      for (let k = 0; k < 3; k++) r[i * 3 + j] += a[i * 3 + k] * b[k * 3 + j];
+  return r;
+}
+var transpose = (m) => [m[0], m[3], m[6], m[1], m[4], m[7], m[2], m[5], m[8]];
+var AXIS_ROTATIONS = (() => {
+  const axes = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 1, 0],
+    [0, -1, 0],
+    [0, 0, 1],
+    [0, 0, -1]
+  ];
+  const out = [];
+  for (const x of axes)
+    for (const y of axes) {
+      if (dot(x, y) !== 0) continue;
+      const z5 = cross(x, y);
+      out.push([x[0], y[0], z5[0], x[1], y[1], z5[1], x[2], y[2], z5[2]]);
+    }
+  return out;
+})();
+var CELL = 0.1;
+var index = (v, i, j, k) => i < 0 || j < 0 || k < 0 || i >= v.dims[0] || j >= v.dims[1] || k >= v.dims[2] ? -1 : (k * v.dims[1] + j) * v.dims[0] + i;
+function cellAt(v, p, field = "solid") {
+  const n = index(
+    v,
+    Math.floor((p[0] - v.origin[0]) / CELL),
+    Math.floor((p[1] - v.origin[1]) / CELL),
+    Math.floor((p[2] - v.origin[2]) / CELL)
+  );
+  return n >= 0 && v[field][n] === 1;
+}
+function voxelize(triangles, min, max) {
+  const origin = [min[0] - CELL, min[1] - CELL, min[2] - CELL];
+  const dims = [0, 1, 2].map(
+    (k) => Math.max(1, Math.ceil((max[k] - origin[k]) / CELL) + 1)
+  );
+  const total = dims[0] * dims[1] * dims[2];
+  const votes = new Uint8Array(total);
+  const v = { origin, dims, solid: new Uint8Array(total), interior: new Uint8Array(total) };
+  for (let axis = 0; axis < 3; axis++) {
+    const u = (axis + 1) % 3;
+    const w = (axis + 2) % 3;
+    const hits = /* @__PURE__ */ new Map();
+    for (let t = 0; t < triangles.length; t += 9) {
+      const a = [triangles[t], triangles[t + 1], triangles[t + 2]];
+      const b = [triangles[t + 3], triangles[t + 4], triangles[t + 5]];
+      const c = [triangles[t + 6], triangles[t + 7], triangles[t + 8]];
+      const area = (b[u] - a[u]) * (c[w] - a[w]) - (c[u] - a[u]) * (b[w] - a[w]);
+      if (Math.abs(area) < 1e-12) continue;
+      const lo = (k) => Math.min(a[k], b[k], c[k]);
+      const hi = (k) => Math.max(a[k], b[k], c[k]);
+      const iu0 = Math.max(0, Math.floor((lo(u) - origin[u]) / CELL - 0.5));
+      const iu1 = Math.min(dims[u] - 1, Math.ceil((hi(u) - origin[u]) / CELL - 0.5));
+      const iw0 = Math.max(0, Math.floor((lo(w) - origin[w]) / CELL - 0.5));
+      const iw1 = Math.min(dims[w] - 1, Math.ceil((hi(w) - origin[w]) / CELL - 0.5));
+      for (let iu = iu0; iu <= iu1; iu++)
+        for (let iw = iw0; iw <= iw1; iw++) {
+          const pu = origin[u] + (iu + 0.5) * CELL + 13e-6;
+          const pw = origin[w] + (iw + 0.5) * CELL + 29e-6;
+          const l0 = ((b[u] - pu) * (c[w] - pw) - (c[u] - pu) * (b[w] - pw)) / area;
+          const l1 = ((c[u] - pu) * (a[w] - pw) - (a[u] - pu) * (c[w] - pw)) / area;
+          const l2 = 1 - l0 - l1;
+          if (l0 < 0 || l1 < 0 || l2 < 0) continue;
+          const key2 = iu * dims[w] + iw;
+          const list = hits.get(key2) ?? [];
+          list.push(l0 * a[axis] + l1 * b[axis] + l2 * c[axis]);
+          hits.set(key2, list);
+        }
+    }
+    for (const [key2, list] of hits) {
+      list.sort((x, y) => x - y);
+      const iu = Math.floor(key2 / dims[w]);
+      const iw = key2 % dims[w];
+      const ijk = [0, 0, 0];
+      ijk[u] = iu;
+      ijk[w] = iw;
+      let before = 0;
+      for (let ia = 0; ia < dims[axis]; ia++) {
+        const c = origin[axis] + (ia + 0.5) * CELL;
+        while (before < list.length && list[before] < c) before++;
+        ijk[axis] = ia;
+        const n = index(v, ijk[0], ijk[1], ijk[2]);
+        votes[n] += before % 2 + (list.length - before) % 2;
+      }
+    }
+  }
+  for (let n = 0; n < total; n++) v.solid[n] = votes[n] >= 4 ? 1 : 0;
+  for (let k = 0; k < dims[2]; k++)
+    for (let j = 0; j < dims[1]; j++)
+      for (let i = 0; i < dims[0]; i++) {
+        const n = index(v, i, j, k);
+        if (!v.solid[n]) continue;
+        const around = [
+          [1, 0, 0],
+          [-1, 0, 0],
+          [0, 1, 0],
+          [0, -1, 0],
+          [0, 0, 1],
+          [0, 0, -1]
+        ].every(([di, dj, dk]) => v.solid[index(v, i + di, j + dj, k + dk)] === 1);
+        v.interior[n] = around ? 1 : 0;
+      }
+  return v;
+}
+function partOf(lib, item) {
+  const part2 = lib[item.part];
+  if (!part2) throw new Error(`Unknown part: ${item.part}`);
+  return part2;
+}
+function worldConnectors(lib, item) {
+  return partOf(lib, item).connectors.map((c) => ({
+    kind: c.kind,
+    p: add(apply(item.rotation, c.p), item.position),
+    a: apply(item.rotation, c.a),
+    len: c.len
+  }));
+}
+function worldBody(lib, item) {
+  const { min, max } = partOf(lib, item).body;
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (const x of [min[0], max[0]])
+    for (const y of [min[1], max[1]])
+      for (const z5 of [min[2], max[2]]) {
+        const p = add(apply(item.rotation, [x, y, z5]), item.position);
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], p[k]);
+          hi[k] = Math.max(hi[k], p[k]);
+        }
+      }
+  return { min: lo, max: hi };
+}
+function pointMates(x, y, adapter) {
+  if (length(sub(x.p, y.p)) > adapter.tolerance) return false;
+  return isSpherical(adapter, x.kind) || dot(x.a, y.a) <= -0.99;
+}
+var isSpherical = (adapter, kind) => adapter.spherical?.includes(kind) ?? false;
+function axialMates(x, y, adapter) {
+  if (length(cross(x.a, y.a)) > 0.01) return false;
+  const d = sub(y.p, x.p);
+  const along = dot(d, x.a);
+  if (length(sub(d, scale(x.a, along))) > adapter.tolerance) return false;
+  const hx = (x.len ?? 0) / 2;
+  const hy = (y.len ?? 0) / 2;
+  return Math.min(hx, along + hy) - Math.max(-hx, along - hy) >= adapter.minEngagement;
+}
+var GRID = 2;
+function nearPairs(boxes, margin) {
+  const cells = /* @__PURE__ */ new Map();
+  const span = (lo, hi) => [
+    Math.floor((lo - margin) / GRID),
+    Math.floor((hi + margin) / GRID)
+  ];
+  boxes.forEach((b, i) => {
+    const [x0, x1] = span(b.min[0], b.max[0]);
+    const [y0, y1] = span(b.min[1], b.max[1]);
+    const [z0, z1] = span(b.min[2], b.max[2]);
+    for (let x = x0; x <= x1; x++)
+      for (let y = y0; y <= y1; y++)
+        for (let z5 = z0; z5 <= z1; z5++) {
+          const key2 = `${x},${y},${z5}`;
+          const list = cells.get(key2);
+          if (list) list.push(i);
+          else cells.set(key2, [i]);
+        }
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const n = boxes.length;
+  for (const list of cells.values())
+    for (let p = 0; p < list.length; p++)
+      for (let q = p + 1; q < list.length; q++) {
+        const [a, b] = list[p] < list[q] ? [list[p], list[q]] : [list[q], list[p]];
+        if (seen.has(a * n + b)) continue;
+        seen.add(a * n + b);
+        if (touches(boxes[a], boxes[b], margin)) out.push([a, b]);
+      }
+  return out.sort((x, y) => x[0] - y[0] || x[1] - y[1]);
+}
+var touches = (x, y, margin) => [0, 1, 2].every((k) => x.min[k] - margin <= y.max[k] && y.min[k] - margin <= x.max[k]);
+function reachBox(lib, item, connectors) {
+  const { min, max } = worldBody(lib, item);
+  const lo = [...min];
+  const hi = [...max];
+  for (const c of connectors) {
+    const h = (c.len ?? 0) / 2;
+    for (const p of [add(c.p, scale(c.a, h)), add(c.p, scale(c.a, -h))])
+      for (let k = 0; k < 3; k++) {
+        lo[k] = Math.min(lo[k], p[k]);
+        hi[k] = Math.max(hi[k], p[k]);
+      }
+  }
+  return { min: lo, max: hi };
+}
+function contacts(model, lib, adapter) {
+  const world = model.items.map((it) => worldConnectors(lib, it));
+  const reach = model.items.map((it, i) => reachBox(lib, it, world[i]));
+  const out = [];
+  for (const [a, b] of nearPairs(reach, adapter.tolerance)) {
+    const kinds = /* @__PURE__ */ new Map();
+    for (const x of world[a])
+      for (const y of world[b]) {
+        if (!adapter.fits[x.kind]?.includes(y.kind)) continue;
+        const axial = x.len !== void 0 && y.len !== void 0;
+        if (axial ? !axialMates(x, y, adapter) : !pointMates(x, y, adapter)) continue;
+        const kind = [x.kind, y.kind].sort().join("-");
+        const seen = kinds.get(kind);
+        kinds.set(kind, {
+          count: (seen?.count ?? 0) + 1,
+          axis: axial ? x.a : void 0,
+          release: axial || isSpherical(adapter, x.kind) ? void 0 : x.a,
+          sum: add(seen?.sum ?? [0, 0, 0], x.p)
+        });
+      }
+    for (const [kind, { sum, ...v }] of kinds)
+      out.push({ a, b, kind, ...v, at: scale(sum, 1 / v.count) });
+  }
+  return out;
+}
+function overlapVolume(x, y, epsilon = 0.02) {
+  let v = 1;
+  for (let k = 0; k < 3; k++) {
+    const d = Math.min(x.max[k], y.max[k]) - Math.max(x.min[k], y.min[k]) - 2 * epsilon;
+    if (d <= 0) return 0;
+    v *= d;
+  }
+  return v;
+}
+function meshBounds(triangles) {
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < triangles.length; i++) {
+    min[i % 3] = Math.min(min[i % 3], triangles[i]);
+    max[i % 3] = Math.max(max[i % 3], triangles[i]);
+  }
+  return { min, max };
+}
+function partVoxels(part2) {
+  if (!part2.voxels) {
+    const { min, max } = meshBounds(part2.triangles);
+    part2.voxels = voxelize(part2.triangles, min, max);
+  }
+  return part2.voxels;
+}
+function collisionCells(lib, x, y, ignore) {
+  let hits = 0;
+  for (const [a, b] of [
+    [x, y],
+    [y, x]
+  ]) {
+    const va = partVoxels(partOf(lib, a));
+    const vb = partVoxels(partOf(lib, b));
+    for (let k = 0; k < va.dims[2]; k++)
+      for (let j = 0; j < va.dims[1]; j++)
+        for (let i = 0; i < va.dims[0]; i++) {
+          if (!va.interior[(k * va.dims[1] + j) * va.dims[0] + i]) continue;
+          const local = [
+            va.origin[0] + (i + 0.5) * CELL,
+            va.origin[1] + (j + 0.5) * CELL,
+            va.origin[2] + (k + 0.5) * CELL
+          ];
+          const world = add(apply(a.rotation, local), a.position);
+          if (ignore && length(sub(world, ignore.centre)) < ignore.radius) continue;
+          const r = b.rotation;
+          const d = sub(world, b.position);
+          const inB = [
+            r[0] * d[0] + r[3] * d[1] + r[6] * d[2],
+            r[1] * d[0] + r[4] * d[1] + r[7] * d[2],
+            r[2] * d[0] + r[5] * d[1] + r[8] * d[2]
+          ];
+          if (cellAt(vb, inB)) hits++;
+        }
+  }
+  return hits;
+}
+var LDU = 20;
+var FLIP = [1, 0, 0, 0, -1, 0, 0, 0, 1];
+var normalizeName = (name) => name.trim().replace(/\\/g, "/").toLowerCase();
+function toStuds(rotation, position) {
+  return {
+    rotation: mul(mul(FLIP, rotation), FLIP),
+    position: [position[0] / LDU, -position[1] / LDU, position[2] / LDU]
+  };
+}
+function readRef(f) {
+  const n = f.slice(2, 14).map(Number);
+  return {
+    color: Number(f[1]),
+    position: [n[0], n[1], n[2]],
+    rotation: [n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11]],
+    name: normalizeName(f.slice(14).join(" "))
+  };
+}
+function parsePart(name, resolve9, isJoint2) {
+  const triangles = [];
+  const colors = [];
+  const edges = [];
+  const joints = [];
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  const walk = (file, m, t, inJoint, depth, color) => {
+    const text = resolve9(file);
+    if (text === void 0) throw new Error(`LDraw file not found: ${file}`);
+    if (depth > 32) throw new Error(`LDraw nesting too deep at ${file}`);
+    for (const line of text.split(/\r?\n/)) {
+      const f = line.trim().split(/\s+/);
+      const type = f[0];
+      if (type === "1" && f.length >= 15) {
+        const ref = readRef(f);
+        const rotation = mul(m, ref.rotation);
+        const position = add(apply(m, ref.position), t);
+        const joint = !inJoint && isJoint2(ref.name);
+        if (joint) joints.push({ name: ref.name, ...toStuds(rotation, position) });
+        const inherited = ref.color === 16 ? color : ref.color;
+        walk(ref.name, rotation, position, inJoint || joint, depth + 1, inherited);
+      } else if (type === "2" && f.length >= 8) {
+        const n = f.slice(2, 8).map(Number);
+        for (const k of [0, 3]) {
+          const w = add(apply(m, [n[k], n[k + 1], n[k + 2]]), t);
+          edges.push(w[0] / LDU, -w[1] / LDU, w[2] / LDU);
+        }
+      } else if (type === "3" || type === "4") {
+        const n = f.slice(2).map(Number);
+        const pts = [];
+        for (let i = 0; i < (type === "3" ? 3 : 4); i++) {
+          const w = add(apply(m, [n[i * 3], n[i * 3 + 1], n[i * 3 + 2]]), t);
+          pts.push([w[0] / LDU, -w[1] / LDU, w[2] / LDU]);
+        }
+        const tris = type === "3" ? [pts] : [
+          [pts[0], pts[1], pts[2]],
+          [pts[0], pts[2], pts[3]]
+        ];
+        const c = Number(f[1]);
+        for (const tri of tris) {
+          for (const p of tri) triangles.push(p[0], p[1], p[2]);
+          colors.push(c === 16 ? color : c);
+        }
+        if (!inJoint)
+          for (const p of pts)
+            for (let k = 0; k < 3; k++) {
+              min[k] = Math.min(min[k], p[k]);
+              max[k] = Math.max(max[k], p[k]);
+            }
+      }
+    }
+  };
+  walk(normalizeName(name), IDENTITY, [0, 0, 0], false, 0, 16);
+  return { triangles, colors, edges, body: { min, max }, joints };
+}
+function parseModel(text) {
+  const items = [];
+  let step = 1;
+  for (const line of text.split(/\r?\n/)) {
+    const f = line.trim().split(/\s+/);
+    if (f[0] === "0" && f[1]?.toUpperCase() === "STEP") step++;
+    else if (f[0] === "1" && f.length >= 15) {
+      const ref = readRef(f);
+      items.push({
+        part: ref.name.replace(/\.dat$/, ""),
+        color: ref.color,
+        step,
+        ...toStuds(ref.rotation, ref.position)
+      });
+    }
+  }
+  return { items };
+}
+function writeModel(model, title) {
+  const fmt = (n) => String(Math.round(n * 1e4) / 1e4 || 0);
+  const lines = [
+    `0 ${title}`,
+    `0 Name: ${title.toLowerCase().replace(/\W+/g, "-")}.ldr`,
+    "0 Author: Makeables"
+  ];
+  let step;
+  for (const it of model.items) {
+    if (step !== void 0 && it.step !== step) lines.push("0 STEP");
+    step = it.step;
+    const r = mul(mul(FLIP, it.rotation), FLIP);
+    const p = [it.position[0] * LDU, -it.position[1] * LDU, it.position[2] * LDU];
+    lines.push(`1 ${it.color} ${[...p, ...r].map(fmt).join(" ")} ${it.part}.dat`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+var REACH = 0.45;
+var DIAGONAL = 0.2;
+var MIN_RUN = 0.4;
+var SAMPLE = 0.05;
+var ring8 = [0, 1, 2, 3, 4, 5, 6, 7].map((k) => [
+  Math.cos(k * Math.PI / 4),
+  Math.sin(k * Math.PI / 4)
+]);
+function technicHoles(voxels, body) {
+  const found = [];
+  for (let axis = 0; axis < 3; axis++) {
+    const u = (axis + 1) % 3;
+    const w = (axis + 2) % 3;
+    const at = (cu, cw, t, du = 0, dw = 0) => {
+      const p = [0, 0, 0];
+      p[axis] = t;
+      p[u] = cu + du;
+      p[w] = cw + dw;
+      return cellAt(voxels, p);
+    };
+    const from = (k) => Math.ceil((body.min[k] + 0.3) / SAMPLE - 1e-9) * SAMPLE;
+    for (let cu = from(u); cu <= body.max[u] - 0.3 + 1e-9; cu += SAMPLE)
+      for (let cw = from(w); cw <= body.max[w] - 0.3 + 1e-9; cw += SAMPLE) {
+        let run2 = 0;
+        let best = { start: 0, length: 0, cross: 0, open: false };
+        let start = 0;
+        let cross2 = 0;
+        for (let t = body.min[axis] + SAMPLE; t < body.max[axis]; t += 0.1) {
+          const hollow = [0, 0.12].every(
+            (r) => [
+              [1, 0],
+              [-1, 0],
+              [0, 1],
+              [0, -1]
+            ].every(([a2, b]) => !at(cu, cw, t, a2 * r, b * r))
+          );
+          const walled = ring8.filter(([a2, b]) => {
+            for (let r = 0.15; r <= REACH + 1e-9; r += 0.05)
+              if (at(cu, cw, t, a2 * r, b * r)) return true;
+            return false;
+          }).length;
+          if (hollow && walled === 8) {
+            if (!run2) {
+              start = t;
+              cross2 = 0;
+            }
+            run2 += 0.1;
+            cross2 += ring8.filter((_, k) => k % 2).filter(([a2, b]) => at(cu, cw, t, a2 * DIAGONAL, b * DIAGONAL)).length;
+            if (run2 > best.length) best = { start, length: run2, cross: cross2, open: false };
+          } else run2 = 0;
+        }
+        if (best.length + 1e-9 < MIN_RUN) continue;
+        const clear = (t0, dt) => {
+          for (let t = t0; t > body.min[axis] - 0.1 && t < body.max[axis] + 0.1; t += dt)
+            if (at(cu, cw, t)) return false;
+          return true;
+        };
+        if (!clear(best.start - 0.1, -0.1) || !clear(best.start + best.length, 0.1)) continue;
+        const p = [0, 0, 0];
+        p[axis] = best.start - 0.05 + best.length / 2;
+        p[u] = cu;
+        p[w] = cw;
+        const a = [0, 0, 0];
+        a[axis] = 1;
+        const steps = best.length / 0.1;
+        found.push({
+          kind: best.cross / steps >= 3 ? "axlehole" : "pinhole",
+          p,
+          a,
+          len: best.length,
+          score: best.length
+        });
+      }
+  }
+  const holes = [];
+  const left = new Set(found);
+  const near = (x, y) => x.a.join() === y.a.join() && x.p.every((v, k) => x.a[k] === 1 || Math.abs(v - y.p[k]) <= SAMPLE + 1e-6);
+  for (const seed of found) {
+    if (!left.has(seed)) continue;
+    const group = [seed];
+    left.delete(seed);
+    for (let i = 0; i < group.length; i++)
+      for (const h of left)
+        if (near(group[i], h)) {
+          group.push(h);
+          left.delete(h);
+        }
+    const mean = [0, 1, 2].map((k) => group.reduce((s, h) => s + h.p[k], 0) / group.length);
+    const longest = group.reduce((x, y) => y.score > x.score ? y : x);
+    const crosses = group.filter((h) => h.kind === "axlehole").length;
+    holes.push({
+      kind: crosses * 2 > group.length ? "axlehole" : "pinhole",
+      p: mean.map((v) => Math.round(v / SAMPLE) * SAMPLE || 0),
+      a: seed.a,
+      len: longest.len
+    });
+  }
+  return holes;
+}
+var SHAFT = /^Technic (Axle\s+\d+(\.\d+)?$|Axle\s+\d+ with Stop|Pin\b|Friction Pin|Axle Pin)/i;
+function technicShafts(name, triangles) {
+  if (!SHAFT.test(name) || /connector|joiner|hole|beam/i.test(name)) return [];
+  const { min, max } = meshBounds(triangles);
+  const size = [0, 1, 2].map((k) => max[k] - min[k]);
+  const axis = size.indexOf(Math.max(...size));
+  const a = [0, 0, 0];
+  a[axis] = 1;
+  const p = [0, 1, 2].map((k) => (min[k] + max[k]) / 2);
+  return [
+    { kind: /pin/i.test(name) && !/axle pin/i.test(name) ? "pin" : "axle", p, a, len: size[axis] }
+  ];
+}
+var STUD = /^(stud|stud2|stud2a|studa|stud26|stud6a?|stud9|stud10|stud13|stud15|stud17a?|studel|studh[lr]?|studp01|studxa?|stud2?-logo\d?)\.dat$/;
+var BALL = /^joint8ball\.dat$/;
+var BALL_SOCKET = /^joint8socket\d\.dat$/;
+var isJoint = (p) => STUD.test(p) || BALL.test(p) || BALL_SOCKET.test(p);
+var FAMILY = {
+  "3001": "brick",
+  "3003": "brick",
+  "3004": "brick",
+  "3005": "brick",
+  "3010": "brick",
+  "3020": "plate",
+  "3021": "plate",
+  "3022": "plate",
+  "3023": "plate",
+  "3024": "plate",
+  "3710": "plate",
+  "3666": "plate",
+  "3460": "plate",
+  "3068b": "tile",
+  "3069b": "tile",
+  "3070b": "tile"
+};
+var lego = {
+  name: "lego",
+  fits: {
+    stud: ["socket"],
+    socket: ["stud"],
+    axle: ["axlehole", "pinhole"],
+    axlehole: ["axle"],
+    pin: ["pinhole"],
+    pinhole: ["pin", "axle"],
+    wheelpin: ["wheelhole"],
+    wheelhole: ["wheelpin"],
+    rim: ["tyre"],
+    tyre: ["rim"],
+    hinge: ["hinge"],
+    bar: ["clip", "barhole"],
+    clip: ["bar"],
+    barhole: ["bar"],
+    neck: ["neckhole"],
+    neckhole: ["neck"],
+    hatstud: ["hat"],
+    hat: ["hatstud"],
+    waist: ["waisthole"],
+    waisthole: ["waist"],
+    hip: ["leg"],
+    leg: ["hip"],
+    shoulder: ["shoulderhole"],
+    shoulderhole: ["shoulder"],
+    wrist: ["hand"],
+    hand: ["wrist"],
+    ball: ["ballsocket"],
+    ballsocket: ["ball"]
+  },
+  spherical: ["ball", "ballsocket"],
+  tolerance: 0.06,
+  minEngagement: 0.24,
+  family: (part2) => FAMILY[part2] ?? part2
+};
+var WRIST_RIGHT = [-0.25, -0.875, -0.5];
+var WRIST_LEFT = [0.25, -0.875, -0.5];
+var LEGO_CONNECTORS = {
+  // Plate 2 x 2 with 2 Wheel Pins; the pins hang below the plate, so its sockets are listed too.
+  "4600": [
+    ...[-0.5, 0.5].flatMap(
+      (x) => [-0.5, 0.5].map((z5) => ({ kind: "socket", p: [x, -0.4, z5], a: [0, -1, 0] }))
+    ),
+    { kind: "wheelpin", p: [1.4, -0.25, 0], a: [1, 0, 0], len: 0.6 },
+    { kind: "wheelpin", p: [-1.4, -0.25, 0], a: [1, 0, 0], len: 0.6 }
+  ],
+  // Wheel Rim 6.4 x 8
+  "4624": [
+    { kind: "wheelhole", p: [0, 0, 0], a: [0, 0, 1], len: 0.8 },
+    { kind: "rim", p: [0, 0, 0], a: [0, 0, 1], len: 0.8 }
+  ],
+  // Tyre 6/ 50 x 8 Offset Tread
+  "3641": [{ kind: "tyre", p: [0, 0, 0], a: [0, 0, 1], len: 0.8 }],
+  // Plate 1 x 2 with Socket Joint-8 and Ball Joint-8: its ball is drawn as a plain sphere,
+  // which also hangs below the plate and pulls the inferred sockets down with it.
+  "14419": [
+    { kind: "ball", p: [-1.5, -0.2, 0], a: [-1, 0, 0] },
+    ...[-0.5, 0.5].map((x) => ({ kind: "socket", p: [x, -0.4, 0], a: [0, -1, 0] }))
+  ],
+  // Hinge 1 x 2 Base and Top: both pivot on the cylinder along x at 10 LDU below the origin.
+  "3937": [{ kind: "hinge", p: [0, -0.5, 0], a: [1, 0, 0], len: 2 }],
+  "3938": [{ kind: "hinge", p: [0, -0.5, 0], a: [1, 0, 0], len: 2 }],
+  // Plate 1 x 3 with 2 Studs Offset: the teeth underneath hold a stud at every half step,
+  // so a jumper also sits straight on another jumper's offset studs.
+  "34103": [-1, -0.5, 0, 0.5, 1].map(
+    (x) => ({ kind: "socket", p: [x, -0.4, 0], a: [0, -1, 0] })
+  ),
+  // Bar 6L with Thick Stop: the bar runs the full height of the part.
+  "63965a": [{ kind: "bar", p: [0, 2.2, 0], a: [0, 1, 0], len: 6 }],
+  // Cone 1 x 1: hollow along its axis, so a bar goes in from the top.
+  "4589": [
+    { kind: "barhole", p: [0, -0.5, 0], a: [0, 1, 0], len: 1.4 },
+    { kind: "socket", p: [0, -1.2, 0], a: [0, -1, 0] }
+  ],
+  // Tile 2 x 3 with Clips Horizontal: both C-clips share an axis along x.
+  "30350b": [{ kind: "clip", p: [0, -0.05, 2], a: [1, 0, 0], len: 2 }],
+  // Minifig, in the frame of each part as LDraw places a standard figure.
+  "973": [
+    { kind: "neck", p: [0, 0, 0], a: [0, 1, 0] },
+    { kind: "waist", p: [0, -1.6, 0], a: [0, -1, 0] },
+    { kind: "shoulder", p: [-0.7776, -0.45, 0], a: [-1, 0, 0] },
+    { kind: "shoulder", p: [0.7776, -0.45, 0], a: [1, 0, 0] }
+  ],
+  "3626c": [
+    { kind: "neckhole", p: [0, -1.2, 0], a: [0, -1, 0] },
+    { kind: "hatstud", p: [0, 0, 0], a: [0, 1, 0] }
+  ],
+  "3626cp7g": [
+    { kind: "neckhole", p: [0, -1.2, 0], a: [0, -1, 0] },
+    { kind: "hatstud", p: [0, 0, 0], a: [0, 1, 0] }
+  ],
+  "86035": [{ kind: "hat", p: [0, 0, 0], a: [0, -1, 0] }],
+  "3815": [
+    { kind: "waisthole", p: [0, 0, 0], a: [0, 1, 0] },
+    { kind: "hip", p: [0, -0.6, 0], a: [0, -1, 0] },
+    { kind: "hip", p: [0, -0.6, 0], a: [0, -1, 0] }
+  ],
+  "3816": [
+    { kind: "leg", p: [0, 0, 0], a: [0, 1, 0] },
+    { kind: "socket", p: [-0.5, -1.4, 0], a: [0, -1, 0] }
+  ],
+  "3817": [
+    { kind: "leg", p: [0, 0, 0], a: [0, 1, 0] },
+    { kind: "socket", p: [0.5, -1.4, 0], a: [0, -1, 0] }
+  ],
+  "3818": [
+    { kind: "shoulderhole", p: [0, 0, 0], a: [1, 0, 0] },
+    { kind: "wrist", p: WRIST_RIGHT, a: [0, 0, -1] }
+  ],
+  "3819": [
+    { kind: "shoulderhole", p: [0, 0, 0], a: [-1, 0, 0] },
+    { kind: "wrist", p: WRIST_LEFT, a: [0, 0, -1] }
+  ],
+  // The hand's peg goes into the sleeve from the front.
+  "3820": [{ kind: "hand", p: [0, 0, 0], a: [0, 0, 1] }]
+};
+function technicConnectors(name, parsed, voxels) {
+  const shafts = technicShafts(name, parsed.triangles);
+  return shafts.length ? shafts : technicHoles(voxels, parsed.body);
+}
+var FLAT_TOP = 0.5;
+function flatTop({ triangles, body }) {
+  let area = 0;
+  for (let t = 0; t < triangles.length; t += 9) {
+    const ys = [triangles[t + 1], triangles[t + 4], triangles[t + 7]];
+    if (ys.some((y) => Math.abs(y - body.max[1]) > 1e-3)) continue;
+    const ux = triangles[t + 3] - triangles[t];
+    const uz = triangles[t + 5] - triangles[t + 2];
+    const vx = triangles[t + 6] - triangles[t];
+    const vz = triangles[t + 8] - triangles[t + 2];
+    area += Math.abs(ux * vz - uz * vx) / 2;
+  }
+  const footprint = (body.max[0] - body.min[0]) * (body.max[2] - body.min[2]);
+  return footprint > 0 ? area / footprint : 0;
+}
+var WALLED_BOTTOM = 0.35;
+var STUD_DEPTH = 0.3;
+var lattice = (lo, hi, phase) => {
+  const out = [];
+  for (let x = Math.ceil(lo - phase) + phase; x < hi; x++)
+    if (x - lo > 0.25 && hi - x > 0.25) out.push(x);
+  return out;
+};
+var BORE = 0.25;
+function takesStud(voxels, x, y, z5, top) {
+  let hollow;
+  for (let h = y + CELL / 2; h < y + STUD_DEPTH && hollow === void 0; h += CELL)
+    if (!cellAt(voxels, [x, h, z5])) hollow = h;
+  if (hollow === void 0) return false;
+  const capped = (dx, dz) => {
+    for (let h = hollow + CELL; h < top; h += CELL)
+      if (cellAt(voxels, [x + dx, h, z5 + dz])) return true;
+    return false;
+  };
+  return capped(0, 0) || [
+    [BORE, 0],
+    [-BORE, 0],
+    [0, BORE],
+    [0, -BORE]
+  ].every(([dx, dz]) => capped(dx, dz));
+}
+function legoConnectors(parsed, voxels) {
+  const out = [];
+  for (const j of parsed.joints) {
+    const a = apply(j.rotation, [0, 1, 0]);
+    if (STUD.test(j.name)) out.push({ kind: "stud", p: j.position, a });
+    else if (BALL.test(j.name)) out.push({ kind: "ball", p: j.position, a });
+    else if (BALL_SOCKET.test(j.name)) out.push({ kind: "ballsocket", p: j.position, a });
+  }
+  const { min, max } = parsed.body;
+  const up = out.find((c) => c.kind === "stud" && dot(c.a, [0, 1, 0]) > 0.99);
+  const wrap = (v) => (v % 1 + 1) % 1;
+  const edgePhase = (k) => wrap(min[k] + 0.5);
+  const studPhase = (k) => up ? wrap(up.p[k]) : edgePhase(k);
+  const y = min[1];
+  const rim = [];
+  for (let x = min[0] + CELL / 2; x < max[0]; x += CELL)
+    rim.push([x, y + CELL / 2, min[2] + CELL / 2], [x, y + CELL / 2, max[2] - CELL / 2]);
+  for (let z5 = min[2] + CELL / 2; z5 < max[2]; z5 += CELL)
+    rim.push([min[0] + CELL / 2, y + CELL / 2, z5], [max[0] - CELL / 2, y + CELL / 2, z5]);
+  const walled = rim.filter((p) => cellAt(voxels, p)).length >= WALLED_BOTTOM * rim.length;
+  if (!up && !walled && flatTop(parsed) < FLAT_TOP) return out;
+  const sockets = (px, pz) => {
+    const found = [];
+    for (const x of lattice(min[0], max[0], px))
+      for (const z5 of lattice(min[2], max[2], pz))
+        if (takesStud(voxels, x, y, z5, max[1]))
+          found.push({ kind: "socket", p: [x, y, z5], a: [0, -1, 0] });
+    return found;
+  };
+  const byStuds = sockets(studPhase(0), studPhase(2));
+  const byEdges = sockets(edgePhase(0), edgePhase(2));
+  out.push(...byEdges.length > byStuds.length ? byEdges : byStuds);
+  return out;
+}
+function loadLegoPart(id, resolve9, opts = {}) {
+  const parsed = parsePart(`${id}.dat`, resolve9, isJoint);
+  const bounds = meshBounds(parsed.triangles);
+  const voxels = voxelize(parsed.triangles, bounds.min, bounds.max);
+  return {
+    id,
+    name: opts.name ?? id,
+    voxels,
+    connectors: [
+      // Listed sockets replace inferred ones, for parts whose underside the solid misreads.
+      ...legoConnectors(parsed, voxels).filter(
+        (c) => c.kind !== "socket" || !LEGO_CONNECTORS[id]?.some((l) => l.kind === "socket")
+      ),
+      ...opts.connectors ?? LEGO_CONNECTORS[id] ?? technicConnectors(opts.name ?? "", parsed, voxels)
+    ],
+    body: parsed.body,
+    triangles: parsed.triangles,
+    colors: parsed.colors,
+    edges: parsed.edges
+  };
+}
+function libraryResolver(read, root) {
+  return (name) => {
+    for (const dir of ["parts", "p", "parts/s"]) {
+      const text = read(`${root}/${dir}/${name}`);
+      if (text !== void 0) return text;
+    }
+    return void 0;
+  };
+}
+function turn(x, y) {
+  const r = AXIS_ROTATIONS.find(
+    (m) => [0, 1, 2].every((k) => m[k * 3] === x[k] && m[k * 3 + 1] === y[k])
+  );
+  if (!r) throw new Error(`No axis rotation sends x to ${x} and y to ${y}.`);
+  return r;
+}
+var round = (v) => v.map((x) => Math.round(x * 1e3) / 1e3 + 0);
+function describePart(part2) {
+  const { min, max } = part2.body;
+  const near = (a, b) => Math.abs(a - b) < 0.05;
+  const connectors = {};
+  for (const c of part2.connectors) {
+    connectors[c.kind] ??= [];
+    const list = connectors[c.kind];
+    list.push({
+      index: list.length,
+      p: round(c.p),
+      a: round(c.a),
+      ...c.len === void 0 ? {} : { len: c.len }
+    });
+  }
+  return {
+    id: part2.id,
+    name: part2.name,
+    size: round([max[0] - min[0], max[1] - min[1], max[2] - min[2]]),
+    body: { min: round(min), max: round(max) },
+    origin: near(max[1], 0) ? "top" : near(min[1], 0) ? "bottom" : "inside",
+    connectors
+  };
+}
+var DEFAULT_PALETTE = {
+  0: "#1B2A34",
+  1: "#1E5AA8",
+  4: "#B40000",
+  14: "#FAC80A",
+  15: "#F4F4F4",
+  71: "#969696",
+  72: "#646464"
+};
+function parsePalette(ldconfig) {
+  const out = {};
+  for (const m of ldconfig.matchAll(/^0 !COLOUR \S+\s+CODE\s+(\d+)\s+VALUE\s+(#[0-9A-Fa-f]{6})/gm))
+    out[Number(m[1])] = m[2];
+  return out;
+}
+var LIGHT = (() => {
+  const v = [0.4, 0.85, 0.35];
+  return scale(v, 1 / length(v));
+})();
+var rgb = (hex) => {
+  const n = Number.parseInt(hex.slice(1), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+};
+function rasterize(model, lib, opts = {}) {
+  const ss = opts.supersample ?? 2;
+  const W2 = (opts.width ?? 800) * ss;
+  const H2 = (opts.height ?? 600) * ss;
+  const yaw = opts.yaw ?? Math.PI / 4;
+  const pitch = opts.pitch ?? Math.PI / 6;
+  const palette = { ...DEFAULT_PALETTE, ...opts.palette };
+  const highlight = new Set(opts.highlight ?? []);
+  const background = rgb(opts.background ?? "#ffffff");
+  const view = [
+    Math.sin(yaw) * Math.cos(pitch),
+    Math.sin(pitch),
+    Math.cos(yaw) * Math.cos(pitch)
+  ];
+  const right = [Math.cos(yaw), 0, -Math.sin(yaw)];
+  const up = cross(view, right);
+  const shown = model.items.map((item, i) => ({ item, i })).filter(({ item }) => opts.maxStep === void 0 || (item.step ?? 0) <= opts.maxStep);
+  const bodies = shown.map(({ item }) => worldBody(lib, item));
+  const center = [0, 0, 0];
+  for (const b of bodies) for (let k = 0; k < 3; k++) center[k] += (b.min[k] + b.max[k]) / 2;
+  if (bodies.length) for (let k = 0; k < 3; k++) center[k] /= bodies.length;
+  let tri = new Float64Array(9 * 4096);
+  let triColor = new Float64Array(3 * 4096);
+  let tris = 0;
+  let seg = new Float64Array(6 * 4096);
+  let segColor = new Float64Array(3 * 4096);
+  let segs = 0;
+  const grow = (buf, need) => {
+    if (need <= buf.length) return buf;
+    const next = new Float64Array(Math.max(need, buf.length * 2));
+    next.set(buf);
+    return next;
+  };
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const [r0, r1, r2] = right;
+  const [u0, u1, u2] = up;
+  const [v0, v1, v2] = view;
+  const project = (out, o, x, y, z5) => {
+    const vx = x * r0 + y * r1 + z5 * r2;
+    const vy = -(x * u0 + y * u1 + z5 * u2);
+    out[o] = vx;
+    out[o + 1] = vy;
+    out[o + 2] = x * v0 + y * v1 + z5 * v2;
+    if (vx < minX) minX = vx;
+    if (vx > maxX) maxX = vx;
+    if (vy < minY) minY = vy;
+    if (vy > maxY) maxY = vy;
+  };
+  const w = new Float64Array(9);
+  shown.forEach(({ item, i }, n) => {
+    const part2 = lib[item.part];
+    if (!part2) throw new Error(`Unknown part: ${item.part}`);
+    const b = bodies[n];
+    const mid = [
+      (b.min[0] + b.max[0]) / 2,
+      (b.min[1] + b.max[1]) / 2,
+      (b.min[2] + b.max[2]) / 2
+    ];
+    const offset = opts.explode ? scale(sub(mid, center), opts.explode) : [0, 0, 0];
+    const fade = highlight.size && !highlight.has(i) ? 0.72 : 0;
+    const m = item.rotation;
+    const [p0, p1, p2] = item.position;
+    const [o0, o1, o2] = offset;
+    const world = (k, x, y, z5) => {
+      w[k] = m[0] * x + m[1] * y + m[2] * z5 + p0 + o0;
+      w[k + 1] = m[3] * x + m[4] * y + m[5] * z5 + p1 + o1;
+      w[k + 2] = m[6] * x + m[7] * y + m[8] * z5 + p2 + o2;
+    };
+    const shade = /* @__PURE__ */ new Map();
+    const t = part2.triangles;
+    const faces = t.length / 9;
+    tri = grow(tri, (tris + faces) * 9);
+    triColor = grow(triColor, (tris + faces) * 3);
+    for (let f = 0; f < faces; f++) {
+      for (let v = 0; v < 3; v++)
+        world(v * 3, t[f * 9 + v * 3], t[f * 9 + v * 3 + 1], t[f * 9 + v * 3 + 2]);
+      const e1 = [w[3] - w[0], w[4] - w[1], w[5] - w[2]];
+      const e2 = [w[6] - w[0], w[7] - w[1], w[8] - w[2]];
+      const normal = cross(e1, e2);
+      const len = length(normal);
+      if (len < 1e-9) continue;
+      const nn = scale(normal, 1 / len);
+      const facing = dot(nn, view) < 0 ? scale(nn, -1) : nn;
+      const code = part2.colors[f] === 16 ? item.color : part2.colors[f];
+      const k = 0.55 + 0.45 * Math.max(0, dot(facing, LIGHT));
+      let base2 = shade.get(code);
+      if (!base2) {
+        base2 = rgb(palette[code] ?? "#888888");
+        shade.set(code, base2);
+      }
+      for (let v = 0; v < 3; v++)
+        project(tri, tris * 9 + v * 3, w[v * 3], w[v * 3 + 1], w[v * 3 + 2]);
+      for (let c = 0; c < 3; c++) {
+        const value = Math.min(255, base2[c] * k);
+        triColor[tris * 3 + c] = value + (255 - value) * fade;
+      }
+      tris++;
+    }
+    const e = part2.edges ?? [];
+    const base = rgb(palette[item.color] ?? "#888888");
+    const dark = base[0] + base[1] + base[2] < 115;
+    const edge = (dark ? [110, 110, 110] : base.map((c) => c * 0.45)).map(
+      (c) => c + (255 - c) * fade
+    );
+    seg = grow(seg, (segs + e.length / 6) * 6);
+    segColor = grow(segColor, (segs + e.length / 6) * 3);
+    for (let q = 0; q < e.length; q += 6) {
+      world(0, e[q], e[q + 1], e[q + 2]);
+      world(3, e[q + 3], e[q + 4], e[q + 5]);
+      project(seg, segs * 6, w[0], w[1], w[2]);
+      project(seg, segs * 6 + 3, w[3], w[4], w[5]);
+      segColor.set(edge, segs * 3);
+      segs++;
+    }
+  });
+  const s = tris ? 0.9 * Math.min(W2 / (maxX - minX || 1), H2 / (maxY - minY || 1)) : 1;
+  const ox = W2 / 2 - s * (minX + maxX) / 2;
+  const oy = H2 / 2 - s * (minY + maxY) / 2;
+  const data = new Uint8ClampedArray(W2 * H2 * 4);
+  const depth = new Float32Array(W2 * H2).fill(-Infinity);
+  const pixels = new Uint32Array(data.buffer);
+  pixels.fill(255 << 24 | background[2] << 16 | background[1] << 8 | background[0]);
+  for (let f = 0; f < tris; f++) {
+    const q = f * 9;
+    const ax = ox + s * tri[q];
+    const ay = oy + s * tri[q + 1];
+    const az = tri[q + 2];
+    const bx = ox + s * tri[q + 3];
+    const by = oy + s * tri[q + 4];
+    const bz = tri[q + 5];
+    const cx = ox + s * tri[q + 6];
+    const cy = oy + s * tri[q + 7];
+    const cz = tri[q + 8];
+    const area = (bx - ax) * (cy - ay) - (cx - ax) * (by - ay);
+    if (Math.abs(area) < 1e-9) continue;
+    const red = triColor[f * 3];
+    const green = triColor[f * 3 + 1];
+    const blue = triColor[f * 3 + 2];
+    const x0 = Math.max(0, Math.floor(Math.min(ax, bx, cx)));
+    const x1 = Math.min(W2 - 1, Math.ceil(Math.max(ax, bx, cx)));
+    const y0 = Math.max(0, Math.floor(Math.min(ay, by, cy)));
+    const y1 = Math.min(H2 - 1, Math.ceil(Math.max(ay, by, cy)));
+    for (let y = y0; y <= y1; y++) {
+      const py = y + 0.5;
+      let lo = Infinity;
+      let hi = -Infinity;
+      for (const [sx, sy, ex, ey] of [
+        [ax, ay, bx, by],
+        [bx, by, cx, cy],
+        [cx, cy, ax, ay]
+      ]) {
+        if ((sy - py) * (ey - py) > 0 || sy === ey) continue;
+        const cross2 = sx + (py - sy) * (ex - sx) / (ey - sy);
+        if (cross2 < lo) lo = cross2;
+        if (cross2 > hi) hi = cross2;
+      }
+      if (lo > hi) continue;
+      const from = Math.max(x0, Math.floor(lo) - 1);
+      const to = Math.min(x1, Math.ceil(hi) + 1);
+      for (let x = from; x <= to; x++) {
+        const px = x + 0.5;
+        const l0 = ((bx - px) * (cy - py) - (cx - px) * (by - py)) / area;
+        if (l0 < 0) continue;
+        const l1 = ((cx - px) * (ay - py) - (ax - px) * (cy - py)) / area;
+        const l2 = 1 - l0 - l1;
+        if (l1 < 0 || l2 < 0) continue;
+        const z5 = l0 * az + l1 * bz + l2 * cz;
+        const p = y * W2 + x;
+        if (z5 <= depth[p]) continue;
+        depth[p] = z5;
+        data[p * 4] = red;
+        data[p * 4 + 1] = green;
+        data[p * 4 + 2] = blue;
+      }
+    }
+  }
+  const bias = 0.02;
+  const thick = ss > 1 ? 2 : 1;
+  for (let l = 0; l < segs; l++) {
+    const q = l * 6;
+    const ax = ox + s * seg[q];
+    const ay = oy + s * seg[q + 1];
+    const az = seg[q + 2];
+    const bx = ox + s * seg[q + 3];
+    const by = oy + s * seg[q + 4];
+    const bz = seg[q + 5];
+    const steps = Math.max(1, Math.ceil(Math.max(Math.abs(bx - ax), Math.abs(by - ay))));
+    for (let k = 0; k <= steps; k++) {
+      const t = k / steps;
+      const x = Math.round(ax + (bx - ax) * t);
+      const y = Math.round(ay + (by - ay) * t);
+      if (x < 0 || y < 0 || x >= W2 || y >= H2) continue;
+      const z5 = az + (bz - az) * t;
+      for (let dy = 0; dy < thick; dy++)
+        for (let dx = 0; dx < thick; dx++) {
+          const p = Math.min(H2 - 1, y + dy) * W2 + Math.min(W2 - 1, x + dx);
+          if (z5 + bias < depth[p]) continue;
+          data[p * 4] = segColor[l * 3];
+          data[p * 4 + 1] = segColor[l * 3 + 1];
+          data[p * 4 + 2] = segColor[l * 3 + 2];
+        }
+    }
+  }
+  return { width: W2, height: H2, data };
+}
+var key = (a, b, kind) => `${a < b ? `${a}~${b}` : `${b}~${a}`}:${kind}`;
+function learnGrammar(model, joints, adapter) {
+  const exact = /* @__PURE__ */ new Set();
+  const family = /* @__PURE__ */ new Set();
+  for (const c of joints) {
+    const a = model.items[c.a].part;
+    const b = model.items[c.b].part;
+    exact.add(key(a, b, c.kind));
+    family.add(key(adapter.family(a), adapter.family(b), c.kind));
+  }
+  return { exact, family };
+}
+function jointAllowed(grammar, adapter, a, b, kind, mode) {
+  if (mode === "free" || grammar.exact.has(key(a, b, kind))) return true;
+  return mode === "family" && grammar.family.has(key(adapter.family(a), adapter.family(b), kind));
+}
+var DIRECTIONS = [
+  [0, 1, 0],
+  [1, 0, 0],
+  [-1, 0, 0],
+  [0, 0, 1],
+  [0, 0, -1],
+  [0, -1, 0]
+];
+var STEP = 0.15;
+var BLOCKING_CELLS = 4;
+var SWEEP = 4;
+var union = (x, y) => ({
+  min: [0, 1, 2].map((k) => Math.min(x.min[k], y.min[k])),
+  max: [0, 1, 2].map((k) => Math.max(x.max[k], y.max[k]))
+});
+var moved = (it, d, s) => ({
+  ...it,
+  position: add(it.position, scale(d, s))
+});
+var shifted = (b, d, s) => ({
+  min: add(b.min, scale(d, s)),
+  max: add(b.max, scale(d, s))
+});
+function planAssembly(model, lib, adapter) {
+  const items = model.items;
+  const bodies = items.map((it) => worldBody(lib, it));
+  const axes = /* @__PURE__ */ new Map();
+  const releases = /* @__PURE__ */ new Map();
+  const snaps = /* @__PURE__ */ new Set();
+  const ways = items.map(() => [...DIRECTIONS]);
+  const tryWay = (i, d) => {
+    if (!ways[i].some((w) => dot(w, d) > 0.999)) ways[i].push(d);
+  };
+  for (const c of contacts(model, lib, adapter)) {
+    if (c.kind.split("-").every((k) => isSpherical(adapter, k))) {
+      snaps.add(`${c.a},${c.b}`);
+      snaps.add(`${c.b},${c.a}`);
+    }
+    if (c.axis) {
+      axes.set(`${c.a},${c.b}`, c.axis);
+      axes.set(`${c.b},${c.a}`, c.axis);
+    }
+    if (c.release) {
+      releases.set(`${c.b},${c.a}`, c.release);
+      releases.set(`${c.a},${c.b}`, scale(c.release, -1));
+      tryWay(c.b, c.release);
+      tryWay(c.a, scale(c.release, -1));
+    }
+  }
+  const allowed = (i, d, around) => {
+    for (const j of around) {
+      if (j === i) continue;
+      const axis = axes.get(`${i},${j}`);
+      if (axis && !slides(i, j, d)) return false;
+      const release = releases.get(`${i},${j}`);
+      if (release && dot(release, d) < 0.99) return false;
+    }
+    return true;
+  };
+  const centre = (b) => scale(add(b.min, b.max), 0.5);
+  const slides = (i, j, d) => {
+    const axis = axes.get(`${i},${j}`);
+    if (!axis || Math.abs(dot(axis, d)) <= 0.99) return false;
+    return dot(d, sub(centre(bodies[i]), centre(bodies[j]))) >= -1e-6;
+  };
+  const left = new Set(items.map((_, i) => i));
+  const freeWay = (i, around) => ways[i].find((d) => {
+    if (!allowed(i, d, around)) return false;
+    const others = [...around].filter(
+      (j) => j !== i && !slides(i, j, d) && !snaps.has(`${i},${j}`)
+    );
+    let nearby = [];
+    for (let s = STEP, until = 0; ; s += STEP) {
+      if (s > until) {
+        const stretch = union(shifted(bodies[i], d, s), shifted(bodies[i], d, s + SWEEP));
+        nearby = others.filter((j) => overlapVolume(stretch, bodies[j], -0.4) > 0);
+        until = s + SWEEP;
+      }
+      const box2 = shifted(bodies[i], d, s);
+      const near = nearby.filter((j) => overlapVolume(box2, bodies[j], -0.4) > 0);
+      if (!near.length) return true;
+      const it = moved(items[i], d, s);
+      if (near.some((j) => collisionCells(lib, it, items[j]) > BLOCKING_CELLS)) return false;
+    }
+  });
+  const removed = [];
+  while (left.size) {
+    const order2 = [...left].sort((a, b) => bodies[b].max[1] - bodies[a].max[1] || b - a);
+    let next;
+    for (const i of order2) {
+      const d = freeWay(i, left);
+      if (d) {
+        next = { item: i, insert: [0 - d[0], 0 - d[1], 0 - d[2]] };
+        break;
+      }
+    }
+    if (!next) break;
+    removed.push(next);
+    left.delete(next.item);
+  }
+  if (!items.length || items.some((it) => it.step === void 0))
+    return { steps: removed.reverse(), locked: [...left] };
+  const step = (i) => items[i].step ?? 0;
+  const order = items.map((_, i) => i).sort((a, b) => step(a) - step(b) || a - b);
+  const built = /* @__PURE__ */ new Set();
+  const steps = [];
+  const locked = [];
+  for (const i of order) {
+    const d = freeWay(i, /* @__PURE__ */ new Set([...built, i]));
+    if (d) steps.push({ item: i, insert: [0 - d[0], 0 - d[1], 0 - d[2]] });
+    else locked.push(i);
+    built.add(i);
+  }
+  return { steps, locked };
+}
+function seededRandom(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function mates(adapter, free, placed) {
+  if (!adapter.fits[free.kind]?.includes(placed.kind)) return false;
+  const axial = free.len !== void 0 && placed.len !== void 0;
+  return axial ? length(cross(free.a, placed.a)) < 0.01 : dot(free.a, placed.a) < -0.99;
+}
+function remix(exemplar, lib, adapter, opts) {
+  const random = seededRandom(opts.seed);
+  const mode = opts.mode ?? "family";
+  const joints = contacts(exemplar, lib, adapter);
+  const grammar = learnGrammar(exemplar, joints, adapter);
+  const parts = [...new Set(exemplar.items.map((it) => it.part))];
+  const owners = /* @__PURE__ */ new Map();
+  for (const part2 of parts)
+    for (const c of lib[part2].connectors)
+      owners.set(c.kind, (owners.get(c.kind) ?? /* @__PURE__ */ new Set()).add(part2));
+  const specialised = (kind) => kind.split("-").every((k) => owners.get(k)?.size === 1);
+  const group = exemplar.items.map((_, i) => i);
+  const find = (i) => {
+    while (group[i] !== i) i = group[i];
+    return i;
+  };
+  for (const c of joints) if (specialised(c.kind)) group[find(c.a)] = find(c.b);
+  const members = /* @__PURE__ */ new Map();
+  exemplar.items.forEach((_, i) => {
+    members.set(find(i), [...members.get(find(i)) ?? [], i]);
+  });
+  const units = [...members.values()].map((ids) => {
+    const r = exemplar.items[ids[0]];
+    const inverse = transpose(r.rotation);
+    return {
+      first: Math.min(...ids),
+      root: r,
+      items: ids.map((i) => {
+        const it = exemplar.items[i];
+        return {
+          ...it,
+          rotation: mul(inverse, it.rotation),
+          position: apply(inverse, sub(it.position, r.position))
+        };
+      })
+    };
+  });
+  units.sort((x, y) => x.first - y.first);
+  const place = (unit, { rotation, position }) => unit.items.map((it) => ({
+    ...it,
+    rotation: mul(rotation, it.rotation),
+    position: add(apply(rotation, it.position), position)
+  }));
+  const freeConnectors = (items2) => {
+    const world = items2.map((it) => worldConnectors(lib, it));
+    const used = /* @__PURE__ */ new Set();
+    for (const c of contacts({ items: items2 }, lib, adapter))
+      for (const [x, y] of [
+        [c.a, c.b],
+        [c.b, c.a]
+      ])
+        world[x].forEach((cx, n) => {
+          if (world[y].some(
+            (cy) => mates(adapter, cx, cy) && length(sub(cx.p, cy.p)) <= adapter.tolerance
+          ))
+            used.add(`${x}:${n}`);
+        });
+    return world.flatMap((list, x) => list.filter((_, n) => !used.has(`${x}:${n}`)));
+  };
+  const poses = (unit, free) => {
+    const own = freeConnectors(unit.items);
+    const out = [];
+    for (const rotation of AXIS_ROTATIONS)
+      for (const c of own) {
+        const turned = { ...c, p: apply(rotation, c.p), a: apply(rotation, c.a) };
+        for (const f of free)
+          if (mates(adapter, f, turned)) out.push({ rotation, position: sub(f.p, turned.p) });
+      }
+    for (let i = out.length - 1; i > 0; i--) {
+      const j = Math.floor(random() * (i + 1));
+      [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+  };
+  const legal = (build, added) => {
+    const all = [...build, ...added];
+    const fresh = contacts({ items: all }, lib, adapter).filter(
+      (c) => c.a < build.length && c.b >= build.length
+    );
+    if (!fresh.length || !fresh.every(
+      (c) => jointAllowed(grammar, adapter, all[c.a].part, all[c.b].part, c.kind, mode)
+    ))
+      return false;
+    const through = new Set(fresh.filter((c) => c.axis).map((c) => `${c.a},${c.b}`));
+    return added.every((item, k) => {
+      const body = worldBody(lib, item);
+      return build.every(
+        (other, j) => through.has(`${j},${build.length + k}`) || overlapVolume(body, worldBody(lib, other), -0.4) <= 0 || collisionCells(lib, item, other) <= 4
+      );
+    });
+  };
+  const [seed, ...rest] = units;
+  const items = place(seed, seed.root).map((it) => ({ ...it, step: 1 }));
+  const pending = [...rest];
+  for (let step = 2; pending.length; step++) {
+    const free = freeConnectors(items);
+    let chosen;
+    for (const unit of pending) {
+      for (const pose of poses(unit, free)) {
+        const added = place(unit, pose).map((it) => ({ ...it, step }));
+        if (legal(items, added) && !planAssembly({ items: [...items, ...added] }, lib, adapter).locked.length) {
+          chosen = { unit, added };
+          break;
+        }
+      }
+      if (chosen) break;
+    }
+    if (!chosen) break;
+    pending.splice(pending.indexOf(chosen.unit), 1);
+    items.push(...chosen.added);
+  }
+  return { model: { items }, left: pending.flatMap((u) => u.items.map((it) => it.part)) };
+}
+var BRICKS = [
+  ["3007", 8, 2],
+  ["2456", 6, 2],
+  ["3001", 4, 2],
+  ["3002", 3, 2],
+  ["3008", 8, 1],
+  ["3009", 6, 1],
+  ["3003", 2, 2],
+  ["3010", 4, 1],
+  ["3622", 3, 1],
+  ["3004", 2, 1],
+  ["3005", 1, 1]
+].sort((a, b) => b[1] * b[2] - a[1] * a[2] || b[1] - a[1]);
+var PLATES = [
+  ["3034", 8, 2],
+  ["3795", 6, 2],
+  ["3020", 4, 2],
+  ["3021", 3, 2],
+  ["3460", 8, 1],
+  ["3666", 6, 1],
+  ["3022", 2, 2],
+  ["3710", 4, 1],
+  ["3623", 3, 1],
+  ["3023b", 2, 1],
+  ["3024", 1, 1]
+].sort((a, b) => b[1] * b[2] - a[1] * a[2] || b[1] - a[1]);
+var TILES = [
+  ["87079", 4, 2],
+  ["26603", 3, 2],
+  ["4162", 8, 1],
+  ["6636", 6, 1],
+  ["3068b", 2, 2],
+  ["2431", 4, 1],
+  ["63864", 3, 1],
+  ["3069b", 2, 1],
+  ["3070b", 1, 1]
+].sort((a, b) => b[1] * b[2] - a[1] * a[2] || b[1] - a[1]);
+var ALONG_Z = turn([0, 0, 1], [0, 1, 0]);
+function stress(model, lib, adapter) {
+  const n = model.items.length;
+  const joints = contacts(model, lib, adapter);
+  const mass = model.items.map((it) => {
+    const v = partVoxels(lib[it.part]);
+    let cells = 0;
+    for (const c of v.interior) if (c) cells++;
+    return cells * CELL ** 3;
+  });
+  const centre = model.items.map((it) => {
+    const { min, max } = worldBody(lib, it);
+    return scale(add(min, max), 0.5);
+  });
+  const floor = Math.min(...model.items.map((it) => worldBody(lib, it).min[1]));
+  const grounded = model.items.map((it, i) => worldBody(lib, it).min[1] - floor < 0.05 ? i : -1).filter((i) => i >= 0);
+  const edges = model.items.map(() => []);
+  joints.forEach((c, k) => {
+    edges[c.a].push([c.b, k]);
+    edges[c.b].push([c.a, k]);
+  });
+  const reach = (start, skip) => {
+    const seen = /* @__PURE__ */ new Set([start]);
+    const queue = [start];
+    while (queue.length) {
+      const x = queue.pop();
+      for (const [y, k] of edges[x])
+        if (k !== skip && !seen.has(y)) {
+          seen.add(y);
+          queue.push(y);
+        }
+    }
+    return seen;
+  };
+  const cut = bridges(n, edges);
+  const out = [];
+  joints.forEach((c, k) => {
+    if (!cut.has(k)) return;
+    const side2 = reach(c.a, k);
+    const held = grounded.some((g) => side2.has(g)) ? [...reach(c.b, k)] : [...side2];
+    if (held.some((i) => grounded.includes(i))) return;
+    const load = held.reduce((s, i) => s + mass[i], 0);
+    const com = scale(
+      held.reduce((s, i) => add(s, scale(centre[i], mass[i])), [0, 0, 0]),
+      1 / load
+    );
+    const lever = Math.hypot(com[0] - c.at[0], com[2] - c.at[2]);
+    out.push({
+      a: c.a,
+      b: c.b,
+      kind: c.kind,
+      count: c.count,
+      holds: held.sort((x, y) => x - y),
+      load: round3(load),
+      lever: round3(lever),
+      moment: round3(load * lever / c.count)
+    });
+  });
+  return out.sort((x, y) => y.moment - x.moment);
+}
+var round3 = (v) => Math.round(v * 1e3) / 1e3;
+function bridges(n, edges) {
+  const order = new Array(n).fill(-1);
+  const low = new Array(n).fill(0);
+  const out = /* @__PURE__ */ new Set();
+  let time = 0;
+  for (let root = 0; root < n; root++) {
+    if (order[root] >= 0) continue;
+    const stack = [{ v: root, via: -1, next: 0 }];
+    order[root] = low[root] = time++;
+    while (stack.length) {
+      const top = stack[stack.length - 1];
+      if (top.next < edges[top.v].length) {
+        const [w, k] = edges[top.v][top.next++];
+        if (k === top.via) continue;
+        if (order[w] < 0) {
+          order[w] = low[w] = time++;
+          stack.push({ v: w, via: k, next: 0 });
+        } else low[top.v] = Math.min(low[top.v], order[w]);
+      } else {
+        stack.pop();
+        const parent = stack[stack.length - 1];
+        if (parent) {
+          low[parent.v] = Math.min(low[parent.v], low[top.v]);
+          if (low[top.v] > order[parent.v]) out.add(top.via);
+        }
+      }
+    }
+  }
+  return out;
+}
+function toStl(model, lib, unit) {
+  const tris = [];
+  for (const item of model.items) {
+    const part2 = lib[item.part];
+    if (!part2) throw new Error(`Unknown part: ${item.part}`);
+    const t = part2.triangles;
+    for (let i = 0; i < t.length; i += 3) {
+      const p = add(apply(item.rotation, [t[i], t[i + 1], t[i + 2]]), item.position);
+      tris.push(p[0] * unit, -p[2] * unit, p[1] * unit);
+    }
+  }
+  return encodeStl(tris);
+}
+function encodeStl(tris) {
+  const count = tris.length / 9;
+  const out = new DataView(new ArrayBuffer(84 + count * 50));
+  out.setUint32(80, count, true);
+  for (let f = 0; f < count; f++) {
+    const o = 84 + f * 50;
+    const v = tris.slice(f * 9, f * 9 + 9);
+    const u = [v[3] - v[0], v[4] - v[1], v[5] - v[2]];
+    const w = [v[6] - v[0], v[7] - v[1], v[8] - v[2]];
+    const n = [u[1] * w[2] - u[2] * w[1], u[2] * w[0] - u[0] * w[2], u[0] * w[1] - u[1] * w[0]];
+    const len = Math.hypot(n[0], n[1], n[2]) || 1;
+    for (let k = 0; k < 3; k++) out.setFloat32(o + k * 4, n[k] / len, true);
+    for (let k = 0; k < 9; k++) out.setFloat32(o + 12 + k * 4, v[k], true);
+  }
+  return new Uint8Array(out.buffer);
+}
+function toSolidStl(model, lib, unit, contacts2 = []) {
+  const placed = model.items.map((item) => {
+    const part2 = lib[item.part];
+    if (!part2) throw new Error(`Unknown part: ${item.part}`);
+    const { min: min2, max: max2 } = meshBounds(part2.triangles);
+    const lo = [Infinity, Infinity, Infinity];
+    const hi = [-Infinity, -Infinity, -Infinity];
+    for (let c = 0; c < 8; c++) {
+      const p = add(
+        apply(item.rotation, [
+          c & 1 ? max2[0] : min2[0],
+          c & 2 ? max2[1] : min2[1],
+          c & 4 ? max2[2] : min2[2]
+        ]),
+        item.position
+      );
+      for (let k = 0; k < 3; k++) {
+        lo[k] = Math.min(lo[k], p[k]);
+        hi[k] = Math.max(hi[k], p[k]);
+      }
+    }
+    return { item, voxels: partVoxels(part2), lo, hi };
+  });
+  const min = [0, 1, 2].map((k) => Math.min(...placed.map((p) => p.lo[k])) - CELL);
+  const max = [0, 1, 2].map((k) => Math.max(...placed.map((p) => p.hi[k])) + CELL);
+  const dims = [0, 1, 2].map((k) => Math.ceil((max[k] - min[k]) / CELL));
+  const solid = new Uint8Array(dims[0] * dims[1] * dims[2]);
+  const owner = new Int32Array(solid.length).fill(-1);
+  const at = (i, j, k) => (k * dims[1] + j) * dims[0] + i;
+  placed.forEach(({ item, voxels, lo, hi }, index2) => {
+    const r = item.rotation;
+    const i0 = [0, 1, 2].map((k) => Math.max(0, Math.floor((lo[k] - min[k]) / CELL)));
+    const i1 = [0, 1, 2].map((k) => Math.min(dims[k] - 1, Math.ceil((hi[k] - min[k]) / CELL)));
+    for (let k = i0[2]; k <= i1[2]; k++)
+      for (let j = i0[1]; j <= i1[1]; j++)
+        for (let i = i0[0]; i <= i1[0]; i++) {
+          const n = at(i, j, k);
+          if (solid[n]) continue;
+          const d = [
+            min[0] + (i + 0.5) * CELL - item.position[0],
+            min[1] + (j + 0.5) * CELL - item.position[1],
+            min[2] + (k + 0.5) * CELL - item.position[2]
+          ];
+          const local = [
+            r[0] * d[0] + r[3] * d[1] + r[6] * d[2],
+            r[1] * d[0] + r[4] * d[1] + r[7] * d[2],
+            r[2] * d[0] + r[5] * d[1] + r[8] * d[2]
+          ];
+          if (cellAt(voxels, local)) {
+            solid[n] = 1;
+            owner[n] = index2;
+          }
+        }
+  });
+  weld(contacts2, placed, solid, owner, dims, min, at);
+  unpinch(solid, dims);
+  const tris = [];
+  const corner = (i, j, k) => {
+    const x = min[0] + i * CELL;
+    const y = min[1] + j * CELL;
+    const z5 = min[2] + k * CELL;
+    tris.push(x * unit, -z5 * unit, y * unit);
+  };
+  const filled = (i, j, k) => i >= 0 && j >= 0 && k >= 0 && i < dims[0] && j < dims[1] && k < dims[2] && solid[at(i, j, k)] === 1;
+  const faces = [
+    [
+      [1, 0, 0],
+      [
+        [1, 0, 0],
+        [1, 1, 0],
+        [1, 1, 1],
+        [1, 0, 1]
+      ]
+    ],
+    [
+      [-1, 0, 0],
+      [
+        [0, 0, 0],
+        [0, 0, 1],
+        [0, 1, 1],
+        [0, 1, 0]
+      ]
+    ],
+    [
+      [0, 1, 0],
+      [
+        [0, 1, 0],
+        [0, 1, 1],
+        [1, 1, 1],
+        [1, 1, 0]
+      ]
+    ],
+    [
+      [0, -1, 0],
+      [
+        [0, 0, 0],
+        [1, 0, 0],
+        [1, 0, 1],
+        [0, 0, 1]
+      ]
+    ],
+    [
+      [0, 0, 1],
+      [
+        [0, 0, 1],
+        [1, 0, 1],
+        [1, 1, 1],
+        [0, 1, 1]
+      ]
+    ],
+    [
+      [0, 0, -1],
+      [
+        [0, 0, 0],
+        [0, 1, 0],
+        [1, 1, 0],
+        [1, 0, 0]
+      ]
+    ]
+  ];
+  for (let k = 0; k < dims[2]; k++)
+    for (let j = 0; j < dims[1]; j++)
+      for (let i = 0; i < dims[0]; i++) {
+        if (!solid[at(i, j, k)]) continue;
+        for (const [n, q] of faces) {
+          if (filled(i + n[0], j + n[1], k + n[2])) continue;
+          for (const v of [q[0], q[1], q[2], q[0], q[2], q[3]])
+            corner(i + v[0], j + v[1], k + v[2]);
+        }
+      }
+  return encodeStl(tris);
+}
+function components(solid, dims) {
+  const label2 = new Int32Array(solid.length);
+  const stack = [];
+  const plane = dims[0] * dims[1];
+  let next = 0;
+  for (let start = 0; start < solid.length; start++) {
+    if (!solid[start] || label2[start]) continue;
+    label2[start] = ++next;
+    stack.push(start);
+    while (stack.length) {
+      const n = stack.pop();
+      const i = n % dims[0];
+      const j = Math.floor(n / dims[0]) % dims[1];
+      const k = Math.floor(n / plane);
+      const near = [
+        i > 0 ? n - 1 : -1,
+        i < dims[0] - 1 ? n + 1 : -1,
+        j > 0 ? n - dims[0] : -1,
+        j < dims[1] - 1 ? n + dims[0] : -1,
+        k > 0 ? n - plane : -1,
+        k < dims[2] - 1 ? n + plane : -1
+      ];
+      for (const m of near)
+        if (m >= 0 && solid[m] && !label2[m]) {
+          label2[m] = next;
+          stack.push(m);
+        }
+    }
+  }
+  return label2;
+}
+function weld(contacts2, placed, solid, owner, dims, min, at) {
+  const cellOf = (item) => owner.indexOf(item);
+  let label2 = components(solid, dims);
+  for (const c of contacts2) {
+    const a = cellOf(c.a);
+    const b = cellOf(c.b);
+    if (a < 0 || b < 0) continue;
+    const boxes = [placed[c.a], placed[c.b]];
+    const reach = Math.max(
+      ...boxes.flatMap(
+        (box2) => [0, 1, 2].map((k) => Math.max(c.at[k] - box2.lo[k], box2.hi[k] - c.at[k]))
+      )
+    );
+    for (let r = CELL; label2[a] !== label2[b] && r <= reach + CELL; r += CELL) {
+      const i0 = [0, 1, 2].map((k) => Math.max(0, Math.floor((c.at[k] - r - min[k]) / CELL)));
+      const i1 = [0, 1, 2].map(
+        (k) => Math.min(dims[k] - 1, Math.ceil((c.at[k] + r - min[k]) / CELL))
+      );
+      for (let k = i0[2]; k <= i1[2]; k++)
+        for (let j = i0[1]; j <= i1[1]; j++)
+          for (let i = i0[0]; i <= i1[0]; i++) {
+            const p = [
+              min[0] + (i + 0.5) * CELL,
+              min[1] + (j + 0.5) * CELL,
+              min[2] + (k + 0.5) * CELL
+            ];
+            if (Math.hypot(p[0] - c.at[0], p[1] - c.at[1], p[2] - c.at[2]) > r) continue;
+            if (!boxes.some((box2) => p.every((v, q) => v >= box2.lo[q] && v <= box2.hi[q]))) continue;
+            solid[at(i, j, k)] = 1;
+          }
+      label2 = components(solid, dims);
+    }
+  }
+}
+function unpinch(solid, dims) {
+  const step = [1, dims[0], dims[0] * dims[1]];
+  const coord = (n) => [
+    n % dims[0],
+    Math.floor(n / dims[0]) % dims[1],
+    Math.floor(n / step[2])
+  ];
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (let n = 0; n < solid.length; n++) {
+      const c = coord(n);
+      for (const [u, w] of [
+        [0, 1],
+        [1, 2],
+        [0, 2]
+      ]) {
+        if (c[u] + 1 >= dims[u] || c[w] + 1 >= dims[w]) continue;
+        const a = n;
+        const b = n + step[u];
+        const d = n + step[w];
+        const e = n + step[u] + step[w];
+        if (solid[a] && solid[e] && !solid[b] && !solid[d]) {
+          solid[b] = 1;
+          changed = true;
+        } else if (solid[b] && solid[d] && !solid[a] && !solid[e]) {
+          solid[a] = 1;
+          changed = true;
+        }
+      }
+    }
+  }
+}
+var COLLISION_CELLS = 4;
+var SOCKET_REACH = 0.5;
+function validate(model, lib, adapter, opts = {}) {
+  const issues = [];
+  const n = model.items.length;
+  const joints = contacts(model, lib, adapter);
+  const bodies = model.items.map((it) => worldBody(lib, it));
+  const through = new Set(joints.filter((c) => c.axis).map((c) => `${c.a},${c.b}`));
+  const balls = new Map(
+    joints.filter((c) => c.kind.split("-").every((k) => isSpherical(adapter, k))).map((c) => [`${c.a},${c.b}`, c.at])
+  );
+  for (const [a, b] of nearPairs(bodies, 0.8)) {
+    if (through.has(`${a},${b}`) || overlapVolume(bodies[a], bodies[b], -0.4) <= 0) continue;
+    const centre = balls.get(`${a},${b}`);
+    const ignore = centre && { centre, radius: SOCKET_REACH };
+    if (collisionCells(lib, model.items[a], model.items[b], ignore) > COLLISION_CELLS)
+      issues.push({ rule: "overlap", items: [a, b], message: "two parts occupy the same space" });
+  }
+  const parent = model.items.map((_, i) => i);
+  const find = (x) => {
+    while (parent[x] !== x) x = parent[x];
+    return x;
+  };
+  for (const c of joints) parent[find(c.a)] = find(c.b);
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) groups.set(find(i), [...groups.get(find(i)) ?? [], i]);
+  const sorted = [...groups.values()].sort((x, y) => y.length - x.length);
+  for (const g of sorted.slice(1))
+    issues.push({ rule: "disconnected", items: g, message: "parts not joined to the main build" });
+  if (opts.grammar)
+    for (const c of joints) {
+      const [a, b] = [model.items[c.a].part, model.items[c.b].part];
+      if (!jointAllowed(opts.grammar, adapter, a, b, c.kind, opts.mode ?? "strict"))
+        issues.push({
+          rule: "unseen-joint",
+          items: [c.a, c.b],
+          message: "a joint the exemplar never makes"
+        });
+    }
+  return { ok: issues.length === 0, issues, contacts: joints };
+}
+
+// src/brick.ts
+import sharp from "sharp";
+function ldrawLibrary(flag) {
+  const dir = typeof flag === "string" ? flag : process.env.LDRAW_DIR;
+  if (!dir)
+    throw new InputError(
+      "Pass --library <ldraw-dir> or set LDRAW_DIR to an unpacked LDraw library (https://library.ldraw.org)."
+    );
+  const root = resolve(dir);
+  if (!existsSync(join(root, "parts")) || !existsSync(join(root, "p")))
+    throw new InputError(`${root} is not an LDraw library: expected parts/ and p/ inside.`);
+  return root;
+}
+async function readBrickModel(file, library) {
+  const text = await readFile(resolve(file), "utf8").catch((error) => {
+    if (error.code === "ENOENT") throw new InputError(`No model at ${resolve(file)}.`);
+    throw error;
+  });
+  const model = parseModel(text);
+  if (!model.items.length) throw new InputError(`${file} places no parts.`);
+  const read = (path) => existsSync(path) ? readFileSync(path, "utf8") : void 0;
+  const resolver = libraryResolver(read, library);
+  const lib = {};
+  const names = {};
+  for (const item of model.items) {
+    if (lib[item.part]) continue;
+    const text2 = resolver(`${item.part}.dat`);
+    if (text2 === void 0) throw new InputError(`Part ${item.part} is not in the LDraw library.`);
+    names[item.part] = text2.split(/\r?\n/, 1)[0].replace(/^0\s*/, "").trim();
+    lib[item.part] = loadLegoPart(item.part, resolver, { name: names[item.part] });
+  }
+  const config = read(join(library, "LDConfig.ldr"));
+  return { model, lib, names, palette: config ? parsePalette(config) : {} };
+}
+function brickPart(id, library) {
+  const read = (path) => existsSync(path) ? readFileSync(path, "utf8") : void 0;
+  const resolver = libraryResolver(read, library);
+  const text = resolver(`${id}.dat`);
+  if (text === void 0) throw new InputError(`Part ${id} is not in the LDraw library.`);
+  const name = text.split(/\r?\n/, 1)[0].replace(/^0\s*/, "").trim();
+  const moved2 = name.match(/^~Moved to (\S+)/);
+  if (moved2) throw new InputError(`Part ${id} moved to ${moved2[1]}; use that id.`);
+  return describePart(loadLegoPart(id, resolver, { name }));
+}
+function brickCheck({ model, lib, names }) {
+  const result = validate(model, lib, lego);
+  const label2 = (i) => `${i}:${model.items[i].part} ${names[model.items[i].part]}`;
+  return {
+    ok: result.ok,
+    parts: model.items.length,
+    joints: result.contacts.length,
+    issues: result.issues.map((issue) => ({ ...issue, parts: issue.items.map(label2) }))
+  };
+}
+function brickStress({ model, lib, names }) {
+  const label2 = (i) => `${i}:${model.items[i].part} ${names[model.items[i].part]}`;
+  return stress(model, lib, lego).map((j) => ({ ...j, between: [label2(j.a), label2(j.b)] }));
+}
+function brickPlan({ model, lib, names }) {
+  const plan = planAssembly(model, lib, lego);
+  const axis = (d) => ["+x", "-x", "+y", "-y", "+z", "-z"][[
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 1, 0],
+    [0, -1, 0],
+    [0, 0, 1],
+    [0, 0, -1]
+  ].findIndex((v) => v.every((x, k) => Math.abs(x - d[k]) < 1e-6))] ?? d.join(",");
+  return {
+    ...plan,
+    rows: plan.steps.map((s) => ({
+      step: model.items[s.item].step ?? 0,
+      part: model.items[s.item].part,
+      name: names[model.items[s.item].part],
+      insert: axis(s.insert)
+    }))
+  };
+}
+async function brickRender({ model, lib, palette }, opts) {
+  const highlight = opts.step === void 0 ? void 0 : model.items.map((it, i) => it.step === opts.step ? i : -1).filter((i) => i >= 0);
+  if (opts.step !== void 0 && !highlight?.length)
+    throw new InputError(`The model has no step ${opts.step}.`);
+  const image = rasterize(model, lib, {
+    width: 1200,
+    height: 900,
+    palette,
+    background: "#ecebe7",
+    maxStep: opts.step,
+    highlight,
+    explode: opts.explode,
+    yaw: opts.yaw === void 0 ? void 0 : opts.yaw * Math.PI / 180,
+    pitch: opts.pitch === void 0 ? void 0 : opts.pitch * Math.PI / 180
+  });
+  return sharp(Buffer.from(image.data.buffer), {
+    raw: { width: image.width, height: image.height, channels: 4 }
+  }).resize(1200, 900).png().toBuffer();
+}
+var MODES = ["strict", "family", "free"];
+function brickRemix(exemplar, seed, mode) {
+  if (mode !== void 0 && !MODES.includes(mode))
+    throw new InputError(`--mode must be one of ${MODES.join(", ")}.`);
+  const result = remix(exemplar.model, exemplar.lib, lego, {
+    seed,
+    mode
+  });
+  const grown = { ...exemplar, model: result.model };
+  return {
+    ldr: writeModel(result.model, `Remix ${seed}`),
+    left: result.left,
+    check: brickCheck(grown)
+  };
+}
+var STUD_MM = 8;
+function brickStl({ model, lib }, scale2 = 1) {
+  if (!Number.isFinite(scale2) || scale2 <= 0)
+    throw new InputError("--scale must be a positive number.");
+  const stl = toSolidStl(model, lib, STUD_MM * scale2, validate(model, lib, lego).contacts);
+  const view = new DataView(stl.buffer);
+  const count = view.getUint32(80, true);
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (let f = 0; f < count; f++)
+    for (let k = 0; k < 9; k++) {
+      const v = view.getFloat32(84 + f * 50 + 12 + k * 4, true);
+      min[k % 3] = Math.min(min[k % 3], v);
+      max[k % 3] = Math.max(max[k % 3], v);
+    }
+  const mm = (k) => +(max[k] - min[k]).toFixed(2);
+  return {
+    stl,
+    parts: model.items.length,
+    triangles: count,
+    sizeMm: { x: mm(0), y: mm(1), z: mm(2) }
+  };
+}
+
 // src/card-import.ts
 import { createHash } from "crypto";
-import { readFile, stat } from "fs/promises";
+import { readFile as readFile2, stat } from "fs/promises";
 import { basename, extname } from "path";
 import { DOMParser } from "@xmldom/xmldom";
-import sharp from "sharp";
+import sharp2 from "sharp";
 var box = { x: 0, y: 0, w: 1200, h: 756 };
 function elements(node) {
   return Array.from(node.childNodes).filter((child) => child.nodeType === 1);
@@ -116,7 +2189,7 @@ async function importCard(file, name) {
   const info = await stat(file);
   if (!info.isFile() || info.size > 2e6)
     throw new InputError("Import a local SVG or raster file below 2 MB.");
-  const bytes = await readFile(file);
+  const bytes = await readFile2(file);
   const title = (name ?? basename(file, extname(file))).slice(0, 60);
   const design = {
     version: 1,
@@ -130,7 +2203,7 @@ async function importCard(file, name) {
     back: { background: "#111111", layers: [] }
   };
   if (extname(file).toLowerCase() !== ".svg") {
-    const meta = await sharp(bytes, { limitInputPixels: 24e6 }).metadata();
+    const meta = await sharp2(bytes, { limitInputPixels: 24e6 }).metadata();
     if (!meta.format || !["png", "jpeg", "webp"].includes(meta.format))
       throw new InputError("Import PNG, JPEG, WebP or a self-contained SVG.");
     design.assets = {
@@ -193,11 +2266,11 @@ async function importCard(file, name) {
         `This SVG uses elements outside the editable format: ${result.error.issues.map((issue) => issue.message).join("; ")}. Keep and edit the original SVG; it was not changed.`
       );
   }
-  design.front.layers = groups.map((children, index) => {
+  design.front.layers = groups.map((children, index2) => {
     const first = children[0];
     return {
-      id: `source-${String(index + 1).padStart(2, "0")}`,
-      name: (grouped ? "Original composition" : first?.attrs?.["aria-label"] ?? first?.attrs?.id ?? first?.text?.trim() ?? `Original ${first?.tag} ${index + 1}`).slice(0, 80),
+      id: `source-${String(index2 + 1).padStart(2, "0")}`,
+      name: (grouped ? "Original composition" : first?.attrs?.["aria-label"] ?? first?.attrs?.id ?? first?.text?.trim() ?? `Original ${first?.tag} ${index2 + 1}`).slice(0, 80),
       kind: "svg",
       nodes: Object.keys(inherited).length ? [{ tag: "g", attrs: inherited, children }] : children,
       ...box,
@@ -210,7 +2283,7 @@ async function importCard(file, name) {
   for (const layer of design.front.layers) {
     if (layer.kind !== "svg") continue;
     const markup = `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="756" viewBox="0 0 1200 756"><defs>${defs}</defs>${layer.nodes.map((node) => svgNodeXml(node)).join("")}</svg>`;
-    const { data, info: pixels } = await sharp(Buffer.from(markup)).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    const { data, info: pixels } = await sharp2(Buffer.from(markup)).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
     let left = 1200, top = 756, right = -1, bottom = -1;
     for (let y = 0; y < pixels.height; y++) {
       for (let x = 0; x < pixels.width; x++) {
@@ -229,14 +2302,43 @@ async function importCard(file, name) {
   return badgeDesignSchema.parse(design);
 }
 
+// src/grid.ts
+var whole = (name, raw) => {
+  const n = Number(raw);
+  if (raw === void 0 || !Number.isInteger(n) || n < 1)
+    throw new InputError(`--${name} must be a whole number of at least 1.`);
+  return n;
+};
+function gridStl(kind, values) {
+  const part2 = kind === "bin" ? gridfinityBin(
+    whole("width", values.width),
+    whole("depth", values.depth),
+    whole("height", values.height)
+  ) : gridfinityBaseplate(whole("width", values.width), whole("depth", values.depth));
+  const stl = toStl(
+    { items: [{ part: part2.id, rotation: IDENTITY, position: [0, 0, 0], color: 16 }] },
+    { [part2.id]: part2 },
+    GRIDFINITY_UNIT_MM
+  );
+  const { min, max } = meshBounds(part2.triangles);
+  const mm = (k) => +((max[k] - min[k]) * GRIDFINITY_UNIT_MM).toFixed(2);
+  return {
+    stl,
+    part: part2.id,
+    name: part2.name,
+    triangles: part2.triangles.length / 9,
+    sizeMm: { x: mm(0), y: mm(2), z: mm(1) }
+  };
+}
+
 // src/images.ts
-import { readFile as readFile2, stat as stat2, writeFile } from "fs/promises";
-import { extname as extname2, resolve } from "path";
+import { readFile as readFile3, stat as stat2, writeFile } from "fs/promises";
+import { extname as extname2, resolve as resolve2 } from "path";
 async function readToolResult(path) {
   const info = await stat2(path);
   if (!info.isFile() || info.size > 12e6)
     throw new InputError("Expected a result file below 12 MB.");
-  let value = JSON.parse(await readFile2(path, "utf8"));
+  let value = JSON.parse(await readFile3(path, "utf8"));
   if (typeof value === "string") value = JSON.parse(value);
   if (value && typeof value === "object" && "success" in value) {
     if (!value.success) throw new InputError("The browser command failed.");
@@ -263,7 +2365,7 @@ async function imageParams(file, state, target = "portrait") {
   const current = await readToolResult(state);
   if (typeof current.revision !== "string")
     throw new InputError("Inspect the editor to obtain its revision.");
-  const bytes = await readFile2(file);
+  const bytes = await readFile3(file);
   if (bytes.length > 4e6) throw new InputError("Image must be smaller than 4 MB.");
   return {
     action: "import",
@@ -281,15 +2383,15 @@ async function extractImage(file, out) {
     throw new InputError("The tool did not return a supported image.");
   const bytes = Buffer.from(match[1], "base64");
   if (bytes.length > 4e6) throw new InputError("Image is larger than 4 MB.");
-  const path = resolve(out);
+  const path = resolve2(out);
   await writeFile(path, bytes, { flag: "wx", mode: 384 });
   return { path, bytes: bytes.length };
 }
 
 // src/kit-extract.ts
 import { mkdir, mkdtemp, rename, rm, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join, resolve as resolve2 } from "path";
-import sharp2 from "sharp";
+import { dirname, join as join2, resolve as resolve3 } from "path";
+import sharp3 from "sharp";
 import { z } from "zod";
 var regionSchema = z.object({
   x: z.number().int().nonnegative(),
@@ -366,33 +2468,33 @@ function artworkRegions(foreground, w, h, gap, minArea) {
 function removeOuterBackground(rgba, w, h, background, tolerance) {
   const result = new Uint8Array(rgba), seen = new Uint8Array(w * h), queue = new Int32Array(w * h);
   let head = 0, tail = 0;
-  const add = (p) => {
+  const add2 = (p) => {
     if (seen[p]) return;
     seen[p] = 1;
     if (rgba[p * 4 + 3] < 16 || [0, 1, 2].reduce((n, c) => n + Math.abs(rgba[p * 4 + c] - background[c]), 0) <= tolerance)
       queue[tail++] = p;
   };
   for (let x = 0; x < w; x++) {
-    add(x);
-    add((h - 1) * w + x);
+    add2(x);
+    add2((h - 1) * w + x);
   }
   for (let y = 0; y < h; y++) {
-    add(y * w);
-    add(y * w + w - 1);
+    add2(y * w);
+    add2(y * w + w - 1);
   }
   while (head < tail) {
     const p = queue[head++], x = p % w, y = Math.floor(p / w);
     result[p * 4 + 3] = 0;
-    if (x) add(p - 1);
-    if (x < w - 1) add(p + 1);
-    if (y) add(p - w);
-    if (y < h - 1) add(p + w);
+    if (x) add2(p - 1);
+    if (x < w - 1) add2(p + 1);
+    if (y) add2(p - w);
+    if (y < h - 1) add2(p + w);
   }
   return result;
 }
 async function extractKit(file, out, input) {
   const options = optionsSchema.parse(input);
-  const { data, info } = await sharp2(resolve2(file), { limitInputPixels: 24e6 }).rotate().ensureAlpha().toColourspace("srgb").raw().toBuffer({ resolveWithObject: true });
+  const { data, info } = await sharp3(resolve3(file), { limitInputPixels: 24e6 }).rotate().ensureAlpha().toColourspace("srgb").raw().toBuffer({ resolveWithObject: true });
   const w = info.width, h = info.height;
   const corners = [0, w - 1, (h - 1) * w, w * h - 1];
   const transparentBackground = corners.every((p) => data[p * 4 + 3] < 16);
@@ -407,9 +2509,9 @@ async function extractKit(file, out, input) {
     throw new InputError("Choose 1\u201324 regions using --params, or adjust gap/minArea.");
   if (regions.some((r) => r.x + r.w > w || r.y + r.h > h))
     throw new InputError("Every region must fit inside the image.");
-  const target = resolve2(out), temporary = await mkdtemp(join(dirname(target), ".makeables-extract-"));
+  const target = resolve3(out), temporary = await mkdtemp(join2(dirname(target), ".makeables-extract-"));
   try {
-    await mkdir(join(temporary, "pieces"));
+    await mkdir(join2(temporary, "pieces"));
     const kit = {
       format: "makeables-kit",
       version: 1,
@@ -418,11 +2520,11 @@ async function extractKit(file, out, input) {
       sheets: []
     };
     const views = [];
-    for (const [index, region] of regions.entries()) {
-      const id = `piece-${String(index + 1).padStart(2, "0")}`, name = region.name ?? `Piece ${index + 1}`;
-      const crop = await sharp2(data, { raw: { width: w, height: h, channels: 4 } }).extract({ left: region.x, top: region.y, width: region.w, height: region.h }).raw().toBuffer();
+    for (const [index2, region] of regions.entries()) {
+      const id = `piece-${String(index2 + 1).padStart(2, "0")}`, name = region.name ?? `Piece ${index2 + 1}`;
+      const crop = await sharp3(data, { raw: { width: w, height: h, channels: 4 } }).extract({ left: region.x, top: region.y, width: region.w, height: region.h }).raw().toBuffer();
       const pixels = transparentBackground ? crop : removeOuterBackground(crop, region.w, region.h, background, options.tolerance);
-      const png = await sharp2(pixels, { raw: { width: region.w, height: region.h, channels: 4 } }).png().toBuffer();
+      const png = await sharp3(pixels, { raw: { width: region.w, height: region.h, channels: 4 } }).png().toBuffer();
       const design = createStickerDesign();
       design.sticker = { ...defaultStickerMaterial, finish: "vinyl", sparkle: 0, holography: 0 };
       design.name = name;
@@ -455,19 +2557,19 @@ async function extractKit(file, out, input) {
       };
       design.back = { background: "#00000000", layers: [] };
       await writeFile2(
-        join(temporary, `pieces/${id}.json`),
+        join2(temporary, `pieces/${id}.json`),
         JSON.stringify(badgeDesignSchema.parse(design), null, 2)
       );
       kit.items.push({ id, file: `pieces/${id}.json` });
       views.push({ name, bytes: png });
     }
-    await writeFile2(join(temporary, "kit.json"), JSON.stringify(kit, null, 2));
-    await writeFile2(join(temporary, "contact.png"), await kitCover(options.name, views));
+    await writeFile2(join2(temporary, "kit.json"), JSON.stringify(kit, null, 2));
+    await writeFile2(join2(temporary, "contact.png"), await kitCover(options.name, views));
     await mkdir(target);
     await rename(temporary, target);
     return {
-      path: join(target, "kit.json"),
-      preview: join(target, "contact.png"),
+      path: join2(target, "kit.json"),
+      preview: join2(target, "contact.png"),
       items: kit.items.length,
       regions,
       source: { width: w, height: h },
@@ -479,6 +2581,246 @@ async function extractKit(file, out, input) {
   }
 }
 
+// src/layers.ts
+import { randomBytes } from "crypto";
+import { ZodError } from "zod";
+var layerKinds = ["text", "shape", "graphic", "qr"];
+function defaults(kind, width, height) {
+  const centered = (w, h) => ({
+    x: Math.round((width - w) / 2),
+    y: Math.round((height - h) / 2),
+    w,
+    h
+  });
+  if (kind === "text")
+    return {
+      ...centered(Math.round(width * 0.8), 160),
+      text: "Text",
+      binding: "none",
+      color: "#141414",
+      font: "sans",
+      size: 72,
+      weight: "700",
+      align: "center",
+      fit: "shrink"
+    };
+  if (kind === "shape")
+    return {
+      ...centered(Math.round(width * 0.6), Math.round(height * 0.3)),
+      shape: "rectangle",
+      color: "#141414",
+      radius: 0,
+      stroke: 0,
+      opacity: 1
+    };
+  if (kind === "qr") return centered(320, 320);
+  return {
+    ...centered(Math.round(width * 0.6), Math.round(width * 0.6)),
+    pattern: "path",
+    color: "#141414",
+    accent: "#141414",
+    density: 1,
+    seed: 1
+  };
+}
+function addLayer(design, face, kind, params = {}) {
+  if (!layerKinds.includes(kind))
+    throw new InputError(
+      `--kind must be one of ${layerKinds.join(", ")}. Add images with --sticker <path>.`
+    );
+  const profile = designProfile(design);
+  const id = typeof params.id === "string" ? params.id : `${kind}-${randomBytes(3).toString("hex")}`;
+  if (design[face].layers.some((layer2) => layer2.id === id))
+    throw new InputError(`Layer ${id} already exists on ${face}. Use layer set to change it.`);
+  const layer = {
+    ...defaults(kind, profile.width, profile.height),
+    ...params,
+    id,
+    kind
+  };
+  if (kind === "graphic" && layer.pattern === "path" && !layer.path)
+    throw new InputError('A path graphic needs "path" (SVG path data) and "viewBox" in --params.');
+  try {
+    const next = badgeDesignSchema.parse({
+      ...design,
+      [face]: { ...design[face], layers: [...design[face].layers, layer] }
+    });
+    const text = typeof layer.text === "string" ? layer.text : "";
+    const unsupported = [
+      ...new Set(
+        [...text].filter((c) => {
+          const code = c.codePointAt(0) ?? 0;
+          return code > 591 && !(code >= 8208 && code <= 8231) && code !== 8364;
+        })
+      )
+    ];
+    const warnings = unsupported.length ? [
+      `The bundled fonts may not draw ${unsupported.join(" ")}. Draw symbols as a graphic path or image layer.`
+    ] : [];
+    return { design: next, id, warnings };
+  } catch (error) {
+    if (error instanceof ZodError)
+      throw new InputError(
+        `Invalid ${kind} layer: ${error.issues.map((issue) => `${issue.path.slice(3).join(".") || "layer"}: ${issue.message}`).join("; ")}. Run makeables schema for every field.`
+      );
+    throw error;
+  }
+}
+function blankDesign(product, name) {
+  const title = typeof name === "string" && name.trim() ? name.trim().slice(0, 60) : `Untitled ${product}`;
+  const preset = structuredClone(
+    product === "card" ? findCardStyle("pearl") : findDesign("herbario-azul")
+  );
+  if (!preset) throw new Error(`Missing base ${product} style.`);
+  const base = {
+    ...preset,
+    product,
+    name: title,
+    event: title,
+    description: "",
+    artPrompt: "",
+    source: void 0,
+    artwork: void 0,
+    assets: {}
+  };
+  if (product === "card")
+    return badgeDesignSchema.parse({
+      ...base,
+      front: {
+        background: "#f4f1eb",
+        layers: preset.front.layers.filter((layer) => layer.kind === "card-mark")
+      },
+      back: { background: "#f4f1eb", layers: [] }
+    });
+  const portrait = preset.front.layers.find((layer) => layer.kind === "portrait");
+  const text = (id, binding, y, size, weight = "700") => ({
+    id,
+    kind: "text",
+    x: 96,
+    y,
+    w: 832,
+    h: Math.round(size * 1.3),
+    text: "",
+    binding,
+    color: "#141414",
+    font: "sans",
+    size,
+    weight,
+    align: "center",
+    fit: "shrink"
+  });
+  return badgeDesignSchema.parse({
+    ...base,
+    front: {
+      background: "#f4f1eb",
+      layers: [
+        ...portrait ? [{ ...portrait, x: 192, y: 240, w: 640, h: 640, filter: "original", fade: void 0 }] : [],
+        text("participant-name", "name", 960, 96),
+        text("participant-role", "role", 1100, 48, "500")
+      ]
+    },
+    back: {
+      background: "#f4f1eb",
+      // The back repeats the holder: badges need name and role on both faces.
+      layers: [
+        text("back-name", "name", 200, 72),
+        text("back-role", "role", 310, 40, "500"),
+        { id: "access-qr", kind: "qr", x: 312, y: 520, w: 400, h: 400 },
+        text("event-name", "event", 1e3, 56)
+      ]
+    }
+  });
+}
+
+// src/preflight.ts
+import { spawnSync } from "child_process";
+import { mkdtemp as mkdtemp2, readdir, rm as rm2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+var generationKeys = [
+  "AI_GATEWAY_API_KEY",
+  "VERCEL_OIDC_TOKEN",
+  "OPENAI_API_KEY",
+  "GOOGLE_GENERATIVE_AI_API_KEY"
+];
+var defaultRun = (command, args) => {
+  const result = spawnSync(command, args, { encoding: "utf8", shell: false, timeout: 12e4 });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error
+  };
+};
+function redact(text, env) {
+  let out = text;
+  for (const key2 of generationKeys) {
+    const value = env[key2];
+    if (value && value.length > 4) out = out.split(value).join("[redacted]");
+  }
+  return out.trim().slice(0, 400);
+}
+async function preflight(options = {}) {
+  const env = options.env ?? process.env;
+  const run2 = options.run ?? defaultRun;
+  const version2 = run2("ai", ["--version"]);
+  const aiCli = {
+    installed: !version2.error && version2.status === 0,
+    version: version2.status === 0 ? version2.stdout.trim().slice(0, 40) : null,
+    install: "npm install --global ai-cli"
+  };
+  const keys = generationKeys.filter((key2) => Boolean(env[key2]));
+  let probe = null;
+  if (options.probe) {
+    if (!aiCli.installed) probe = { ok: false, error: "ai-cli is not installed." };
+    else if (!keys.length) probe = { ok: false, error: "No generation key in the environment." };
+    else {
+      const dir = await mkdtemp2(join3(tmpdir(), "makeables-probe-"));
+      try {
+        const result = run2("ai", [
+          "image",
+          "--quiet",
+          "--json",
+          "--no-preview",
+          "--output",
+          dir,
+          "a small flat orange circle on a white background"
+        ]);
+        const made = (await readdir(dir)).length > 0;
+        probe = result.status === 0 && made ? { ok: true } : {
+          ok: false,
+          error: redact(result.stderr || result.stdout || "No image was produced.", env)
+        };
+      } finally {
+        await rm2(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const cliReady = probe ? probe.ok : aiCli.installed && keys.length > 0;
+  const tracing = run2("potrace", ["--version"]);
+  return {
+    imageGeneration: {
+      aiCli,
+      keys,
+      probe,
+      ready: cliReady,
+      recommendation: cliReady ? "generate" : "host-or-install"
+    },
+    potrace: { installed: !tracing.error && tracing.status === 0 },
+    ask: {
+      source: ["official", "generated", "mixed"],
+      defaultSource: "mixed",
+      stickers: { min: 6, max: 10 }
+    }
+  };
+}
+function preflightSummary(result) {
+  const generation = result.imageGeneration;
+  const line = generation.ready ? `Image generation: ready (ai-cli${generation.probe?.ok ? ", probe passed" : ""}).` : generation.probe && !generation.probe.ok ? `Image generation: failed (${generation.probe.error}).` : generation.aiCli.installed ? "Image generation: ai-cli installed, no key. Use the host's image tool or set AI_GATEWAY_API_KEY." : "Image generation: not installed. Use the host's image tool or ask to install ai-cli.";
+  return `${line}
+Ask the user: art source (official, generated or mixed) and how many stickers (6-10).`;
+}
+
 // src/presentation.ts
 import { stripVTControlCharacters } from "util";
 function machineOutput(json) {
@@ -503,10 +2845,10 @@ function banner(version2) {
 // src/publish.ts
 import { createHash as createHash2, randomUUID } from "crypto";
 import { constants } from "fs";
-import { appendFile, link, mkdir as mkdir2, open, readFile as readFile3, rename as rename2, rm as rm2 } from "fs/promises";
+import { appendFile, link, mkdir as mkdir2, open, readFile as readFile4, rename as rename2, rm as rm3 } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname2, join as join2, resolve as resolve3 } from "path";
-import sharp3 from "sharp";
+import { dirname as dirname2, join as join4, resolve as resolve4 } from "path";
+import sharp4 from "sharp";
 import { z as z2 } from "zod";
 async function saveBundle(url, out) {
   const state = await studioRequest(url, "/call", {
@@ -528,7 +2870,7 @@ async function saveBundle(url, out) {
       result.error?.message ?? "The editor could not export a bundle. Refresh it after saving the current draft."
     );
   const pkg = await readPackageJson(result.data);
-  const path = resolve3(out);
+  const path = resolve4(out);
   const file = await open(path, "wx", 384);
   try {
     await file.writeFile(`${JSON.stringify(packageJson(pkg))}
@@ -537,7 +2879,7 @@ async function saveBundle(url, out) {
   } finally {
     await file.close();
   }
-  const saved = await readFile3(path);
+  const saved = await readFile4(path);
   return {
     path,
     bytes: saved.length,
@@ -557,12 +2899,12 @@ var receiptSchema = z2.object({
 });
 
 // src/reference-image.ts
-import { spawnSync } from "child_process";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join as join3, resolve as resolve4 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join5, resolve as resolve5 } from "path";
 import { DOMParser as DOMParser2, XMLSerializer } from "@xmldom/xmldom";
-import sharp4 from "sharp";
+import sharp5 from "sharp";
 import { z as z3 } from "zod";
 var W = 1200;
 var H = 756;
@@ -597,7 +2939,7 @@ function fail(message) {
 }
 var nums = (value, count, name) => {
   const parts = value.split(",").map(Number);
-  if (value.split(",").some((part) => !part.trim())) fail(`${name} contains an empty coordinate.`);
+  if (value.split(",").some((part2) => !part2.trim())) fail(`${name} contains an empty coordinate.`);
   if (parts.length < count || parts.some((v) => !Number.isFinite(v)))
     fail(`${name} needs ${count} comma-separated numbers.`);
   return parts;
@@ -609,7 +2951,7 @@ function validBox(values, width, height) {
 }
 var lumOf = (r, g, b) => 0.299 * r + 0.587 * g + 0.114 * b;
 async function detect(file) {
-  const { data, info } = await sharp4(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const { data, info } = await sharp5(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const { width: w, height: h } = info;
   const px = (x, y) => {
     const i = (y * w + x) * 3;
@@ -685,7 +3027,7 @@ async function detect(file) {
 async function prepare(file, o) {
   if (!o.crop || !o.out) fail('prepare needs --out <dir> and --params with {"crop":"x,y,w,h"}.');
   const [cx, cy, cw, ch] = nums(o.crop, 4, "crop");
-  const meta = await sharp4(file, { limitInputPixels: 24e6 }).metadata();
+  const meta = await sharp5(file, { limitInputPixels: 24e6 }).metadata();
   validBox([cx, cy, cw, ch], meta.width ?? 0, meta.height ?? 0);
   if (Math.abs(cw / ch / (W / H) - 1) > 0.03)
     fail(
@@ -698,12 +3040,12 @@ async function prepare(file, o) {
     if (feather < 0 || ![0, 1].includes(flop))
       fail("Patch feather must be nonnegative and flop must be 0 or 1.");
   }
-  const out = resolve4(o.out);
+  const out = resolve5(o.out);
   mkdirSync(out);
   const layers = [];
   for (const spec of o.patch) {
     const [dx, dy, pw, ph, sx, sy, feather = 6, flop = 0] = nums(spec, 6, "patch");
-    const patch = await sharp4(file).extract({ left: sx, top: sy, width: pw, height: ph }).flop(!!flop).toColourspace("srgb").removeAlpha().raw().toBuffer();
+    const patch = await sharp5(file).extract({ left: sx, top: sy, width: pw, height: ph }).flop(!!flop).toColourspace("srgb").removeAlpha().raw().toBuffer();
     const rgba = Buffer.alloc(pw * ph * 4);
     for (let y = 0; y < ph; y++)
       for (let x = 0; x < pw; x++) {
@@ -715,10 +3057,10 @@ async function prepare(file, o) {
       }
     layers.push({ input: rgba, raw: { width: pw, height: ph, channels: 4 }, left: dx, top: dy });
   }
-  const patched = await sharp4(file).removeAlpha().composite(layers).png().toBuffer();
-  const card = await sharp4(patched).extract({ left: cx, top: cy, width: cw, height: ch }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const patched = await sharp5(file).removeAlpha().composite(layers).png().toBuffer();
+  const card = await sharp5(patched).extract({ left: cx, top: cy, width: cw, height: ch }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const px = card.data, CW = card.info.width, CH = card.info.height;
-  const src = await sharp4(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const src = await sharp5(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const sp = (x, y) => {
     const i = (y * src.info.width + x) * 3;
     return [src.data[i], src.data[i + 1], src.data[i + 2]];
@@ -758,14 +3100,14 @@ async function prepare(file, o) {
     if (y > 0) queue.push(i - CW);
     if (y < CH - 1) queue.push(i + CW);
   }
-  const cardPng = await sharp4(px, { raw: card.info }).png().toBuffer();
-  const resized = sharp4(cardPng).resize(W, H, { fit: "fill", kernel: "lanczos3" });
-  await resized.clone().png().toFile(join3(out, "card.png"));
-  await resized.clone().jpeg({ quality: 84, mozjpeg: true }).toFile(join3(out, "card.jpg"));
-  const rgb = await resized.clone().toColourspace("srgb").raw().toBuffer();
+  const cardPng = await sharp5(px, { raw: card.info }).png().toBuffer();
+  const resized = sharp5(cardPng).resize(W, H, { fit: "fill", kernel: "lanczos3" });
+  await resized.clone().png().toFile(join5(out, "card.png"));
+  await resized.clone().jpeg({ quality: 84, mozjpeg: true }).toFile(join5(out, "card.jpg"));
+  const rgb2 = await resized.clone().toColourspace("srgb").raw().toBuffer();
   const g = await resized.clone().toColourspace("b-w").raw().toBuffer();
-  writeFileSync(join3(out, "rgb.raw"), rgb);
-  writeFileSync(join3(out, "lum.raw"), g);
+  writeFileSync(join5(out, "rgb.raw"), rgb2);
+  writeFileSync(join5(out, "lum.raw"), g);
   const GW = W * 2, GH = H * 2, big = Buffer.alloc(GW * GH);
   for (let y = 0; y < GH; y++) {
     const fy = Math.min(H - 1, Math.max(0, (y + 0.5) / 2 - 0.5)), y0 = Math.floor(fy), y1 = Math.min(H - 1, y0 + 1), ty = fy - y0;
@@ -777,14 +3119,14 @@ async function prepare(file, o) {
       );
     }
   }
-  writeFileSync(join3(out, "ink.pgm"), Buffer.concat([Buffer.from(`P5
+  writeFileSync(join5(out, "ink.pgm"), Buffer.concat([Buffer.from(`P5
 ${GW} ${GH}
 255
 `), big]));
   const hex = paper.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("");
   return {
     out,
-    preview: join3(out, "card.png"),
+    preview: join5(out, "card.png"),
     paper: `#${hex}`,
     patches: o.patch.length,
     filledEdgePixels: filled,
@@ -792,7 +3134,7 @@ ${GW} ${GH}
   };
 }
 function potrace(input, extra) {
-  const r = spawnSync(
+  const r = spawnSync2(
     "potrace",
     [input, "-b", "svg", "-o", "-", "-W", `${W}pt`, "-H", `${H}pt`, ...extra],
     { maxBuffer: 64 << 20 }
@@ -809,11 +3151,11 @@ function potrace(input, extra) {
 }
 var esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 function vectorize(dir, o) {
-  dir = resolve4(dir);
+  dir = resolve5(dir);
   if (!o.out || !o.title) fail("vectorize needs --out <file.svg> and --title");
   const K = Number(o.tones ?? 7);
-  const lum = readFileSync(join3(dir, "lum.raw")), rgb = readFileSync(join3(dir, "rgb.raw"));
-  if (lum.length !== N || rgb.length !== N * 3)
+  const lum = readFileSync2(join5(dir, "lum.raw")), rgb2 = readFileSync2(join5(dir, "rgb.raw"));
+  if (lum.length !== N || rgb2.length !== N * 3)
     fail("Expected an intact directory created by image prepare.");
   let c = [...Array(K)].map((_, i) => 30 + i * 200 / (K - 1));
   const band = new Uint8Array(N);
@@ -851,9 +3193,9 @@ function vectorize(dir, o) {
     let r = 0, g = 0, b = 0, n = 0;
     for (let i = 0; i < N; i++)
       if (band[i] === k) {
-        r += rgb[i * 3];
-        g += rgb[i * 3 + 1];
-        b += rgb[i * 3 + 2];
+        r += rgb2[i * 3];
+        g += rgb2[i * 3 + 1];
+        b += rgb2[i * 3 + 2];
         n++;
       }
     const h = (v) => Math.round(v / Math.max(n, 1)).toString(16).padStart(2, "0");
@@ -862,11 +3204,11 @@ function vectorize(dir, o) {
   const L = used.length;
   const inkK = o.ink !== void 0 ? Number(o.ink) : L > 1 ? (c[used[0]] + c[used[1]]) / 2 / 255 : 0.25;
   const groups = [];
-  const maskFile = join3(dir, "mask.pbm");
+  const maskFile = join5(dir, "mask.pbm");
   for (let j = o.raster ? 0 : L - 2; j >= 0; j--) {
     let traced;
     if (j === 0) {
-      traced = potrace(join3(dir, "ink.pgm"), [
+      traced = potrace(join5(dir, "ink.pgm"), [
         "-k",
         inkK.toFixed(4),
         "-t",
@@ -889,7 +3231,7 @@ ${W} ${H}
     if (traced) groups.push(`<g transform="${traced.tr}" fill="${colors[j]}">${traced.paths}</g>`);
   }
   const base = o.raster ? `<rect width="${W}" height="${H}" fill="${colors[L - 1]}"/>
-<image width="${W}" height="${H}" preserveAspectRatio="none" href="data:image/jpeg;base64,${readFileSync(join3(dir, "card.jpg")).toString("base64")}"/>` : `<rect width="${W}" height="${H}" fill="${colors[L - 1]}"/>`;
+<image width="${W}" height="${H}" preserveAspectRatio="none" href="data:image/jpeg;base64,${readFileSync2(join5(dir, "card.jpg")).toString("base64")}"/>` : `<rect width="${W}" height="${H}" fill="${colors[L - 1]}"/>`;
   const title = esc(o.title), desc = esc(o.desc ?? `${o.title} card artwork.`);
   const meta = esc(o.credit ?? "Original artwork traced from a reference image.");
   const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" role="img" aria-label="${desc}">
@@ -902,9 +3244,9 @@ ${groups.join("\n")}
 `;
   const checked = checkSubmittedSvg(svg);
   if (!checked.ok) fail(checked.error);
-  writeFileSync(resolve4(o.out), svg, { flag: "wx" });
+  writeFileSync(resolve5(o.out), svg, { flag: "wx" });
   return {
-    out: resolve4(o.out),
+    out: resolve5(o.out),
     bytes: Buffer.byteLength(svg),
     mode: o.raster ? "raster background + vector ink" : "pure vector",
     tones: colors,
@@ -912,7 +3254,7 @@ ${groups.join("\n")}
   };
 }
 async function rawImage(file) {
-  const { data, info } = await sharp4(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const { data, info } = await sharp5(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const px = (x, y) => {
     if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= info.width || y >= info.height)
       fail("Pixel coordinates are outside the image.");
@@ -1011,19 +3353,19 @@ async function glyphs(file, o) {
   if (!o.box || !o.at) fail("glyphs needs --box x,y,w,h and --at X,Y");
   const [bx, by, bw, bh] = nums(o.box, 4, "box");
   const [ax, ay] = nums(o.at, 2, "at");
-  const meta = await sharp4(file, { limitInputPixels: 24e6 }).metadata();
+  const meta = await sharp5(file, { limitInputPixels: 24e6 }).metadata();
   validBox([bx, by, bw, bh], meta.width ?? 0, meta.height ?? 0);
   const up = Number(o.up ?? 4);
   if (bw * bh * up * up > 24e6)
     fail("Trace region is too large; lower up or choose a smaller box.");
-  const { data, info } = await sharp4(file).extract({ left: bx, top: by, width: bw, height: bh }).greyscale().removeAlpha().resize({ width: bw * up, kernel: "lanczos3" }).raw().toBuffer({ resolveWithObject: true });
-  const temp = mkdtempSync(join3(tmpdir(), "makeables-glyphs-"));
-  const pgm = join3(temp, "glyphs.pgm");
+  const { data, info } = await sharp5(file).extract({ left: bx, top: by, width: bw, height: bh }).greyscale().removeAlpha().resize({ width: bw * up, kernel: "lanczos3" }).raw().toBuffer({ resolveWithObject: true });
+  const temp = mkdtempSync(join5(tmpdir2(), "makeables-glyphs-"));
+  const pgm = join5(temp, "glyphs.pgm");
   writeFileSync(pgm, Buffer.concat([Buffer.from(`P5
 ${info.width} ${info.height}
 255
 `), data]));
-  const r = spawnSync(
+  const r = spawnSync2(
     "potrace",
     [pgm, "-b", "svg", "-o", "-", "-k", String(o.k ?? 0.5), "-t", "2", "-a", "1", "-O", "0.3"],
     { maxBuffer: 64 << 20 }
@@ -1037,18 +3379,18 @@ ${info.width} ${info.height}
   const paths = [...svg.matchAll(/ d="([^"]+)"/g)].map((m) => m[1].replace(/\s+/g, " ")).join(" ");
   if (!tr || !paths) fail("nothing dark enough to trace in that box; lower --k or check the box");
   const snippet = `<g transform="translate(${ax} ${ay}) scale(${+(1 / up).toFixed(6)})"><path transform="${tr}" fill="${o.fill ?? "#0a0a0a"}" fill-rule="evenodd" d="${paths}"/></g>`;
-  if (o.out) writeFileSync(resolve4(o.out), snippet, { flag: "wx" });
+  if (o.out) writeFileSync(resolve5(o.out), snippet, { flag: "wx" });
   return {
     box: { x: bx, y: by, w: bw, h: bh },
     at: { x: ax, y: ay },
     bytes: snippet.length,
-    out: o.out ? resolve4(o.out) : null,
+    out: o.out ? resolve5(o.out) : null,
     snippet: o.out ? void 0 : snippet
   };
 }
 function rotate(file, o) {
   if (!o.out) fail("rotate needs --out <card.svg>");
-  const text = readFileSync(file, "utf8");
+  const text = readFileSync2(file, "utf8");
   const parser = new DOMParser2({ onError: (_level, message) => fail(`Malformed SVG: ${message}`) });
   if (/<!DOCTYPE|<!ENTITY/i.test(text)) fail("SVG declarations are not supported.");
   const root = parser.parseFromString(text, "image/svg+xml").documentElement;
@@ -1064,28 +3406,28 @@ function rotate(file, o) {
   const svg = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}"><g transform="${transform}"><g${inherited}>${body}</g></g></svg>`;
   const checked = checkSubmittedSvg(svg);
   if (!checked.ok) fail(checked.error);
-  writeFileSync(resolve4(o.out), svg, { flag: "wx" });
-  return { out: resolve4(o.out), transform, bytes: Buffer.byteLength(svg) };
+  writeFileSync(resolve5(o.out), svg, { flag: "wx" });
+  return { out: resolve5(o.out), transform, bytes: Buffer.byteLength(svg) };
 }
 async function compare(file, ref, o) {
   if (!o.out) fail("compare needs --out <file.png>");
-  let card = sharp4(readFileSync(file));
+  let card = sharp5(readFileSync2(file));
   if (o.upright) card = card.rotate(o.upright === "left" ? 90 : -90);
   const cardPng = await card.png().toBuffer();
-  let reference = sharp4(ref);
+  let reference = sharp5(ref);
   if (o["ref-box"]) {
     const [x, y, w, h] = nums(o["ref-box"], 4, "ref-box");
     reference = reference.extract({ left: x, top: y, width: w, height: h });
   }
   const height = 900;
-  const a = await sharp4(cardPng).resize({ height }).png().toBuffer({ resolveWithObject: true });
-  const b = await sharp4(await reference.png().toBuffer()).resize({ height }).png().toBuffer({ resolveWithObject: true });
+  const a = await sharp5(cardPng).resize({ height }).png().toBuffer({ resolveWithObject: true });
+  const b = await sharp5(await reference.png().toBuffer()).resize({ height }).png().toBuffer({ resolveWithObject: true });
   const gap = 24, width = a.info.width + b.info.width + gap * 3;
-  await sharp4({ create: { width, height: height + gap * 2, channels: 3, background: "#ffffff" } }).composite([
+  await sharp5({ create: { width, height: height + gap * 2, channels: 3, background: "#ffffff" } }).composite([
     { input: a.data, left: gap, top: gap },
     { input: b.data, left: a.info.width + gap * 2, top: gap }
-  ]).png().toFile(resolve4(o.out));
-  return { out: resolve4(o.out), left: "card", right: "reference" };
+  ]).png().toFile(resolve5(o.out));
+  return { out: resolve5(o.out), left: "card", right: "reference" };
 }
 var imageTools = [
   "detect",
@@ -1105,8 +3447,8 @@ async function referenceImage(command, file, options, out, reference) {
       parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
     );
   const o = { ...parsed.data, out };
-  if (out && existsSync(resolve4(out))) fail("Output already exists. Choose a new --out path.");
-  if (!existsSync(file)) fail("Input file does not exist.");
+  if (out && existsSync2(resolve5(out))) fail("Output already exists. Choose a new --out path.");
+  if (!existsSync2(file)) fail("Input file does not exist.");
   switch (command) {
     case "detect":
       return detect(file);
@@ -1134,10 +3476,10 @@ async function referenceImage(command, file, options, out, reference) {
 }
 
 // src/sticker-cut.ts
-import sharp5 from "sharp";
+import sharp6 from "sharp";
 async function stickerPrintCut(design) {
   const { png } = await renderBadge(design, { face: "front", person: {} });
-  const { data, info } = await sharp5(png).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  const { data, info } = await sharp6(png).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
   const material = design.sticker ?? defaultStickerMaterial;
   const cut = stickerCut(
     new Uint8ClampedArray(data.buffer, data.byteOffset, data.length),
@@ -1150,9 +3492,9 @@ async function stickerPrintCut(design) {
 }
 
 // src/sticker-material.ts
-import { readFile as readFile4, stat as stat3 } from "fs/promises";
+import { readFile as readFile5, stat as stat3 } from "fs/promises";
 import { basename as basename2 } from "path";
-import sharp6 from "sharp";
+import sharp7 from "sharp";
 async function bindStickerMap(design, layerId, path) {
   if (design.product !== "sticker") throw new InputError("Optical maps require a sticker.");
   const layer = design.front.layers.find((layer2) => layer2.id === layerId);
@@ -1160,8 +3502,8 @@ async function bindStickerMap(design, layerId, path) {
   const info = await stat3(path);
   if (!info.isFile() || info.size > 4e6)
     throw new InputError("Use an optical image below 4 MB.");
-  const bytes = await readFile4(path);
-  const meta = await sharp6(bytes, { limitInputPixels: 16777216 }).metadata();
+  const bytes = await readFile5(path);
+  const meta = await sharp7(bytes, { limitInputPixels: 16777216 }).metadata();
   if (!meta.width || !meta.height || meta.width > 4096 || meta.height > 4096 || !["png", "webp"].includes(meta.format ?? ""))
     throw new InputError("Use an RGB PNG or WebP optical map up to 4096 \xD7 4096.");
   const asset = design.sticker?.effectMap?.asset ?? "optical-map";
@@ -1208,9 +3550,9 @@ function compactReceipt(value) {
   if (Array.isArray(value)) return value.map(compactReceipt);
   if (value && typeof value === "object")
     return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [
-        key,
-        key === "design" && entry && typeof entry === "object" ? {
+      Object.entries(value).map(([key2, entry]) => [
+        key2,
+        key2 === "design" && entry && typeof entry === "object" ? {
           name: "name" in entry ? entry.name : void 0,
           product: "product" in entry ? entry.product : "badge",
           omitted: true
@@ -1224,11 +3566,11 @@ function compactReceipt(value) {
 // src/wallet.ts
 import { spawn } from "child_process";
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync2 } from "fs";
-import { chmod as chmod2, lstat as lstat3, mkdir as mkdir4, mkdtemp as mkdtemp3, readFile as readFile6, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
-import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname4, extname as extname3, join as join7, resolve as resolve6 } from "path";
-import sharp7 from "sharp";
+import { existsSync as existsSync3 } from "fs";
+import { chmod as chmod2, lstat as lstat3, mkdir as mkdir4, mkdtemp as mkdtemp4, readFile as readFile7, rename as rename4, rm as rm6, writeFile as writeFile4 } from "fs/promises";
+import { homedir as homedir3, tmpdir as tmpdir3 } from "os";
+import { dirname as dirname4, extname as extname3, join as join9, resolve as resolve7 } from "path";
+import sharp8 from "sharp";
 
 // src/wallet-release.json
 var wallet_release_default = {
@@ -1250,16 +3592,16 @@ var wallet_release_default = {
 // src/wallet-storage.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { constants as constants3 } from "fs";
-import { chmod, lstat, mkdir as mkdir3, open as open3, rename as rename3, rm as rm3 } from "fs/promises";
+import { chmod, lstat, mkdir as mkdir3, open as open3, rename as rename3, rm as rm4 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join4, resolve as resolve5 } from "path";
+import { dirname as dirname3, join as join6, resolve as resolve6 } from "path";
 function walletHome() {
-  return resolve5(
-    process.env.MAKEABLES_WALLET_HOME ?? join4(homedir2(), "Library", "Application Support", "Makeables", "Wallet")
+  return resolve6(
+    process.env.MAKEABLES_WALLET_HOME ?? join6(homedir2(), "Library", "Application Support", "Makeables", "Wallet")
   );
 }
 async function privateDirectory(path) {
-  const absolute = resolve5(path);
+  const absolute = resolve6(path);
   const parent = dirname3(absolute);
   if (parent !== absolute) {
     try {
@@ -1289,7 +3631,7 @@ async function readPrivateJson(path) {
   }
 }
 async function writePrivateJson(path, value) {
-  const temporary = join4(dirname3(path), `.${randomUUID2()}.json`);
+  const temporary = join6(dirname3(path), `.${randomUUID2()}.json`);
   try {
     const handle = await open3(temporary, "wx", 384);
     try {
@@ -1301,13 +3643,13 @@ async function writePrivateJson(path, value) {
     }
     await rename3(temporary, path);
   } finally {
-    await rm3(temporary, { force: true });
+    await rm4(temporary, { force: true });
   }
 }
 
 // src/wallet-submission.ts
-import { mkdtemp as mkdtemp2, readFile as readFile5, rm as rm4, writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdtemp as mkdtemp3, readFile as readFile6, rm as rm5, writeFile as writeFile3 } from "fs/promises";
+import { join as join7 } from "path";
 var uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function submissionId(input) {
   if (uuid.test(input)) return input.toLowerCase();
@@ -1355,16 +3697,16 @@ async function downloadWalletSubmission(input) {
   const pkg = await readPackageZip(bytes);
   if (pkg.manifest.product !== "card")
     throw new InputError("Wallet artwork requires a card submission.");
-  const directory = await mkdtemp2(
-    join5(
-      await privateDirectory(join5(await privateDirectory(walletHome()), "submissions")),
+  const directory = await mkdtemp3(
+    join7(
+      await privateDirectory(join7(await privateDirectory(walletHome()), "submissions")),
       "download-"
     )
   );
   try {
-    const path = join5(directory, `${id}.makeables.zip`);
+    const path = join7(directory, `${id}.makeables.zip`);
     await writeFile3(path, bytes, { mode: 384, flag: "wx" });
-    const saved = await readFile5(path);
+    const saved = await readFile6(path);
     const sha256 = await hashBytes(saved);
     if (saved.length !== bytes.length || sha256 !== await hashBytes(bytes))
       throw new Error("Saved submission checksum does not match.");
@@ -1378,14 +3720,14 @@ async function downloadWalletSubmission(input) {
       elapsedMs: Math.round(performance.now() - started2)
     };
   } catch (error) {
-    await rm4(directory, { recursive: true, force: true });
+    await rm5(directory, { recursive: true, force: true });
     throw error;
   }
 }
 
 // src/wallet-targets.ts
 import { lstat as lstat2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import lockfile from "proper-lockfile";
 import { z as z4 } from "zod";
 var alias = z4.string().regex(/^[a-z][a-z0-9-]{0,47}$/).refine((value) => !/\d{5}/.test(value));
@@ -1403,25 +3745,25 @@ var targetSchema = z4.object({
   createdAt: z4.string().datetime()
 }).strict();
 var registrySchema = z4.object({ version: z4.literal(1), targets: z4.array(targetSchema).max(100) }).strict();
-function targetIdentity(values, key = "remember") {
+function targetIdentity(values, key2 = "remember") {
   const result = targetSchema.pick({ target: true, label: true, last4: true }).safeParse({
-    target: values[key],
+    target: values[key2],
     label: values.label,
     last4: values.last4
   });
   if (!result.success)
     throw new InputError(
-      `Supply --${key} with a lowercase alias and --label with the user-confirmed card name. Optional --last4 must be exactly four digits; never supply a full card number.`
+      `Supply --${key2} with a lowercase alias and --label with the user-confirmed card name. Optional --last4 must be exactly four digits; never supply a full card number.`
     );
   return result.data;
 }
 function registryPath() {
-  return join6(walletHome(), "targets", "registry.json");
+  return join8(walletHome(), "targets", "registry.json");
 }
 async function walletTargets() {
   const path = registryPath();
   try {
-    for (const parent of [walletHome(), join6(walletHome(), "targets")]) {
+    for (const parent of [walletHome(), join8(walletHome(), "targets")]) {
       if (!(await lstat2(parent)).isDirectory())
         throw new InputError("Invalid Wallet target storage.");
     }
@@ -1444,7 +3786,7 @@ function targetChoices(targets) {
   }));
 }
 async function withWalletTargets(action) {
-  const directory = await privateDirectory(join6(await privateDirectory(walletHome()), "targets"));
+  const directory = await privateDirectory(join8(await privateDirectory(walletHome()), "targets"));
   const release = await lockfile.lock(directory, { realpath: false, retries: 0 });
   try {
     return await action(await walletTargets(), async (targets) => {
@@ -1473,9 +3815,9 @@ var WalletError = class extends Error {
 };
 function installation() {
   const platform = `${process.platform}-${process.arch}`;
-  const cache = process.env.MAKEABLES_WALLET_CACHE ?? join7(homedir3(), "Library", "Caches", "Makeables", "wallet");
-  const root = resolve6(cache, `${wallet_release_default.version}-${platform}`);
-  return { platform, root, executable: join7(root, "makeables-wallet", "makeables-wallet") };
+  const cache = process.env.MAKEABLES_WALLET_CACHE ?? join9(homedir3(), "Library", "Caches", "Makeables", "wallet");
+  const root = resolve7(cache, `${wallet_release_default.version}-${platform}`);
+  return { platform, root, executable: join9(root, "makeables-wallet", "makeables-wallet") };
 }
 async function execute(command, args, progress) {
   return new Promise((accept, reject) => {
@@ -1542,7 +3884,7 @@ async function walletDoctor() {
       supported: false,
       reason: "Wallet artwork requires a Mac and an iPhone connected by USB."
     };
-  if (!existsSync2(installed))
+  if (!existsSync3(installed))
     return {
       ready: false,
       supported: true,
@@ -1572,7 +3914,7 @@ async function setupWallet(progress) {
     return info;
   }
   const { platform, root, executable } = installation();
-  if (existsSync2(executable)) {
+  if (existsSync3(executable)) {
     const info = await walletDoctor();
     if (!info.ready)
       throw new InputError("The installed Wallet companion is incomplete or incompatible.");
@@ -1607,9 +3949,9 @@ async function setupWallet(progress) {
   if (createHash3("sha256").update(bytes).digest("hex") !== artifact.sha256)
     throw new Error("Wallet companion checksum did not match. Nothing was installed.");
   await mkdir4(dirname4(root), { recursive: true, mode: 448 });
-  const stage = await mkdtemp3(join7(dirname4(root), ".install-"));
+  const stage = await mkdtemp4(join9(dirname4(root), ".install-"));
   try {
-    const archive = join7(stage, "companion.tar.gz");
+    const archive = join9(stage, "companion.tar.gz");
     await writeFile4(archive, bytes, { mode: 384, flag: "wx" });
     const members = (await execute("tar", ["-tzf", archive])).trim().split("\n");
     if (members.some(
@@ -1617,19 +3959,19 @@ async function setupWallet(progress) {
     ))
       throw new Error("Unexpected companion archive contents.");
     await execute("tar", ["-xzf", archive, "-C", stage]);
-    await rm5(archive);
-    await chmod2(join7(stage, "makeables-wallet", "makeables-wallet"), 448);
-    const info = await invoke(join7(stage, "makeables-wallet", "makeables-wallet"), ["version"]);
+    await rm6(archive);
+    await chmod2(join9(stage, "makeables-wallet", "makeables-wallet"), 448);
+    const info = await invoke(join9(stage, "makeables-wallet", "makeables-wallet"), ["version"]);
     if (info.version !== wallet_release_default.version || info.protocol !== wallet_release_default.protocol)
       throw new Error("Companion version does not match the installed CLI.");
     await rename4(stage, root);
   } finally {
-    await rm5(stage, { recursive: true, force: true });
+    await rm6(stage, { recursive: true, force: true });
   }
   return walletDoctor();
 }
 async function walletArtwork(file, side2 = "front") {
-  const input = resolve6(file);
+  const input = resolve7(file);
   const info = await lstat3(input);
   if (!info.isFile() || info.size > 336e5)
     throw new InputError("Expected artwork or a complete Makeables package below 32 MB.");
@@ -1642,16 +3984,16 @@ async function walletArtwork(file, side2 = "front") {
     if (!path) throw new InputError("This package has no back artwork.");
     source = Buffer.from(pkg.files[path]);
   } else {
-    source = await readFile6(input);
+    source = await readFile7(input);
     if (extname3(input).toLowerCase() === ".svg") {
       const result = checkSubmittedSvg(source.toString("utf8"));
       if (!result.ok) throw new InputError(result.error);
     }
   }
-  return sharp7(source, { limitInputPixels: 24e6, density: 144 }).rotate().resize(1536, 969, { fit: "contain", background: "#000000" }).flatten({ background: "#000000" }).toColourspace("srgb").png().toBuffer();
+  return sharp8(source, { limitInputPixels: 24e6, density: 144 }).rotate().resize(1536, 969, { fit: "contain", background: "#000000" }).flatten({ background: "#000000" }).toColourspace("srgb").png().toBuffer();
 }
 async function preparedArtwork(directory) {
-  const path = resolve6(directory);
+  const path = resolve7(directory);
   if (!(await lstat3(path)).isDirectory())
     throw new InputError("--assets must be a prepared artwork directory.");
   for (const name of [
@@ -1659,15 +4001,15 @@ async function preparedArtwork(directory) {
     "cardBackgroundCombined@2x.png",
     "cardBackgroundCombined.pdf"
   ]) {
-    const file = join7(path, name);
+    const file = join9(path, name);
     const info = await lstat3(file);
     if (!info.isFile() || info.size === 0 || info.size > 16 * 1024 * 1024)
       throw new InputError(`Invalid prepared asset: ${name}. Run wallet prep again.`);
     const signature = Buffer.from(name.endsWith(".pdf") ? "%PDF-" : "\x89PNG\r\n\n", "latin1");
-    if (!(await readFile6(file)).subarray(0, signature.length).equals(signature))
+    if (!(await readFile7(file)).subarray(0, signature.length).equals(signature))
       throw new InputError(`Invalid prepared asset: ${name}. Run wallet prep again.`);
   }
-  return { path, preview: join7(path, "cardBackgroundCombined@3x.png") };
+  return { path, preview: join9(path, "cardBackgroundCombined@3x.png") };
 }
 async function walletCommand(command, values, progress) {
   if (values.remember) {
@@ -1877,7 +4219,7 @@ async function runWalletCommand(command, values, progress) {
     }
   }
   if (command === "wallet prep" || applying || installing) {
-    const work = await mkdtemp3(join7(tmpdir2(), "makeables-wallet-"));
+    const work = await mkdtemp4(join9(tmpdir3(), "makeables-wallet-"));
     let phase = "prepare";
     let deviceWriteAttempted = false;
     let persistent;
@@ -1885,23 +4227,23 @@ async function runWalletCommand(command, values, progress) {
     try {
       let target;
       if (existing) {
-        target = resolve6(need("assets"));
+        target = resolve7(need("assets"));
         prepared = existing;
       } else {
         report("prepare", "Preparing the complete card artwork.");
         const png = await walletArtwork(need("file"), values.side === "back" ? "back" : "front");
-        const raster = join7(work, "artwork.png");
+        const raster = join9(work, "artwork.png");
         await writeFile4(raster, png, { mode: 384 });
         if (command === "wallet prep") {
-          target = resolve6(need("out"));
+          target = resolve7(need("out"));
         } else if (installing && !applying) {
           const root = await privateDirectory(
-            join7(await privateDirectory(walletHome()), "prepared")
+            join9(await privateDirectory(walletHome()), "prepared")
           );
-          persistent = await mkdtemp3(join7(root, "install-"));
-          target = join7(persistent, "assets");
+          persistent = await mkdtemp4(join9(root, "install-"));
+          target = join9(persistent, "assets");
         } else {
-          target = join7(work, "assets");
+          target = join9(work, "assets");
         }
         prepared = await invoke(
           executable,
@@ -1987,8 +4329,8 @@ async function runWalletCommand(command, values, progress) {
       }
       throw error;
     } finally {
-      await rm5(work, { recursive: true, force: true });
-      if (persistent && phase === "prepare") await rm5(persistent, { recursive: true, force: true });
+      await rm6(work, { recursive: true, force: true });
+      if (persistent && phase === "prepare") await rm6(persistent, { recursive: true, force: true });
     }
   }
   throw new InputError("Unknown Wallet command.");
@@ -2039,6 +4381,16 @@ function walletSummary(result) {
 
 // src/cli.ts
 var commands = [
+  "preflight [--probe]",
+  "badge package --file <badge.json> --photo <portrait> --name <name> --out <badge.makeables.json> [--role] [--organization] [--number] [--event] [--url <https://...>]",
+  "brand new --name <brand> --out <brand.json> [--slug <slug>]",
+  "brand from-url --url <https://event-or-site> (--out <new-directory> | --file <brand.json>) [--name <brand>] [--slug <slug>]",
+  "brand add-kit --file <brand.json> --ref <kit.json|kit.makeables.zip> --id <kit-id> [--family <family-id>]",
+  "brand add-logo --file <brand.json> --ref <logo.svg|logo.png> --id <logo-id> [--name <label>]",
+  "brand inspect --file <brand.json>",
+  "brand export --file <brand.json> --out <brand.makeables.zip> [--overwrite]",
+  "brand preview --file <brand.json> [--site <origin>] [--no-open]",
+  "kit check --file <kit.json> --brand <brand.json>",
   "kit new --name <title> --out <kit.json>",
   "kit extract --file <artwork-sheet.png> --out <new-directory> [--params <json|@file>]",
   "kit add --file <kit.json> --ref <design|package> --id <piece-id>",
@@ -2048,13 +4400,14 @@ var commands = [
   "kit export --file <kit.json|kit.makeables.zip> --out <kit.makeables.zip> [--overwrite]",
   "kit import --file <kit.makeables.zip> --out <new-directory>",
   "designs list",
-  "new card --design <slug> | --style <id> --out <new-file> [--dry-run]",
+  "new card --design <slug> | --style <id> | --blank [--name <title>] --out <new-file> [--dry-run]",
   "material set --file <design.json> --params <json|@file>",
   "material map --file <sticker.json> --id <image-layer> --ref <optical.png|optical.webp>",
-  "new badge --style <id> --out <new-file> [--dry-run]",
-  "new sticker --style <id> --out <new-file> [--dry-run]",
+  "new badge (--style <id> | --blank [--name <title>]) --out <new-file> [--dry-run]",
+  "new sticker (--style <id> | --blank [--name <title>]) --out <new-file> [--dry-run]",
   "layer list --file <design.json>",
   "layer add --file <design.json> --sticker <petdex:slug|path> [--side front|back] [--relative-to document|cwd]",
+  "layer add --file <design.json> --kind text|shape|graphic|qr [--params <json|@file>] [--side front|back]",
   "layer set --file <design.json> --id <layer> [--side front|back] [--x --y --rotation] [--params <json|@file>]",
   "layer remove --file <design.json> --id <layer> [--side front|back]",
   "cut --file <sticker.json> [--out <cut.svg>] [--overwrite]",
@@ -2063,6 +4416,17 @@ var commands = [
   "sheet pack --file <sheet.json>",
   "sheet check --file <sheet.json>",
   "sheet export --file <sheet.json> --out <sheet.pdf> [--preview <proof.png>] [--overwrite]",
+  "brick part --id <ldraw-id> [--library <ldraw-dir>]",
+  "brick check --file <model.ldr> [--library <ldraw-dir>]",
+  "brick plan --file <model.ldr> [--library <ldraw-dir>]",
+  "brick stress --file <model.ldr> [--library <ldraw-dir>]",
+  "brick remix --file <exemplar.ldr> --seed <n> --out <new.ldr> [--mode strict|family|free] [--library <ldraw-dir>]",
+  "brick stl --file <model.ldr> --out <file.stl> [--scale <factor>] [--library <ldraw-dir>] [--overwrite]",
+  "print list",
+  "print <object> [--param <name=value>]... [--brand <slug|brand.json>] --out <file.stl|file.3mf> [--colors <body,label>] [--preview <views.png>] [--overwrite]",
+  "grid bin --width <cells> --depth <cells> --height <units> --out <file.stl> [--overwrite]",
+  "grid plate --width <cells> --depth <cells> --out <file.stl> [--overwrite]",
+  "brick render --file <model.ldr> --out <png> [--step <n>] [--explode <factor>] [--yaw=<deg>] [--pitch=<deg>] [--library <ldraw-dir>] [--overwrite]",
   "render --file <design.json|design.makeables.json> --out <png> [--appearance flat|material] [--side front|back] [--photo <image>] [--name --role --number] [--overwrite]",
   "validate --file <design.json|artwork.svg> [--out <preview.png>]",
   "new card --file <artwork.svg|image.png> --out <card.json> [--name <title>]",
@@ -2127,7 +4491,7 @@ function emit(data, next, human, json) {
   );
 }
 async function newPath(file) {
-  const path = resolve7(file);
+  const path = resolve8(file);
   try {
     await lstat4(path);
     throw new InputError(`File already exists: ${path}. Choose a new --out path.`);
@@ -2138,7 +4502,10 @@ async function newPath(file) {
   return path;
 }
 async function run() {
-  const { values, positionals } = parseArgs({
+  const {
+    values: { param: printParams, ...values },
+    positionals
+  } = parseArgs({
     allowPositionals: true,
     strict: true,
     options: {
@@ -2162,6 +4529,7 @@ async function run() {
       port: { type: "string" },
       url: { type: "string" },
       params: { type: "string" },
+      param: { type: "string", multiple: true },
       state: { type: "string" },
       target: { type: "string" },
       yes: { type: "boolean" },
@@ -2193,8 +4561,28 @@ async function run() {
       size: { type: "string" },
       "width-mm": { type: "string" },
       preview: { type: "string" },
+      library: { type: "string" },
+      step: { type: "string" },
+      explode: { type: "string" },
+      yaw: { type: "string" },
+      pitch: { type: "string" },
+      seed: { type: "string" },
+      scale: { type: "string" },
+      width: { type: "string" },
+      depth: { type: "string" },
+      height: { type: "string" },
+      mode: { type: "string" },
       appearance: { type: "string" },
       "relative-to": { type: "string" },
+      slug: { type: "string" },
+      family: { type: "string" },
+      brand: { type: "string" },
+      colors: { type: "string" },
+      probe: { type: "boolean" },
+      blank: { type: "boolean" },
+      kind: { type: "string" },
+      organization: { type: "string" },
+      event: { type: "string" },
       compact: { type: "boolean" },
       trace: { type: "string" }
     }
@@ -2228,12 +4616,33 @@ From a built checkout: npm run studio -- <command>`,
     );
     return;
   }
-  const command = ["skills get", "studio call"].includes(positionals.slice(0, 2).join(" ")) ? positionals.slice(0, 2).join(" ") : positionals.join(" ");
+  const printTarget = positionals[0] === "print" && positionals.length === 2 && positionals[1] !== "list" ? positionals[1] : void 0;
+  const command = printTarget ? "print <object>" : ["skills get", "studio call"].includes(positionals.slice(0, 2).join(" ")) ? positionals.slice(0, 2).join(" ") : positionals.join(" ");
   const allowed = {
     "kit new": ["name", "out"],
     "kit extract": ["file", "out", "params"],
     "kit add": ["file", "ref", "id"],
     "kit sheet": ["file", "ref", "id"],
+    "kit check": ["file", "brand"],
+    preflight: ["probe"],
+    "badge package": [
+      "file",
+      "photo",
+      "name",
+      "role",
+      "organization",
+      "number",
+      "event",
+      "url",
+      "out"
+    ],
+    "brand new": ["name", "slug", "out"],
+    "brand from-url": ["url", "out", "file", "name", "slug"],
+    "brand add-kit": ["file", "ref", "id", "family"],
+    "brand add-logo": ["file", "ref", "id", "name"],
+    "brand inspect": ["file"],
+    "brand export": ["file", "out", "overwrite"],
+    "brand preview": ["file", "site", "no-open"],
     "kit inspect": ["file"],
     "kit render": ["file", "out", "overwrite"],
     "kit export": ["file", "out", "overwrite"],
@@ -2310,13 +4719,13 @@ From a built checkout: npm run studio -- <command>`,
     "design create": ["style", "out", "dry-run"],
     "design validate": ["file"],
     "designs list": [],
-    "new card": ["design", "style", "file", "name", "out", "dry-run"],
-    "new sticker": ["style", "out", "dry-run"],
+    "new card": ["design", "style", "file", "blank", "name", "out", "dry-run"],
+    "new sticker": ["style", "blank", "name", "out", "dry-run"],
     "material set": ["file", "params"],
     "material map": ["file", "id", "ref"],
-    "new badge": ["style", "out", "dry-run"],
+    "new badge": ["style", "blank", "name", "out", "dry-run"],
     "layer list": ["file"],
-    "layer add": ["file", "sticker", "side", "relative-to"],
+    "layer add": ["file", "sticker", "kind", "params", "side", "relative-to"],
     "layer set": ["file", "id", "x", "y", "rotation", "side", "params"],
     "layer remove": ["file", "id", "side"],
     cut: ["file", "out", "overwrite"],
@@ -2325,6 +4734,17 @@ From a built checkout: npm run studio -- <command>`,
     "sheet pack": ["file"],
     "sheet check": ["file"],
     "sheet export": ["file", "out", "preview", "overwrite"],
+    "brick part": ["id", "library"],
+    "brick check": ["file", "library"],
+    "brick plan": ["file", "library"],
+    "brick stress": ["file", "library"],
+    "brick render": ["file", "out", "step", "explode", "yaw", "pitch", "library", "overwrite"],
+    "brick remix": ["file", "seed", "out", "mode", "library"],
+    "brick stl": ["file", "out", "scale", "library", "overwrite"],
+    "print list": [],
+    "print <object>": ["out", "brand", "colors", "preview", "overwrite"],
+    "grid bin": ["width", "depth", "height", "out", "overwrite"],
+    "grid plate": ["width", "depth", "out", "overwrite"],
     render: ["file", "out", "overwrite", "side", "photo", "name", "role", "number", "appearance"],
     validate: ["file", "out"]
   };
@@ -2333,16 +4753,162 @@ From a built checkout: npm run studio -- <command>`,
   for (const flag of Object.keys(values))
     if (!["json", "help", "version", "compact", "trace", ...allowed[command]].includes(flag))
       throw new InputError(`--${flag} is not supported by ${command}`);
+  if (printParams && command !== "print <object>")
+    throw new InputError(`--param is not supported by ${command}`);
   const progress = (data) => process.stderr.write(`${JSON.stringify(data)}
 `);
   if (values.product && !["card", "badge", "sticker"].includes(values.product))
     throw new InputError("--product must be card, badge or sticker.");
+  if (command === "badge package") {
+    const need = (value, flag) => {
+      if (!value) throw new InputError(`Supply --${flag}.`);
+      return value;
+    };
+    const out = await newPath(need(values.out, "out"));
+    if (!out.endsWith(".makeables.json"))
+      throw new InputError("--out must end in .makeables.json.");
+    const { badgePackage } = await import("./badge-package-RBQ43DQX.js");
+    const { json: body, participant } = await badgePackage(
+      need(values.file, "file"),
+      need(values.photo, "photo"),
+      {
+        name: need(values.name, "name"),
+        role: values.role,
+        organization: values.organization,
+        number: values.number ? Number(values.number) : void 0,
+        event: values.event,
+        url: values.url
+      }
+    );
+    await writeAtomic(out, JSON.stringify(body), true);
+    emit(
+      {
+        path: out,
+        participant: {
+          name: participant.name,
+          role: participant.role,
+          publicUrl: participant.publicUrl
+        }
+      },
+      [`makeables kit add --file <kit.json> --ref ${JSON.stringify(out)} --id badge`],
+      `Badge package ready: ${out}`,
+      json
+    );
+    return;
+  }
+  if (command === "preflight") {
+    const result2 = await preflight({ probe: Boolean(values.probe) });
+    emit(result2, ["makeables skills get kits"], preflightSummary(result2), json);
+    return;
+  }
+  if (command.startsWith("brand ")) {
+    const need = (value, flag) => {
+      if (!value) throw new InputError(`Supply --${flag}.`);
+      return value;
+    };
+    let result2;
+    let human = "Brand ready.";
+    if (command === "brand new") {
+      const path2 = await newPath(need(values.out, "out"));
+      const brand = newBrand(need(values.name, "name"), values.slug);
+      await writeBrand(path2, brand);
+      result2 = { path: path2, brand };
+    } else if (command === "brand from-url") {
+      const out = resolve8(values.file ? dirname5(values.file) : need(values.out, "out"));
+      if (!values.file)
+        try {
+          await lstat4(out);
+          throw new InputError(`Directory already exists: ${out}. Choose a new --out path.`);
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+      result2 = await brandFromUrl(need(values.url, "url"), out, {
+        name: values.name,
+        slug: values.slug,
+        into: values.file
+      });
+      human = `Brand refs ready. Open ${result2.proof} and confirm the assets with the user.`;
+    } else if (command === "brand add-kit") {
+      const path2 = need(values.file, "file");
+      const brand = await addBrandKit(
+        path2,
+        need(values.ref, "ref"),
+        need(values.id, "id"),
+        values.family
+      );
+      await writeBrand(path2, brand);
+      result2 = { path: resolve8(path2), kits: brand.kits.length };
+    } else if (command === "brand add-logo") {
+      const path2 = need(values.file, "file");
+      const brand = await addBrandLogo(
+        path2,
+        need(values.ref, "ref"),
+        need(values.id, "id"),
+        values.name
+      );
+      await writeBrand(path2, brand);
+      result2 = { path: resolve8(path2), logos: brand.logos.map((logo) => logo.id) };
+    } else if (command === "brand inspect") {
+      const brand = await readBrand(need(values.file, "file"));
+      const view = await brandView(need(values.file, "file"));
+      result2 = {
+        brand,
+        pieces: view.pieces.length,
+        products: Object.fromEntries(
+          ["card", "badge", "sticker"].map((product) => [
+            product,
+            view.pieces.filter((piece) => piece.product === product).length
+          ])
+        ),
+        unsubmitted: brand.kits.filter((kit) => !kit.submission).map((kit) => kit.id)
+      };
+    } else if (command === "brand export") {
+      const out = resolve8(need(values.out, "out"));
+      if (!out.endsWith(".zip")) throw new InputError("--out must end in .zip.");
+      const { packageZip } = await import("./submission-H3RXUH7T.js");
+      const pkg = await prepareBrand(need(values.file, "file"));
+      const bytes = await packageZip(pkg);
+      const handle2 = await open4(
+        values.overwrite ? out : await newPath(out),
+        values.overwrite ? "w" : "wx"
+      );
+      try {
+        await handle2.writeFile(bytes);
+      } finally {
+        await handle2.close();
+      }
+      result2 = {
+        path: out,
+        product: "brand",
+        kits: pkg.manifest.product === "brand" ? pkg.manifest.kits.length : 0,
+        bytes: bytes.length
+      };
+    } else {
+      const { serveBrandPreview } = await import("./brand-preview-C6HBXUXH.js");
+      result2 = await serveBrandPreview(need(values.file, "file"), {
+        site: values.site,
+        open: !values["no-open"]
+      });
+      human = `Brand preview at ${result2.url}. Press Ctrl+C to stop.`;
+    }
+    emit(result2, ["makeables skills get kits"], human, json);
+    return;
+  }
   if (command.startsWith("kit ")) {
     const required = (value, flag) => {
       if (!value) throw new InputError(`Supply --${flag}.`);
       return value;
     };
     let result2;
+    if (command === "kit check") {
+      result2 = await checkKitAgainstBrand(
+        required(values.file, "file"),
+        required(values.brand, "brand")
+      );
+      emit(result2, ["makeables skills get kits"], JSON.stringify(result2, null, 2), json);
+      if (!result2.ok) process.exitCode = 2;
+      return;
+    }
     if (command === "kit extract") {
       result2 = await extractKit(
         required(values.file, "file"),
@@ -2369,11 +4935,11 @@ From a built checkout: npm run studio -- <command>`,
         command === "kit add" ? "items" : "sheets"
       );
       await writeAtomic(path2, JSON.stringify(kit, null, 2));
-      result2 = { path: resolve7(path2), items: kit.items.length, sheets: kit.sheets.length };
+      result2 = { path: resolve8(path2), items: kit.items.length, sheets: kit.sheets.length };
     } else if (command === "kit import") {
       result2 = await importKit(required(values.file, "file"), required(values.out, "out"));
     } else if (command === "kit inspect" && !required(values.file, "file").toLowerCase().endsWith(".zip")) {
-      const value = JSON.parse(await readFile7(required(values.file, "file"), "utf8"));
+      const value = JSON.parse(await readFile8(required(values.file, "file"), "utf8"));
       if (value.format === "makeables-kit") result2 = await readKit(required(values.file, "file"));
       else {
         const pkg = await readSubmission(required(values.file, "file"));
@@ -2385,7 +4951,7 @@ From a built checkout: npm run studio -- <command>`,
       const { pkg, bytes } = await exportKit(required(values.file, "file"));
       if (command === "kit inspect") result2 = pkg.manifest;
       else {
-        const out = resolve7(required(values.out, "out"));
+        const out = resolve8(required(values.out, "out"));
         const rendering = command === "kit render";
         if (!out.endsWith(rendering ? ".png" : ".zip"))
           throw new InputError(rendering ? "--out must end in .png." : "--out must end in .zip.");
@@ -2434,6 +5000,74 @@ From a built checkout: npm run studio -- <command>`,
     emit(result2, ["makeables skills get cards"], JSON.stringify(result2, null, 2), json);
     return;
   }
+  if (command === "print list") {
+    const { printList } = await import("./print-NGPUZPVN.js");
+    const objects = printList();
+    emit(
+      { objects },
+      ["Build one with makeables print <object> --param name=value --out <file.stl>."],
+      objects.map(
+        (o) => `${style(o.id, "1", !json)}  ${o.description}
+${[
+          ...o.params.map(
+            (p) => `    --param ${p.name}=${p.options ? p.options.join("|") : p.type === "number" ? `${p.min}..${p.max}` : "<text>"}  (default ${JSON.stringify(p.default)})`
+          ),
+          ...Object.entries(o.assets).map(
+            ([slot, a]) => `    --param ${slot}=<file.${a.kind}>  ${a.description}`
+          )
+        ].join("\n")}`
+      ).join("\n"),
+      json
+    );
+    return;
+  }
+  if (command === "print <object>" && printTarget) {
+    if (!values.out) throw new InputError("Supply --out.");
+    const out = resolve8(values.out);
+    const preview = values.preview ? resolve8(values.preview) : void 0;
+    const { printObject, printPreview } = await import("./print-NGPUZPVN.js");
+    const multicolor = out.toLowerCase().endsWith(".3mf");
+    if (!multicolor && !out.toLowerCase().endsWith(".stl"))
+      throw new InputError("--out must end in .stl, or .3mf for two colours.");
+    if (values.colors && !multicolor)
+      throw new InputError("--colors needs a .3mf --out; an STL has one colour.");
+    const result2 = await printObject(printTarget, printParams ?? [], values.brand, {
+      multicolor,
+      colors: values.colors
+    });
+    const files = [[out, result2.threeMf ?? result2.stl]];
+    if (preview) files.push([preview, await printPreview(result2)]);
+    for (const [path2, bytes] of files) {
+      const handle2 = await open4(path2, values.overwrite ? "w" : "wx", 420);
+      try {
+        await handle2.writeFile(bytes);
+      } finally {
+        await handle2.close();
+      }
+    }
+    const { x, y, z: z5 } = result2.sizeMm;
+    emit(
+      {
+        out,
+        object: result2.object,
+        brand: result2.brand,
+        params: result2.params,
+        triangles: result2.triangles,
+        sizeMm: result2.sizeMm,
+        check: result2.check,
+        printability: result2.printability,
+        ...result2.colors && { colors: result2.colors },
+        ...preview && { preview }
+      },
+      [
+        preview ? `Look at ${preview} (top, three-quarter, front) before printing.` : `Add --preview <views.png> to look at it before printing.`,
+        `Open ${out} in your slicer; it is one closed solid with no edges to repair.`
+      ],
+      `${style("Written", "1", !json)} ${result2.name}, ${x} x ${y} x ${z5} mm, ${out}`,
+      json
+    );
+    return;
+  }
   const card = await cardCommand(command, values, json);
   if (card) return;
   if (command === "login" || command === "logout") {
@@ -2468,7 +5102,12 @@ From a built checkout: npm run studio -- <command>`,
       throw new InputError(
         "Supply --file with editable JSON, an original SVG or a Makeables package."
       );
-    const result2 = await submitDesign({
+    const isBrand = values.file.endsWith(".json") && await readFile8(values.file, "utf8").then(
+      (text) => text.includes('"makeables-brand"'),
+      () => false
+    );
+    const submit = isBrand ? (await import("./brand-UNVFUN4H.js")).submitBrand : submitDesign;
+    const result2 = await submit({
       title: values.title,
       credit: values.credit,
       creditUrl: values["credit-url"],
@@ -2518,7 +5157,7 @@ From a built checkout: npm run studio -- <command>`,
   }
   if (command === "doctor") {
     const check = (command2) => {
-      const result2 = spawnSync2(command2, ["--version"], {
+      const result2 = spawnSync3(command2, ["--version"], {
         encoding: "utf8",
         timeout: 5e3,
         stdio: ["ignore", "pipe", "pipe"]
@@ -2574,7 +5213,7 @@ Run makeables skills get core for setup.`,
   }
   if (command === "mcp") {
     try {
-      const { runMcp } = await import("./mcp-VS5XYXVM.js");
+      const { runMcp } = await import("./mcp-2VMGYAUZ.js");
       await runMcp(values.root ?? process.cwd());
     } catch (error) {
       process.stderr.write(
@@ -2633,7 +5272,7 @@ Keep this process running while you design.`,
         const info = await lstat4(path2);
         if (!info.isFile() || info.size > 12e6)
           throw new InputError("Expected a params file below 12 MB.");
-        params = JSON.parse(await readFile7(path2, "utf8"));
+        params = JSON.parse(await readFile8(path2, "utf8"));
       } else if (values.params) params = JSON.parse(values.params);
     }
     const result2 = await studioRequest(
@@ -2739,14 +5378,14 @@ ${dryRun ? "Dry run. No files changed." : "2 faces \xB7 editable layers"}`,
     return;
   }
   if (!values.file) throw new InputError("Supply --file to validate a document.");
-  const path = resolve7(values.file);
+  const path = resolve8(values.file);
   const handle = await open4(path, "r");
   let input;
   try {
     const info = await handle.stat();
     if (!info.isFile() || info.size > 2 * 1024 * 1024)
       throw new InputError("Expected a JSON file smaller than 2 MB.");
-    input = JSON.parse(await readFile7(handle, "utf8"));
+    input = JSON.parse(await readFile8(handle, "utf8"));
   } finally {
     await handle.close();
   }
@@ -2765,7 +5404,7 @@ Schema and layout constraints passed.`,
 }
 async function readParams(value) {
   return JSON.parse(
-    value.startsWith("@") ? await readFile7(resolve7(value.slice(1)), "utf8") : value
+    value.startsWith("@") ? await readFile8(resolve8(value.slice(1)), "utf8") : value
   );
 }
 async function cardCommand(command, values, json) {
@@ -2776,12 +5415,26 @@ async function cardCommand(command, values, json) {
   };
   const renderHint = (path, face, design) => `npx makeables render --file ${JSON.stringify(path)} --side ${face} --out ${design.product ?? "badge"}.png --overwrite`;
   if (command === "new sticker") {
+    if (values.blank && values.style) throw new InputError("Choose --blank or --style, not both.");
     const preset = stickerStyles.find(
       (entry) => entry.source === (values.style ?? "typingmind-absolutely-right")
     );
     if (!preset)
       throw new InputError("Unknown sticker style. Run makeables styles list --product sticker.");
-    const design = badgeDesignSchema.parse(structuredClone(preset));
+    const design = badgeDesignSchema.parse(
+      values.blank ? {
+        ...structuredClone(preset),
+        name: typeof values.name === "string" ? values.name : "Untitled sticker",
+        source: void 0,
+        event: typeof values.name === "string" ? values.name : "Makeables",
+        description: "",
+        artPrompt: "",
+        assets: {},
+        front: { background: "#00000000", layers: [] },
+        back: { background: "#00000000", layers: [] },
+        sticker: { ...defaultStickerMaterial }
+      } : structuredClone(preset)
+    );
     const path = values.out ? await newPath(String(values.out)) : null;
     const dryRun = Boolean(values["dry-run"]);
     if (path && !dryRun) await writeAtomic(path, `${JSON.stringify(design, null, 2)}
@@ -2798,10 +5451,29 @@ ${path ?? "No file written. Add --out sticker.json."}`,
     );
     return true;
   }
+  if ((command === "new badge" || command === "new card") && values.blank) {
+    if (values.style || values.design || values.file)
+      throw new InputError("Choose --blank or a --style, --design or --file, not both.");
+    const design = blankDesign(command === "new card" ? "card" : "badge", values.name);
+    const path = values.out ? await newPath(String(values.out)) : null;
+    const dryRun = Boolean(values["dry-run"]);
+    if (path && !dryRun) await writeAtomic(path, `${JSON.stringify(design, null, 2)}
+`, true);
+    emit(
+      { design, path, written: Boolean(path && !dryRun), dryRun },
+      path ? [
+        `makeables layer add --file ${JSON.stringify(path)} --kind text --params '{"text":"..."}'`
+      ] : [],
+      `${design.product === "card" ? "Card" : "Badge"} ready \xB7 ${design.name}
+${path ?? "No file written. Add --out."}`,
+      json
+    );
+    return true;
+  }
   if (command === "new badge" || command === "new card") {
     const card = command === "new card";
     if (card && [values.design, values.style, values.file].filter(Boolean).length !== 1)
-      throw new InputError("Choose exactly one --design, --style or --file.");
+      throw new InputError("Choose exactly one --design, --style, --file or --blank.");
     const preset = card && values.style ? findCardStyle(need(values.style, "style")) : void 0;
     if (card && values.style && !preset)
       throw new InputError("Unknown card style. Run makeables styles list --product card.");
@@ -2827,7 +5499,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "material map") {
-    const path = resolve7(need(file, "file"));
+    const path = resolve8(need(file, "file"));
     const next = await bindStickerMap(
       await readBadge(path),
       need(values.id, "id"),
@@ -2843,10 +5515,10 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "material set") {
-    const path = resolve7(need(file, "file"));
+    const path = resolve8(need(file, "file"));
     const design = await readBadge(path);
     const raw = need(values.params, "params");
-    const input = JSON.parse(raw.startsWith("@") ? await readFile7(raw.slice(1), "utf8") : raw);
+    const input = JSON.parse(raw.startsWith("@") ? await readFile8(raw.slice(1), "utf8") : raw);
     if (design.product === "sticker") {
       const patch2 = stickerMaterialSchema.partial().strict().safeParse(input);
       if (!patch2.success)
@@ -2905,11 +5577,11 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
       const changes = values.params ? await readParams(String(values.params)) : {};
       if (typeof changes !== "object" || changes === null || Array.isArray(changes))
         throw new InputError("--params must be a JSON object of layer fields.");
-      for (const key of ["x", "y", "rotation"])
-        if (values[key] !== void 0) {
-          const value = Number(values[key]);
-          if (!Number.isFinite(value)) throw new InputError(`--${key} must be a number.`);
-          changes[key] = value;
+      for (const key2 of ["x", "y", "rotation"])
+        if (values[key2] !== void 0) {
+          const value = Number(values[key2]);
+          if (!Number.isFinite(value)) throw new InputError(`--${key2} must be a number.`);
+          changes[key2] = value;
         }
       design = setBadgeLayer(design, face, id, changes);
     }
@@ -2923,6 +5595,27 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     );
     return true;
   }
+  if (command === "layer add" && values.kind) {
+    if (values.sticker) throw new InputError("Choose --kind or --sticker, not both.");
+    const path = need(file, "file");
+    const face = side(values.side);
+    const { design, id, warnings } = addLayer(
+      await readBadge(path),
+      face,
+      String(values.kind),
+      values.params ? await readParams(String(values.params)) : {}
+    );
+    await writeAtomic(path, `${JSON.stringify(design, null, 2)}
+`);
+    const layer = design[face].layers.find((item) => item.id === id);
+    emit(
+      { layer, warnings },
+      [renderHint(path, face, design)],
+      [`${style("Added", "1", !json)} ${id} on ${face}`, ...warnings].join("\n"),
+      json
+    );
+    return true;
+  }
   if (command === "layer add") {
     const path = need(file, "file");
     const face = side(values.side);
@@ -2932,7 +5625,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
       await readBadge(path),
       face,
       need(values.sticker, "sticker"),
-      values["relative-to"] === "cwd" ? process.cwd() : dirname5(resolve7(path))
+      values["relative-to"] === "cwd" ? process.cwd() : dirname5(resolve8(path))
     );
     await writeAtomic(path, `${JSON.stringify(design, null, 2)}
 `);
@@ -2945,6 +5638,147 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     );
     return true;
   }
+  if (command === "grid bin" || command === "grid plate") {
+    const out = resolve8(need(values.out, "out"));
+    const result = gridStl(command === "grid bin" ? "bin" : "plate", values);
+    const handle = await open4(out, values.overwrite ? "w" : "wx", 420);
+    try {
+      await handle.writeFile(result.stl);
+    } finally {
+      await handle.close();
+    }
+    const { x, y, z: z5 } = result.sizeMm;
+    emit(
+      { out, part: result.part, triangles: result.triangles, sizeMm: result.sizeMm },
+      [`Open ${out} in your slicer.`],
+      `${style("Written", "1", !json)} ${result.name}, ${x} x ${y} x ${z5} mm, ${out}`,
+      json
+    );
+    return true;
+  }
+  if (command === "brick part") {
+    const id = need(values.id, "id");
+    const sheet = brickPart(id, ldrawLibrary(values.library));
+    emit(
+      sheet,
+      [`Place ${id} with Assembly.seat, which counts sockets as listed here.`],
+      [
+        `${style(sheet.id, "1", !json)} ${sheet.name}`,
+        `  size ${sheet.size.join(" x ")} studs, origin at ${sheet.origin}`,
+        ...Object.entries(sheet.connectors).map(
+          ([kind, list]) => `  ${kind}: ${list.map((c) => `#${c.index} (${c.p.join(", ")})`).join(" ")}`
+        )
+      ].join("\n"),
+      json
+    );
+    return true;
+  }
+  if (command.startsWith("brick ")) {
+    const path = need(file, "file");
+    const model = await readBrickModel(path, ldrawLibrary(values.library));
+    if (command === "brick check") {
+      const report = brickCheck(model);
+      emit(
+        report,
+        report.ok ? [`makeables brick plan --file ${JSON.stringify(path)}`] : ["Fix the parts listed, or add connectors for joints the checker cannot see."],
+        [
+          `${style(report.ok ? "Buildable" : "Not buildable", "1", !json)} ${report.parts} parts, ${report.joints} joints`,
+          ...report.issues.map((i) => `  ${i.rule}: ${i.message}: ${i.parts.join(", ")}`)
+        ].join("\n"),
+        json
+      );
+      if (!report.ok) process.exitCode = 2;
+      return true;
+    }
+    if (command === "brick stress") {
+      const joints = brickStress(model);
+      emit(
+        { joints },
+        joints.length ? [
+          "Brace the joints at the top: add a second connection, shorten the lever, or lighten the load."
+        ] : ["Every joint sits in a loop; nothing hangs on a single joint."],
+        joints.length ? joints.map(
+          (j) => `  ${j.moment.toFixed(2).padStart(8)}  ${j.kind.padEnd(16)} x${j.count}  holds ${j.holds.length} parts, lever ${j.lever} studs  ${j.between.join(" -> ")}`
+        ).join("\n") : "No joint holds part of the build alone.",
+        json
+      );
+      return true;
+    }
+    if (command === "brick plan") {
+      const plan = brickPlan(model);
+      emit(
+        { steps: plan.rows, locked: plan.locked },
+        [`makeables brick render --file ${JSON.stringify(path)} --out step.png --step 1`],
+        [
+          ...plan.rows.map(
+            (r) => `  ${String(r.step).padStart(3)}  ${r.part.padEnd(9)} ${r.insert}  ${r.name}`
+          ),
+          ...plan.locked.length ? [`  locked: ${plan.locked.join(", ")}`] : []
+        ].join("\n"),
+        json
+      );
+      return true;
+    }
+    const number = (name) => {
+      const raw = values[name];
+      if (raw === void 0) return void 0;
+      const n = Number(raw);
+      if (!Number.isFinite(n)) throw new InputError(`--${name} must be a number.`);
+      return n;
+    };
+    if (command === "brick stl") {
+      const out2 = resolve8(need(values.out, "out"));
+      const scale2 = number("scale");
+      const result = brickStl(model, scale2);
+      const handle2 = await open4(out2, values.overwrite ? "w" : "wx", 420);
+      try {
+        await handle2.writeFile(result.stl);
+      } finally {
+        await handle2.close();
+      }
+      const { x, y, z: z5 } = result.sizeMm;
+      emit(
+        { out: out2, parts: result.parts, triangles: result.triangles, sizeMm: result.sizeMm },
+        [`Open ${out2} in your slicer; the parts are already fused into one closed solid.`],
+        `${style("Written", "1", !json)} ${result.parts} parts, ${x} x ${y} x ${z5} mm, ${out2}`,
+        json
+      );
+      return true;
+    }
+    if (command === "brick remix") {
+      const seed = number("seed");
+      if (seed === void 0 || !Number.isInteger(seed))
+        throw new InputError("--seed must be an integer.");
+      const out2 = await newPath(need(values.out, "out"));
+      const result = brickRemix(model, seed, values.mode);
+      await writeAtomic(out2, result.ldr, true);
+      emit(
+        { out: out2, parts: result.check.parts, left: result.left, check: result.check },
+        [
+          `makeables brick plan --file ${JSON.stringify(out2)}`,
+          `makeables brick render --file ${JSON.stringify(out2)} --out remix.png`
+        ],
+        `${style(result.check.ok ? "Remixed" : "Remixed, not buildable", "1", !json)} ${result.check.parts} parts${result.left.length ? `, ${result.left.length} left in the bag` : ""} ${out2}`,
+        json
+      );
+      return true;
+    }
+    const out = resolve8(need(values.out, "out"));
+    const png = await brickRender(model, {
+      step: number("step"),
+      explode: number("explode"),
+      yaw: number("yaw"),
+      pitch: number("pitch")
+    });
+    const handle = await open4(out, values.overwrite ? "w" : "wx", 420);
+    try {
+      await handle.writeFile(png);
+    } finally {
+      await handle.close();
+    }
+    emit({ out }, [`Open ${out} and look at it.`], `${style("Rendered", "1", !json)} ${out}`, json);
+    return true;
+  }
   if (command.startsWith("sheet ")) {
     const write = async (target, bytes) => {
       const handle = await open4(target, values.overwrite ? "w" : "wx", 420);
@@ -3026,9 +5860,9 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
         throw new InputError(
           `The sheet is not printable. Run makeables sheet check --file ${JSON.stringify(path)}.`
         );
-      const out = resolve7(need(values.out, "out"));
+      const out = resolve8(need(values.out, "out"));
       if (!out.endsWith(".pdf")) throw new InputError("--out must end in .pdf.");
-      const preview = typeof values.preview === "string" ? resolve7(values.preview) : void 0;
+      const preview = typeof values.preview === "string" ? resolve8(values.preview) : void 0;
       if (preview && !preview.endsWith(".png")) throw new InputError("--preview must end in .png.");
       const targets = [out, ...preview ? [preview] : []];
       if (!values.overwrite) for (const target of targets) await newPath(target);
@@ -3046,7 +5880,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   if (command === "cut") {
     const design = await readBadge(need(file, "file"));
     if (design.product !== "sticker") throw new InputError("cut applies to sticker designs.");
-    const out = typeof values.out === "string" ? resolve7(values.out) : void 0;
+    const out = typeof values.out === "string" ? resolve8(values.out) : void 0;
     if (out && !out.endsWith(".svg")) throw new InputError("--out must end in .svg.");
     const target = out && (values.overwrite ? out : await newPath(out));
     const { cut, svg } = await stickerPrintCut(design);
@@ -3087,16 +5921,16 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
       throw new InputError("--appearance must be flat or material.");
     const appearance = values.appearance;
     const path = need(file, "file");
-    const out = resolve7(need(values.out, "out"));
+    const out = resolve8(need(values.out, "out"));
     if (!out.endsWith(".png")) throw new InputError("--out must end in .png.");
     const target = values.overwrite ? out : await newPath(out);
     const number = values.number === void 0 ? void 0 : Number(values.number);
     if (number !== void 0 && !Number.isInteger(number))
       throw new InputError("--number must be an integer.");
     const face = side(values.side);
-    const value = JSON.parse(await readFile7(resolve7(path), "utf8"));
+    const value = JSON.parse(await readFile8(resolve8(path), "utf8"));
     const pkg = value?.format === "makeables-package" ? await readPackageJson(value) : void 0;
-    if (pkg && ["photo", "name", "role", "number"].some((key) => values[key] !== void 0))
+    if (pkg && ["photo", "name", "role", "number"].some((key2) => values[key2] !== void 0))
       throw new InputError(
         "Portable packages include their participant and images. Edit the package before rendering, or use these flags with a plain design JSON."
       );
@@ -3158,13 +5992,13 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "validate") {
-    const path = resolve7(need(file, "file"));
+    const path = resolve8(need(file, "file"));
     if (extname4(path).toLowerCase() === ".svg") {
-      const source = await readFile7(path, "utf8");
+      const source = await readFile8(path, "utf8");
       const result2 = checkSubmittedSvg(source);
       if (!result2.ok) throw new InputError(result2.error);
       const preview = values.out ? await newPath(need(values.out, "out")) : void 0;
-      if (preview) await sharp8(Buffer.from(result2.svg)).png().toFile(preview);
+      if (preview) await sharp9(Buffer.from(result2.svg)).png().toFile(preview);
       emit(
         {
           valid: true,
@@ -3181,7 +6015,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
       return true;
     }
     if (values.out) throw new InputError("--out is only used to preview SVG validation.");
-    const input = JSON.parse(await readFile7(path, "utf8"));
+    const input = JSON.parse(await readFile8(path, "utf8"));
     const result = badgeDesignSchema.safeParse(input);
     if (!result.success)
       throw new InputError(
@@ -3199,7 +6033,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   return false;
 }
 run().catch((error) => {
-  const userError = error instanceof InputError || error instanceof ZodError || error instanceof WalletError && error.details.code === "INVALID_INPUT" || error instanceof SyntaxError || [
+  const userError = error instanceof InputError || error instanceof ZodError2 || error instanceof WalletError && error.details.code === "INVALID_INPUT" || error instanceof SyntaxError || [
     "ERR_PARSE_ARGS_UNKNOWN_OPTION",
     "ERR_PARSE_ARGS_INVALID_OPTION_VALUE",
     "ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL",
@@ -3229,7 +6063,7 @@ run().catch((error) => {
   if (!traceFile) return;
   try {
     const supplied = process.env.MAKEABLES_TRACE_SESSION;
-    await appendTrace(resolve7(traceFile), {
+    await appendTrace(resolve8(traceFile), {
       sessionId: supplied && /^[a-zA-Z0-9_-]{1,80}$/.test(supplied) ? supplied : randomUUID3(),
       version,
       command: traceCommand,