makeables 0.11.0 → 0.12.0

package/dist/cli.js

@@ -10,7 +10,7 @@ import {
   prepareBrand,
   readBrand,
   writeBrand
-} from "./chunk-ZZA6CR6X.js";
+} from "./chunk-YOGNQAYJ.js";
 import {
   addKitMember,
   addToSheet,
@@ -25,12 +25,12 @@ import {
   readSheet,
   sheetPreviewPng,
   sheetReport
-} from "./chunk-6RBOBRL4.js";
+} from "./chunk-7A4TRTVE.js";
 import {
   getSkill,
   skills,
   version
-} from "./chunk-4WLCMPRH.js";
+} from "./chunk-WEPC5LJ7.js";
 import {
   CloudError,
   InputError,
@@ -61,7 +61,7 @@ import {
   submitDesign,
   summarizeBadgeLayers,
   writeAtomic
-} from "./chunk-YB2YJCBS.js";
+} from "./chunk-MXT43NAQ.js";
 import {
   PACKAGE_LIMIT,
   badgeDesignObjectSchema,
@@ -79,7 +79,7 @@ import {
   stickerMaterialSchema,
   svgNodeSchema,
   svgNodeXml
-} from "./chunk-DLTVENEP.js";
+} from "./chunk-KLJRRHMY.js";
 
 // src/cli.ts
 import { spawnSync as spawnSync3 } from "child_process";
@@ -453,8 +453,10 @@ function worldBody(lib, item) {
   return { min: lo, max: hi };
 }
 function pointMates(x, y, adapter) {
-  return length(sub(x.p, y.p)) <= adapter.tolerance && dot(x.a, y.a) <= -0.99;
+  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);
@@ -464,26 +466,77 @@ function axialMates(x, y, adapter) {
   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 (let a = 0; a < world.length; a++)
-    for (let b = a + 1; b < world.length; b++) {
-      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("-");
-          kinds.set(kind, {
-            count: (kinds.get(kind)?.count ?? 0) + 1,
-            axis: axial ? x.a : void 0,
-            release: axial ? void 0 : x.a
-          });
-        }
-      for (const [kind, v] of kinds) out.push({ a, b, kind, ...v });
-    }
+  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) {
@@ -511,7 +564,7 @@ function partVoxels(part2) {
   }
   return part2.voxels;
 }
