ldr 0.0.0-alpha.1 → 0.3.0

package/dist/node/index.js

@@ -0,0 +1,2354 @@
+// src/spec.ts
+var norm = (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 texNames(rest) {
+  const out = [];
+  let i = 0;
+  while (i < rest.length) {
+    while (rest[i] === " " || rest[i] === "\t")
+      i++;
+    if (i >= rest.length)
+      break;
+    if (rest[i] === '"') {
+      let v = "";
+      i++;
+      while (i < rest.length && rest[i] !== '"') {
+        if (rest[i] === "\\" && i + 1 < rest.length)
+          i++;
+        v += rest[i++];
+      }
+      i++;
+      out.push(v);
+    } else {
+      let j = i;
+      while (j < rest.length && rest[j] !== " " && rest[j] !== "\t")
+        j++;
+      out.push(rest.slice(i, j));
+      i = j;
+    }
+  }
+  return out;
+}
+function parseTexMap(tail, next = false) {
+  const m = /^\s*(\S+)\s+(.*)$/.exec(tail);
+  if (!m)
+    return null;
+  const method = m[1].toUpperCase();
+  const n = method === "PLANAR" ? 9 : method === "CYLINDRICAL" ? 10 : method === "SPHERICAL" ? 11 : 0;
+  if (!n)
+    return null;
+  const parts = m[2].trim().split(/\s+/);
+  if (parts.length < n + 1)
+    return null;
+  const v = parts.slice(0, n).map(Number);
+  if (!v.every(Number.isFinite))
+    return null;
+  let rest = m[2].trim();
+  for (let k = 0;k < n; k++)
+    rest = rest.replace(/^\S+\s*/, "");
+  const names = texNames(rest);
+  if (!names.length)
+    return null;
+  const t = { method, p1: v.slice(0, 3), p2: v.slice(3, 6), p3: v.slice(6, 9), texture: names[0] };
+  if (n >= 10)
+    t.a = v[9];
+  if (n === 11)
+    t.b = v[10];
+  const g = names.findIndex((x, i) => i > 0 && x.toUpperCase() === "GLOSSMAP");
+  if (g > 0 && names[g + 1])
+    t.glossmap = names[g + 1];
+  if (next)
+    t.next = true;
+  return t;
+}
+var b64 = (s) => {
+  const clean = s.replace(/[^A-Za-z0-9+/]/g, "");
+  const pad = clean + "=".repeat((4 - clean.length % 4) % 4);
+  const bin = atob(pad);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0;i < bin.length; i++)
+    out[i] = bin.charCodeAt(i);
+  return out;
+};
+function geomLine(tk) {
+  const t = +tk[0];
+  if (!(t >= 1 && t <= 5) || tk.length < 2)
+    return null;
+  const color = parseColor(tk[1]);
+  const nums = tk.slice(2).map(Number);
+  if (t === 1)
+    return { t: 1, color, m: nums.slice(0, 12), file: norm(tk.slice(14).join(" ")) };
+  if (t === 2)
+    return { t: 2, color, p: nums.slice(0, 6) };
+  if (t === 3)
+    return { t: 3, color, p: nums.slice(0, 9) };
+  if (t === 4)
+    return { t: 4, color, p: nums.slice(0, 12) };
+  return { t: 5, color, p: nums.slice(0, 12) };
+}
+function parse(src, name = "main.ldr") {
+  const files = new Map;
+  let cur = null;
+  let main = "";
+  let data;
+  let dataCur = null;
+  let texStack = [];
+  let texNext = null;
+  const closeData = () => {
+    if (!dataCur)
+      return;
+    const bytes = b64(dataCur.chunks.join(""));
+    const png = bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
+    (data ??= new Map).set(norm(dataCur.name), { name: dataCur.name, bytes, ...png ? { mime: "image/png" } : {} });
+    dataCur = null;
+  };
+  const start = (n) => {
+    closeData();
+    cur = { name: norm(n), cmds: [] };
+    files.set(cur.name, cur);
+    if (!main)
+      main = cur.name;
+    texStack = [];
+    texNext = null;
+  };
+  let skip = false, sawBlock = false;
+  const firstBlock = () => {
+    if (sawBlock)
+      return;
+    sawBlock = true;
+    files.clear();
+    cur = null;
+    main = "";
+  };
+  const annotate = (c, fromColon) => {
+    if (texNext) {
+      c.tex = texNext;
+      texNext = null;
+      return;
+    }
+    const top = texStack[texStack.length - 1];
+    if (!top)
+      return;
+    if (top.fallback) {
+      if (!fromColon)
+        c.fallback = true;
+    } else
+      c.tex = top.map;
+  };
+  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") {
+        firstBlock();
+        skip = false;
+        start(text.slice(5));
+        continue;
+      }
+      if (tk[1] === "NOFILE") {
+        closeData();
+        cur = null;
+        skip = true;
+        continue;
+      }
+      if (tk[1] === "!DATA") {
+        firstBlock();
+        closeData();
+        cur = null;
+        skip = false;
+        dataCur = { name: text.slice(5).trim(), chunks: [] };
+        continue;
+      }
+      if (skip)
+        continue;
+      if (dataCur) {
+        if (tk[1] === "!:")
+          dataCur.chunks.push(tk.slice(2).join(""));
+        continue;
+      }
+      if (!cur)
+        start(name);
+      const c = { t: 0, text };
+      if (tk[1] === "STEP") {
+        c.step = true;
+        texStack = [];
+        texNext = null;
+      } 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];
+      if (tk[1] === "!TEXMAP") {
+        const op = (tk[2] ?? "").toUpperCase();
+        texNext = null;
+        if (op === "START" || op === "NEXT") {
+          const map = parseTexMap(text.replace(/^!TEXMAP\s+\S+/i, ""), op === "NEXT");
+          c.texmap = { op, ...map ? { map } : {} };
+          if (map) {
+            (cur.texmaps ??= []).push(map);
+            if (op === "START")
+              texStack.push({ map, fallback: false });
+            else
+              texNext = map;
+          }
+        } else if (op === "FALLBACK") {
+          c.texmap = { op };
+          const top = texStack[texStack.length - 1];
+          if (top)
+            top.fallback = true;
+        } else if (op === "END") {
+          c.texmap = { op };
+          texStack.pop();
+        }
+      } else if (tk[1] === "!:") {
+        texNext = null;
+        const g = geomLine(tk.slice(2));
+        if (g) {
+          annotate(g, true);
+          c.geom = g;
+        }
+      } else
+        texNext = null;
+      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 = norm(target);
+      }
+      cur.cmds.push(c);
+      continue;
+    }
+    if (dataCur || skip)
+      continue;
+    if (!cur)
+      start(name);
+    const g = geomLine(tk);
+    if (!g)
+      continue;
+    annotate(g, false);
+    cur.cmds.push(g);
+  }
+  closeData();
+  return data ? { main, files, data } : { main, files };
+}
+function resolveTexture(doc, name) {
+  if (!doc.data)
+    return null;
+  const n = norm(name);
+  return doc.data.get(n) ?? doc.data.get(n.replace(/^textures\//, "")) ?? doc.data.get("textures/" + n) ?? null;
+}
+var sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+var dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross3 = (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 unit3 = (a) => {
+  const l = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / l, a[1] / l, a[2] / l];
+};
+var DEG = Math.PI / 180;
+function texmapUV(map, p) {
+  const w = texmapTriangleUV(map, [p, p, p]);
+  const u = w[0], v = w[1];
+  return { u, v, inside: u >= -0.000001 && u <= 1 + 0.000001 && v >= -0.000001 && v <= 1 + 0.000001 };
+}
+var radial = (p, c, n) => {
+  const d = sub3(p, c);
+  const k = dot3(d, n);
+  const r = [d[0] - n[0] * k, d[1] - n[1] * k, d[2] - n[2] * k];
+  return Math.hypot(r[0], r[1], r[2]) < 0.00001 ? null : unit3(r);
+};
+function texmapTriangleUV(map, pts) {
+  const { p1, p2, p3 } = map;
+  const out = new Array(pts.length * 2).fill(0);
+  if (map.method === "PLANAR") {
+    const e1 = sub3(p2, p1), e2 = sub3(p3, p1);
+    const l1 = dot3(e1, e1) || 1, l2 = dot3(e2, e2) || 1;
+    pts.forEach((p, i) => {
+      const d = sub3(p, p1);
+      out[i * 2] = dot3(d, e1) / l1;
+      out[i * 2 + 1] = dot3(d, e2) / l2;
+    });
+    return out;
+  }
+  const cyl = map.method === "CYLINDRICAL";
+  const n = cyl ? unit3(sub3(p2, p1)) : unit3(cross3(sub3(p1, p2), sub3(p3, p2)).map((x) => -x));
+  const dir = cyl ? radial(p3, p1, n) : unit3(sub3(p2, p1));
+  const A = (map.a ?? 360) * DEG;
+  let base = null, baseAng = 0;
+  const sAng = (q) => {
+    if (!base) {
+      base = q;
+      baseAng = Math.atan2(dot3(cross3(dir, q), n), dot3(q, dir));
+      return baseAng;
+    }
+    return Math.atan2(dot3(cross3(base, q), n), dot3(q, base)) + baseAng;
+  };
+  const miss = [];
+  let uSum = 0;
+  const h = cyl ? Math.hypot(...sub3(p2, p1)) || 1 : 0, n2 = cyl ? null : unit3(cross3(n, sub3(p2, p1))), B = (map.b ?? 180) * DEG;
+  pts.forEach((p, i) => {
+    if (cyl) {
+      const q = dir ? radial(p, p1, n) : null;
+      if (q) {
+        const a = sAng(q);
+        out[i * 2] = 0.5 + a / A;
+        uSum += out[i * 2];
+      } else
+        miss.push(i);
+      out[i * 2 + 1] = dot3(n, sub3(p2, p)) / h;
+    } else {
+      const pd = unit3(sub3(p, p1));
+      const c = dot3(pd, n);
+      if (Math.abs(c) > 1 - 0.000000001) {
+        miss.push(i);
+        out[i * 2 + 1] = 0.5 + (c > 0 ? -Math.PI / 2 : Math.PI / 2) / B;
+        return;
+      }
+      const a = sAng(radial(p, p1, n));
+      uSum += a;
+      out[i * 2] = 0.5 + a / A;
+      const th = -a, ct = Math.cos(th), st = Math.sin(th), cr = cross3(n, pd), k = dot3(n, pd) * (1 - ct);
+      const r = unit3([pd[0] * ct + cr[0] * st + n[0] * k, pd[1] * ct + cr[1] * st + n[1] * k, pd[2] * ct + cr[2] * st + n[2] * k]);
+      out[i * 2 + 1] = 0.5 + Math.atan2(dot3(cross3(dir, r), n2), dot3(r, dir)) / B;
+    }
+  });
+  if (miss.length && miss.length < pts.length) {
+    const avg = cyl ? uSum / (pts.length - miss.length) : 0.5 + uSum / (pts.length - miss.length) / A;
+    for (const i of miss)
+      out[i * 2] = avg;
+  }
+  return out;
+}
+function transformTexMap(map, m) {
+  const x = (q) => [m[3] * q[0] + m[4] * q[1] + m[5] * q[2] + m[0], m[6] * q[0] + m[7] * q[1] + m[8] * q[2] + m[1], m[9] * q[0] + m[10] * q[1] + m[11] * q[2] + m[2]];
+  return { ...map, p1: x(map.p1), p2: x(map.p2), p3: x(map.p3) };
+}
+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 flatten(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 flatten(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/render.ts
+import * as THREE from "three";
+async function loadPack(url) {
+  const res = await fetch(url);
+  const t0 = performance.now();
+  let buf;
+  if (url.endsWith(".gz"))
+    buf = await new Response(res.body.pipeThrough(new DecompressionStream("gzip"))).arrayBuffer();
+  else if (url.endsWith(".br"))
+    buf = await new Response(res.body.pipeThrough(new DecompressionStream("brotli"))).arrayBuffer();
+  else if (url.endsWith(".zst")) {
+    const raw = new Uint8Array(await res.arrayBuffer());
+    const t1 = performance.now();
+    const { decompress } = await import("fzstd");
+    const o = decompress(raw);
+    buf = o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength);
+    globalThis.__decodeMs = performance.now() - t1;
+  } else
+    buf = await res.arrayBuffer();
+  if (!url.endsWith(".zst"))
+    globalThis.__decodeMs = performance.now() - t0;
+  return decodePack(buf);
+}
+function decodePack(buf) {
+  const hl = new DataView(buf).getUint32(0, true);
+  const header = JSON.parse(new TextDecoder().decode(new Uint8Array(buf, 4, hl)));
+  const base = 4 + hl;
+  const arr = (r) => r && (r[2] === "f32" ? new Float32Array(buf, base + r[0], r[1]) : r[2] === "u16" ? new Uint16Array(buf, base + r[0], r[1]) : r[2] === "u8" ? new Uint8Array(buf, base + r[0], r[1]) : new Uint32Array(buf, base + r[0], r[1]));
+  return { header, arr, bytes: buf.byteLength };
+}
+function geom(b, arr) {
+  if (!b)
+    return null;
+  const g = new THREE.BufferGeometry;
+  g.setAttribute("position", new THREE.BufferAttribute(arr(b.pos), 3));
+  g.setAttribute("normal", new THREE.BufferAttribute(arr(b.nrm), 3));
+  g.setAttribute("ldrColor", new THREE.BufferAttribute(arr(b.col), 4));
+  if (b.idx)
+    g.setIndex(new THREE.BufferAttribute(arr(b.idx), 1));
+  if (b.uv)
+    g.setAttribute("ldrUV", new THREE.BufferAttribute(arr(b.uv), 2));
+  return g;
+}
+function makeMaterial(side) {
+  const m = new THREE.MeshStandardMaterial({ vertexColors: true, roughness: 0.45, side });
+  m.onBeforeCompile = (s) => {
+    s.vertexShader = `attribute vec4 ldrColor;
+` + s.vertexShader.replace("#include <color_vertex>", `#ifdef USE_INSTANCING_COLOR
+ vColor = vec4(ldrColor.a > 0.5 ? pow(ldrColor.rgb, vec3(2.2)) : instanceColor.rgb, 1.0); // baked LDConfig colours are sRGB
+#else
+ vColor = vec4(pow(ldrColor.rgb, vec3(2.2)), 1.0);
+#endif`);
+  };
+  m.customProgramCacheKey = () => "ldrColor";
+  return m;
+}
+function makeTexturedMaterial(side, map, wrapU = false) {
+  const m = makeMaterial(side);
+  const base = m.onBeforeCompile;
+  m.onBeforeCompile = (sh, r) => {
+    base.call(m, sh, r);
+    sh.uniforms.ldrMap = { value: map };
+    sh.uniforms.ldrWrapU = { value: wrapU ? 1 : 0 };
+    sh.vertexShader = `attribute vec2 ldrUV; varying vec2 vLdrUV;
+` + sh.vertexShader.replace("#include <uv_vertex>", `#include <uv_vertex>
+ vLdrUV = ldrUV;`);
+    sh.fragmentShader = `uniform sampler2D ldrMap; uniform int ldrWrapU; varying vec2 vLdrUV;
+` + sh.fragmentShader.replace("#include <color_fragment>", `#include <color_fragment>
+ { vec2 uv = vec2(ldrWrapU == 1 ? fract(vLdrUV.x) : vLdrUV.x, vLdrUV.y); vec4 t = texture2D(ldrMap, uv);
+   float inside = step(0.0, uv.x) * step(uv.x, 1.0) * step(0.0, uv.y) * step(uv.y, 1.0);
+   diffuseColor.rgb = mix(diffuseColor.rgb, t.rgb, t.a * inside); }`);
+  };
+  m.customProgramCacheKey = () => "ldrColorTex";
+  m.userData.ldrMap = map;
+  return m;
+}
+function packTexture(pack, i) {
+  const t = new THREE.Texture;
+  t.flipY = false;
+  t.colorSpace = THREE.SRGBColorSpace;
+  t.wrapS = t.wrapT = THREE.ClampToEdgeWrapping;
+  const e = pack.header.textures?.[i];
+  const bytes = e?.data ? pack.arr(e.data) : null;
+  if (!bytes || typeof createImageBitmap === "undefined")
+    return { texture: t, ready: Promise.resolve() };
+  const ready = createImageBitmap(new Blob([bytes], { type: e.mime || "image/png" }), { premultiplyAlpha: "none", colorSpaceConversion: "none" }).then((img) => {
+    t.image = img;
+    t.needsUpdate = true;
+  }).catch(() => {});
+  return { texture: t, ready };
+}
+var lineMat = () => new THREE.ShaderMaterial({
+  vertexShader: `attribute vec4 im0; attribute vec4 im1; attribute vec4 im2; attribute vec4 im3;
+    void main(){ gl_Position = projectionMatrix * modelViewMatrix * mat4(im0,im1,im2,im3) * vec4(position,1.0); }`,
+  fragmentShader: `void main(){ gl_FragColor = vec4(0.13,0.13,0.13,1.0); }`
+});
+var sharedLineMat = () => new THREE.ShaderMaterial({
+  vertexShader: `attribute mat4 instanceMatrix; void main(){ gl_Position = projectionMatrix * modelViewMatrix * instanceMatrix * vec4(position,1.0); }`,
+  fragmentShader: `void main(){ gl_FragColor = vec4(0.13,0.13,0.13,1.0); }`
+});
+var weldLines = (pos) => {
+  const map = new Map;
+  const P = [];
+  const I = [];
+  for (let i = 0;i < pos.length; i += 3) {
+    const k = pos[i].toFixed(2) + "," + pos[i + 1].toFixed(2) + "," + pos[i + 2].toFixed(2);
+    let j = map.get(k);
+    if (j === undefined) {
+      j = P.length / 3;
+      map.set(k, j);
+      P.push(pos[i], pos[i + 1], pos[i + 2]);
+    }
+    I.push(j);
+  }
+  return { P: new Float32Array(P), I: P.length / 3 < 65536 ? new Uint16Array(I) : new Uint32Array(I) };
+};
+function createInstancedEdges(pos, im, material = sharedLineMat()) {
+  return sharedLines(pos, im, material);
+}
+function conditionalLines(pack, entry, which = "all") {
+  if (which === "all") {
+    const a = conditionalLines(pack, entry, "body"), b = conditionalLines(pack, entry, "under");
+    if (!a || !b)
+      return a ?? b;
+    const o = new Float32Array(a.length + b.length);
+    o.set(a);
+    o.set(b, a.length);
+    return o;
+  }
+  const c = which === "under" ? entry?.condlu : entry?.condl;
+  if (!c)
+    return null;
+  const { arr } = pack;
+  if (c.raw)
+    return arr(c.raw);
+  const pools = [entry.body ? arr(entry.body.pos) : [], entry.under ? arr(entry.under.pos) : [], entry.edges ? arr(entry.edges) : [], c.x ? arr(c.x) : []];
+  const idx = arr(c.idx);
+  const out = new Float32Array(idx.length * 3);
+  const starts = [];
+  let base = 0;
+  for (const p of pools) {
+    starts.push(base);
+    base += p.length / 3;
+  }
+  let prev = 0;
+  for (let i = 0;i < idx.length; i++) {
+    const z = idx[i];
+    const j = prev + (z & 1 ? -(z + 1) / 2 : z / 2);
+    prev = j;
+    let k = 3;
+    while (k > 0 && j < starts[k])
+      k--;
+    const p = pools[k], o = (j - starts[k]) * 3;
+    out[i * 3] = p[o];
+    out[i * 3 + 1] = p[o + 1];
+    out[i * 3 + 2] = p[o + 2];
+  }
+  return out;
+}
+var condLineMat = () => new THREE.ShaderMaterial({
+  uniforms: { ldrViewProj: { value: new THREE.Matrix4 } },
+  vertexShader: `uniform mat4 ldrViewProj; attribute mat4 instanceMatrix; attribute vec3 ldrP1; attribute vec3 ldrC0; attribute vec3 ldrC1; attribute float ldrSide;
+    void main(){
+      mat4 mvp = ldrViewProj * instanceMatrix;
+      vec4 a = mvp * vec4(position, 1.0), b = mvp * vec4(ldrP1, 1.0), c0 = mvp * vec4(ldrC0, 1.0), c1 = mvp * vec4(ldrC1, 1.0);
+      vec2 A = a.xy / a.w, B = b.xy / b.w, C0 = c0.xy / c0.w, C1 = c1.xy / c1.w, d = B - A;
+      float s0 = d.x * (C0.y - A.y) - d.y * (C0.x - A.x), s1 = d.x * (C1.y - A.y) - d.y * (C1.x - A.x);
+      gl_Position = s0 * s1 >= 0.0 ? (ldrSide > 0.5 ? b : a) : vec4(2.0, 2.0, 2.0, 1.0);
+    }`,
+  fragmentShader: `void main(){ gl_FragColor = vec4(0.13,0.13,0.13,1.0); }`
+});
+function conditionalLineVisible(cond, i, mvp) {
+  const e = mvp.elements;
+  const pr = (o) => {
+    const x = cond[o], y = cond[o + 1], z = cond[o + 2];
+    const w = e[3] * x + e[7] * y + e[11] * z + e[15];
+    return [(e[0] * x + e[4] * y + e[8] * z + e[12]) / w, (e[1] * x + e[5] * y + e[9] * z + e[13]) / w];
+  };
+  const o = i * 12;
+  const A = pr(o), B = pr(o + 3), C0 = pr(o + 6), C1 = pr(o + 9);
+  const dx = B[0] - A[0], dy = B[1] - A[1];
+  const s0 = dx * (C0[1] - A[1]) - dy * (C0[0] - A[0]), s1 = dx * (C1[1] - A[1]) - dy * (C1[0] - A[0]);
+  return s0 * s1 >= 0;
+}
+function createInstancedConditionalEdges(cond, im, material = condLineMat()) {
+  return condEdges(condBuffers(cond), im, material);
+}
+function condBuffers(cond) {
+  const n = Math.floor(cond.length / 12);
+  const buf = new Float32Array(n * 24), side = new Float32Array(n * 2);
+  for (let l = 0;l < n; l++) {
+    for (let k = 0;k < 12; k++) {
+      const v = cond[l * 12 + k];
+      buf[l * 24 + k] = v;
+      buf[l * 24 + 12 + k] = v;
+    }
+    side[l * 2 + 1] = 1;
+  }
+  return { ib: new THREE.InterleavedBuffer(buf, 12), side: new THREE.BufferAttribute(side, 1) };
+}
+function condEdges({ ib, side }, im, material) {
+  const g = new THREE.InstancedBufferGeometry;
+  g.setAttribute("position", new THREE.InterleavedBufferAttribute(ib, 3, 0));
+  g.setAttribute("ldrP1", new THREE.InterleavedBufferAttribute(ib, 3, 3));
+  g.setAttribute("ldrC0", new THREE.InterleavedBufferAttribute(ib, 3, 6));
+  g.setAttribute("ldrC1", new THREE.InterleavedBufferAttribute(ib, 3, 9));
+  g.setAttribute("ldrSide", side);
+  g.setAttribute("instanceMatrix", im.instanceMatrix);
+  g.instanceCount = im.count;
+  const l = new THREE.LineSegments(g, material);
+  l.frustumCulled = false;
+  l.name = "ldrCondLines";
+  l.onBeforeRender = (_r, _s, cam, _g, mat) => {
+    const u = mat.uniforms?.ldrViewProj;
+    if (!u)
+      return;
+    l.modelViewMatrix.multiplyMatrices(cam.matrixWorldInverse, l.matrixWorld);
+    u.value.multiplyMatrices(cam.projectionMatrix, l.modelViewMatrix);
+    mat.uniformsNeedUpdate = true;
+  };
+  return l;
+}
+function sharedLines(pos, im, material = sharedLineMat()) {
+  const { P, I } = weldLines(pos);
+  const g = new THREE.InstancedBufferGeometry;
+  g.setAttribute("position", new THREE.BufferAttribute(P, 3));
+  g.setIndex(new THREE.BufferAttribute(I, 1));
+  g.setAttribute("instanceMatrix", im.instanceMatrix);
+  g.instanceCount = im.count;
+  const l = new THREE.LineSegments(g, material);
+  l.frustumCulled = false;
+  return l;
+}
+function instancedLines(pos, mats, count) {
+  const g = new THREE.InstancedBufferGeometry;
+  g.setAttribute("position", new THREE.BufferAttribute(pos, 3));
+  const ib = new THREE.InstancedInterleavedBuffer(mats, 16);
+  for (let i = 0;i < 4; i++)
+    g.setAttribute("im" + i, new THREE.InterleavedBufferAttribute(ib, 4, i * 4));
+  g.instanceCount = count;
+  const l = new THREE.LineSegments(g, lineMat());
+  l.frustumCulled = false;
+  return l;
+}
+var toM4 = (m, o = 0) => new THREE.Matrix4().set(m[o + 3], m[o + 4], m[o + 5], m[o], m[o + 6], m[o + 7], m[o + 8], m[o + 1], m[o + 9], m[o + 10], m[o + 11], m[o + 2], 0, 0, 0, 1);
+var mul12 = (a, b) => {
+  const r = (i, j) => a[3 + i * 3] * b[3 + j] + a[4 + i * 3] * b[6 + j] + a[5 + i * 3] * b[9 + j];
+  return [a[0] + a[3] * b[0] + a[4] * b[1] + a[5] * b[2], a[1] + a[6] * b[0] + a[7] * b[1] + a[8] * b[2], a[2] + a[9] * b[0] + a[10] * b[1] + a[11] * b[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)];
+};
+function computeCulling(insts, H) {
+  const upright = (m) => Math.abs(m[7] - 1) < 0.001 && Math.abs(m[4]) < 0.001 && Math.abs(m[10]) < 0.001;
+  const CELL = 40;
+  const rects = new Map;
+  const lk = (y) => Math.round(y * 2) / 2;
+  insts.forEach((it, idx) => {
+    const p = H.parts[it.part];
+    if (!p || !p.mask || !upright(it.m))
+      return;
+    const b = p.bbox;
+    const xs = [], zs = [];
+    for (const x of [b[0], b[3]])
+      for (const z of [b[2], b[5]]) {
+        const w = [it.m[0] + it.m[3] * x + it.m[5] * z, it.m[2] + it.m[9] * x + it.m[11] * z];
+        xs.push(w[0]);
+        zs.push(w[1]);
+      }
+    const r = [Math.min(...xs), Math.max(...xs), Math.min(...zs), Math.max(...zs), idx];
+    const lv = lk(it.m[1] + b[4]);
+    for (let cx = Math.floor(r[0] / CELL);cx <= Math.floor(r[1] / CELL); cx++)
+      for (let cz = Math.floor(r[2] / CELL);cz <= Math.floor(r[3] / CELL); cz++) {
+        const k = lv + "|" + cx + "|" + cz;
+        (rects.get(k) || rects.set(k, []).get(k)).push(r);
+      }
+  });
+  const covered = (x, y, z, self) => {
+    const list = rects.get(lk(y) + "|" + Math.floor(x / CELL) + "|" + Math.floor(z / CELL));
+    if (!list)
+      return false;
+    for (const r of list) {
+      if (r[4] === self || !(x - 6 >= r[0] - 0.5 && x + 6 <= r[1] + 0.5 && z - 6 >= r[2] - 0.5 && z + 6 <= r[3] + 0.5))
+        continue;
+      const it = insts[r[4]];
+      const p = H.parts[it.part];
+      const m = it.m;
+      const dx = x - m[0], dy = y - m[1], dz = z - m[2];
+      const lx = m[3] * dx + m[6] * dy + m[9] * dz, lz = m[5] * dx + m[8] * dy + m[11] * dz;
+      const [nx, nz, bits] = p.mask;
+      let ok = true;
+      for (const [ox, oz] of [[0, 0], [5, 5], [-5, 5], [5, -5], [-5, -5]]) {
+        const ca = Math.floor((lx + ox - p.bbox[0]) / 20), cb = Math.floor((lz + oz - p.bbox[2]) / 20);
+        if (ca < 0 || cb < 0 || ca >= nx || cb >= nz || bits[ca * nz + cb] !== "1") {
+          ok = false;
+          break;
+        }
+      }
+      if (ok)
+        return true;
+    }
+    return false;
+  };
+  const studs = [];
+  const studTops = new Set;
+  const key3 = (x, y, z) => `${Math.round(x)},${Math.round(y)},${Math.round(z)}`;
+  insts.forEach((it, idx) => {
+    const p = H.parts[it.part];
+    if (!p)
+      return;
+    for (const s of p.studs) {
+      const w = mul12(it.m, s.slice(2));
+      const color = s[1] === "16" ? it.color : s[1];
+      const up = upright(w);
+      studs.push({ kind: s[0], color, w, hidden: up && covered(w[0], w[1], w[2], idx) });
+      if (up)
+        studTops.add(key3(w[0], w[1], w[2]));
+    }
+  });
+  const underHidden = insts.map((it) => {
+    const p = H.parts[it.part];
+    if (!p || !p.under || !upright(it.m))
+      return false;
+    const b = p.bbox;
+    const nx = Math.round((b[3] - b[0]) / 20), nz = Math.round((b[5] - b[2]) / 20);
+    if (!nx || !nz || nx * nz > 4096)
+      return false;
+    for (let a = 0;a < nx; a++)
+      for (let c = 0;c < nz; c++) {
+        const lx = b[0] + 10 + 20 * a, lz = b[2] + 10 + 20 * c;
+        const x = it.m[0] + it.m[3] * lx + it.m[5] * lz, z = it.m[2] + it.m[9] * lx + it.m[11] * lz;
+        if (!studTops.has(key3(x, it.m[1] + b[4], z)))
+          return false;
+      }
+    return true;
+  });
+  return { studs, underHidden };
+}
+function buildLdrScene(insts, pack, P, color, mark) {
+  const { header: H, arr } = pack;
+  const root = new THREE.Group;
+  const matF = makeMaterial(P.side === "front" ? THREE.FrontSide : THREE.DoubleSide), matB = makeMaterial(P.side === "front" ? THREE.BackSide : THREE.DoubleSide);
+  const matD = makeMaterial(THREE.DoubleSide);
+  let nUncert = 0;
+  const det = (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]);
+  const byPart = new Map;
+  insts.forEach((it, i) => {
+    if (H.parts[it.part]) {
+      const k = it.part + (det(it.m) < 0 ? "#m" : "");
+      (byPart.get(k) || byPart.set(k, []).get(k)).push(i);
+    }
+  });
+  const cull = computeCulling(insts, H);
+  mark("culling");
+  const edgeObjs = [];
+  const condObjs = [];
+  const wantCond = P.cond !== false && P.edges === "idx";
+  let condMat = null;
+  const cmat = () => condMat ??= condLineMat();
+  const condCache = new Map;
+  const addCond = (entry, im, which = "body") => {
+    if (!wantCond)
+      return null;
+    const ck = which === "under" ? entry.condlu : entry.condl;
+    if (!ck)
+      return null;
+    let cb = condCache.get(ck);
+    if (cb === undefined) {
+      const c = conditionalLines(pack, entry, which);
+      cb = c && c.length ? condBuffers(c) : null;
+      condCache.set(ck, cb);
+    }
+    if (!cb)
+      return null;
+    const l = condEdges(cb, im, cmat());
+    edgeObjs.push(l);
+    condObjs.push(l);
+    root.add(l);
+    return l;
+  };
+  const stats = { studsTotal: cull.studs.length, studsHidden: cull.studs.filter((s) => s.hidden).length, undersTotal: 0, undersHidden: 0 };
+  const toggles = [];
+  const studMeshes = [];
+  const wantTex = P.tex !== false && !!H.textures;
+  const texCache = new Map;
+  const texMats = new Map;
+  const pending = [];
+  const texMat = (t, base, wrapU) => {
+    const role = base === matF ? "F" : base === matB ? "B" : "D";
+    const k = t + ":" + role + ":" + (wrapU ? 1 : 0);
+    let m = texMats.get(k);
+    if (!m) {
+      let tx = texCache.get(t);
+      if (!tx) {
+        const r = packTexture(pack, t);
+        tx = r.texture;
+        pending.push(r.ready);
+        texCache.set(t, tx);
+      }
+      texMats.set(k, m = makeTexturedMaterial(base.side, tx, wrapU));
+    }
+    return m;
+  };
+  let texBatches = 0;
+  for (const [pk, ids] of byPart) {
+    const part = pk.replace(/#m$/, "");
+    const p = H.parts[part];
+    const mat = P.uncertDouble !== false && p.uncert ? (nUncert++, matD) : pk.endsWith("#m") ? matB : matF;
+    const textured = wantTex && !!p.tex;
+    const body = geom(textured ? p.tbody : p.body, arr);
+    let bodyIm = null;
+    const place = (im) => {
+      ids.forEach((id, k) => {
+        im.setMatrixAt(k, toM4(insts[id].m));
+        im.setColorAt(k, color(insts[id].color));
+      });
+      im.computeBoundingSphere();
+      root.add(im);
+    };
+    if (body) {
+      const im = bodyIm = new THREE.InstancedMesh(body, mat, ids.length);
+      place(im);
+    }
+    if (textured)
+      for (const tb of p.tex) {
+        const g = geom(tb, arr);
+        const im = new THREE.InstancedMesh(g, texMat(tb.t, mat, !!tb.wrapU), ids.length);
+        texBatches++;
+        if (bodyIm) {
+          im.instanceMatrix = bodyIm.instanceMatrix;
+          im.instanceColor = bodyIm.instanceColor;
+          im.boundingSphere = bodyIm.boundingSphere;
+          root.add(im);
+        } else {
+          place(im);
+          bodyIm = im;
+        }
+      }
+    if (P.edges === "idx" && p.edges && bodyIm) {
+      const l = sharedLines(arr(p.edges), bodyIm);
+      edgeObjs.push(l);
+      root.add(l);
+    }
+    if (bodyIm)
+      addCond(p, bodyIm);
+    const under = geom(p.under, arr);
+    if (under) {
+      const ord = [...ids.filter((i) => !cull.underHidden[i]), ...ids.filter((i) => cull.underHidden[i])];
+      const vis = ids.filter((i) => !cull.underHidden[i]).length;
+      stats.undersTotal += ids.length;
+      stats.undersHidden += ids.length - vis;
+      const im = new THREE.InstancedMesh(under, mat, ids.length);
+      ord.forEach((id, k) => {
+        im.setMatrixAt(k, toM4(insts[id].m));
+        im.setColorAt(k, color(insts[id].color));
+      });
+      im.computeBoundingSphere();
+      im.count = P.cullUnder ? vis : ids.length;
+      root.add(im);
+      toggles.push({ mesh: im, all: ids.length, visible: vis, flag: "under" });
+      {
+        const cl = addCond(p, im, "under");
+        if (cl) {
+          toggles.push({ mesh: { set count(n) {
+            cl.geometry.instanceCount = n;
+          } }, all: ids.length, visible: vis, flag: "under" });
+          cl.geometry.instanceCount = im.count;
+        }
+      }
+    }
+    if (P.edges === true && p.edges) {
+      const mats = new Float32Array(ids.length * 16);
+      ids.forEach((id, k) => toM4(insts[id].m).toArray(mats, k * 16));
+      {
+        const l = instancedLines(arr(p.edges), mats, ids.length);
+        edgeObjs.push(l);
+        root.add(l);
+      }
+    }
+  }
+  const byKind = new Map;
+  for (const s of cull.studs) {
+    const k = s.kind + (det(s.w) < 0 ? "#m" : "");
+    (byKind.get(k) || byKind.set(k, []).get(k)).push(s);
+  }
+  for (const [kk, list] of byKind) {
+    const kind = kk.replace(/#m$/, "");
+    const mat = kk.endsWith("#m") ? matB : matF;
+    const k = H.studKinds[kind];
+    const g = geom(k.body, arr);
+    if (!g)
+      continue;
+    const ord = [...list.filter((s) => !s.hidden), ...list.filter((s) => s.hidden)];
+    const vis = list.filter((s) => !s.hidden).length;
+    const im = new THREE.InstancedMesh(g, mat, ord.length);
+    ord.forEach((s, i) => {
+      im.setMatrixAt(i, toM4(s.w));
+      im.setColorAt(i, color(s.color));
+    });
+    im.computeBoundingSphere();
+    im.count = P.cullStuds ? vis : ord.length;
+    root.add(im);
+    toggles.push({ mesh: im, all: ord.length, visible: vis, flag: "studs" });
+    studMeshes.push({ im, kind });
+    if (P.edges === "idx" && k.edges) {
+      const l = sharedLines(arr(k.edges), im);
+      edgeObjs.push(l);
+      root.add(l);
+      toggles.push({ mesh: { set count(n) {
+        l.geometry.instanceCount = n;
+      } }, all: ord.length, visible: vis, flag: "studs" });
+      l.geometry.instanceCount = im.count;
+    }
+    {
+      const cl = P.condStuds === false ? null : addCond(k, im);
+      if (cl) {
+        toggles.push({ mesh: { set count(n) {
+          cl.geometry.instanceCount = n;
+        } }, all: ord.length, visible: vis, flag: "studs" });
+        cl.geometry.instanceCount = im.count;
+      }
+    }
+    if (P.edges === true && k.edges) {
+      const mats = new Float32Array(ord.length * 16);
+      ord.forEach((s, i) => toM4(s.w).toArray(mats, i * 16));
+      const l = instancedLines(arr(k.edges), mats, P.cullStuds ? vis : ord.length);
+      edgeObjs.push(l);
+      root.add(l);
+      toggles.push({ mesh: { set count(n) {
+        l.geometry.instanceCount = n;
+      } }, all: ord.length, visible: vis, flag: "studs" });
+    }
+  }
+  stats.uncertParts = Object.values(H.parts).filter((x) => x.uncert).length;
+  stats.uncertBatches = nUncert;
+  let condOn = true, edgesOn = true;
+  const setEdges = (v) => {
+    edgesOn = v;
+    edgeObjs.forEach((o) => o.visible = v && (condOn || !condObjs.includes(o)));
+  };
+  const setCond = (v) => {
+    condOn = v;
+    condObjs.forEach((o) => o.visible = v && edgesOn);
+  };
+  stats.condBatches = condObjs.length;
+  stats.texBatches = texBatches;
+  stats.textures = texCache.size;
+  const texturesReady = Promise.all(pending).then(() => {});
+  const setCull = (studs, under) => {
+    for (const t of toggles)
+      t.mesh.count = (t.flag === "studs" ? studs : under) ? t.visible : t.all;
+  };
+  const box = new THREE.Box3;
+  for (const it of insts) {
+    const p = H.parts[it.part];
+    if (!p)
+      continue;
+    box.expandByPoint(new THREE.Vector3(it.m[0], it.m[1], it.m[2]));
+  }
+  const setSide = (front) => {
+    matF.side = front ? THREE.FrontSide : THREE.DoubleSide;
+    matB.side = front ? THREE.BackSide : THREE.DoubleSide;
+    matF.needsUpdate = matB.needsUpdate = true;
+    for (const [k, m] of texMats) {
+      const role = k.split(":")[1];
+      m.side = role === "D" || !front ? THREE.DoubleSide : role === "B" ? THREE.BackSide : THREE.FrontSide;
+      m.needsUpdate = true;
+    }
+  };
+  const swapStuds = (alt) => {
+    const saved = studMeshes.map((s) => s.im.geometry);
+    for (const s of studMeshes) {
+      const k2 = alt.header.studKinds[s.kind] ? s.kind : Object.keys(alt.header.studKinds).find((k) => k.replace("p/8/", "p/") === s.kind.replace("p/8/", "p/"));
+      if (k2)
+        s.im.geometry = geom(alt.header.studKinds[k2].body, alt.arr);
+    }
+    return () => studMeshes.forEach((s, i) => s.im.geometry = saved[i]);
+  };
+  return { root, stats, setCull, setSide, setEdges, setCond, swapStuds, box, texturesReady };
+}
+// src/scene.ts
+import * as THREE2 from "three";
+function colorFn(src, pack, fallback) {
+  const table = new Map;
+  const put = (k, v) => table.set(String(k), new THREE2.Color(typeof v === "string" ? v : v.hex));
+  if (typeof src === "function") {
+    return (c) => {
+      let col = table.get(c);
+      if (!col) {
+        const v = src(+c);
+        col = v === undefined ? direct(c) ?? fallback : new THREE2.Color(v);
+        table.set(c, col);
+      }
+      return col;
+    };
+  }
+  const base = src ?? pack.header.colors ?? {};
+  if (base instanceof Map)
+    for (const [k, v] of base)
+      put(k, v);
+  else
+    for (const k in base)
+      put(k, base[k]);
+  return (c) => table.get(c) ?? direct(c) ?? fallback;
+}
+var direct = (c) => {
+  const n = +c;
+  return n > 16777215 && n >>> 24 === 2 ? new THREE2.Color(n & 16777215) : null;
+};
+var plasticCache = new WeakMap;
+function toPlastic(old) {
+  let m = plasticCache.get(old);
+  if (!m) {
+    const p = new THREE2.MeshPhysicalMaterial({ vertexColors: true, roughness: 0.3, clearcoat: 0.3, clearcoatRoughness: 0.2, specularIntensity: 0.6, side: old.side });
+    p.onBeforeCompile = old.onBeforeCompile;
+    p.customProgramCacheKey = () => "Phys" + old.customProgramCacheKey() + old.side;
+    p.userData = old.userData;
+    plasticCache.set(old, m = p);
+  }
+  return m;
+}
+function createLdrObject(instances, pack, options = {}) {
+  const o = { edges: true, conditionalLines: true, cullStuds: true, cullUndersides: true, side: "front", material: "plastic", ...options };
+  const color = colorFn(o.colors, pack, new THREE2.Color(o.fallbackColor ?? 10528169));
+  const all = instances.map((i) => ({ part: i.part, color: String(i.color), m: i.m, steps: i.steps }));
+  const key = (i) => i.steps.map((x) => String(x).padStart(6, "0")).join(".");
+  const uniq = [...new Set(all.map(key))].sort();
+  const rank = new Map(uniq.map((k, j) => [k, j]));
+  const stepOf = all.map((i) => rank.get(key(i)));
+  const missing = [...new Set(all.filter((i) => !pack.header.parts[i.part]).map((i) => i.part))];
+  const object = new THREE2.Group;
+  object.name = "ldr";
+  if (!o.ldrawSpace)
+    object.rotation.x = Math.PI;
+  if (o.scale && o.scale !== 1)
+    object.scale.setScalar(o.scale);
+  const pairs = new Map;
+  let cur = null;
+  let { edges, conditionalLines: cond, cullStuds: cs, cullUndersides: cu, side } = o;
+  const stats = { instances: all.length, drawn: 0, missing, studsTotal: 0, studsHidden: 0, undersTotal: 0, undersHidden: 0, buildMs: 0 };
+  const disposeCur = () => {
+    if (!cur)
+      return;
+    object.remove(cur.root);
+    const mats = new Set;
+    cur.root.traverse((x) => {
+      x.geometry?.dispose?.();
+      if (x.material)
+        mats.add(x.material);
+      if (x.dispose && x.isInstancedMesh)
+        x.dispose();
+    });
+    for (const m of [...mats, ...pairs.values()]) {
+      m.userData.ldrMap?.dispose();
+      m.dispose();
+    }
+    cur = null;
+  };
+  const build = (step) => {
+    const t0 = performance.now();
+    disposeCur();
+    const insts = step == null ? all : all.filter((_, k) => stepOf[k] <= step);
+    cur = buildLdrScene(insts, pack, { pack: "", cullStuds: cs, cullUnder: cu, edges: edges ? "idx" : false, side, cond, condStuds: o.conditionalStudLines !== false, tex: o.textures !== false }, color, () => {});
+    pairs.clear();
+    if (o.material === "plastic")
+      cur.root.traverse((x) => {
+        if (x.isMesh && x.material?.isMeshStandardMaterial) {
+          const old = x.material;
+          x.material = toPlastic(old);
+          pairs.set(x.material, old);
+        }
+      });
+    if (!edges)
+      cur.setEdges(false);
+    if (!cond)
+      cur.setCond(false);
+    object.add(cur.root);
+    Object.assign(stats, { drawn: insts.filter((i) => pack.header.parts[i.part]).length, studsTotal: cur.stats.studsTotal, studsHidden: cur.stats.studsHidden, undersTotal: cur.stats.undersTotal, undersHidden: cur.stats.undersHidden, condBatches: cur.stats.condBatches ?? 0, texBatches: cur.stats.texBatches ?? 0, textures: cur.stats.textures ?? 0, buildMs: performance.now() - t0 });
+    api.texturesReady = cur.texturesReady;
+  };
+  const api = { texturesReady: Promise.resolve() };
+  build(o.step ?? null);
+  return Object.assign(api, {
+    object,
+    stats,
+    stepCount: uniq.length,
+    setStep: (s) => build(s),
+    setEdges: (v) => {
+      edges = v;
+      cur.setEdges(v);
+    },
+    setConditionalLines: (v) => {
+      cond = v;
+      cur.setCond(v);
+    },
+    setCulling: (a, b) => {
+      cs = a;
+      cu = b;
+      cur.setCull(a, b);
+    },
+    setSide: (s) => {
+      side = s;
+      cur.setSide(s === "front");
+      for (const [p, old] of pairs) {
+        p.side = old.side;
+        p.needsUpdate = true;
+      }
+    },
+    getBox: (target = new THREE2.Box3) => {
+      object.updateMatrixWorld(true);
+      target.makeEmpty();
+      object.traverse((x) => {
+        if (x.isInstancedMesh && x.count) {
+          x.computeBoundingBox();
+          const b = x.boundingBox.clone().applyMatrix4(x.matrixWorld);
+          target.union(b);
+        }
+      });
+      return target;
+    },
+    dispose: disposeCur
+  });
+}
+// src/pack-io.ts
+import { decompress } from "fzstd";
+async function decompressPack(data) {
+  const u = data instanceof Uint8Array ? data : new Uint8Array(data);
+  const own = (o) => o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength);
+  if (u[0] === 40 && u[1] === 181 && u[2] === 47 && u[3] === 253)
+    return own(decompress(u));
+  if (u[0] === 31 && u[1] === 139)
+    return new Response(new Blob([u]).stream().pipeThrough(new DecompressionStream("gzip"))).arrayBuffer();
+  return own(u);
+}
+// src/node/library.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var xf = (m, x, y, z) => [m[3] * x + m[4] * y + m[5] * z + m[0], m[6] * x + m[7] * y + m[8] * z + m[1], m[9] * x + m[10] * y + m[11] * z + m[2]];
+var det = (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 Library {
+  root;
+  unofficialRoot;
+  cache = new Map;
+  meshCache = new Map;
+  constructor(root, unofficialRoot) {
+    this.root = root;
+    this.unofficialRoot = unofficialRoot;
+  }
+  where(name, _seen) {
+    name = norm(name);
+    const seen = _seen ?? new Set;
+    if (seen.has(name))
+      return null;
+    seen.add(name);
+    const hit = this.lookup(name);
+    if (!hit)
+      return null;
+    const file = hit.doc.files.get(hit.doc.main);
+    if (file?.movedTo && file.movedTo !== name) {
+      const target = this.where(file.movedTo, seen);
+      if (target)
+        return { ...target, aliasOf: name };
+    }
+    return hit;
+  }
+  lookup(name) {
+    const roots = [
+      { root: this.root, dirs: [["parts", "part"], ["p", "prim"], ["models", "model"], ["parts/s", "part"]] }
+    ];
+    const unoff = this.unofficialRoot ?? (existsSync(join(this.root, "unofficial")) ? join(this.root, "unofficial") : undefined);
+    if (unoff)
+      roots.push({ root: unoff, dirs: [["parts", "part"], ["p", "prim"], ["models", "model"], ["parts/s", "part"]] });
+    for (const { root, dirs } of roots) {
+      for (const [d, kind] of dirs) {
+        if (d === "parts/s" && name.startsWith("s/"))
+          continue;
+        const key = root + "|" + d + "/" + name;
+        if (!this.cache.has(key)) {
+          const f = this.resolveFile(root, d, name);
+          this.cache.set(key, f ? parse(readFileSync(f, "latin1"), name) : null);
+        }
+        const doc = this.cache.get(key);
+        if (doc)
+          return { kind, doc };
+      }
+    }
+    return null;
+  }
+  resolveFile(root, dir, name) {
+    const exact = join(root, dir, name);
+    if (existsSync(exact))
+      return exact;
+    return null;
+  }
+  colors() {
+    const out = new Map;
+    const d = parse(readFileSync(join(this.root, "LDConfig.ldr"), "latin1"));
+    for (const c of d.files.get(d.main).cmds)
+      if (c.t === 0 && c.meta === "!COLOUR") {
+        const t = c.text.split(/\s+/);
+        const g = (k) => t[t.indexOf(k) + 1];
+        out.set(+g("CODE"), { name: t[1], hex: g("VALUE"), edge: g("EDGE"), alpha: t.includes("ALPHA") ? +g("ALPHA") : 255 });
+      }
+    return out;
+  }
+  mesh(name, opts = {}) {
+    name = norm(name);
+    const ck = opts.texmap ? name + "#texmap" : name;
+    const hit = this.meshCache.get(ck);
+    if (hit)
+      return hit;
+    const pos = [], col = [], edges = [], cond = [];
+    const tx = opts.texmap ? { uv: [], tri: [], names: [] } : undefined;
+    const r = this.where(name);
+    if (r)
+      this.emit(r.doc, r.doc.main, I, 16, false, true, pos, col, edges, cond, tx, null);
+    const m = { name: r?.doc.main ?? name, pos: new Float32Array(pos), col: new Uint32Array(col), edges: new Float32Array(edges), cond: new Float32Array(cond), nrm: smoothNormals(pos, edges, cond) };
+    if (tx) {
+      m.uv = new Float32Array(tx.uv);
+      m.texture = new Int32Array(tx.tri);
+      m.textures = tx.names;
+    }
+    this.meshCache.set(ck, m);
+    return m;
+  }
+  texture(name, doc) {
+    if (doc) {
+      const d = resolveTexture(doc, name);
+      if (d)
+        return d.bytes;
+    }
+    const n = norm(name);
+    const roots = [this.root];
+    const unoff = this.unofficialRoot ?? (existsSync(join(this.root, "unofficial")) ? join(this.root, "unofficial") : undefined);
+    if (unoff)
+      roots.push(unoff);
+    for (const cand of ["textures/" + n, n])
+      for (const root of roots)
+        for (const d of ["parts", "p", "models"]) {
+          const f = join(root, d, cand);
+          if (existsSync(f))
+            return new Uint8Array(readFileSync(f));
+        }
+    return null;
+  }
+  emit(doc, fname, m, color, inv, clip, pos, col, edges, cond, tx, texIn = null) {
+    const f = doc.files.get(fname);
+    if (!f)
+      return;
+    let ccw = true, invertNext = false, clipLocal = clip;
+    const flip = inv !== det(m) < 0;
+    const cc = (c) => c === 16 ? color : c;
+    const texIdx = (t) => {
+      let i = tx.names.indexOf(t.texture);
+      if (i < 0) {
+        i = tx.names.length;
+        tx.names.push(t.texture);
+      }
+      return i;
+    };
+    for (const c0 of f.cmds) {
+      let c = c0;
+      if (c.t === 0) {
+        if (tx && c.geom)
+          c = c.geom;
+        else {
+          if (c.bfc) {
+            if (c.bfc.includes("CW") && !c.bfc.includes("CCW"))
+              ccw = false;
+            if (c.bfc.includes("CCW"))
+              ccw = true;
+            if (c.bfc.includes("INVERTNEXT"))
+              invertNext = true;
+            if (/\bNOCLIP\b/.test(c.bfc))
+              clipLocal = false;
+            else if (/\bCLIP\b/.test(c.bfc))
+              clipLocal = true;
+          }
+          continue;
+        }
+      }
+      if (c.t === 0)
+        continue;
+      if (tx && c.fallback)
+        continue;
+      const tex = tx ? c.tex ? transformTexMap(c.tex, m) : texIn : null;
+      if (c.t === 1) {
+        const sub = doc.files.has(c.file) ? doc : this.where(c.file)?.doc;
+        if (sub)
+          this.emit(sub, sub === doc ? c.file : sub.main, mul(m, c.m), cc(c.color), inv !== invertNext, clipLocal, pos, col, edges, cond, tx, tex);
+        invertNext = false;
+        continue;
+      }
+      const p = c.p, v = [];
+      for (let i = 0;i < p.length; i += 3)
+        v.push(xf(m, p[i], p[i + 1], p[i + 2]));
+      if (c.t === 2) {
+        edges.push(...v[0], ...v[1]);
+        continue;
+      }
+      if (c.t === 5) {
+        cond.push(...v[0], ...v[1], ...v[2] ?? [0, 0, 0], ...v[3] ?? [0, 0, 0]);
+        continue;
+      }
+      const ordered = ccw !== flip ? v : [...v].reverse();
+      const ti = tx && tex ? texIdx(tex) : -1;
+      const code = cc(c.color);
+      const tri = (a, b, d) => {
+        pos.push(...a, ...b, ...d);
+        col.push(code);
+        if (tx) {
+          tx.tri.push(ti);
+          if (tex)
+            tx.uv.push(...texmapTriangleUV(tex, [a, b, d]));
+          else
+            tx.uv.push(NaN, NaN, NaN, NaN, NaN, NaN);
+        }
+      };
+      const emitFace = (w) => {
+        tri(w[0], w[1], w[2]);
+        if (c.t === 4)
+          tri(w[0], w[2], w[3]);
+      };
+      emitFace(ordered);
+      if (!clipLocal)
+        emitFace([...ordered].reverse());
+    }
+  }
+  flatten(doc) {
+    const out = [];
+    const walk = (d, fname, m, color, path, stepPath) => {
+      const f = d.files.get(fname);
+      if (!f)
+        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);
+          continue;
+        }
+        const r = this.where(c.file);
+        if (r?.kind === "model")
+          walk(r.doc, r.doc.main, mm, col, path + "/" + c.file, sp);
+        else {
+          const part = r ? r.doc.main : c.file;
+          out.push({ part, color: col, m: mm, step: sp[0], localStep: s, steps: sp, path, missing: !r, aliasOf: r?.aliasOf });
+        }
+      }
+    };
+    walk(doc, doc.main, I, 16, doc.main, []);
+    return out;
+  }
+}
+// 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 norm2 = (ref) => ref.trim().replace(/\\/g, "/").toLowerCase();
+var threeName = (ref) => {
+  const n = norm2(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 xf2(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 = xf2(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 Library2 {
+  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 = norm2(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(norm2(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(xf2(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(xf2(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;
+  const data = new Map;
+  let dataCur = null;
+  let cur = null, buf = [], main = null;
+  let skip = false, sawBlock = false;
+  const flush = () => {
+    if (cur)
+      files.set(cur, buf.join(`
+`));
+    cur = null;
+    buf = [];
+  };
+  const firstBlock = () => {
+    if (sawBlock)
+      return;
+    sawBlock = true;
+    files.clear();
+    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) {
+      firstBlock();
+      flush();
+      skip = false;
+      dataCur = null;
+      cur = norm2(m[1]);
+      if (!main)
+        main = cur;
+      continue;
+    }
+    if (/^\s*0\s+(NOFILE|!DATA)(\s|$)/i.test(line)) {
+      dataCur = null;
+      if (/!DATA/i.test(line)) {
+        firstBlock();
+        const dn = norm2(line.replace(/^\s*0\s+!DATA\s*/i, ""));
+        dataCur = dn;
+        data.set(dn, "");
+      }
+      flush();
+      skip = true;
+      continue;
+    }
+    if (skip) {
+      const dc = dataCur;
+      if (dc) {
+        const d = /^\s*0\s+!:\s*(.*)$/.exec(line);
+        if (d)
+          data.set(dc, data.get(dc) + d[1].trim());
+      }
+      continue;
+    }
+    if (!cur) {
+      cur = norm2(fallbackName);
+      main = cur;
+    }
+    buf.push(line);
+  }
+  flush();
+  return { files, main, data };
+}
+function flatten2(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 = norm2(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, cond: this.opts.cond ? [] : undefined, condUnder: this.opts.cond ? [] : undefined, 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(...xf2(M, v.slice(0, 3)), ...xf2(M, v.slice(3, 6)));
+          continue;
+        }
+        if (c === "5") {
+          out.condLines++;
+          const dst = target === "under" ? out.condUnder : out.cond;
+          if (dst) {
+            const v = t.split(/\s+/).slice(2, 14).map(Number);
+            if (v.length === 12 && v.every(Number.isFinite))
+              for (let i = 0;i < 12; i += 3)
+                dst.push(...xf2(M, v.slice(i, i + 3)));
+          }
+          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(xf2(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);
+    if (this.opts.tex && this.hasTex(key))
+      this.texPass(key, out, separateStuds, colorOf);
+    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;
+  }
+  texMemo = new Map;
+  hasTex(key) {
+    const m = this.texMemo.get(key);
+    if (m !== undefined)
+      return m;
+    this.texMemo.set(key, false);
+    const txt = this.lib.read(key);
+    let r = /^\s*0\s+!TEXMAP/im.test(txt);
+    if (!r)
+      for (const l of txt.split(/\r?\n/)) {
+        const t = l.trim();
+        const p = t.startsWith("0 !:") ? parseType1(t.slice(4)) : t[0] === "1" ? parseType1(t) : null;
+        if (p) {
+          const k = this.lib.resolve(p.name);
+          if (k && this.hasTex(k)) {
+            r = true;
+            break;
+          }
+        }
+      }
+    this.texMemo.set(key, r);
+    return r;
+  }
+  texture(name) {
+    const n = norm2(name);
+    for (const pre of ["parts/textures/", "p/textures/", "models/textures/", "parts/", "p/", "models/"]) {
+      const k = pre + n;
+      if (this.lib.index.has(k))
+        return new Uint8Array(fs2.readFileSync(this.lib.index.get(k)));
+    }
+    return null;
+  }
+  texPass(key, out, separateStuds, colorOf) {
+    const tbody = { pos: [], col: [] }, texb = new Map;
+    const walk = (fk, M, color, invert, target, depth, texIn) => {
+      if (depth > 40)
+        return;
+      let ccw = true, invertNext = false;
+      let stack = [];
+      let next = null;
+      for (const raw of this.lib.read(fk).split(/\r?\n/)) {
+        let t = raw.trim();
+        if (!t)
+          continue;
+        let colon = false;
+        if (t[0] === "0") {
+          const m = /^0\s+(\S+)\s*(.*)$/.exec(t);
+          const kw = (m?.[1] ?? "").toUpperCase(), rest = m?.[2] ?? "";
+          if (kw === "!TEXMAP") {
+            const op = (rest.split(/\s+/)[0] || "").toUpperCase();
+            next = null;
+            if (op === "START" || op === "NEXT") {
+              const map = parseTexMap(rest.replace(/^\S+/, ""), op === "NEXT");
+              if (map) {
+                const pm = transformTexMap(map, M);
+                if (op === "START")
+                  stack.push({ map: pm, fallback: false });
+                else
+                  next = pm;
+              }
+            } else if (op === "FALLBACK") {
+              const top = stack[stack.length - 1];
+              if (top)
+                top.fallback = true;
+            } else if (op === "END")
+              stack.pop();
+            continue;
+          }
+          if (kw === "!:") {
+            next = null;
+            t = rest.trim();
+            colon = true;
+            if (!t || t[0] === "0")
+              continue;
+          } else {
+            if (kw === "BFC") {
+              if (/\bCW\b/.test(t))
+                ccw = false;
+              if (/\bCCW\b/.test(t))
+                ccw = true;
+              if (/INVERTNEXT/.test(t))
+                invertNext = true;
+            }
+            if (kw === "STEP")
+              stack = [];
+            next = null;
+            continue;
+          }
+        }
+        let tex = texIn;
+        if (next) {
+          tex = next;
+          next = null;
+        } else {
+          const top = stack[stack.length - 1];
+          if (top) {
+            if (top.fallback) {
+              if (!colon)
+                continue;
+            } else
+              tex = top.map;
+          }
+        }
+        const c = t[0];
+        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 inv = invert !== invertNext !== det3(r.m) < 0;
+          invertNext = false;
+          if (isTop && separateStuds)
+            continue;
+          walk(ck2, compose(M, r.m), r.color === "16" ? color : r.color, inv, isUnder ? "under" : target, depth + 1, tex);
+          continue;
+        }
+        if (c !== "3" && c !== "4")
+          continue;
+        const tok = t.split(/\s+/);
+        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(xf2(M, v.slice(i * 3, i * 3 + 3)));
+        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);
+        if (tex) {
+          let b = texb.get(tex.texture);
+          if (!b)
+            texb.set(tex.texture, b = { pos: [], col: [], uv: [] });
+          if (Math.abs(tex.a ?? 0) >= 360)
+            b.wrapU = true;
+          for (let k = 0;k < order.length; k += 3) {
+            const tri = [pts[order[k]], pts[order[k + 1]], pts[order[k + 2]]];
+            const w = texmapTriangleUV(tex, tri);
+            for (let j = 0;j < 3; j++) {
+              b.pos.push(...tri[j]);
+              b.col.push(...rgba);
+              b.uv.push(w[j * 2], w[j * 2 + 1]);
+            }
+          }
+        } else if (target === "body")
+          for (const i of order) {
+            tbody.pos.push(...pts[i]);
+            tbody.col.push(...rgba);
+          }
+      }
+    };
+    walk(key, IDENT, "16", false, "body", 0, null);
+    if (texb.size) {
+      out.tbody = tbody;
+      out.texb = texb;
+    }
+  }
+}
+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, xf2(M, [x, y, z]));
+}
+function writePack(file, parts, studKinds, weld, extra, options) {
+  fs2.writeFileSync(file, encodePack(parts, studKinds, weld, extra, options));
+}
+function encodePack(parts, studKinds, weld, extra, options = {}) {
+  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" : a instanceof Uint8Array ? "u8" : "u32"];
+    chunks.push(a);
+    off += a.byteLength;
+    return r;
+  };
+  let lastPos = [];
+  const bucket = (b) => {
+    const n = b.pos.length / 3;
+    lastPos = [];
+    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) {
+      lastPos = b.pos;
+      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;
+    lastPos = P;
+    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 };
+  };
+  let anyCond = false;
+  const condl = (a, pools) => {
+    if (!a || !a.length)
+      return;
+    anyCond = true;
+    const key = (p, i) => Math.round(p[i] * 1000) + "," + Math.round(p[i + 1] * 1000) + "," + Math.round(p[i + 2] * 1000);
+    const need = new Map;
+    for (let i = 0;i < a.length; i += 3)
+      need.set(key(a, i), -1);
+    let base = 0;
+    for (const p of pools) {
+      for (let i = 0;i < p.length; i += 3) {
+        const k = key(p, i);
+        if (need.get(k) === -1)
+          need.set(k, base + i / 3);
+      }
+      base += p.length / 3;
+    }
+    const X = [], I = new Array(a.length / 3);
+    for (let i = 0;i < a.length; i += 3) {
+      const k = key(a, i);
+      let j = need.get(k);
+      if (j === -1) {
+        j = base + X.length / 3;
+        need.set(k, j);
+        X.push(a[i], a[i + 1], a[i + 2]);
+      }
+      I[i / 3] = j;
+    }
+    let prev = 0, max = 0;
+    for (let i = 0;i < I.length; i++) {
+      const d = I[i] - prev;
+      prev = I[i];
+      const z = d >= 0 ? d * 2 : -d * 2 - 1;
+      I[i] = z;
+      if (z > max)
+        max = z;
+    }
+    return { idx: put(max < 65536 ? new Uint16Array(I) : new Uint32Array(I)), ...X.length ? { x: put(new Float32Array(X)) } : {} };
+  };
+  const texNames = [];
+  const texBucket = (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;
+      }
+    }
+    const map = new Map;
+    const P = [], N = [], C = [], U = [], I = [];
+    for (let i = 0;i < n; i++) {
+      const k = weld ? `${b.pos.slice(i * 3, i * 3 + 3).map((x) => x.toFixed(3))},${[...nrm.subarray(i * 3, i * 3 + 3)].map((x) => x.toFixed(3))},${b.col.slice(i * 4, i * 4 + 4).join()},${b.uv[i * 2].toFixed(5)},${b.uv[i * 2 + 1].toFixed(5)}` : String(i);
+      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));
+        U.push(b.uv[i * 2], b.uv[i * 2 + 1]);
+      }
+      I.push(j);
+    }
+    return { pos: put(new Float32Array(P)), nrm: put(new Float32Array(N)), col: put(new Float32Array(C)), uv: put(new Float32Array(U)), idx: put(P.length / 3 < 65536 ? new Uint16Array(I) : new Uint32Array(I)), tris: n / 3 };
+  };
+  const encTex = (c) => {
+    if (!c.texb)
+      return {};
+    const tex = [...c.texb].map(([name, b]) => {
+      let t = texNames.indexOf(name);
+      if (t < 0)
+        t = texNames.push(name) - 1;
+      return { t, ...b.wrapU ? { wrapU: true } : {}, ...texBucket(b) };
+    });
+    return { tbody: bucket(c.tbody), tex };
+  };
+  const enc = (c) => {
+    const body = bucket(c.body), bodyP = lastPos, under = bucket(c.under), underP = lastPos;
+    const edges = c.edges.length ? put(new Float32Array(c.edges)) : null;
+    const condlB = condl(c.cond, [bodyP, underP, c.edges]), condlU = condl(c.condUnder, [bodyP, underP, c.edges]);
+    return { body, under, edges, cond: c.condLines, condl: condlB, condlu: condlU, 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, ...encTex(c) };
+  };
+  const encParts = Object.fromEntries([...parts].map(([k, c]) => [k, enc(c)])), encKinds = Object.fromEntries([...studKinds].map(([k, c]) => [k, enc(c)]));
+  const textures = texNames.map((name) => {
+    const b = options.texture?.(name);
+    return b ? { name, mime: "image/png", data: put(b) } : { name, missing: true };
+  });
+  const features = [...anyCond ? ["cond"] : [], ...texNames.length ? ["tex"] : []];
+  const header = { version: features.length ? 2 : 1, ...features.length ? { features } : {}, weld, parts: encParts, studKinds: encKinds, ...texNames.length ? { textures } : {}, ...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/node/build-pack.ts
+function buildPack(o) {
+  const lib = new Library2(o.ldrawRoot);
+  const refs = new Map;
+  const missing = new Set;
+  const data = new Map;
+  for (const m of o.models ?? []) {
+    const { name, text } = typeof m === "string" ? { name: path3.basename(m), text: fs3.readFileSync(m, "latin1") } : m;
+    const sm = splitModel(text, name);
+    for (const [k, v] of sm.data)
+      if (!data.has(k))
+        data.set(k, v);
+    const r = flatten2(sm, 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(norm2(p), k);
+    else
+      missing.add(norm2(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, cond: !!o.cond, tex: !!o.textures });
+  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])) };
+  }
+  const texture = (n) => {
+    const k = norm2(n), b = data.get(k) ?? data.get(k.replace(/^textures\//, "")) ?? data.get("textures/" + k);
+    return b ? new Uint8Array(Buffer.from(b, "base64")) : comp.texture(n);
+  };
+  return { data: encodePack(parts, kinds, comp.opts.weld, extra, { texture }), parts: parts.size, studKinds: kinds.size, missing: [...missing] };
+}
+export {
+  Compiler,
+  I as IDENTITY,
+  Library,
+  Library2 as ResolverLibrary,
+  buildLdrScene,
+  buildPack,
+  collectDeps,
+  computeCulling,
+  conditionalLineVisible,
+  conditionalLines,
+  createInstancedConditionalEdges,
+  createInstancedEdges,
+  createLdrObject,
+  decodePack,
+  decompressPack,
+  encodePack,
+  flatten,
+  flatten2 as flattenWithLibrary,
+  isDirectColor,
+  loadColors,
+  loadPack,
+  makeMaterial,
+  mul,
+  norm,
+  parse,
+  parseColor,
+  parseLDConfig,
+  parseModel,
+  parseTexMap,
+  resolveTexture,
+  sequenceSteps,
+  smoothNormals,
+  splitModel,
+  texmapTriangleUV,
+  texmapUV,
+  transformTexMap,
+  writePack
+};