ldr 0.2.0 → 0.4.0

package/dist/index.js

@@ -6,41 +6,250 @@ function parseColor(tok) {
   return +tok;
 }
 var MOVED_RE = /^~?\s*moved\s+to\s+(.+)$/i;
-function parse(src, name = "main.ldr") {
+var SPECIAL0 = new Set(["FILE", "NOFILE", "!DATA", "!:", "STEP", "BFC", "ROTSTEP", "BUFEXCHG", "!TEXMAP"]);
+var PART_ORG = new Set(["part", "subpart", "primitive", "8_primitive", "48_primitive", "shortcut", "helper"]);
+var MODEL_ORG = new Set(["model", "submodel", "configuration"]);
+var ORG_RE = /^(?:!?LDRAW_ORG|Unofficial|Official\s+LCAD)\s+(\S+)/i;
+function orgType(text) {
+  const m = ORG_RE.exec(text);
+  if (!m)
+    return;
+  const t = m[1].toLowerCase().replace(/^unofficial_/, "");
+  return PART_ORG.has(t) || MODEL_ORG.has(t) ? t : undefined;
+}
+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", popts = {}) {
+  const gtext = !!popts.geometryText;
   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;
+  };
+  let inHeader = true;
   const start = (n) => {
+    closeData();
     cur = { name: norm(n), cmds: [] };
     files.set(cur.name, cur);
     if (!main)
       main = cur.name;
+    texStack = [];
+    texNext = null;
+    inHeader = true;
+  };
+  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;
+    if (gtext && line.charCodeAt(0) >= 50 && line.charCodeAt(0) <= 53 && (line.charCodeAt(1) === 32 || line.charCodeAt(1) === 9)) {
+      if (dataCur || skip)
+        continue;
+      if (!cur)
+        start(name);
+      const sp = line.slice(2).trimStart();
+      const e = sp.search(/\s/);
+      const g = { t: line.charCodeAt(0) - 48, color: parseColor(e < 0 ? sp : sp.slice(0, e)), p: [], src: line };
+      annotate(g, false);
+      cur.cmds.push(g);
+      inHeader = false;
+      continue;
+    }
+    if (line.charCodeAt(0) === 48 && (line.charCodeAt(1) === 32 || line.charCodeAt(1) === 9)) {
+      let a = 2;
+      while (line.charCodeAt(a) === 32 || line.charCodeAt(a) === 9)
+        a++;
+      let b = a;
+      while (b < line.length && line.charCodeAt(b) !== 32 && line.charCodeAt(b) !== 9)
+        b++;
+      const kw = line.slice(a, b);
+      if (!SPECIAL0.has(kw)) {
+        if (skip || dataCur)
+          continue;
+        if (!cur)
+          start(name);
+        const text = line.slice(a);
+        const c = { t: 0, text };
+        if (kw.charCodeAt(0) === 33)
+          c.meta = kw;
+        texNext = null;
+        if (inHeader && !cur.org) {
+          const o = orgType(text);
+          if (o)
+            cur.org = o;
+        }
+        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;
+      }
+    }
     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")
+      if (tk[1] === "STEP") {
         c.step = true;
-      else if (tk[1] === "BFC")
+        texStack = [];
+        texNext = null;
+      } else if (tk[1] === "BFC")
         c.bfc = tk.slice(2).join(" ");
       else if (tk[1] === "ROTSTEP") {
         c.meta = "ROTSTEP";
+        c.step = true;
+        texStack = [];
+        texNext = null;
         if ((tk[2] ?? "").toUpperCase() === "END")
           c.rotstep = { x: 0, y: 0, z: 0, mode: "END" };
         else {
@@ -53,6 +262,42 @@ function parse(src, name = "main.ldr") {
         c.bufexchg = { op: op === "RETRIEVE" ? "RETRIEVE" : "STORE", buf: tk[3] ?? "A" };
       } else if (tk[1]?.startsWith("!"))
         c.meta = tk[1];
+      if (inHeader && !cur.org) {
+        const o = orgType(text);
+        if (o)
+          cur.org = o;
+      }
+      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, "/");
@@ -63,22 +308,110 @@ function parse(src, name = "main.ldr") {
       cur.cmds.push(c);
       continue;
     }
+    if (dataCur || skip)
+      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: norm(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) });
+    const g = geomLine(tk);
+    if (!g)
+      continue;
+    annotate(g, false);
+    cur.cmds.push(g);
+    inHeader = false;
+  }
+  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;
   }
