@mylasertools/kerfscript 0.3.0 → 0.4.0

package/dist/cli.js

@@ -12302,6 +12302,273 @@ var require_opentype = __commonJS({
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
 
+// src/assembly.ts
+var RAD = Math.PI / 180;
+function multiply(a, b) {
+  const out = new Array(16).fill(0);
+  for (let r = 0; r < 4; r++)
+    for (let c = 0; c < 4; c++)
+      for (let k = 0; k < 4; k++) out[r * 4 + c] += a[r * 4 + k] * b[k * 4 + c];
+  return out;
+}
+function rotation(axis, degrees) {
+  const c = Math.cos(degrees * RAD);
+  const s = Math.sin(degrees * RAD);
+  if (axis === 0) return [1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1];
+  if (axis === 1) return [c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1];
+  return [c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+var clean = (n2) => Math.abs(n2) < 1e-12 ? 0 : n2;
+function placementMatrix(p) {
+  const [ax, ay, az] = p.rotate;
+  const r = multiply(rotation(2, az), multiply(rotation(1, ay), rotation(0, ax)));
+  r[3] = p.at[0];
+  r[7] = p.at[1];
+  r[11] = p.at[2];
+  return r.map(clean);
+}
+function apply(m, x, y, z) {
+  return [
+    m[0] * x + m[1] * y + m[2] * z + m[3],
+    m[4] * x + m[5] * y + m[6] * z + m[7],
+    m[8] * x + m[9] * y + m[10] * z + m[11]
+  ];
+}
+function invertRigid(m) {
+  const [tx, ty, tz] = [m[3], m[7], m[11]];
+  const r = [m[0], m[4], m[8], m[1], m[5], m[9], m[2], m[6], m[10]];
+  return [
+    r[0],
+    r[1],
+    r[2],
+    -(r[0] * tx + r[1] * ty + r[2] * tz),
+    r[3],
+    r[4],
+    r[5],
+    -(r[3] * tx + r[4] * ty + r[5] * tz),
+    r[6],
+    r[7],
+    r[8],
+    -(r[6] * tx + r[7] * ty + r[8] * tz),
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function bounds2(regions) {
+  let [x0, y0, x1, y1] = [Infinity, Infinity, -Infinity, -Infinity];
+  for (const ring of regions)
+    for (const [x, y] of ring) {
+      x0 = Math.min(x0, x);
+      y0 = Math.min(y0, y);
+      x1 = Math.max(x1, x);
+      y1 = Math.max(y1, y);
+    }
+  return [x0, y0, x1, y1];
+}
+function worldBox(p) {
+  const [x0, y0, x1, y1] = bounds2(p.outline);
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (const x of [x0, x1])
+    for (const y of [y0, y1])
+      for (const z of [0, p.thickness]) {
+        const w = apply(p.matrix, x, y, z);
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], w[k]);
+          hi[k] = Math.max(hi[k], w[k]);
+        }
+      }
+  return [lo, hi];
+}
+function besideAssembly(placed, loose, gap = 10) {
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (const [a, b] of placed.map(worldBox))
+    for (let k = 0; k < 3; k++) {
+      lo[k] = Math.min(lo[k], a[k]);
+      hi[k] = Math.max(hi[k], b[k]);
+    }
+  const sizes = loose.map((p) => bounds2(p.outline));
+  const limit = sizes.reduce((w, [x0, , x1]) => Math.max(w, x1 - x0), hi[0] - lo[0]);
+  let x = 0;
+  let y = 0;
+  let row = 0;
+  return loose.map((p, i) => {
+    const [x0, y0, x1, y1] = sizes[i];
+    if (x > 0 && x + x1 - x0 > limit) {
+      x = 0;
+      y += row + gap;
+      row = 0;
+    }
+    const matrix = [
+      1,
+      0,
+      0,
+      hi[0] + gap + x - x0,
+      0,
+      1,
+      0,
+      lo[1] + y - y0,
+      0,
+      0,
+      1,
+      lo[2],
+      0,
+      0,
+      0,
+      1
+    ];
+    x += x1 - x0 + gap;
+    row = Math.max(row, y1 - y0);
+    return { ...p, matrix: matrix.map(clean) };
+  });
+}
+var overlaps = (a, b, eps) => [0, 1, 2].every((k) => a[0][k] < b[1][k] - eps && b[0][k] < a[1][k] - eps);
+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 add = (a, b, k = 1) => [a[0] + b[0] * k, a[1] + b[1] * k, a[2] + b[2] * k];
+var normal = (m) => [m[2], m[6], m[10]];
+var origin = (m) => [m[3], m[7], m[11]];
+var turn = (m, v) => [
+  m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
+  m[4] * v[0] + m[5] * v[1] + m[6] * v[2],
+  m[8] * v[0] + m[9] * v[1] + m[10] * v[2]
+];
+function spans(regions, from, dir) {
+  const len = dir[0] * dir[0] + dir[1] * dir[1];
+  const hits = [];
+  for (const ring of regions)
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+      const a = ring[j];
+      const b = ring[i];
+      const da = dir[0] * (a[1] - from[1]) - dir[1] * (a[0] - from[0]);
+      const db = dir[0] * (b[1] - from[1]) - dir[1] * (b[0] - from[0]);
+      if (da > 0 === db > 0) continue;
+      const f = da / (da - db);
+      const x = a[0] + (b[0] - a[0]) * f - from[0];
+      const y = a[1] + (b[1] - a[1]) * f - from[1];
+      hits.push((x * dir[0] + y * dir[1]) / len);
+    }
+  return hits.sort((p, q) => p - q);
+}
+function shared(a, b, eps) {
+  let total = 0;
+  let i = 0;
+  let j = 0;
+  while (i + 1 < a.length && j + 1 < b.length) {
+    const length = Math.min(a[i + 1], b[j + 1]) - Math.max(a[i], b[j]);
+    if (length > eps) total += length;
+    if (a[i + 1] < b[j + 1]) i += 2;
+    else j += 2;
+  }
+  return total;
+}
+function steps(lo, hi, eps, pitch) {
+  const from = lo + eps;
+  const to = hi - eps;
+  if (to <= from) return { at: [], size: 0 };
+  const n2 = Math.max(4, Math.ceil((to - from) / pitch));
+  return {
+    at: Array.from({ length: n2 }, (_, i) => from + (to - from) * (i + 0.5) / n2),
+    size: (to - from) / n2
+  };
+}
+function localLine(inverse, at, dir) {
+  const p = apply(inverse, at[0], at[1], at[2]);
+  const d2 = turn(inverse, dir);
+  return [
+    [p[0], p[1]],
+    [d2[0], d2[1]]
+  ];
+}
+function crossing(A, B, invA, invB, eps, pitch, volume) {
+  const nA = normal(A.matrix);
+  const nB = normal(B.matrix);
+  const raw = cross(nA, nB);
+  const size = Math.hypot(...raw);
+  const line = [raw[0] / size, raw[1] / size, raw[2] / size];
+  const side = cross(line, nA);
+  const tilt = dot(nB, side);
+  const oA = origin(A.matrix);
+  const bLevel = dot(nB, origin(B.matrix));
+  const depths = steps(0, A.thickness, eps, pitch);
+  let total = 0;
+  for (const depth of depths.at) {
+    const base = add(oA, nA, depth);
+    const b0 = (bLevel - dot(nB, base)) / tilt;
+    const b1 = (bLevel + B.thickness - dot(nB, base)) / tilt;
+    const alongs = steps(Math.min(b0, b1), Math.max(b0, b1), eps, pitch);
+    for (const along of alongs.at) {
+      const at = add(base, side, along);
+      const [fromA, dirA] = localLine(invA, at, line);
+      const [fromB, dirB] = localLine(invB, at, line);
+      total += shared(spans(A.outline, fromA, dirA), spans(B.outline, fromB, dirB), eps) * depths.size * alongs.size;
+      if (total > volume) return true;
+    }
+  }
+  return false;
+}
+function stacked(A, B, invA, eps, pitch, volume) {
+  const rel = [0, 1, 2, 3].flatMap(
+    (r) => [0, 1, 2, 3].map((c) => {
+      let v = 0;
+      for (let k = 0; k < 4; k++) v += invA[r * 4 + k] * B.matrix[k * 4 + c];
+      return v;
+    })
+  );
+  const z0 = rel[11];
+  const z1 = rel[11] + rel[10] * B.thickness;
+  const depth = Math.min(A.thickness, Math.max(z0, z1)) - Math.max(0, Math.min(z0, z1));
+  if (depth <= eps) return false;
+  const moved = B.outline.map(
+    (ring) => ring.map(
+      ([x, y]) => [rel[0] * x + rel[1] * y + rel[3], rel[4] * x + rel[5] * y + rel[7]]
+    )
+  );
+  const [ax0, ay0, ax1, ay1] = bounds2(A.outline);
+  const [bx0, by0, bx1, by1] = bounds2(moved);
+  const rows = steps(Math.max(ay0, by0), Math.min(ay1, by1), eps, pitch);
+  let across = 0;
+  for (const y of rows.at) {
+    across += shared(spans(A.outline, [0, y], [1, 0]), spans(moved, [0, y], [1, 0]), eps) * rows.size * depth;
+    if (across > volume) return true;
+  }
+  const columns = steps(Math.max(ax0, bx0), Math.min(ax1, bx1), eps, pitch);
+  let down = 0;
+  for (const x of columns.at) {
+    down += shared(spans(A.outline, [x, 0], [0, 1]), spans(moved, [x, 0], [0, 1]), eps) * columns.size * depth;
+    if (down > volume) return true;
+  }
+  return false;
+}
+function collisions(parts, maxPairs = Infinity, eps = 0.05, pitch = 0.25, volume = 1) {
+  const boxes = parts.map(worldBox);
+  const inverses = parts.map((p) => invertRigid(p.matrix));
+  const order = parts.map((_, i) => i).sort((i, j) => boxes[i][0][0] - boxes[j][0][0]);
+  const found = [];
+  let checked = 0;
+  for (let i = 0; i < order.length; i++)
+    for (let j = i + 1; j < order.length; j++) {
+      const a = order[i];
+      const b = order[j];
+      if (boxes[b][0][0] >= boxes[a][1][0] - eps) break;
+      if (!overlaps(boxes[a], boxes[b], eps)) continue;
+      if (++checked > maxPairs) return { found, complete: false };
+      const [A, B] = a < b ? [parts[a], parts[b]] : [parts[b], parts[a]];
+      const [invA, invB] = a < b ? [inverses[a], inverses[b]] : [inverses[b], inverses[a]];
+      const parallel = Math.hypot(...cross(normal(A.matrix), normal(B.matrix))) < 1e-9;
+      const hit = parallel ? stacked(A, B, invA, eps, pitch, volume) : crossing(A, B, invA, invB, eps, pitch, volume);
+      if (hit) found.push([A, B]);
+    }
+  return { found, complete: true };
+}
+
 // src/values.ts
 var isRange = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && v.type === "range";
 var isFn = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && v.type === "function";
@@ -12440,7 +12707,7 @@ function fmt(n2) {
 }
 
 // src/functions.ts
-var RAD = Math.PI / 180;
+var RAD2 = Math.PI / 180;
 var def = (sig, run, order) => ({
   params: sig.replace("...", "").split(",").map((p) => p.trim()).filter(Boolean),
   rest: sig.endsWith("..."),
@@ -12506,8 +12773,8 @@ function argumentWork(name, args, max) {
   }
   return n2;
 }
-var math1 = (f) => def("x", (a) => typeof a[0] === "number" ? clean(f(a[0])) : void 0);
-function clean(x) {
+var math1 = (f) => def("x", (a) => typeof a[0] === "number" ? clean2(f(a[0])) : void 0);
+function clean2(x) {
   const r = Math.round(x);
   return Math.abs(x - r) < 1e-12 ? r : x;
 }
@@ -12538,16 +12805,16 @@ var FUNCTIONS = {
   // log(x) is base 10; log(base, x) takes the base first
   log: def(
     "x, base",
-    (a, c) => c.given < 2 ? clean(Math.log10(num(a[0], "log"))) : Math.log(num(a[0], "log")) / Math.log(num(a[1], "log")),
+    (a, c) => c.given < 2 ? clean2(Math.log10(num(a[0], "log"))) : Math.log(num(a[0], "log")) / Math.log(num(a[1], "log")),
     (n2) => n2 >= 2 ? ["base", "x"] : ["x", "base"]
   ),
-  sin: math1((x) => Math.sin(x * RAD)),
-  cos: math1((x) => Math.cos(x * RAD)),
-  tan: math1((x) => Math.tan(x * RAD)),
-  asin: math1((x) => Math.asin(x) / RAD),
-  acos: math1((x) => Math.acos(x) / RAD),
-  atan: math1((x) => Math.atan(x) / RAD),
-  atan2: def("y, x", (a) => clean(Math.atan2(num(a[0], "atan2"), num(a[1], "atan2")) / RAD)),
+  sin: math1((x) => Math.sin(x * RAD2)),
+  cos: math1((x) => Math.cos(x * RAD2)),
+  tan: math1((x) => Math.tan(x * RAD2)),
+  asin: math1((x) => Math.asin(x) / RAD2),
+  acos: math1((x) => Math.acos(x) / RAD2),
+  atan: math1((x) => Math.atan(x) / RAD2),
+  atan2: def("y, x", (a) => clean2(Math.atan2(num(a[0], "atan2"), num(a[1], "atan2")) / RAD2)),
   pow: def("x, y", (a) => Math.pow(num(a[0], "pow"), num(a[1], "pow"))),
   min: def(
     "values...",
@@ -14012,7 +14279,7 @@ var ClipperBase = class _ClipperBase {
       next.prevInAEL = prev;
   }
   getBounds() {
-    const bounds2 = {
+    const bounds3 = {
       left: Number.MAX_SAFE_INTEGER,
       top: Number.MAX_SAFE_INTEGER,
       right: Number.MIN_SAFE_INTEGER,
@@ -14021,18 +14288,18 @@ var ClipperBase = class _ClipperBase {
     for (const t of this.vertexList) {
       let v = t;
       do {
-        if (v.pt.x < bounds2.left)
-          bounds2.left = v.pt.x;
-        if (v.pt.x > bounds2.right)
-          bounds2.right = v.pt.x;
-        if (v.pt.y < bounds2.top)
-          bounds2.top = v.pt.y;
-        if (v.pt.y > bounds2.bottom)
-          bounds2.bottom = v.pt.y;
+        if (v.pt.x < bounds3.left)
+          bounds3.left = v.pt.x;
+        if (v.pt.x > bounds3.right)
+          bounds3.right = v.pt.x;
+        if (v.pt.y < bounds3.top)
+          bounds3.top = v.pt.y;
+        if (v.pt.y > bounds3.bottom)
+          bounds3.bottom = v.pt.y;
         v = v.next;
       } while (v !== t);
     }
-    return Rect64Utils.isEmpty(bounds2) ? { left: 0, top: 0, right: 0, bottom: 0 } : bounds2;
+    return Rect64Utils.isEmpty(bounds3) ? { left: 0, top: 0, right: 0, bottom: 0 } : bounds3;
   }
   executeInternal(ct, fillRule) {
     if (ct === ClipType.NoClip)
@@ -15247,17 +15514,17 @@ var ClipperBase = class _ClipperBase {
       return false;
     const maxCoord = InternalClipper.maxCoordForSafeCrossSq;
     if (Math.abs(a) < maxCoord && Math.abs(b) < maxCoord && Math.abs(c) < maxCoord && Math.abs(d2) < maxCoord) {
-      const cross2 = a * d2 - c * b;
-      return cross2 * cross2 / (c * c + d2 * d2) > 0.25;
+      const cross3 = a * d2 - c * b;
+      return cross3 * cross3 / (c * c + d2 * d2) > 0.25;
     }
     if (Number.isSafeInteger(a) && Number.isSafeInteger(b) && Number.isSafeInteger(c) && Number.isSafeInteger(d2)) {
-      const cross2 = BigInt(a) * BigInt(d2) - BigInt(c) * BigInt(b);
-      const crossSq = cross2 * cross2;
+      const cross3 = BigInt(a) * BigInt(d2) - BigInt(c) * BigInt(b);
+      const crossSq = cross3 * cross3;
       const denom = BigInt(c) * BigInt(c) + BigInt(d2) * BigInt(d2);
       return B42 * crossSq > denom;
     }
-    const cross = a * d2 - c * b;
-    return cross * cross / (c * c + d2 * d2) > 0.25;
+    const cross2 = a * d2 - c * b;
+    return cross2 * cross2 / (c * c + d2 * d2) > 0.25;
   }
   intersectEdges(ae1, ae2, pt) {
     let resultOp;
@@ -16442,8 +16709,8 @@ var ClipperOffset = class _ClipperOffset {
       y: Math.round(pt.y + offsetVec.y),
       z: ptz
     });
-    const steps = Math.ceil(this.stepsPerRad * Math.abs(angle));
-    for (let i = 1; i < steps; i++) {
+    const steps2 = Math.ceil(this.stepsPerRad * Math.abs(angle));
+    for (let i = 1; i < steps2; i++) {
       offsetVec = {
         x: offsetVec.x * this.stepCos - this.stepSin * offsetVec.y,
         y: offsetVec.x * this.stepSin + offsetVec.y * this.stepCos
@@ -16613,8 +16880,8 @@ var ClipperOffset = class _ClipperOffset {
         }
         const ptz = pt.z || 0;
         if (group.endType === EndType.Round) {
-          const steps = Math.ceil(this.stepsPerRad * 2 * Math.PI);
-          this.pathOut = _ClipperOffset.ellipse(pt, Math.abs(this.groupDelta), Math.abs(this.groupDelta), steps);
+          const steps2 = Math.ceil(this.stepsPerRad * 2 * Math.PI);
+          this.pathOut = _ClipperOffset.ellipse(pt, Math.abs(this.groupDelta), Math.abs(this.groupDelta), steps2);
           if (ptz !== 0)
             for (let i = 0; i < this.pathOut.length; i++)
               this.pathOut[i].z = ptz;
@@ -16672,20 +16939,20 @@ var ClipperOffset = class _ClipperOffset {
   static sqr(val) {
     return val * val;
   }
-  static ellipse(center, radiusX, radiusY = 0, steps = 0) {
+  static ellipse(center, radiusX, radiusY = 0, steps2 = 0) {
     if (radiusX <= 0)
       return [];
     if (radiusY <= 0)
       radiusY = radiusX;
-    if (steps <= 2) {
-      steps = Math.ceil(Math.PI * Math.sqrt((radiusX + radiusY) / 2));
+    if (steps2 <= 2) {
+      steps2 = Math.ceil(Math.PI * Math.sqrt((radiusX + radiusY) / 2));
     }
-    const si = Math.sin(2 * Math.PI / steps);
-    const co = Math.cos(2 * Math.PI / steps);
+    const si = Math.sin(2 * Math.PI / steps2);
+    const co = Math.cos(2 * Math.PI / steps2);
     let dx = co;
     let dy = si;
     const result = [{ x: Math.round(center.x + radiusX), y: center.y }];
-    for (let i = 1; i < steps; ++i) {
+    for (let i = 1; i < steps2; ++i) {
       result.push({
         x: Math.round(center.x + radiusX * dx),
         y: Math.round(center.y + radiusY * dy)
@@ -16831,7 +17098,7 @@ function area2(p) {
     a += (p[j][0] + p[i][0]) * (p[j][1] - p[i][1]);
   return -a / 2;
 }
-function apply(m, [x, y]) {
+function apply2(m, [x, y]) {
   return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
 }
 function transformLayers(layers, m) {
@@ -16840,10 +17107,10 @@ function transformLayers(layers, m) {
   for (const [k, l] of layers) {
     out.set(k, {
       regions: l.regions.map((p) => {
-        const q = p.map((pt) => apply(m, pt));
+        const q = p.map((pt) => apply2(m, pt));
         return flip ? q.reverse() : q;
       }),
-      lines: l.lines.map((p) => p.map((pt) => apply(m, pt)))
+      lines: l.lines.map((p) => p.map((pt) => apply2(m, pt)))
     });
   }
   return out;
@@ -16907,17 +17174,17 @@ function layerBounds(layers, skip) {
 function hull(points) {
   const pts = [...points].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
   if (pts.length < 3) return pts;
-  const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const cross2 = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
   const lower = [];
   for (const p of pts) {
-    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0)
+    while (lower.length >= 2 && cross2(lower[lower.length - 2], lower[lower.length - 1], p) <= 0)
       lower.pop();
     lower.push(p);
   }
   const upper = [];
   for (let i = pts.length - 1; i >= 0; i--) {
     const p = pts[i];
-    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0)
+    while (upper.length >= 2 && cross2(upper[upper.length - 2], upper[upper.length - 1], p) <= 0)
       upper.pop();
     upper.push(p);
   }
@@ -17562,7 +17829,7 @@ var Parser = class _Parser {
 
 // src/stdlib.ts
 var LIBRARIES = {
-  "kerf/box": '// kerf/box: finger-jointed boxes.\n// Copyright (c) 2026 MyLaserTools. AGPL-3.0-only or MyLaserTools commercial licence.\n\n// Box from its outer size [width, depth, height] in the current material.\n// Edges pair "out" with "in", and the bottom owns every bottom corner,\n// so the six panels interlock without gaps.\nmodule box(size, lid = false, finger = undef) {\n  w = size[0];\n  d = size[1];\n  h = size[2];\n  top = lid ? "in" : "flat";\n  part("bottom") finger_rect([w, d], "out", finger = finger);\n  if (lid) part("lid") finger_rect([w, d], "out", finger = finger);\n  part("front") finger_rect([w, h], ["in", "out", top, "out"], finger = finger);\n  part("back") finger_rect([w, h], ["in", "out", top, "out"], finger = finger);\n  part("left") finger_rect([d, h], ["in", "in", top, "in"], finger = finger);\n  part("right") finger_rect([d, h], ["in", "in", top, "in"], finger = finger);\n}\n\n// Divider that slides between two walls: tabs on both sides drop into\n// finger_holes() cut in the walls.\nmodule divider(size, finger = undef) {\n  finger_rect(size, ["flat", "out", "flat", "out"], finger = finger);\n}\n'
+  "kerf/box": '// kerf/box: finger-jointed boxes.\n// Copyright (c) 2026 MyLaserTools. AGPL-3.0-only or MyLaserTools commercial licence.\n\n// Box from its outer size [width, depth, height] in the current material.\n// Edges pair "out" with "in", and the bottom owns every bottom corner,\n// so the six panels interlock without gaps.\nmodule box(size, lid = false, finger = undef) {\n  w = size[0];\n  d = size[1];\n  h = size[2];\n  t = $thickness;\n  top = lid ? "in" : "flat";\n  part("bottom", at = [0, 0, 0]) finger_rect([w, d], "out", finger = finger);\n  if (lid) part("lid", at = [0, 0, h - t]) finger_rect([w, d], "out", finger = finger);\n  part("front", at = [0, t, 0], rotate = [90, 0, 0])\n    finger_rect([w, h], ["in", "out", top, "out"], finger = finger);\n  part("back", at = [0, d, 0], rotate = [90, 0, 0])\n    finger_rect([w, h], ["in", "out", top, "out"], finger = finger);\n  part("left", rotate = [90, 0, 90])\n    finger_rect([d, h], ["in", "in", top, "in"], finger = finger);\n  part("right", at = [w - t, 0, 0], rotate = [90, 0, 90])\n    finger_rect([d, h], ["in", "in", top, "in"], finger = finger);\n}\n\n// Divider that slides between two walls: tabs on both sides drop into\n// finger_holes() cut in the walls.\nmodule divider(size, finger = undef) {\n  finger_rect(size, ["flat", "out", "flat", "out"], finger = finger);\n}\n'
 };
 
 // src/paths.ts
@@ -17576,7 +17843,7 @@ function flatten(cmds, tolerance = 0.02) {
     if (cur.length >= 2) (close ? closed : open).push(cur);
     cur = [];
   };
-  const steps = (len) => Math.max(2, Math.min(256, Math.ceil(Math.sqrt(len / tolerance))));
+  const steps2 = (len) => Math.max(2, Math.min(256, Math.ceil(Math.sqrt(len / tolerance))));
   for (const c of cmds) {
     if (c.type === "M") {
       finish(false);
@@ -17587,7 +17854,7 @@ function flatten(cmds, tolerance = 0.02) {
       cur.push(last);
     } else if (c.type === "Q") {
       const [x0, y0] = last;
-      const n2 = steps(Math.hypot(c.x1 - x0, c.y1 - y0) + Math.hypot(c.x - c.x1, c.y - c.y1));
+      const n2 = steps2(Math.hypot(c.x1 - x0, c.y1 - y0) + Math.hypot(c.x - c.x1, c.y - c.y1));
       for (let i = 1; i <= n2; i++) {
         const t = i / n2, u = 1 - t;
         cur.push([
@@ -17598,7 +17865,7 @@ function flatten(cmds, tolerance = 0.02) {
       last = [c.x, c.y];
     } else if (c.type === "C") {
       const [x0, y0] = last;
-      const n2 = steps(
+      const n2 = steps2(
         Math.hypot(c.x1 - x0, c.y1 - y0) + Math.hypot(c.x2 - c.x1, c.y2 - c.y1) + Math.hypot(c.x - c.x2, c.y - c.y2)
       );
       for (let i = 1; i <= n2; i++) {
@@ -17869,21 +18136,22 @@ var DEFAULT_LIMITS = {
   maxTextLength: 2e3,
   maxPoints: 2e6,
   maxOutputPoints: 1e6,
-  maxSheets: 200
+  maxSheets: 200,
+  maxCollisionPairs: 2e4
 };
 var SHAPE_COST = 100;
 var LIST_COST = 4;
 var CHARS_PER_ITEM = 8;
 var shapePoints = (s) => {
   let n2 = SHAPE_COST;
-  const add = (layers) => {
+  const add2 = (layers) => {
     for (const l of layers.values()) {
       for (const p of l.regions) n2 += p.length;
       for (const p of l.lines) n2 += p.length;
     }
   };
-  add(s.layers);
-  for (const p of s.parts) add(p.layers);
+  add2(s.layers);
+  for (const p of s.parts) add2(p.layers);
   return n2;
 };
 var Env = class {
@@ -18397,7 +18665,7 @@ var Evaluator = class {
     const max = this.limits.maxListLength;
     const parts = [];
     let n2 = 0;
-    const add = (label, v, quote) => {
+    const add2 = (label, v, quote) => {
       if (parts.length) n2 += 2;
       const r = write(v, max - n2 - label.length, quote);
       n2 += label.length + r.text.length;
@@ -18408,8 +18676,8 @@ var Evaluator = class {
         );
       parts.push(label + r.text);
     };
-    for (const v of a.pos) add("", v, false);
-    for (const [k, v] of a.named) add(`${k} = `, v, true);
+    for (const v of a.pos) add2("", v, false);
+    for (const [k, v] of a.named) add2(`${k} = `, v, true);
     return parts.join(", ");
   }
   arith(op, a, b, at) {
@@ -18512,6 +18780,34 @@ var Evaluator = class {
       return [v[0], v[1] ?? 0];
     throw new Error(`${name} must be a number or [x, y], got ${show(v)}`);
   }
+  vec3(v, name) {
+    const ok = (x) => typeof x === "number" && Number.isFinite(x);
+    if (Array.isArray(v) && (v.length === 2 || v.length === 3) && v.every(ok))
+      return [v[0], v[1], v[2] ?? 0];
+    throw new Error(`${name} must be [x, y, z], got ${show(v)}`);
+  }
+  placements(at, turn2, qty) {
+    const list2 = (v, name) => {
+      if (v === void 0) return [[0, 0, 0]];
+      if (Array.isArray(v) && v.length > 0 && Array.isArray(v[0]))
+        return v.map((item, i) => this.vec3(item, `${name}[${i}]`));
+      return [this.vec3(v, name)];
+    };
+    const ats = list2(at, "at");
+    const turns = list2(turn2, "rotate");
+    for (const [items, name] of [
+      [ats, "at"],
+      [turns, "rotate"]
+    ])
+      if (items.length !== 1 && items.length !== qty)
+        throw new Error(
+          `${name} needs one placement per copy: qty is ${qty} but ${name} has ${items.length}`
+        );
+    return Array.from({ length: qty }, (_, i) => ({
+      at: ats[ats.length === 1 ? 0 : i],
+      rotate: turns[turns.length === 1 ? 0 : i]
+    }));
+  }
   points(v, name) {
     if (!Array.isArray(v)) throw new Error(`${name} must be a list of [x, y] points`);
     return v.map((p, i) => {
@@ -18832,6 +19128,9 @@ var Evaluator = class {
         this.copies += qty;
         if (!(this.copies <= this.limits.maxParts))
           throw new Error(`more than ${this.limits.maxParts} part copies in total, the limit`);
+        const at = this.arg(c.args, "at", -1);
+        const turn2 = this.arg(c.args, "rotate", -1);
+        const placements = at === void 0 && turn2 === void 0 ? void 0 : this.placements(at, turn2, qty);
         const s = c.children();
         return {
           layers: /* @__PURE__ */ new Map(),
@@ -18843,7 +19142,8 @@ var Evaluator = class {
               layers: s.layers,
               thickness: this.thickness(c.env),
               kerf: toNumber(this.dyn(c.env, "$kerf")) || 0,
-              material: toText(this.dyn(c.env, "$material") ?? "material")
+              material: toText(this.dyn(c.env, "$material") ?? "material"),
+              ...placements ? { placements } : {}
             }
           ]
         };
@@ -19189,6 +19489,9 @@ function render(source, options = {}) {
     });
   if (!parts.length) warnings.push("Nothing to cut: the program made no shapes.");
   const infos = [];
+  const assembly = [];
+  const loose = [];
+  const stackedCopies = /* @__PURE__ */ new Set();
   const ready = [];
   for (const p of parts) {
     const material = union2(
@@ -19209,6 +19512,30 @@ function render(source, options = {}) {
       }
       if (regions.length || lines.length) layers.set(k, { regions, lines });
     }
+    if (material.length) {
+      const flat = { name: p.name, thickness: p.thickness, outline: material };
+      if (p.placements) {
+        const seen = /* @__PURE__ */ new Set();
+        p.placements.forEach((placement, i) => {
+          const part = { ...flat, copy: i + 1, matrix: placementMatrix(placement), placed: true };
+          assembly.push(part);
+          const key = part.matrix.map((v) => v.toFixed(6)).join(",");
+          if (seen.has(key)) stackedCopies.add(part);
+          seen.add(key);
+        });
+        if (seen.size < p.placements.length)
+          warnings.push(
+            `Copies of part "${p.name}" are in the same place in the assembly. Give at a list with one placement per copy to spread them out.`
+          );
+      } else
+        for (let i = 0; i < p.qty; i++)
+          loose.push({
+            ...flat,
+            copy: i + 1,
+            matrix: placementMatrix({ at: [0, 0, 0], rotate: [0, 0, 0] }),
+            placed: false
+          });
+    }
     const n2 = pieces(material).length;
     if (n2 > 1)
       warnings.push(
@@ -19250,6 +19577,27 @@ function render(source, options = {}) {
     infos.push(info);
     ready.push({ info, layers });
   }
+  const { found: clashes, complete } = collisions(
+    assembly.filter((part) => !stackedCopies.has(part)),
+    limits.maxCollisionPairs
+  );
+  if (!complete)
+    warnings.push(
+      `The assembly has more than ${limits.maxCollisionPairs} pairs of touching parts, the limit, so only those were checked for collisions.`
+    );
+  for (const [a, b] of clashes.slice(0, 5))
+    warnings.push(
+      `Parts "${a.name}"${a.copy > 1 ? ` (copy ${a.copy})` : ""} and "${b.name}"${b.copy > 1 ? ` (copy ${b.copy})` : ""} collide in the assembly. Check their edges and where they are placed.`
+    );
+  if (clashes.length > 5)
+    warnings.push(`${clashes.length - 5} more pairs of parts collide in the assembly.`);
+  if (assembly.length && loose.length) {
+    const names = [...new Set(loose.map((p) => `"${p.name}"`))];
+    warnings.push(
+      `${names.length === 1 ? "Part" : "Parts"} ${names.slice(0, 5).join(", ")}${names.length > 5 ? ` and ${names.length - 5} more` : ""} ${names.length === 1 ? "has" : "have"} no at or rotate, so ${names.length === 1 ? "it lies" : "they lie"} flat beside the assembly.`
+    );
+    assembly.push(...besideAssembly(assembly, loose));
+  }
   let outputPoints = 0;
   for (const r of ready) {
     let n2 = 0;
@@ -19396,7 +19744,7 @@ function render(source, options = {}) {
     };
   }
   const single = sheets.length === 1 ? sheets[0] : void 0;
-  const stacked = single ? [] : sheets.flatMap((s, i) => {
+  const stacked2 = single ? [] : sheets.flatMap((s, i) => {
     const dy = sheets.slice(0, i).reduce((acc, p) => acc + p.height + 10, 0);
     return s.items.map((it) => ({ ...it, layers: moved(it.layers, [1, 0, 0, 1, 0, dy]) }));
   });
@@ -19404,8 +19752,8 @@ function render(source, options = {}) {
   const height = round2(
     Math.max(1, sheets.reduce((acc, s) => acc + s.height, 0) + 10 * Math.max(0, sheets.length - 1))
   );
-  const svg = single ? single.svg : toSvg(stacked, width, height, layerList);
-  const paths = single ? single.paths : layerPaths(stacked, layerList);
+  const svg = single ? single.svg : toSvg(stacked2, width, height, layerList);
+  const paths = single ? single.paths : layerPaths(stacked2, layerList);
   return {
     sheets,
     width: single?.width ?? width,
@@ -19413,6 +19761,7 @@ function render(source, options = {}) {
     paths,
     svg,
     parts: infos,
+    assembly,
     layers: layerList,
     warnings,
     echoes: res.echoes
@@ -19503,7 +19852,7 @@ function parameters(source) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.4.0";
 var LANGUAGE_VERSION = "0.1";
 
 // fonts/AtkinsonHyperlegible-Regular.ttf