ldr 0.0.0-alpha.1 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,876 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import fs4 from "node:fs";
+import zlib from "node:zlib";
+
+// src/node/build-pack.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// src/node/resolver.ts
+import fs from "node:fs";
+import path from "node:path";
+var TOP_STUD_RE = /^(stud|studa|stud2|stud2a|stud6|stud6a|stud10|stud15|stud2s|stud2s2|stud-logo\d*|stud2-logo\d*)\.dat$/i;
+var UNDER_STUD_RE = /^(stud3|stud3a|stud4.*|stud12|stud16.*|stud18a)\.dat$/i;
+var norm = (ref) => ref.trim().replace(/\\/g, "/").toLowerCase();
+var threeName = (ref) => {
+  const n = norm(ref);
+  if (n.startsWith("s/"))
+    return "parts/" + n;
+  if (n.startsWith("48/"))
+    return "p/" + n;
+  return n;
+};
+function parseType1(line) {
+  const t = line.trim().split(/\s+/);
+  if (t[0] !== "1" || t.length < 15)
+    return null;
+  const v = t.slice(2, 14).map(Number);
+  return { color: t[1], m: v, name: t.slice(14).join(" ") };
+}
+function xf(m, p) {
+  return [
+    m[0] + m[3] * p[0] + m[4] * p[1] + m[5] * p[2],
+    m[1] + m[6] * p[0] + m[7] * p[1] + m[8] * p[2],
+    m[2] + m[9] * p[0] + m[10] * p[1] + m[11] * p[2]
+  ];
+}
+function compose(a, b) {
+  const r = (i, j) => a[3 + i * 3] * b[3 + j] + a[3 + i * 3 + 1] * b[6 + j] + a[3 + i * 3 + 2] * b[9 + j];
+  const t = xf(a, [b[0], b[1], b[2]]);
+  return [t[0], t[1], t[2], r(0, 0), r(0, 1), r(0, 2), r(1, 0), r(1, 1), r(1, 2), r(2, 0), r(2, 1), r(2, 2)];
+}
+var IDENT = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1];
+
+class Library {
+  root;
+  index;
+  text;
+  stats;
+  constructor(root) {
+    this.root = root;
+    this.index = new Map;
+    this.text = new Map;
+    this.stats = new Map;
+    for (const d of ["parts", "p", "models"])
+      this.#walk(path.join(root, d), d);
+  }
+  #walk(dir, rel) {
+    if (!fs.existsSync(dir))
+      return;
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      const r = rel + "/" + e.name;
+      if (e.isDirectory())
+        this.#walk(path.join(dir, e.name), r);
+      else
+        this.index.set(r.toLowerCase(), path.join(dir, e.name));
+    }
+  }
+  resolve(ref) {
+    const n = norm(ref);
+    for (const pre of ["parts/", "p/", "models/"])
+      if (this.index.has(pre + n))
+        return pre + n;
+    return null;
+  }
+  read(key) {
+    if (!this.text.has(key))
+      this.text.set(key, fs.readFileSync(this.index.get(key), "latin1"));
+    return this.text.get(key);
+  }
+  isPart(key) {
+    return key.startsWith("parts/") && !key.startsWith("parts/s/");
+  }
+  fileStats(key) {
+    if (this.stats.has(key))
+      return this.stats.get(key);
+    const s = { tris: 0, studTris: 0, underTris: 0, studs: [], min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity], missing: new Set };
+    this.stats.set(key, s);
+    const base = path.basename(key);
+    const isTop = TOP_STUD_RE.test(base), isUnder = UNDER_STUD_RE.test(base);
+    const grow = (p) => {
+      for (let i = 0;i < 3; i++) {
+        if (p[i] < s.min[i])
+          s.min[i] = p[i];
+        if (p[i] > s.max[i])
+          s.max[i] = p[i];
+      }
+    };
+    for (const line of this.read(key).split(/\r?\n/)) {
+      const t = line.trim();
+      const c = t[0];
+      if (c === "3" || c === "4") {
+        const v = t.split(/\s+/).slice(2).map(Number);
+        const nt = c === "3" ? 1 : 2;
+        s.tris += nt;
+        for (let i = 0;i + 2 < v.length; i += 3)
+          grow([v[i], v[i + 1], v[i + 2]]);
+      } else if (c === "1") {
+        const r = parseType1(t);
+        if (!r)
+          continue;
+        const ck = this.resolve(r.name);
+        if (!ck) {
+          s.missing.add(norm(r.name));
+          continue;
+        }
+        const cs = this.fileStats(ck);
+        s.tris += cs.tris;
+        s.studTris += cs.studTris;
+        s.underTris += cs.underTris;
+        for (const m of cs.missing)
+          s.missing.add(m);
+        if (TOP_STUD_RE.test(path.basename(ck)))
+          s.studs.push([r.m[0], r.m[1], r.m[2]]);
+        else
+          for (const p of cs.studs)
+            s.studs.push(xf(r.m, p));
+        if (isFinite(cs.min[0])) {
+          for (const x of [cs.min[0], cs.max[0]])
+            for (const y of [cs.min[1], cs.max[1]])
+              for (const z of [cs.min[2], cs.max[2]])
+                grow(xf(r.m, [x, y, z]));
+        }
+      }
+    }
+    if (isTop) {
+      s.studTris = s.tris;
+    }
+    if (isUnder) {
+      s.underTris = s.tris;
+    }
+    return s;
+  }
+}
+function splitModel(text, fallbackName = "main.ldr") {
+  const files = new Map;
+  let cur = null, buf = [], main = null;
+  for (const line of text.split(/\r?\n/)) {
+    const m = /^\s*0\s+FILE\s+(.+)$/i.exec(line);
+    if (m) {
+      if (cur)
+        files.set(cur, buf.join(`
+`));
+      cur = norm(m[1]);
+      buf = [];
+      if (!main)
+        main = cur;
+      continue;
+    }
+    if (/^\s*0\s+NOFILE/i.test(line))
+      continue;
+    if (!cur) {
+      cur = norm(fallbackName);
+      main = cur;
+    }
+    buf.push(line);
+  }
+  if (cur)
+    files.set(cur, buf.join(`
+`));
+  return { files, main };
+}
+function flatten(model, lib, onInstance) {
+  const missing = new Map;
+  const walk = (name, parentM, parentColor, depth) => {
+    if (depth > 32)
+      return;
+    for (const line of model.files.get(name).split(`
+`)) {
+      const r = parseType1(line);
+      if (!r)
+        continue;
+      const color = r.color === "16" ? parentColor : r.color;
+      const m = compose(parentM, r.m);
+      const n = norm(r.name);
+      if (model.files.has(n)) {
+        walk(n, m, color, depth + 1);
+        continue;
+      }
+      const key = lib.resolve(r.name);
+      if (!key) {
+        missing.set(n, (missing.get(n) || 0) + 1);
+        continue;
+      }
+      onInstance({ part: key, ref: n, color, m });
+    }
+  };
+  walk(model.main, IDENT, "16", 0);
+  return { missing };
+}
+function collectDeps(lib, refs) {
+  const out = new Map;
+  const stack = [...refs];
+  while (stack.length) {
+    const ref = stack.pop();
+    const tn = threeName(ref);
+    if (out.has(tn))
+      continue;
+    const key = lib.resolve(ref);
+    if (!key)
+      continue;
+    out.set(tn, key);
+    for (const line of lib.read(key).split(/\r?\n/)) {
+      const r = parseType1(line);
+      if (r)
+        stack.push(r.name);
+    }
+  }
+  return out;
+}
+
+// src/node/compile.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+function loadColors(root) {
+  const map = new Map;
+  for (const l of fs2.readFileSync(path2.join(root, "LDConfig.ldr"), "latin1").split(/\r?\n/)) {
+    const m = /!COLOUR\s+\S+\s+CODE\s+(\d+)\s+VALUE\s+#([0-9A-Fa-f]{6})/.exec(l);
+    if (m) {
+      const h = parseInt(m[2], 16);
+      map.set(m[1], [(h >> 16) / 255, (h >> 8 & 255) / 255, (h & 255) / 255]);
+    }
+  }
+  return map;
+}
+var det3 = (m) => m[3] * (m[7] * m[11] - m[8] * m[10]) - m[4] * (m[6] * m[11] - m[8] * m[9]) + m[5] * (m[6] * m[10] - m[7] * m[9]);
+
+class Compiler {
+  lib;
+  opts;
+  colors;
+  cache = new Map;
+  constructor(lib, opts) {
+    this.lib = lib;
+    this.opts = opts;
+    this.colors = loadColors(lib.root);
+  }
+  resolve(ref, isStud) {
+    const key = this.lib.resolve(ref);
+    if (!key)
+      return null;
+    const low = isStud ? this.opts.studs === "low" : this.opts.prims === "low";
+    if (low && key.startsWith("p/") && !key.startsWith("p/8/") && !key.startsWith("p/48/")) {
+      const alt = "p/8/" + key.slice(2);
+      if (this.lib.index.has(alt))
+        return alt;
+    }
+    if (low && key.startsWith("p/48/")) {
+      const alt = "p/8/" + key.slice(5);
+      if (this.lib.index.has(alt))
+        return alt;
+      const a2 = "p/" + key.slice(5);
+      if (this.lib.index.has(a2))
+        return a2;
+    }
+    return key;
+  }
+  compile(key, separateStuds = this.opts.separateStuds) {
+    const ck = key + (separateStuds ? "" : "#nostudsep");
+    if (this.cache.has(ck))
+      return this.cache.get(ck);
+    const out = { body: { pos: [], col: [] }, under: { pos: [], col: [] }, edges: [], condLines: 0, studs: [], bbox: [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity], fullBottom: false };
+    const colorOf = (code) => code === "16" ? [1, 1, 1, 0] : [...this.colors.get(code) || (code.startsWith("0x2") ? [parseInt(code.slice(3, 5), 16) / 255, parseInt(code.slice(5, 7), 16) / 255, parseInt(code.slice(7, 9), 16) / 255] : [1, 0, 1]), 1];
+    const walk = (fk, M, color, invert, target, depth) => {
+      if (depth > 40)
+        return;
+      let ccw = true, certified = false, invertNext = false;
+      for (const raw of this.lib.read(fk).split(/\r?\n/)) {
+        const t = raw.trim();
+        if (!t)
+          continue;
+        const c = t[0];
+        if (c === "0") {
+          if (/^0\s+BFC/.test(t)) {
+            if (/CERTIFY/.test(t) && !/NOCERTIFY/.test(t))
+              certified = true;
+            if (/\bCW\b/.test(t))
+              ccw = false;
+            if (/\bCCW\b/.test(t))
+              ccw = true;
+            if (/INVERTNEXT/.test(t))
+              invertNext = true;
+          }
+          continue;
+        }
+        if (c === "1") {
+          const r = parseType1(t);
+          if (!r)
+            continue;
+          const base = r.name.trim().replace(/\\/g, "/").split("/").pop().toLowerCase();
+          const isTop = TOP_STUD_RE.test(base), isUnder = UNDER_STUD_RE.test(base);
+          const ck2 = this.resolve(r.name, isTop);
+          if (!ck2) {
+            invertNext = false;
+            continue;
+          }
+          const childColor = r.color === "16" ? color : r.color;
+          const Mc = compose(M, r.m);
+          const inv = invert !== invertNext !== det3(r.m) < 0;
+          invertNext = false;
+          if (isTop && separateStuds) {
+            out.studs.push({ kind: ck2, color: childColor, m: Mc });
+            growBox(out.bbox, Mc, this.compile(ck2, false).bbox);
+            continue;
+          }
+          walk(ck2, Mc, childColor, inv, isUnder ? "under" : target, depth + 1);
+          continue;
+        }
+        const tok = t.split(/\s+/);
+        if (c === "2") {
+          const v = tok.slice(2, 8).map(Number);
+          out.edges.push(...xf(M, v.slice(0, 3)), ...xf(M, v.slice(3, 6)));
+          continue;
+        }
+        if (c === "5") {
+          out.condLines++;
+          continue;
+        }
+        if (c === "3" || c === "4") {
+          const code = tok[1] === "16" ? color : tok[1];
+          const n = c === "3" ? 3 : 4;
+          const v = tok.slice(2, 2 + n * 3).map(Number);
+          const pts = [];
+          for (let i = 0;i < n; i++)
+            pts.push(xf(M, v.slice(i * 3, i * 3 + 3)));
+          for (const p of pts)
+            grow(out.bbox, p);
+          let order = n === 3 ? [0, 1, 2] : [0, 1, 2, 0, 2, 3];
+          if (!ccw !== invert)
+            order = n === 3 ? [0, 2, 1] : [0, 2, 1, 0, 3, 2];
+          const rgba = colorOf(code);
+          const b = out[target];
+          for (const i of order) {
+            b.pos.push(...pts[i]);
+            b.col.push(...rgba);
+          }
+        }
+      }
+      if (!certified)
+        out.uncertified = true;
+    };
+    walk(key, IDENT, "16", false, "body", 0);
+    const [x0, y0, z0, x1, y1, z1] = out.bbox;
+    let ax0 = Infinity, ax1 = -Infinity, az0 = Infinity, az1 = -Infinity;
+    for (const b of [out.body, out.under])
+      for (let i = 0;i < b.pos.length; i += 3)
+        if (b.pos[i + 1] > y1 - 0.5) {
+          ax0 = Math.min(ax0, b.pos[i]);
+          ax1 = Math.max(ax1, b.pos[i]);
+          az0 = Math.min(az0, b.pos[i + 2]);
+          az1 = Math.max(az1, b.pos[i + 2]);
+        }
+    out.fullBottom = isFinite(x0) && ax0 <= x0 + 0.5 && ax1 >= x1 - 0.5 && az0 <= z0 + 0.5 && az1 >= z1 - 0.5;
+    if (separateStuds && isFinite(x0))
+      out.bottomMask = enclosureMask(out);
+    this.cache.set(ck, out);
+    return out;
+  }
+}
+function enclosureMask(c) {
+  const [x0, , z0, x1, y1, z1] = c.bbox;
+  const nx = Math.round((x1 - x0) / 20), nz = Math.round((z1 - z0) / 20);
+  if (!nx || !nz || nx * nz > 4096)
+    return;
+  const tris = [];
+  for (const b of [c.body, c.under])
+    for (let i = 0;i < b.pos.length; i += 9) {
+      const t = b.pos.slice(i, i + 9);
+      if (Math.max(t[1], t[4], t[7]) < y1 - 6)
+        continue;
+      tris.push(t);
+    }
+  let yRay = y1 - 2;
+  const bits = [];
+  const BIN = 4;
+  const buckets = [new Map, new Map];
+  for (const t of tris) {
+    if (Math.min(t[1], t[4], t[7]) > y1 - 0.5 || Math.max(t[1], t[4], t[7]) < y1 - 4)
+      continue;
+    for (const [ai, o] of [[0, 2], [1, 0]]) {
+      const lo = Math.floor(Math.min(t[o], t[3 + o], t[6 + o]) / BIN), hi = Math.floor(Math.max(t[o], t[3 + o], t[6 + o]) / BIN);
+      for (let k = lo;k <= hi; k++)
+        (buckets[ai].get(k) || buckets[ai].set(k, []).get(k)).push(t);
+    }
+  }
+  const hit = (px, pz, axis, sign) => {
+    const o = axis === 0 ? 2 : 0;
+    const pv = axis === 0 ? pz : px;
+    for (const t of buckets[axis === 0 ? 0 : 1].get(Math.floor(pv / BIN)) || []) {
+      const a = [t[1], t[o]], b = [t[4], t[3 + o]], d = [t[7], t[6 + o]];
+      const den = (b[1] - d[1]) * (a[0] - d[0]) + (d[0] - b[0]) * (a[1] - d[1]);
+      if (Math.abs(den) < 0.000000001)
+        continue;
+      const y = yRay;
+      const w1 = ((b[1] - d[1]) * (y - d[0]) + (d[0] - b[0]) * (pv - d[1])) / den, w2 = ((d[1] - a[1]) * (y - d[0]) + (a[0] - d[0]) * (pv - d[1])) / den, w3 = 1 - w1 - w2;
+      if (w1 < -0.000001 || w2 < -0.000001 || w3 < -0.000001)
+        continue;
+      const along = w1 * t[axis] + w2 * t[3 + axis] + w3 * t[6 + axis];
+      const start = axis === 0 ? px : pz;
+      if ((along - start) * sign > 0.01)
+        return true;
+    }
+    return false;
+  };
+  for (let a = 0;a < nx; a++)
+    for (let b = 0;b < nz; b++) {
+      const px = x0 + 10 + 20 * a, pz = z0 + 10 + 20 * b;
+      let ok = true;
+      for (const yy of [y1 - 1, y1 - 3.5]) {
+        yRay = yy;
+        for (const [ox, oz] of [[0, 0], [5, 5], [-5, 5], [5, -5], [-5, -5]]) {
+          const qx = px + ox, qz = pz + oz;
+          if (!(hit(qx, qz, 0, 1) && hit(qx, qz, 0, -1) && hit(qx, qz, 2, 1) && hit(qx, qz, 2, -1))) {
+            ok = false;
+            break;
+          }
+        }
+        if (!ok)
+          break;
+      }
+      bits.push(ok ? 1 : 0);
+    }
+  return { nx, nz, bits };
+}
+function grow(b, p) {
+  for (let i = 0;i < 3; i++) {
+    if (p[i] < b[i])
+      b[i] = p[i];
+    if (p[i] > b[i + 3])
+      b[i + 3] = p[i];
+  }
+}
+function growBox(b, M, cb) {
+  if (!isFinite(cb[0]))
+    return;
+  for (const x of [cb[0], cb[3]])
+    for (const y of [cb[1], cb[4]])
+      for (const z of [cb[2], cb[5]])
+        grow(b, xf(M, [x, y, z]));
+}
+function writePack(file, parts, studKinds, weld, extra) {
+  fs2.writeFileSync(file, encodePack(parts, studKinds, weld, extra));
+}
+function encodePack(parts, studKinds, weld, extra) {
+  const chunks = [];
+  let off = 0;
+  const put = (a) => {
+    const pad = (4 - off % 4) % 4;
+    if (pad) {
+      chunks.push(new Uint8Array(pad));
+      off += pad;
+    }
+    const r = [off, a.length, a instanceof Float32Array ? "f32" : a instanceof Uint16Array ? "u16" : "u32"];
+    chunks.push(a);
+    off += a.byteLength;
+    return r;
+  };
+  const bucket = (b) => {
+    const n = b.pos.length / 3;
+    if (!n)
+      return null;
+    const nrm = new Float32Array(n * 3);
+    for (let i = 0;i < n; i += 3) {
+      const p = b.pos;
+      const a = i * 3;
+      const ux = p[a + 3] - p[a], uy = p[a + 4] - p[a + 1], uz = p[a + 5] - p[a + 2], vx = p[a + 6] - p[a], vy = p[a + 7] - p[a + 1], vz = p[a + 8] - p[a + 2];
+      let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+      const l = Math.hypot(nx, ny, nz) || 1;
+      nx /= l;
+      ny /= l;
+      nz /= l;
+      for (let k = 0;k < 3; k++) {
+        nrm[(i + k) * 3] = nx;
+        nrm[(i + k) * 3 + 1] = ny;
+        nrm[(i + k) * 3 + 2] = nz;
+      }
+    }
+    if (!weld)
+      return { pos: put(new Float32Array(b.pos)), nrm: put(nrm), col: put(new Float32Array(b.col)), tris: n / 3 };
+    const map = new Map;
+    const P = [], N = [], C = [], I = [];
+    for (let i = 0;i < n; i++) {
+      const k = `${b.pos[i * 3].toFixed(3)},${b.pos[i * 3 + 1].toFixed(3)},${b.pos[i * 3 + 2].toFixed(3)},${nrm[i * 3].toFixed(3)},${nrm[i * 3 + 1].toFixed(3)},${nrm[i * 3 + 2].toFixed(3)},${b.col.slice(i * 4, i * 4 + 4).join()}`;
+      let j = map.get(k);
+      if (j === undefined) {
+        j = P.length / 3;
+        map.set(k, j);
+        P.push(b.pos[i * 3], b.pos[i * 3 + 1], b.pos[i * 3 + 2]);
+        N.push(nrm[i * 3], nrm[i * 3 + 1], nrm[i * 3 + 2]);
+        C.push(...b.col.slice(i * 4, i * 4 + 4));
+      }
+      I.push(j);
+    }
+    const vcount = P.length / 3;
+    return { pos: put(new Float32Array(P)), nrm: put(new Float32Array(N)), col: put(new Float32Array(C)), idx: put(vcount < 65536 ? new Uint16Array(I) : new Uint32Array(I)), tris: n / 3 };
+  };
+  const enc = (c) => ({ body: bucket(c.body), under: bucket(c.under), edges: c.edges.length ? put(new Float32Array(c.edges)) : null, cond: c.condLines, studs: c.studs.map((s) => [s.kind, s.color, ...s.m.map((x) => +x.toFixed(4))]), bbox: c.bbox, fullBottom: c.fullBottom, uncert: !!c.uncertified, mask: c.bottomMask ? [c.bottomMask.nx, c.bottomMask.nz, c.bottomMask.bits.join("")] : null });
+  const header = { version: 1, weld, parts: Object.fromEntries([...parts].map(([k, c]) => [k, enc(c)])), studKinds: Object.fromEntries([...studKinds].map(([k, c]) => [k, enc(c)])), ...extra };
+  const hj = new TextEncoder().encode(JSON.stringify(header));
+  const hpad = (4 - (4 + hj.length) % 4) % 4;
+  const head = new Uint8Array(4 + hj.length + hpad);
+  new DataView(head.buffer).setUint32(0, hj.length + hpad, true);
+  head.set(hj, 4);
+  head.fill(32, 4 + hj.length);
+  return Buffer.concat([head, ...chunks.map((c) => new Uint8Array(c.buffer, c.byteOffset, c.byteLength))]);
+}
+
+// src/spec.ts
+var norm2 = (s) => s.trim().toLowerCase().replace(/\\/g, "/").replace(/\/+/g, "/");
+function parseColor(tok) {
+  if (/^0x/i.test(tok))
+    return parseInt(tok, 16);
+  return +tok;
+}
+var MOVED_RE = /^~?\s*moved\s+to\s+(.+)$/i;
+function parse(src, name = "main.ldr") {
+  const files = new Map;
+  let cur = null;
+  let main = "";
+  const start = (n) => {
+    cur = { name: norm2(n), cmds: [] };
+    files.set(cur.name, cur);
+    if (!main)
+      main = cur.name;
+  };
+  for (const raw of src.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    const tk = line.split(/\s+/);
+    const t = +tk[0];
+    if (t === 0) {
+      const text = line.slice(1).trim();
+      if (tk[1] === "FILE") {
+        start(text.slice(5));
+        continue;
+      }
+      if (tk[1] === "NOFILE") {
+        cur = null;
+        continue;
+      }
+      if (!cur)
+        start(name);
+      const c = { t: 0, text };
+      if (tk[1] === "STEP")
+        c.step = true;
+      else if (tk[1] === "BFC")
+        c.bfc = tk.slice(2).join(" ");
+      else if (tk[1] === "ROTSTEP") {
+        c.meta = "ROTSTEP";
+        if ((tk[2] ?? "").toUpperCase() === "END")
+          c.rotstep = { x: 0, y: 0, z: 0, mode: "END" };
+        else {
+          const mode = (tk[5] ?? "REL").toUpperCase();
+          c.rotstep = { x: +tk[2] || 0, y: +tk[3] || 0, z: +tk[4] || 0, mode: ["REL", "ABS", "ADD"].includes(mode) ? mode : "REL" };
+        }
+      } else if (tk[1] === "BUFEXCHG") {
+        c.meta = "BUFEXCHG";
+        const op = (tk[2] ?? "").toUpperCase();
+        c.bufexchg = { op: op === "RETRIEVE" ? "RETRIEVE" : "STORE", buf: tk[3] ?? "A" };
+      } else if (tk[1]?.startsWith("!"))
+        c.meta = tk[1];
+      const moved = text.match(MOVED_RE);
+      if (moved && !cur.movedTo) {
+        let target = moved[1].trim().replace(/\\/g, "/");
+        if (!/\.(dat|ldr|mpd)$/i.test(target))
+          target += ".dat";
+        cur.movedTo = norm2(target);
+      }
+      cur.cmds.push(c);
+      continue;
+    }
+    if (!cur)
+      start(name);
+    const color = parseColor(tk[1]);
+    const nums = tk.slice(2).map(Number);
+    if (t === 1)
+      cur.cmds.push({ t: 1, color, m: nums.slice(0, 12), file: norm2(tk.slice(14).join(" ")) });
+    else if (t === 2)
+      cur.cmds.push({ t: 2, color, p: nums.slice(0, 6) });
+    else if (t === 3)
+      cur.cmds.push({ t: 3, color, p: nums.slice(0, 9) });
+    else if (t === 4)
+      cur.cmds.push({ t: 4, color, p: nums.slice(0, 12) });
+    else if (t === 5)
+      cur.cmds.push({ t: 5, color, p: nums.slice(0, 12) });
+  }
+  return { main, files };
+}
+function mul(a, b) {
+  const [ax, ay, az, a0, a1, a2, a3, a4, a5, a6, a7, a8] = a, [bx, by, bz, b0, b1, b2, b3, b4, b5, b6, b7, b8] = b;
+  return [
+    a0 * bx + a1 * by + a2 * bz + ax,
+    a3 * bx + a4 * by + a5 * bz + ay,
+    a6 * bx + a7 * by + a8 * bz + az,
+    a0 * b0 + a1 * b3 + a2 * b6,
+    a0 * b1 + a1 * b4 + a2 * b7,
+    a0 * b2 + a1 * b5 + a2 * b8,
+    a3 * b0 + a4 * b3 + a5 * b6,
+    a3 * b1 + a4 * b4 + a5 * b7,
+    a3 * b2 + a4 * b5 + a5 * b8,
+    a6 * b0 + a7 * b3 + a8 * b6,
+    a6 * b1 + a7 * b4 + a8 * b7,
+    a6 * b2 + a7 * b5 + a8 * b8
+  ];
+}
+var I = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1];
+var isDirectColor = (c) => c > 16777215;
+function smoothNormals(pos, edges, cond, creaseDeg = 35) {
+  const q = (i, a) => `${a[i].toFixed(2)},${a[i + 1].toFixed(2)},${a[i + 2].toFixed(2)}`;
+  const ek = (a, b) => a < b ? a + "|" + b : b + "|" + a;
+  const hard = new Set, soft = new Set;
+  for (let i = 0;i < edges.length; i += 6)
+    hard.add(ek(q(i, edges), q(i + 3, edges)));
+  const stride = cond.length > 0 && cond.length % 12 === 0 ? 12 : 6;
+  for (let i = 0;i < cond.length; i += stride)
+    soft.add(ek(q(i, cond), q(i + 3, cond)));
+  const nT = pos.length / 9, fn = [], vk = [];
+  for (let t = 0;t < nT; t++) {
+    const a = t * 9;
+    const u = [pos[a + 3] - pos[a], pos[a + 4] - pos[a + 1], pos[a + 5] - pos[a + 2]], v = [pos[a + 6] - pos[a], pos[a + 7] - pos[a + 1], pos[a + 8] - pos[a + 2]];
+    const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
+    const l = Math.hypot(...n) || 1;
+    fn.push(n.map((x) => x / l));
+    for (let k = 0;k < 3; k++)
+      vk.push(q(a + k * 3, pos));
+  }
+  const byV = new Map;
+  vk.forEach((k, i) => (byV.get(k) ?? byV.set(k, []).get(k)).push(i));
+  const edgeFaces = new Map;
+  for (let t = 0;t < nT; t++)
+    for (let k = 0;k < 3; k++) {
+      const e = ek(vk[t * 3 + k], vk[t * 3 + (k + 1) % 3]);
+      (edgeFaces.get(e) ?? edgeFaces.set(e, []).get(e)).push(t);
+    }
+  const cosC = Math.cos(creaseDeg * Math.PI / 180), out = new Float32Array(pos.length);
+  const joinable = (e, a, b) => {
+    if (hard.has(e))
+      return false;
+    const d = fn[a][0] * fn[b][0] + fn[a][1] * fn[b][1] + fn[a][2] * fn[b][2];
+    return soft.has(e) ? d > -0.2 : d > cosC;
+  };
+  for (const [key, corners] of byV) {
+    const faces = corners.map((c) => c / 3 | 0), par = faces.map((_, i) => i);
+    const f = (i) => par[i] === i ? i : par[i] = f(par[i]);
+    for (let i = 0;i < faces.length; i++)
+      for (let j = i + 1;j < faces.length; j++) {
+        const A = faces[i], B = faces[j];
+        const va = [0, 1, 2].map((k) => vk[A * 3 + k]), vb = new Set([0, 1, 2].map((k) => vk[B * 3 + k]));
+        for (const o of va)
+          if (o !== key && vb.has(o)) {
+            const e = ek(key, o);
+            if ((edgeFaces.get(e)?.length ?? 0) >= 2 && joinable(e, A, B))
+              par[f(i)] = f(j);
+          }
+      }
+    const acc = new Map;
+    faces.forEach((F, i) => {
+      const r = f(i), s = acc.get(r) ?? [0, 0, 0];
+      s[0] += fn[F][0];
+      s[1] += fn[F][1];
+      s[2] += fn[F][2];
+      acc.set(r, s);
+    });
+    corners.forEach((c, i) => {
+      const s = acc.get(f(i)), l = Math.hypot(...s) || 1;
+      out[c * 3] = s[0] / l;
+      out[c * 3 + 1] = s[1] / l;
+      out[c * 3 + 2] = s[2] / l;
+    });
+  }
+  return out;
+}
+
+// src/model.ts
+function flatten2(doc, opts = {}) {
+  const out = [];
+  const maxDepth = opts.maxDepth ?? 64;
+  const walk = (d, fname, m, color, path, stepPath, depth) => {
+    const f = d.files.get(fname);
+    if (!f || depth > maxDepth)
+      return;
+    let s = 0;
+    for (const c of f.cmds) {
+      if (c.t === 0 && c.step)
+        s++;
+      if (c.t !== 1)
+        continue;
+      const col = c.color === 16 ? color : c.color, mm = mul(m, c.m), sp = [...stepPath, s];
+      if (d.files.has(c.file)) {
+        walk(d, c.file, mm, col, path + "/" + c.file, sp, depth + 1);
+        continue;
+      }
+      const ext = opts.resolveModel?.(c.file);
+      if (ext) {
+        walk(ext, ext.main, mm, col, path + "/" + c.file, sp, depth + 1);
+        continue;
+      }
+      out.push({ part: c.file, color: col, m: mm, step: sp[0], steps: sp, path });
+    }
+  };
+  walk(doc, doc.main, I, 16, doc.main, [], 0);
+  return out;
+}
+function parseModel(text, name = "main.ldr", opts) {
+  return flatten2(parse(text, name), opts);
+}
+function sequenceSteps(insts) {
+  const key = (i) => i.steps.map((x) => String(x).padStart(6, "0")).join(".");
+  const uniq = [...new Set(insts.map(key))].sort();
+  const rank = new Map(uniq.map((k, j) => [k, j]));
+  const stepOf = new Int32Array(insts.length);
+  insts.forEach((i, k) => stepOf[k] = rank.get(key(i)));
+  return { count: uniq.length, stepOf };
+}
+function parseLDConfig(text) {
+  const out = new Map;
+  for (const l of text.split(/\r?\n/)) {
+    const m = /!COLOUR\s+(\S+)\s+CODE\s+(\d+)\s+VALUE\s+(#[0-9A-Fa-f]{6})\s+EDGE\s+(\S+)(?:.*?ALPHA\s+(\d+))?/.exec(l);
+    if (m)
+      out.set(+m[2], { code: +m[2], name: m[1], hex: m[3].toUpperCase(), edge: m[4], alpha: m[5] ? +m[5] : 255 });
+  }
+  return out;
+}
+
+// src/node/build-pack.ts
+function buildPack(o) {
+  const lib = new Library(o.ldrawRoot);
+  const refs = new Map;
+  const missing = new Set;
+  for (const m of o.models ?? []) {
+    const { name, text } = typeof m === "string" ? { name: path3.basename(m), text: fs3.readFileSync(m, "latin1") } : m;
+    const r = flatten(splitModel(text, name), lib, (i) => refs.set(i.ref, i.part));
+    for (const k of r.missing.keys())
+      missing.add(k);
+  }
+  for (const p of o.parts ?? []) {
+    const k = lib.resolve(p);
+    if (k)
+      refs.set(norm(p), k);
+    else
+      missing.add(norm(p));
+  }
+  if (o.allParts) {
+    for (const k of lib.index.keys())
+      if (lib.isPart(k) && /\.dat$/.test(k))
+        refs.set(k.slice(6), k);
+  }
+  const comp = new Compiler(lib, { studs: o.studs ?? "low", prims: o.primitives ?? "full", weld: o.weld ?? true, separateStuds: true });
+  const parts = new Map, kinds = new Map;
+  let n = 0;
+  for (const [ref, key] of refs) {
+    try {
+      const c = comp.compile(key);
+      parts.set(ref, c);
+      for (const s of c.studs)
+        if (!kinds.has(s.kind))
+          kinds.set(s.kind, comp.compile(s.kind, false));
+    } catch {
+      missing.add(ref);
+    }
+    o.onProgress?.(++n, refs.size);
+  }
+  let extra;
+  if (o.colors !== false) {
+    const cfg = path3.join(o.ldrawRoot, "LDConfig.ldr");
+    if (fs3.existsSync(cfg))
+      extra = { colors: Object.fromEntries([...parseLDConfig(fs3.readFileSync(cfg, "latin1"))].map(([k, v]) => [k, v.hex])) };
+  }
+  return { data: encodePack(parts, kinds, comp.opts.weld, extra), parts: parts.size, studKinds: kinds.size, missing: [...missing] };
+}
+
+// src/cli.ts
+var HELP = `ldr pack — build a parts pack for the ldr three.js renderer
+
+Usage:
+  ldr pack --ldraw <dir> -o <out.bin[.zst|.gz]> [model.ldr ...] [options]
+
+Options:
+  --ldraw <dir>       LDraw library root (contains LDConfig.ldr, parts/, p/). Download complete.zip from https://library.ldraw.org
+  -o, --out <file>    Output file. Extension .zst / .gz compresses (recommended for serving).
+  --part <ref>        Include a part (repeatable), e.g. --part 3001.dat
+  --all-parts         Include every part in the library (large)
+  --studs low|full    Stud detail (default low)
+  --prims full|low    Other primitive detail (default full)
+  --no-weld           Don't index/weld vertices
+  --no-colors         Don't embed the LDConfig colour table
+`;
+var argv = process.argv.slice(2);
+if (argv[0] !== "pack" || argv.includes("-h") || argv.includes("--help")) {
+  console.log(HELP);
+  process.exit(argv[0] === "pack" || argv.includes("--help") || argv.includes("-h") ? 0 : 1);
+}
+var a = argv.slice(1);
+var models = [];
+var parts = [];
+var ldraw = "";
+var out = "";
+var studs = "low";
+var prims = "full";
+var weld = true;
+var colors = true;
+var all = false;
+for (let i = 0;i < a.length; i++) {
+  const k = a[i];
+  const v = () => {
+    const x = a[++i];
+    if (x === undefined) {
+      console.error(`missing value for ${k}`);
+      process.exit(1);
+    }
+    return x;
+  };
+  if (k === "--ldraw")
+    ldraw = v();
+  else if (k === "-o" || k === "--out")
+    out = v();
+  else if (k === "--part")
+    parts.push(v());
+  else if (k === "--studs")
+    studs = v();
+  else if (k === "--prims")
+    prims = v();
+  else if (k === "--no-weld")
+    weld = false;
+  else if (k === "--no-colors")
+    colors = false;
+  else if (k === "--all-parts")
+    all = true;
+  else if (k.startsWith("-")) {
+    console.error(`unknown option ${k}
+
+${HELP}`);
+    process.exit(1);
+  } else
+    models.push(k);
+}
+if (!ldraw || !out) {
+  console.error(HELP);
+  process.exit(1);
+}
+if (!fs4.existsSync(ldraw + "/LDConfig.ldr")) {
+  console.error(`${ldraw} does not look like an LDraw library (no LDConfig.ldr)`);
+  process.exit(1);
+}
+var t0 = performance.now();
+var r = buildPack({ ldrawRoot: ldraw, models, parts, allParts: all, studs, primitives: prims, weld, colors });
+var data = r.data;
+if (out.endsWith(".gz"))
+  data = zlib.gzipSync(data, { level: 9 });
+else if (out.endsWith(".zst")) {
+  const B = globalThis.Bun, z = zlib;
+  if (B?.zstdCompressSync)
+    data = B.zstdCompressSync(data, { level: 19 });
+  else if (z.zstdCompressSync)
+    data = z.zstdCompressSync(data, { params: { [z.constants.ZSTD_c_compressionLevel]: 19 } });
+  else {
+    console.error("zstd output needs Bun or Node >= 22.15 (try `bunx ldr pack ...` or use a .gz output)");
+    process.exit(1);
+  }
+}
+fs4.writeFileSync(out, data);
+console.log(`${out}: ${r.parts} parts, ${r.studKinds} stud kinds, ${(data.length / 1048576).toFixed(2)} MB (raw ${(r.data.length / 1048576).toFixed(2)} MB), ${Math.round(performance.now() - t0)} ms`);
+if (r.missing.length)
+  console.warn(`missing ${r.missing.length} refs: ${r.missing.slice(0, 20).join(", ")}${r.missing.length > 20 ? " …" : ""}`);