-  return { main, files };
+  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;
@@ -164,34 +497,249 @@ function smoothNormals(pos, edges, cond, creaseDeg = 35) {
   }
   return out;
 }
+var kindMemo = new WeakMap;
+var SUBREF_RE = /^(s|8|48)\//;
+function fileKind(doc, name) {
+  const f = doc.files.get(norm(name));
+  if (!f)
+    return "part";
+  let k = kindMemo.get(f);
+  if (k)
+    return k;
+  if (f.org)
+    k = PART_ORG.has(f.org) ? "part" : "model";
+  else if (f.name === doc.main)
+    k = "model";
+  else
+    k = f.cmds.some((c) => c.t >= 2 || c.t === 0 && !!c.geom || c.t === 1 && SUBREF_RE.test(c.file)) ? "part" : "model";
+  kindMemo.set(f, k);
+  return k;
+}
+var looseMemo = new WeakMap;
+function looseSteps(f) {
+  let r = looseMemo.get(f);
+  if (r)
+    return r;
+  r = [];
+  let s = 0;
+  for (const c of f.cmds) {
+    if (c.t === 0 && c.step) {
+      s++;
+      continue;
+    }
+    if ((c.t >= 2 || c.t === 0 && c.geom && c.geom.t >= 2) && r[r.length - 1] !== s)
+      r.push(s);
+  }
+  looseMemo.set(f, r);
+  return r;
+}
+var colorToken = (c) => c > 16777215 ? "0x" + c.toString(16).toUpperCase() : String(c);
+var lineOf = (c) => c.t === 0 ? "0 " + c.text : c.t === 1 ? `1 ${colorToken(c.color)} ${c.m.join(" ")} ${c.file}` : c.src ? c.src : `${c.t} ${colorToken(c.color)} ${c.p.join(" ")}`;
+var loosePartName = (file, step) => `${norm(file)}#${step}`;
+function looseFile(f, step) {
+  const out = [];
+  let s = 0;
+  const isNext = (c) => !!c && c.t === 0 && c.texmap?.op === "NEXT";
+  for (const c of f.cmds) {
+    if (c.t === 0) {
+      if (c.step) {
+        s++;
+        continue;
+      }
+      if (c.bfc !== undefined) {
+        out.push(c);
+        continue;
+      }
+      if (s !== step)
+        continue;
+      if (c.texmap)
+        out.push(c);
+      else if (c.geom) {
+        if (c.geom.t >= 2)
+          out.push(c);
+        else if (isNext(out[out.length - 1]))
+          out.pop();
+      }
+      continue;
+    }
+    if (s !== step)
+      continue;
+    if (c.t === 1) {
+      if (isNext(out[out.length - 1]))
+        out.pop();
+      continue;
+    }
+    out.push(c);
+  }
+  return { name: loosePartName(f.name, step), cmds: out };
+}
+function looseSource(f, step) {
+  return [`0 ldr: own geometry of ${f.name}, step ${step}`, ...looseFile(f, step).cmds.map(lineOf)].join(`
+`) + `
+`;
+}
+function hash32(s) {
+  let h = 2166136261;
+  for (let i = 0;i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function invert(m) {
+  const [x, y, z, a, b, c, d, e, f, g, h, i] = m;
+  const A = e * i - f * h, B = -(d * i - f * g), C = d * h - e * g;
+  const det = a * A + b * B + c * C;
+  if (!Number.isFinite(det) || Math.abs(det) < 0.000000000001)
+    return null;
+  const k = 1 / det;
+  const r = [A * k, -(b * i - c * h) * k, (b * f - c * e) * k, B * k, (a * i - c * g) * k, -(a * f - c * d) * k, C * k, -(a * h - b * g) * k, (a * e - b * d) * k];
+  return [-(r[0] * x + r[1] * y + r[2] * z), -(r[3] * x + r[4] * y + r[5] * z), -(r[6] * x + r[7] * y + r[8] * z), ...r];
+}
+var num = (x) => String(+x.toFixed(6) || 0);
+var quote = (s) => '"' + s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + '"';
+function texWrapper(part, map) {
+  const v = [...map.p1, ...map.p2, ...map.p3, ...map.method !== "PLANAR" ? [map.a ?? 360] : [], ...map.method === "SPHERICAL" ? [map.b ?? 180] : []].map(num).join(" ");
+  const source = `0 ldr: ${part} with a model-level !TEXMAP
+0 BFC CERTIFY CCW
+0 !TEXMAP START ${map.method} ${v} ${quote(map.texture)}${map.glossmap ? " GLOSSMAP " + quote(map.glossmap) : ""}
+1 16 0 0 0 1 0 0 0 1 0 0 0 1 ${norm(part)}
+0 !TEXMAP END
+`;
+  return { name: `${norm(part)}#tex-${hash32(source)}`, source };
+}
+var mul3 = (a, b) => {
+  const r = new Array(9);
+  for (let i = 0;i < 3; i++)
+    for (let j = 0;j < 3; j++)
+      r[i * 3 + j] = a[i * 3] * b[j] + a[i * 3 + 1] * b[3 + j] + a[i * 3 + 2] * b[6 + j];
+  return r;
+};
+function rotStepMatrix(x, y, z) {
+  const D = Math.PI / 180, s1 = Math.sin(x * D), c1 = Math.cos(x * D), s2 = Math.sin(y * D), c2 = Math.cos(y * D), s3 = Math.sin(z * D), c3 = Math.cos(z * D);
+  return [c2 * c3, -c2 * s3, s2, c1 * s3 + s1 * s2 * c3, c1 * c3 - s1 * s2 * s3, -s1 * c2, s1 * s3 - c1 * s2 * c3, s1 * c3 + c1 * s2 * s3, c1 * c2];
+}
+function stepViewMatrix(view, defaultView = [1, 0, 0, 0, 1, 0, 0, 0, 1]) {
+  return !view ? [...defaultView] : view.abs ? [...view.m] : mul3(defaultView, view.m);
+}
+var viewMemo = new WeakMap;
+function fileStepViews(f) {
+  const hit = viewMemo.get(f);
+  if (hit)
+    return hit;
+  const out = [];
+  let cur = null;
+  for (const c of f.cmds) {
+    if (c.t !== 0 || !c.step)
+      continue;
+    const r = c.rotstep;
+    if (r) {
+      if (r.mode === "END")
+        cur = null;
+      else {
+        const R = rotStepMatrix(r.x, r.y, r.z);
+        cur = r.mode === "ABS" ? { abs: true, m: R, rotstep: r } : r.mode === "ADD" && cur ? { abs: cur.abs, m: mul3(cur.m, R), rotstep: r } : { abs: false, m: R, rotstep: r };
+      }
+    }
+    out.push(cur);
+  }
+  out.push(cur);
+  viewMemo.set(f, out);
+  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 loose = opts.looseGeometry !== false, tx = !!opts.textures;
+  const src = new Map;
+  const lazy = (f, k) => {
+    const key = f.name + "#" + k;
+    let fn = src.get(key);
+    if (!fn) {
+      let s;
+      fn = Object.assign(() => s ??= looseSource(f, k), { file: f, step: k });
+      src.set(key, fn);
+    }
+    return fn;
+  };
+  const walk = (d, fname, m, color, path, stepPath, depth, texIn) => {
     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)
+    const views = fileStepViews(f);
+    const ls = loose ? looseSteps(f) : [];
+    let li = 0;
+    const emit = (part, col, mm, sp, k, embedded, tex) => {
+      const i = { part, color: col, m: mm, step: sp[0], steps: sp, localStep: k, path };
+      if (embedded)
+        i.embedded = true;
+      if (tex) {
+        const w = texWrapper(part, tex);
+        i.texPart = w.name;
+        i.texSource = w.source;
+      }
+      const v = views[k];
+      if (v)
+        i.view = v;
+      out.push(i);
+      return i;
+    };
+    const flushLoose = (upTo) => {
+      while (li < ls.length && ls[li] <= upTo) {
+        const k = ls[li++];
+        emit(loosePartName(f.name, k), color, m, [...stepPath, k], k, false, null).source = lazy(f, k);
+      }
+    };
+    for (const c0 of f.cmds) {
+      if (c0.t === 0 && c0.step) {
         s++;
+        continue;
+      }
+      let c = c0;
+      if (c.t >= 2 || c.t === 0 && c.geom && c.geom.t >= 2) {
+        flushLoose(s);
+        continue;
+      }
+      if (c.t === 0) {
+        if (tx && c.geom?.t === 1)
+          c = c.geom;
+        else
+          continue;
+      }
       if (c.t !== 1)
         continue;
+      if (tx && c.fallback)
+        continue;
       const col = c.color === 16 ? color : c.color, mm = mul(m, c.m), sp = [...stepPath, s];
+      const tex = tx ? c.tex ?? texIn : null;
+      const local = tex ? invert(c.m) : null;
+      const lt = tex && local ? transformTexMap(tex, local) : null;
       if (d.files.has(c.file)) {
-        walk(d, c.file, mm, col, path + "/" + c.file, sp, depth + 1);
+        if (fileKind(d, c.file) === "model") {
+          walk(d, c.file, mm, col, path + "/" + c.file, sp, depth + 1, lt);
+          continue;
+        }
+        emit(c.file, col, mm, sp, s, true, lt);
         continue;
       }
       const ext = opts.resolveModel?.(c.file);
       if (ext) {
-        walk(ext, ext.main, mm, col, path + "/" + c.file, sp, depth + 1);
+        walk(ext, ext.main, mm, col, path + "/" + c.file, sp, depth + 1, lt);
         continue;
       }
-      out.push({ part: c.file, color: col, m: mm, step: sp[0], steps: sp, path });
+      emit(c.file, col, mm, sp, s, false, lt);
     }
+    flushLoose(Infinity);
   };
-  walk(doc, doc.main, I, 16, doc.main, [], 0);
+  if (fileKind(doc, doc.main) === "part") {
+    const f = doc.files.get(doc.main);
+    if (f)
+      out.push({ part: doc.main, color: 16, m: [...I], step: 0, steps: [0], localStep: 0, path: doc.main, embedded: true });
+    return out;
+  }
+  walk(doc, doc.main, I, 16, doc.main, [], 0, null);
   return out;
 }
 function parseModel(text, name = "main.ldr", opts) {
@@ -202,8 +750,14 @@ function sequenceSteps(insts) {
   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 };
+  const views = new Array(uniq.length).fill(null);
+  insts.forEach((i, k) => {
+    const r = rank.get(key(i));
+    stepOf[k] = r;
+    if (i.view)
+      views[r] = i.view;
+  });
+  return { count: uniq.length, stepOf, views };
 }
 function parseLDConfig(text) {
   const out = new Map;
@@ -241,7 +795,7 @@ 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]) : new Uint32Array(buf, base + r[0], r[1]));
+  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) {
@@ -253,6 +807,8 @@ function geom(b, arr) {
   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) {
@@ -268,6 +824,41 @@ function makeMaterial(side) {
   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); }`,
@@ -296,6 +887,109 @@ var weldLines = (pos) => {
 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;
@@ -426,29 +1120,96 @@ function buildLdrScene(insts, pack, P, color, mark) {
   const cull = computeCulling(insts, H);
   mark("culling");
   const edgeObjs = [];
+  const condObjs = [];
+  const wantCond = P.cond !== false && (P.edges === "idx" || P.edges === true);
+  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 body = geom(p.body, arr);
+    const textured = wantTex && !!p.tex;
+    const body = geom(textured ? p.tbody : p.body, arr);
     let bodyIm = null;
-    if (body) {
-      const im = bodyIm = new THREE.InstancedMesh(body, mat, ids.length);
+    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])];
@@ -464,6 +1225,15 @@ function buildLdrScene(insts, pack, P, color, mark) {
       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);
@@ -508,6 +1278,15 @@ function buildLdrScene(insts, pack, P, color, mark) {
       } }, 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));
@@ -521,7 +1300,19 @@ function buildLdrScene(insts, pack, P, color, mark) {
   }
   stats.uncertParts = Object.values(H.parts).filter((x) => x.uncert).length;
   stats.uncertBatches = nUncert;
-  const setEdges = (v) => edgeObjs.forEach((o) => o.visible = v);
+  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;
@@ -537,6 +1328,11 @@ function buildLdrScene(insts, pack, P, color, mark) {
     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);
@@ -547,7 +1343,7 @@ function buildLdrScene(insts, pack, P, color, mark) {
     }
     return () => studMeshes.forEach((s, i) => s.im.geometry = saved[i]);
   };
-  return { root, stats, setCull, setSide, setEdges, swapStuds, box };
+  return { root, stats, setCull, setSide, setEdges, setCond, swapStuds, box, texturesReady };
 }
 // src/scene.ts
 import * as THREE2 from "three";
@@ -584,19 +1380,27 @@ function toPlastic(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 = () => "ldrColorPhys" + old.side;
+    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, cullStuds: true, cullUndersides: true, side: "front", material: "plastic", ...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 useTex = o.textures !== false;
+  const pick = (i) => useTex && i.texPart && pack.header.parts[i.texPart] ? i.texPart : i.part;
+  const all = instances.map((i) => ({ part: pick(i), 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 stepViews = new Array(uniq.length).fill(null);
+  instances.forEach((i, k) => {
+    if (i.view)
+      stepViews[stepOf[k]] = i.view;
+  });
   const missing = [...new Set(all.filter((i) => !pack.header.parts[i.part]).map((i) => i.part))];
   const object = new THREE2.Group;
   object.name = "ldr";
@@ -606,7 +1410,7 @@ function createLdrObject(instances, pack, options = {}) {
     object.scale.setScalar(o.scale);
   const pairs = new Map;
   let cur = null;
-  let { edges, cullStuds: cs, cullUndersides: cu, side } = o;
+  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)
@@ -620,17 +1424,17 @@ function createLdrObject(instances, pack, options = {}) {
       if (x.dispose && x.isInstancedMesh)
         x.dispose();
     });
-    for (const m of mats)
+    for (const m of [...mats, ...pairs.values()]) {
+      m.userData.ldrMap?.dispose();
       m.dispose();
-    for (const old of pairs.values())
-      old.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 }, color, () => {});
+    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) => {
@@ -642,19 +1446,28 @@ function createLdrObject(instances, pack, options = {}) {
       });
     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, buildMs: performance.now() - t0 });
+    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 {
+  return Object.assign(api, {
     object,
     stats,
     stepCount: uniq.length,
+    stepViews,
     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;
@@ -681,7 +1494,7 @@ function createLdrObject(instances, pack, options = {}) {
       return target;
     },
     dispose: disposeCur
-  };
+  });
 }
 // src/pack-io.ts
 import { decompress } from "fzstd";
@@ -697,14 +1510,26 @@ async function decompressPack(data) {
 export {
   I as IDENTITY,
   buildLdrScene,
+  colorToken,
   computeCulling,
+  conditionalLineVisible,
+  conditionalLines,
+  createInstancedConditionalEdges,
   createInstancedEdges,
   createLdrObject,
   decodePack,
   decompressPack,
+  fileKind,
+  fileStepViews,
   flatten,
+  hash32,
+  invert,
   isDirectColor,
   loadPack,
+  looseFile,
+  loosePartName,
+  looseSource,
+  looseSteps,
   makeMaterial,
   mul,
   norm,
@@ -712,6 +1537,14 @@ export {
   parseColor,
   parseLDConfig,
   parseModel,
+  parseTexMap,
+  resolveTexture,
+  rotStepMatrix,
   sequenceSteps,
-  smoothNormals
+  smoothNormals,
+  stepViewMatrix,
+  texWrapper,
+  texmapTriangleUV,
+  texmapUV,
+  transformTexMap
 };