-function collisionCells(lib, x, y) {
+function collisionCells(lib, x, y, ignore) {
   let hits = 0;
   for (const [a, b] of [
     [x, y],
@@ -529,6 +582,7 @@ function collisionCells(lib, x, y) {
             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 = [
@@ -559,7 +613,7 @@ function readRef(f) {
     name: normalizeName(f.slice(14).join(" "))
   };
 }
-function parsePart(name, resolve9, isJoint) {
+function parsePart(name, resolve9, isJoint2) {
   const triangles = [];
   const colors = [];
   const edges = [];
@@ -577,7 +631,7 @@ function parsePart(name, resolve9, isJoint) {
         const ref = readRef(f);
         const rotation = mul(m, ref.rotation);
         const position = add(apply(m, ref.position), t);
-        const joint = !inJoint && isJoint(ref.name);
+        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);
@@ -764,6 +818,9 @@ function technicShafts(name, triangles) {
   ];
 }
 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",
@@ -810,8 +867,11 @@ var lego = {
     shoulder: ["shoulderhole"],
     shoulderhole: ["shoulder"],
     wrist: ["hand"],
-    hand: ["wrist"]
+    hand: ["wrist"],
+    ball: ["ballsocket"],
+    ballsocket: ["ball"]
   },
+  spherical: ["ball", "ballsocket"],
   tolerance: 0.06,
   minEngagement: 0.24,
   family: (part2) => FAMILY[part2] ?? part2
@@ -834,6 +894,12 @@ var LEGO_CONNECTORS = {
   ],
   // 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 }],
@@ -918,17 +984,37 @@ var lattice = (lo, hi, phase) => {
     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)
-    if (STUD.test(j.name))
-      out.push({ kind: "stud", p: j.position, a: apply(j.rotation, [0, 1, 0]) });
+  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) => dot(c.a, [0, 1, 0]) > 0.99);
-  const phase = (k) => {
-    const v = (min[k] + 0.5) % 1;
-    return v < 0 ? v + 1 : v;
-  };
+  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)
@@ -937,21 +1023,21 @@ function legoConnectors(parsed, voxels) {
     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;
-  for (const x of lattice(min[0], max[0], phase(0)))
-    for (const z5 of lattice(min[2], max[2], phase(2))) {
-      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) continue;
-      let ceiling = false;
-      for (let h = hollow + CELL; h < max[1] && !ceiling; h += CELL)
-        ceiling = cellAt(voxels, [x, h, z5]);
-      if (ceiling) out.push({ kind: "socket", p: [x, y, z5], a: [0, -1, 0] });
-    }
+  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, (p) => STUD.test(p));
+  const parsed = parsePart(`${id}.dat`, resolve9, isJoint);
   const bounds = meshBounds(parsed.triangles);
   const voxels = voxelize(parsed.triangles, bounds.min, bounds.max);
   return {
@@ -980,6 +1066,37 @@ function libraryResolver(read, root) {
     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",
@@ -1024,20 +1141,37 @@ function rasterize(model, lib, opts = {}) {
   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;
-  const tris = [];
-  const lines = [];
+  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 toView = (p) => {
-    const v = [dot(p, right), -dot(p, up), dot(p, view)];
-    minX = Math.min(minX, v[0]);
-    maxX = Math.max(maxX, v[0]);
-    minY = Math.min(minY, v[1]);
-    maxY = Math.max(maxY, v[1]);
-    return v;
+  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}`);
@@ -1049,27 +1183,43 @@ function rasterize(model, lib, opts = {}) {
     ];
     const offset = opts.explode ? scale(sub(mid, center), opts.explode) : [0, 0, 0];
     const fade = highlight.size && !highlight.has(i) ? 0.72 : 0;
-    const world = (x, y, z5) => add(add(apply(item.rotation, [x, y, z5]), item.position), offset);
+    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;
-    for (let f = 0; f < t.length / 9; f++) {
-      const w = [0, 1, 2].map(
-        (v) => world(t[f * 9 + v * 3], t[f * 9 + v * 3 + 1], t[f * 9 + v * 3 + 2])
-      );
-      const normal = cross(sub(w[1], w[0]), sub(w[2], w[0]));
+    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));
-      const base2 = rgb(palette[code] ?? "#888888");
-      tris.push({
-        p: w.map(toView),
-        color: base2.map((c) => {
-          const v = Math.min(255, c * k);
-          return v + (255 - v) * fade;
-        })
-      });
+      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");
@@ -1077,77 +1227,103 @@ function rasterize(model, lib, opts = {}) {
     const edge = (dark ? [110, 110, 110] : base.map((c) => c * 0.45)).map(
       (c) => c + (255 - c) * fade
     );
-    for (let s2 = 0; s2 < e.length; s2 += 6)
-      lines.push({
-        a: toView(world(e[s2], e[s2 + 1], e[s2 + 2])),
-        b: toView(world(e[s2 + 3], e[s2 + 4], e[s2 + 5])),
-        color: edge
-      });
+    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.length ? 0.9 * Math.min(W2 / (maxX - minX || 1), H2 / (maxY - minY || 1)) : 1;
+  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 sx = (v) => [ox + s * v[0], oy + s * v[1], v[2]];
   const data = new Uint8ClampedArray(W2 * H2 * 4);
   const depth = new Float32Array(W2 * H2).fill(-Infinity);
-  for (let p = 0; p < W2 * H2; p++) {
-    data[p * 4] = background[0];
-    data[p * 4 + 1] = background[1];
-    data[p * 4 + 2] = background[2];
-    data[p * 4 + 3] = 255;
-  }
-  const put = (x, y, z5, c) => {
-    const p = y * W2 + x;
-    if (z5 <= depth[p]) return;
-    depth[p] = z5;
-    data[p * 4] = c[0];
-    data[p * 4 + 1] = c[1];
-    data[p * 4 + 2] = c[2];
-  };
-  for (const tri of tris) {
-    const [a, b, c] = tri.p.map(sx);
-    const area = (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]);
+  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 x0 = Math.max(0, Math.floor(Math.min(a[0], b[0], c[0])));
-    const x1 = Math.min(W2 - 1, Math.ceil(Math.max(a[0], b[0], c[0])));
-    const y0 = Math.max(0, Math.floor(Math.min(a[1], b[1], c[1])));
-    const y1 = Math.min(H2 - 1, Math.ceil(Math.max(a[1], b[1], c[1])));
-    for (let y = y0; y <= y1; y++)
-      for (let x = x0; x <= x1; x++) {
+    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 py = y + 0.5;
-        const l0 = ((b[0] - px) * (c[1] - py) - (c[0] - px) * (b[1] - py)) / area;
-        const l1 = ((c[0] - px) * (a[1] - py) - (a[0] - px) * (c[1] - py)) / area;
+        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 (l0 < 0 || l1 < 0 || l2 < 0) continue;
-        put(x, y, l0 * a[2] + l1 * b[2] + l2 * c[2], tri.color);
+        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;
-  for (const line of lines) {
-    const a = sx(line.a);
-    const b = sx(line.b);
-    const steps = Math.max(1, Math.ceil(Math.max(Math.abs(b[0] - a[0]), Math.abs(b[1] - a[1]))));
+  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(a[0] + (b[0] - a[0]) * t);
-      const y = Math.round(a[1] + (b[1] - a[1]) * t);
+      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;
-      for (const [dx, dy] of ss > 1 ? [
-        [0, 0],
-        [1, 0],
-        [0, 1],
-        [1, 1]
-      ] : [[0, 0]]) {
-        const X = Math.min(W2 - 1, x + dx);
-        const Y = Math.min(H2 - 1, y + dy);
-        const p = Y * W2 + X;
-        const z5 = a[2] + (b[2] - a[2]) * t;
-        if (z5 + bias < depth[p]) continue;
-        data[p * 4] = line.color[0];
-        data[p * 4 + 1] = line.color[1];
-        data[p * 4 + 2] = line.color[2];
-      }
+      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 };
@@ -1178,6 +1354,11 @@ var DIRECTIONS = [
 ];
 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))
@@ -1191,7 +1372,16 @@ function planAssembly(model, lib, adapter) {
   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);
@@ -1199,6 +1389,8 @@ function planAssembly(model, lib, adapter) {
     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) => {
@@ -1218,12 +1410,20 @@ function planAssembly(model, lib, adapter) {
     return dot(d, sub(centre(bodies[i]), centre(bodies[j]))) >= -1e-6;
   };
   const left = new Set(items.map((_, i) => i));
-  const freeWay = (i, around) => DIRECTIONS.find((d) => {
+  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));
-    for (let s = STEP; ; s += STEP) {
+    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 = others.filter((j) => overlapVolume(box2, bodies[j], -0.4) > 0);
+      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;
@@ -1387,6 +1587,134 @@ function remix(exemplar, lib, adapter, opts) {
   }
   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) {
@@ -1398,6 +1726,9 @@ function toStl(model, lib, unit) {
       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);
@@ -1413,17 +1744,253 @@ function toStl(model, lib, unit) {
   }
   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}`));
-  for (let a = 0; a < n; a++)
-    for (let b = a + 1; b < n; b++)
-      if (!through.has(`${a},${b}`) && overlapVolume(bodies[a], bodies[b], -0.4) > 0 && collisionCells(lib, model.items[a], model.items[b]) > COLLISION_CELLS)
-        issues.push({ rule: "overlap", items: [a, b], message: "two parts occupy the same space" });
+  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];
@@ -1482,6 +2049,16 @@ async function readBrickModel(file, library) {
   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]}`;
@@ -1492,6 +2069,10 @@ function brickCheck({ model, lib, names }) {
     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"][[
@@ -1546,6 +2127,29 @@ function brickRemix(exemplar, seed, mode) {
     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";
@@ -3812,9 +4416,14 @@ 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]",
@@ -3893,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: {
@@ -3917,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" },
@@ -3954,6 +4567,7 @@ async function run() {
       yaw: { type: "string" },
       pitch: { type: "string" },
       seed: { type: "string" },
+      scale: { type: "string" },
       width: { type: "string" },
       depth: { type: "string" },
       height: { type: "string" },
@@ -3963,6 +4577,7 @@ async function run() {
       slug: { type: "string" },
       family: { type: "string" },
       brand: { type: "string" },
+      colors: { type: "string" },
       probe: { type: "boolean" },
       blank: { type: "boolean" },
       kind: { type: "string" },
@@ -4001,7 +4616,8 @@ 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"],
@@ -4118,10 +4734,15 @@ 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"],
@@ -4132,6 +4753,8 @@ 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))
@@ -4144,7 +4767,7 @@ From a built checkout: npm run studio -- <command>`,
     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-CMFI3BIR.js");
+    const { badgePackage } = await import("./badge-package-RBQ43DQX.js");
     const { json: body, participant } = await badgePackage(
       need(values.file, "file"),
       need(values.photo, "photo"),
@@ -4242,7 +4865,7 @@ From a built checkout: npm run studio -- <command>`,
     } 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-ATVS5YTK.js");
+      const { packageZip } = await import("./submission-H3RXUH7T.js");
       const pkg = await prepareBrand(need(values.file, "file"));
       const bytes = await packageZip(pkg);
       const handle2 = await open4(
@@ -4261,7 +4884,7 @@ From a built checkout: npm run studio -- <command>`,
         bytes: bytes.length
       };
     } else {
-      const { serveBrandPreview } = await import("./brand-preview-W4FTJJM3.js");
+      const { serveBrandPreview } = await import("./brand-preview-C6HBXUXH.js");
       result2 = await serveBrandPreview(need(values.file, "file"), {
         site: values.site,
         open: !values["no-open"]
@@ -4377,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") {
@@ -4415,7 +5106,7 @@ From a built checkout: npm run studio -- <command>`,
       (text) => text.includes('"makeables-brand"'),
       () => false
     );
-    const submit = isBrand ? (await import("./brand-NMENEWIZ.js")).submitBrand : submitDesign;
+    const submit = isBrand ? (await import("./brand-UNVFUN4H.js")).submitBrand : submitDesign;
     const result2 = await submit({
       title: values.title,
       credit: values.credit,
@@ -4522,7 +5213,7 @@ Run makeables skills get core for setup.`,
   }
   if (command === "mcp") {
     try {
-      const { runMcp } = await import("./mcp-YBRUVIWG.js");
+      const { runMcp } = await import("./mcp-2VMGYAUZ.js");
       await runMcp(values.root ?? process.cwd());
     } catch (error) {
       process.stderr.write(
@@ -4965,6 +5656,23 @@ ${path ?? `No file written. Add --out ${kind}.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));
@@ -4982,6 +5690,20 @@ ${path ?? `No file written. Add --out ${kind}.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(
@@ -5004,6 +5726,25 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
       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))