ldr 0.3.0 → 0.4.0

package/dist/node/index.js

@@ -6,6 +6,17 @@ function parseColor(tok) {
   return +tok;
 }
 var MOVED_RE = /^~?\s*moved\s+to\s+(.+)$/i;
+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;
@@ -91,7 +102,8 @@ function geomLine(tk) {
     return { t: 4, color, p: nums.slice(0, 12) };
   return { t: 5, color, p: nums.slice(0, 12) };
 }
-function parse(src, name = "main.ldr") {
+function parse(src, name = "main.ldr", popts = {}) {
+  const gtext = !!popts.geometryText;
   const files = new Map;
   let cur = null;
   let main = "";
@@ -107,6 +119,7 @@ function parse(src, name = "main.ldr") {
     (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: [] };
@@ -115,6 +128,7 @@ function parse(src, name = "main.ldr") {
       main = cur.name;
     texStack = [];
     texNext = null;
+    inHeader = true;
   };
   let skip = false, sawBlock = false;
   const firstBlock = () => {
@@ -144,6 +158,53 @@ function parse(src, name = "main.ldr") {
     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) {
@@ -186,6 +247,9 @@ function parse(src, name = "main.ldr") {
         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 {
@@ -198,6 +262,11 @@ 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;
@@ -248,6 +317,7 @@ function parse(src, name = "main.ldr") {
       continue;
     annotate(g, false);
     cur.cmds.push(g);
+    inHeader = false;
   }
   closeData();
   return data ? { main, files, data } : { main, files };
@@ -427,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) {
@@ -465,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;
@@ -830,7 +1121,7 @@ function buildLdrScene(insts, pack, P, color, mark) {
   mark("culling");
   const edgeObjs = [];
   const condObjs = [];
-  const wantCond = P.cond !== false && P.edges === "idx";
+  const wantCond = P.cond !== false && (P.edges === "idx" || P.edges === true);
   let condMat = null;
   const cmat = () => condMat ??= condLineMat();
   const condCache = new Map;
@@ -1098,11 +1389,18 @@ function toPlastic(old) {
 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 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";
@@ -1160,6 +1458,7 @@ function createLdrObject(instances, pack, options = {}) {
     object,
     stats,
     stepCount: uniq.length,
+    stepViews,
     setStep: (s) => build(s),
     setEdges: (v) => {
       edges = v;
@@ -1219,6 +1518,16 @@ class Library {
   unofficialRoot;
   cache = new Map;
   meshCache = new Map;
+  embedded = new Map;
+  register(name, doc, file = doc.main) {
+    name = norm(name);
+    const prev = this.embedded.get(name);
+    if (prev && prev.files === doc.files && prev.main === file)
+      return;
+    if (prev || this.lookup(name))
+      this.meshCache.clear();
+    this.embedded.set(name, file === doc.main ? doc : { main: file, files: doc.files, ...doc.data ? { data: doc.data } : {} });
+  }
   constructor(root, unofficialRoot) {
     this.root = root;
     this.unofficialRoot = unofficialRoot;
@@ -1229,6 +1538,9 @@ class Library {
     if (seen.has(name))
       return null;
     seen.add(name);
+    const emb = this.embedded.get(name);
+    if (emb)
+      return { kind: "part", doc: emb };
     const hit = this.lookup(name);
     if (!hit)
       return null;
@@ -1403,34 +1715,48 @@ class Library {
         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 });
+  flatten(doc, opts = {}) {
+    for (const f of doc.files.keys())
+      this.register(f, doc, f);
+    const memo = new Map;
+    const at = (n) => {
+      if (!memo.has(n))
+        memo.set(n, this.where(n));
+      return memo.get(n);
+    };
+    const insts = flatten(doc, { ...opts, resolveModel: (n) => {
+      const r = at(n);
+      return r?.kind === "model" ? r.doc : null;
+    } });
+    const synth = new Map;
+    for (const i of insts) {
+      if (i.texPart && !synth.has(i.texPart)) {
+        synth.set(i.texPart, i.texSource);
+        this.register(i.texPart, parse(i.texSource, i.texPart));
+      }
+      if (i.embedded) {
+        i.missing = false;
+        continue;
+      }
+      if (i.source) {
+        if (!synth.has(i.part)) {
+          synth.set(i.part, "");
+          const s = i.source;
+          const lf = s.file ? looseFile(s.file, s.step) : parse(s(), i.part).files.get(i.part);
+          this.register(i.part, { main: i.part, files: new Map([[i.part, lf]]) });
         }
+        i.missing = false;
+        continue;
       }
-    };
-    walk(doc, doc.main, I, 16, doc.main, []);
-    return out;
+      const r = at(i.part);
+      i.missing = !r;
+      if (r) {
+        i.part = r.doc.main;
+        if (r.aliasOf)
+          i.aliasOf = r.aliasOf;
+      }
+    }
+    return insts;
   }
 }
 // src/node/build-pack.ts
@@ -1496,8 +1822,22 @@ class Library2 {
         this.index.set(r.toLowerCase(), path.join(dir, e.name));
     }
   }
+  virtual = new Map;
+  conflicts = new Set;
+  addVirtual(name, text) {
+    const n = norm(name), key = "mpd/" + n, prev = this.virtual.get(n);
+    if (prev === undefined) {
+      this.virtual.set(n, text);
+      this.text.set(key, text);
+      this.index.set(key, "(mpd) " + n);
+    } else if (prev !== text)
+      this.conflicts.add(n);
+    return key;
+  }
   resolve(ref) {
     const n = norm2(ref);
+    if (this.virtual.size && this.virtual.has(n))
+      return "mpd/" + n;
     for (const pre of ["parts/", "p/", "models/"])
       if (this.index.has(pre + n))
         return pre + n;
@@ -1636,32 +1976,42 @@ function splitModel(text, fallbackName = "main.ldr") {
   flush();
   return { files, main, data };
 }
-function flatten2(model, lib, onInstance) {
+function modelDoc(model) {
+  const files = new Map;
+  for (const [n, t] of model.files) {
+    const f = parse(t, n, { geometryText: true }).files.get(norm(n)) ?? { name: norm(n), cmds: [] };
+    files.set(norm(n), f);
+  }
+  return { main: norm(model.main ?? ""), files };
+}
+function flatten2(model, lib, onInstance, opts = {}) {
   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 });
+  for (const [n, t] of model.files)
+    lib.addVirtual(n, t);
+  const doc = modelDoc(model);
+  const at = new Map;
+  for (const i of flatten(doc, opts)) {
+    let key;
+    if (i.embedded)
+      key = "mpd/" + i.part;
+    else if (i.source)
+      key = lib.addVirtual(i.part, i.source());
+    else {
+      if (!at.has(i.part))
+        at.set(i.part, lib.resolve(i.part));
+      key = at.get(i.part);
     }
-  };
-  walk(model.main, IDENT, "16", 0);
+    if (!key) {
+      missing.set(i.part, (missing.get(i.part) || 0) + 1);
+      continue;
+    }
+    const r = { part: key, ref: i.part, color: colorToken(i.color), m: i.m, inst: i };
+    if (i.texPart) {
+      r.texRef = i.texPart;
+      r.texPart = lib.addVirtual(i.texPart, i.texSource);
+    }
+    onInstance(r);
+  }
   return { missing };
 }
 function collectDeps(lib, refs) {
@@ -2270,9 +2620,15 @@ function buildPack(o) {
     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 textures of o.textures ? [false, true] : [false]) {
+      const r = flatten2(sm, lib, (i) => {
+        refs.set(i.ref, i.part);
+        if (i.texRef)
+          refs.set(i.texRef, i.texPart);
+      }, { textures, looseGeometry: o.looseGeometry });
+      for (const k of r.missing.keys())
+        missing.add(k);
+    }
   }
   for (const p of o.parts ?? []) {
     const k = lib.resolve(p);
@@ -2311,7 +2667,8 @@ function buildPack(o) {
     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] };
+  const warnings = [...lib.conflicts].map((n) => `${n}: defined differently by two models; the first definition is used`);
+  return { data: encodePack(parts, kinds, comp.opts.weld, extra, { texture }), parts: parts.size, studKinds: kinds.size, missing: [...missing], ...warnings.length ? { warnings } : {} };
 }
 export {
   Compiler,
@@ -2321,6 +2678,7 @@ export {
   buildLdrScene,
   buildPack,
   collectDeps,
+  colorToken,
   computeCulling,
   conditionalLineVisible,
   conditionalLines,
@@ -2330,11 +2688,19 @@ export {
   decodePack,
   decompressPack,
   encodePack,
+  fileKind,
+  fileStepViews,
   flatten,
   flatten2 as flattenWithLibrary,
+  hash32,
+  invert,
   isDirectColor,
   loadColors,
   loadPack,
+  looseFile,
+  loosePartName,
+  looseSource,
+  looseSteps,
   makeMaterial,
   mul,
   norm,
@@ -2344,9 +2710,12 @@ export {
   parseModel,
   parseTexMap,
   resolveTexture,
+  rotStepMatrix,
   sequenceSteps,
   smoothNormals,
   splitModel,
+  stepViewMatrix,
+  texWrapper,
   texmapTriangleUV,
   texmapUV,
   transformTexMap,