@developerz.ai/ts23d 0.1.0 → 0.2.0

package/dist/{chunk-gcyp9b4d.js → chunk-dbq4qf52.js}

@@ -5,14 +5,16 @@ import {
   quatFromAxisAngle2,
   worldTransforms2,
   toWorld2,
-  rotateZ2
-} from "./chunk-4ddzsqtc.js";
+  rotateZ2,
+  worldMeshes2
+} from "./chunk-hg7pf34j.js";
 import {
-  hex2
-} from "./chunk-kvcep7ft.js";
+  hex2,
+  stripCredits2
+} from "./chunk-y63c6zcv.js";
 import {
   optimize2
-} from "./chunk-xnt2sdhf.js";
+} from "./chunk-drna2rny.js";
 
 // src/export/bin-writer.ts
 var ARRAY_BUFFER = 34962;
@@ -111,6 +113,28 @@ function concat(a, b) {
   return out;
 }
 
+// src/export/credits.ts
+function creditsOf(asset) {
+  const out = new Set;
+  for (const p of asset.parts) {
+    const uv = p.mesh?.uvs;
+    if (!uv)
+      continue;
+    const v = new Float32Array(uv.length >> 1);
+    for (let i = 0;i < v.length; i++)
+      v[i] = uv[i * 2 + 1] ?? 0;
+    for (const c of stripCredits2(v))
+      out.add(c);
+  }
+  return [...out].sort();
+}
+function withCredits(asset, meta) {
+  const credits = creditsOf(asset);
+  if (!credits.length)
+    return meta;
+  return { ...meta, credits: [...meta?.credits ?? [], ...credits] };
+}
+
 // src/export/lights.ts
 var LIGHTS = "KHR_lights_punctual";
 function between(a, b) {
@@ -148,6 +172,273 @@ function lightOf(part) {
   };
 }
 
+// src/export/motion.ts
+var LOOP_SECONDS = 4;
+var cyclesOf = (rate) => Math.max(1, Math.round(Math.abs(rate) * LOOP_SECONDS)) * Math.sign(rate || 1);
+var timeAccessors = new WeakMap;
+function times(bin, keys) {
+  const t = new Float32Array(keys + 1).map((_, i) => i / keys * LOOP_SECONDS);
+  const byBin = timeAccessors.get(bin) ?? new Map;
+  timeAccessors.set(bin, byBin);
+  let input = byBin.get(keys);
+  if (input === undefined) {
+    input = bin.accessor(t, "SCALAR", undefined, true);
+    byBin.set(keys, input);
+  }
+  return { input, t };
+}
+function motionChannel(bin, motion, node, rest) {
+  const rate = motion.kind === "spin" ? motion.rps : motion.hz;
+  const cycles = cyclesOf(rate);
+  const keys = Math.max(24, Math.abs(cycles) * (motion.kind === "spin" ? 12 : 16));
+  const { input, t } = times(bin, keys);
+  const phase = (time) => time / LOOP_SECONDS * cycles * Math.PI * 2;
+  const wave = (time) => motion.kind !== "spin" && motion.oneWay ? (1 - Math.cos(phase(time))) / 2 : Math.sin(phase(time));
+  if (motion.kind === "slide") {
+    const values = new Float32Array((keys + 1) * 3);
+    t.forEach((time, i) => {
+      const s = wave(time);
+      values.set([0, 1, 2].map((k) => (rest[k] ?? 0) + (motion.offset[k] ?? 0) * s), i * 3);
+    });
+    return {
+      sampler: { input, output: bin.accessor(values, "VEC3"), interpolation: "LINEAR" },
+      channel: { target: { node, path: "translation" } }
+    };
+  }
+  const values = new Float32Array((keys + 1) * 4);
+  const peak = motion.kind === "sway" ? motion.degrees * Math.PI / 180 : 0;
+  t.forEach((time, i) => {
+    const angle = motion.kind === "spin" ? phase(time) : peak * wave(time);
+    values.set(quatFromAxisAngle2(motion.axis, angle), i * 4);
+  });
+  return {
+    sampler: { input, output: bin.accessor(values, "VEC4"), interpolation: "LINEAR" },
+    channel: { target: { node, path: "rotation" } }
+  };
+}
+
+// src/export/tangents.ts
+function tangentsOf(m) {
+  const n = m.positions.length / 3;
+  const tan = new Float32Array(n * 3);
+  const bit = new Float32Array(n * 3);
+  const P = m.positions;
+  const U = m.uvs;
+  for (let t = 0;t < m.indices.length; t += 3) {
+    const a = m.indices[t] ?? 0;
+    const b = m.indices[t + 1] ?? 0;
+    const c = m.indices[t + 2] ?? 0;
+    const e1x = (P[b * 3] ?? 0) - (P[a * 3] ?? 0);
+    const e1y = (P[b * 3 + 1] ?? 0) - (P[a * 3 + 1] ?? 0);
+    const e1z = (P[b * 3 + 2] ?? 0) - (P[a * 3 + 2] ?? 0);
+    const e2x = (P[c * 3] ?? 0) - (P[a * 3] ?? 0);
+    const e2y = (P[c * 3 + 1] ?? 0) - (P[a * 3 + 1] ?? 0);
+    const e2z = (P[c * 3 + 2] ?? 0) - (P[a * 3 + 2] ?? 0);
+    const du1 = (U[b * 2] ?? 0) - (U[a * 2] ?? 0);
+    const dv1 = -((U[b * 2 + 1] ?? 0) - (U[a * 2 + 1] ?? 0));
+    const du2 = (U[c * 2] ?? 0) - (U[a * 2] ?? 0);
+    const dv2 = -((U[c * 2 + 1] ?? 0) - (U[a * 2 + 1] ?? 0));
+    const det = du1 * dv2 - du2 * dv1;
+    if (Math.abs(det) < 0.000000000001)
+      continue;
+    const r = 1 / det;
+    const tx = (e1x * dv2 - e2x * dv1) * r;
+    const ty = (e1y * dv2 - e2y * dv1) * r;
+    const tz = (e1z * dv2 - e2z * dv1) * r;
+    const bx = (e2x * du1 - e1x * du2) * r;
+    const by = (e2y * du1 - e1y * du2) * r;
+    const bz = (e2z * du1 - e1z * du2) * r;
+    for (const v of [a, b, c]) {
+      tan[v * 3] = (tan[v * 3] ?? 0) + tx;
+      tan[v * 3 + 1] = (tan[v * 3 + 1] ?? 0) + ty;
+      tan[v * 3 + 2] = (tan[v * 3 + 2] ?? 0) + tz;
+      bit[v * 3] = (bit[v * 3] ?? 0) + bx;
+      bit[v * 3 + 1] = (bit[v * 3 + 1] ?? 0) + by;
+      bit[v * 3 + 2] = (bit[v * 3 + 2] ?? 0) + bz;
+    }
+  }
+  const out = new Float32Array(n * 4);
+  for (let v = 0;v < n; v++) {
+    const nx = m.normals[v * 3] ?? 0;
+    const ny = m.normals[v * 3 + 1] ?? 0;
+    const nz = m.normals[v * 3 + 2] ?? 1;
+    let tx = tan[v * 3] ?? 0;
+    let ty = tan[v * 3 + 1] ?? 0;
+    let tz = tan[v * 3 + 2] ?? 0;
+    const d = nx * tx + ny * ty + nz * tz;
+    tx -= nx * d;
+    ty -= ny * d;
+    tz -= nz * d;
+    let len = Math.hypot(tx, ty, tz);
+    if (len < 0.00000001) {
+      [tx, ty, tz] = Math.abs(nx) < 0.9 ? [0, -nz, ny] : [nz, 0, -nx];
+      len = Math.hypot(tx, ty, tz) || 1;
+    }
+    tx /= len;
+    ty /= len;
+    tz /= len;
+    const cx = ny * tz - nz * ty;
+    const cy = nz * tx - nx * tz;
+    const cz = nx * ty - ny * tx;
+    const w = cx * (bit[v * 3] ?? 0) + cy * (bit[v * 3 + 1] ?? 0) + cz * (bit[v * 3 + 2] ?? 0);
+    out.set([tx, ty, tz, w < 0 ? -1 : 1], v * 4);
+  }
+  return out;
+}
+
+// src/export/primitive.ts
+function writePrimitive(bin, m, material, tangents) {
+  const colors = new Uint16Array(m.colors.length / 3 * 4);
+  const q = (v) => Math.round(Math.min(1, Math.max(0, v)) * 65535);
+  for (let i = 0;i < m.colors.length / 3; i++)
+    colors.set([q(m.colors[i * 3] ?? 1), q(m.colors[i * 3 + 1] ?? 1), q(m.colors[i * 3 + 2] ?? 1), 65535], i * 4);
+  return {
+    attributes: {
+      POSITION: bin.accessor(m.positions, "VEC3", ARRAY_BUFFER, true),
+      NORMAL: bin.accessor(m.normals, "VEC3", ARRAY_BUFFER),
+      TEXCOORD_0: bin.accessor(m.uvs, "VEC2", ARRAY_BUFFER),
+      COLOR_0: bin.accessor(colors, "VEC4", ARRAY_BUFFER, false, true),
+      ...tangents ? { TANGENT: bin.accessor(tangentsOf(m), "VEC4", ARRAY_BUFFER) } : {}
+    },
+    indices: bin.accessor(m.positions.length / 3 <= 65535 ? Uint16Array.from(m.indices) : m.indices, "SCALAR", ELEMENT_ARRAY_BUFFER),
+    material
+  };
+}
+
+// src/export/hierarchy.ts
+var newDoc = (bin) => ({
+  bin,
+  nodes: [],
+  meshes: [],
+  lights: [],
+  samplers: [],
+  channels: [],
+  motionSamplers: new Map,
+  lightIndex: new Map
+});
+function attach(doc, parentId, id) {
+  const parent = doc.nodes[parentId];
+  if (!parent)
+    return;
+  parent["children"] = [...parent["children"] ?? [], id];
+}
+function lightIndexOf(doc, light) {
+  const key = JSON.stringify(light);
+  const known = doc.lightIndex.get(key);
+  if (known !== undefined)
+    return known;
+  doc.lights.push(light);
+  doc.lightIndex.set(key, doc.lights.length - 1);
+  return doc.lights.length - 1;
+}
+function addMotion(doc, part, id) {
+  if (!part.motion)
+    return;
+  const key = JSON.stringify([part.motion, part.at]);
+  let sampler = doc.motionSamplers.get(key);
+  let channel;
+  if (sampler === undefined) {
+    const written = motionChannel(doc.bin, part.motion, id, part.at);
+    doc.samplers.push(written.sampler);
+    sampler = doc.samplers.length - 1;
+    doc.motionSamplers.set(key, sampler);
+    channel = written.channel;
+  } else {
+    channel = {
+      target: { node: id, path: part.motion.kind === "slide" ? "translation" : "rotation" }
+    };
+  }
+  doc.channels.push({ ...channel, sampler });
+}
+function writeHierarchy(doc, asset, rootName, o) {
+  doc.nodes.push({ name: rootName, children: [] });
+  const root = doc.nodes.length - 1;
+  const index = new Map;
+  asset.parts.forEach((part, i) => {
+    const node = { name: part.name, translation: [...part.at] };
+    if (part.yaw)
+      node["rotation"] = [...quatFromAxisAngle2([0, 0, 1], part.yaw)];
+    if (part.emitter || part.socket) {
+      node["extras"] = {
+        ts23d: {
+          ...part.emitter ? { emitter: part.emitter } : {},
+          ...part.socket ? { socket: part.socket } : {}
+        }
+      };
+    }
+    if (part.mesh && part.mesh.indices.length > 0) {
+      doc.meshes.push({
+        name: part.name,
+        primitives: [writePrimitive(doc.bin, part.mesh, o.materialOf(part, i), o.withSheet)]
+      });
+      node["mesh"] = doc.meshes.length - 1;
+    }
+    doc.nodes.push(node);
+    const id = doc.nodes.length - 1;
+    index.set(part.name, id);
+    attach(doc, part.parent === null ? root : index.get(part.parent) ?? root, id);
+    const lit = lightOf(part);
+    if (lit) {
+      doc.nodes.push({
+        name: `${part.name}_light`,
+        rotation: [...lit.rotation],
+        extensions: { [LIGHTS]: { light: lightIndexOf(doc, lit.light) } }
+      });
+      attach(doc, id, doc.nodes.length - 1);
+    }
+    if (o.animations)
+      addMotion(doc, part, id);
+  });
+  return root;
+}
+
+// src/export/lod-coverage.ts
+var MSFT_LOD2 = "MSFT_lod";
+var SCREEN_COVERAGE2 = "MSFT_screencoverage";
+var tris = (a) => a.parts.reduce((s, p) => s + (p.mesh ? p.mesh.indices.length / 3 : 0), 0);
+function extent(a) {
+  if (a.real)
+    return Math.max(a.real.length, a.real.width, a.real.height);
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (const mesh of worldMeshes2(a.parts).values()) {
+    const p = mesh.positions;
+    for (let i = 0;i < p.length; i++) {
+      const k = i % 3;
+      const v = p[i] ?? 0;
+      lo[k] = Math.min(lo[k] ?? 0, v);
+      hi[k] = Math.max(hi[k] ?? 0, v);
+    }
+  }
+  return Math.max(0, ...hi.map((h, k) => h - (lo[k] ?? 0)));
+}
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var round = (v) => Math.round(v * 1000) / 1000;
+function defaultCoverage2(lods) {
+  const byLod = new Map(lods.map((a) => [a.lod, tris(a)]));
+  const top = lods[0];
+  const t0 = Math.max(1, top ? tris(top) : 1);
+  const ratio = (lod) => (byLod.get(lod) ?? t0) / t0;
+  const c1 = round(clamp(Math.sqrt(ratio(1)), 0.1, 0.6));
+  const c2 = round(clamp(Math.sqrt(ratio(2)), 0.02, c1 / 2));
+  const cull = top && extent(top) >= 10 ? 0.002 : 0.01;
+  return [c1, c2, Math.min(cull, round(c2 / 2))];
+}
+function checkCoverage2(c, asset) {
+  const [a = -1, b = -1, cull = -1] = c;
+  if (c.length !== 3 || !(a < 1 && a > b && b > cull && cull >= 0))
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `lodCoverage ${JSON.stringify(c)} on '${asset}' is not strictly descending in [0, 1)`,
+      fix: "give [LOD0→LOD1, LOD1→LOD2, cull] screen-height fractions, e.g. [0.5, 0.2, 0.01]; 0 = never cull"
+    });
+}
+function coverageFor2(levels, c) {
+  return levels.map((_, j) => {
+    const next = levels[j + 1];
+    return next === undefined ? c[2] : c[next - 1] ?? c[2];
+  });
+}
+
 // src/export/materials.ts
 var MATERIALS = {
   opaque: {
@@ -341,7 +632,7 @@ function mergeToPivots2(asset, glow = []) {
 }
 
 // src/export/version.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 var GENERATOR = `@developerz.ai/ts23d ${VERSION}`;
 
 // src/export/metadata.ts
@@ -371,6 +662,7 @@ function metadata(name, meta) {
     ...meta.copyright ? { "dc:rights": alt(meta.copyright) } : {},
     ...meta.license ? { "xmpRights:UsageTerms": alt(meta.license) } : {},
     ...meta.sources?.length ? { "dc:relation": { "@set": [...meta.sources] } } : {},
+    ...meta.credits?.length ? { "dc:contributor": { "@set": [...meta.credits] } } : {},
     "xmp:CreatorTool": GENERATOR
   };
   return {
@@ -380,51 +672,6 @@ function metadata(name, meta) {
   };
 }
 
-// src/export/motion.ts
-var LOOP_SECONDS = 4;
-var cyclesOf = (rate) => Math.max(1, Math.round(Math.abs(rate) * LOOP_SECONDS)) * Math.sign(rate || 1);
-var timeAccessors = new WeakMap;
-function times(bin, keys) {
-  const t = new Float32Array(keys + 1).map((_, i) => i / keys * LOOP_SECONDS);
-  const byBin = timeAccessors.get(bin) ?? new Map;
-  timeAccessors.set(bin, byBin);
-  let input = byBin.get(keys);
-  if (input === undefined) {
-    input = bin.accessor(t, "SCALAR", undefined, true);
-    byBin.set(keys, input);
-  }
-  return { input, t };
-}
-function motionChannel(bin, motion, node, rest) {
-  const rate = motion.kind === "spin" ? motion.rps : motion.hz;
-  const cycles = cyclesOf(rate);
-  const keys = Math.max(24, Math.abs(cycles) * (motion.kind === "spin" ? 12 : 16));
-  const { input, t } = times(bin, keys);
-  const phase = (time) => time / LOOP_SECONDS * cycles * Math.PI * 2;
-  const wave = (time) => motion.kind !== "spin" && motion.oneWay ? (1 - Math.cos(phase(time))) / 2 : Math.sin(phase(time));
-  if (motion.kind === "slide") {
-    const values = new Float32Array((keys + 1) * 3);
-    t.forEach((time, i) => {
-      const s = wave(time);
-      values.set([0, 1, 2].map((k) => (rest[k] ?? 0) + (motion.offset[k] ?? 0) * s), i * 3);
-    });
-    return {
-      sampler: { input, output: bin.accessor(values, "VEC3"), interpolation: "LINEAR" },
-      channel: { target: { node, path: "translation" } }
-    };
-  }
-  const values = new Float32Array((keys + 1) * 4);
-  const peak = motion.kind === "sway" ? motion.degrees * Math.PI / 180 : 0;
-  t.forEach((time, i) => {
-    const angle = motion.kind === "spin" ? phase(time) : peak * wave(time);
-    values.set(quatFromAxisAngle2(motion.axis, angle), i * 4);
-  });
-  return {
-    sampler: { input, output: bin.accessor(values, "VEC4"), interpolation: "LINEAR" },
-    channel: { target: { node, path: "rotation" } }
-  };
-}
-
 // src/export/optimize-parts.ts
 function summarize2(parts, optimized) {
   const sum = (f) => parts.reduce((s, r) => s + f(r), 0);
@@ -476,94 +723,6 @@ function optimizeParts2(asset, o) {
   return { asset: { ...asset, parts }, report: summarize2(reports, o !== false) };
 }
 
-// src/export/tangents.ts
-function tangentsOf(m) {
-  const n = m.positions.length / 3;
-  const tan = new Float32Array(n * 3);
-  const bit = new Float32Array(n * 3);
-  const P = m.positions;
-  const U = m.uvs;
-  for (let t = 0;t < m.indices.length; t += 3) {
-    const a = m.indices[t] ?? 0;
-    const b = m.indices[t + 1] ?? 0;
-    const c = m.indices[t + 2] ?? 0;
-    const e1x = (P[b * 3] ?? 0) - (P[a * 3] ?? 0);
-    const e1y = (P[b * 3 + 1] ?? 0) - (P[a * 3 + 1] ?? 0);
-    const e1z = (P[b * 3 + 2] ?? 0) - (P[a * 3 + 2] ?? 0);
-    const e2x = (P[c * 3] ?? 0) - (P[a * 3] ?? 0);
-    const e2y = (P[c * 3 + 1] ?? 0) - (P[a * 3 + 1] ?? 0);
-    const e2z = (P[c * 3 + 2] ?? 0) - (P[a * 3 + 2] ?? 0);
-    const du1 = (U[b * 2] ?? 0) - (U[a * 2] ?? 0);
-    const dv1 = -((U[b * 2 + 1] ?? 0) - (U[a * 2 + 1] ?? 0));
-    const du2 = (U[c * 2] ?? 0) - (U[a * 2] ?? 0);
-    const dv2 = -((U[c * 2 + 1] ?? 0) - (U[a * 2 + 1] ?? 0));
-    const det = du1 * dv2 - du2 * dv1;
-    if (Math.abs(det) < 0.000000000001)
-      continue;
-    const r = 1 / det;
-    const tx = (e1x * dv2 - e2x * dv1) * r;
-    const ty = (e1y * dv2 - e2y * dv1) * r;
-    const tz = (e1z * dv2 - e2z * dv1) * r;
-    const bx = (e2x * du1 - e1x * du2) * r;
-    const by = (e2y * du1 - e1y * du2) * r;
-    const bz = (e2z * du1 - e1z * du2) * r;
-    for (const v of [a, b, c]) {
-      tan[v * 3] = (tan[v * 3] ?? 0) + tx;
-      tan[v * 3 + 1] = (tan[v * 3 + 1] ?? 0) + ty;
-      tan[v * 3 + 2] = (tan[v * 3 + 2] ?? 0) + tz;
-      bit[v * 3] = (bit[v * 3] ?? 0) + bx;
-      bit[v * 3 + 1] = (bit[v * 3 + 1] ?? 0) + by;
-      bit[v * 3 + 2] = (bit[v * 3 + 2] ?? 0) + bz;
-    }
-  }
-  const out = new Float32Array(n * 4);
-  for (let v = 0;v < n; v++) {
-    const nx = m.normals[v * 3] ?? 0;
-    const ny = m.normals[v * 3 + 1] ?? 0;
-    const nz = m.normals[v * 3 + 2] ?? 1;
-    let tx = tan[v * 3] ?? 0;
-    let ty = tan[v * 3 + 1] ?? 0;
-    let tz = tan[v * 3 + 2] ?? 0;
-    const d = nx * tx + ny * ty + nz * tz;
-    tx -= nx * d;
-    ty -= ny * d;
-    tz -= nz * d;
-    let len = Math.hypot(tx, ty, tz);
-    if (len < 0.00000001) {
-      [tx, ty, tz] = Math.abs(nx) < 0.9 ? [0, -nz, ny] : [nz, 0, -nx];
-      len = Math.hypot(tx, ty, tz) || 1;
-    }
-    tx /= len;
-    ty /= len;
-    tz /= len;
-    const cx = ny * tz - nz * ty;
-    const cy = nz * tx - nx * tz;
-    const cz = nx * ty - ny * tx;
-    const w = cx * (bit[v * 3] ?? 0) + cy * (bit[v * 3 + 1] ?? 0) + cz * (bit[v * 3 + 2] ?? 0);
-    out.set([tx, ty, tz, w < 0 ? -1 : 1], v * 4);
-  }
-  return out;
-}
-
-// src/export/primitive.ts
-function writePrimitive(bin, m, material, tangents) {
-  const colors = new Uint16Array(m.colors.length / 3 * 4);
-  const q = (v) => Math.round(Math.min(1, Math.max(0, v)) * 65535);
-  for (let i = 0;i < m.colors.length / 3; i++)
-    colors.set([q(m.colors[i * 3] ?? 1), q(m.colors[i * 3 + 1] ?? 1), q(m.colors[i * 3 + 2] ?? 1), 65535], i * 4);
-  return {
-    attributes: {
-      POSITION: bin.accessor(m.positions, "VEC3", ARRAY_BUFFER, true),
-      NORMAL: bin.accessor(m.normals, "VEC3", ARRAY_BUFFER),
-      TEXCOORD_0: bin.accessor(m.uvs, "VEC2", ARRAY_BUFFER),
-      COLOR_0: bin.accessor(colors, "VEC4", ARRAY_BUFFER, false, true),
-      ...tangents ? { TANGENT: bin.accessor(tangentsOf(m), "VEC4", ARRAY_BUFFER) } : {}
-    },
-    indices: bin.accessor(m.positions.length / 3 <= 65535 ? Uint16Array.from(m.indices) : m.indices, "SCALAR", ELEMENT_ARRAY_BUFFER),
-    material
-  };
-}
-
 // src/export/textures.ts
 var SHEET_MAPS2 = ["albedo", "normal", "orm"];
 var sheetFileName2 = (map, prefix = "trim_sheet") => `${prefix}_${map}.png`;
@@ -620,18 +779,25 @@ function sheetGltf(sheet, views, offset) {
 
 // src/export/glb.ts
 var Z_UP_TO_Y_UP = [-0.5, -0.5, -0.5, 0.5];
-function restClip(bin) {
+function restClip(bin, roots) {
   const input = bin.accessor(new Float32Array([0, 1]), "SCALAR", undefined, true);
   const output = bin.accessor(new Float32Array([...Z_UP_TO_Y_UP, ...Z_UP_TO_Y_UP]), "VEC4");
   return {
     name: "rest",
     samplers: [{ input, output, interpolation: "STEP" }],
-    channels: [{ sampler: 0, target: { node: 0, path: "rotation" } }]
+    channels: roots.map((node) => ({ sampler: 0, target: { node, path: "rotation" } }))
   };
 }
 function toGlb2(input, o = {}) {
   return exportGlb2(input, o).glb;
 }
+function exportGlb2(input, o = {}) {
+  const { glb, reports } = exportLodGlb2([input], o);
+  return { glb, report: reports[0] ?? summarize2([], false) };
+}
+function toLodGlb2(lods, o = {}) {
+  return exportLodGlb2(lods, o).glb;
+}
 function checkGlow(rules) {
   for (const r of rules)
     if ((r.strength ?? 4) < 0 || (r.color ?? [0, 0, 0]).some((c) => c < 0 || c > 1))
@@ -640,106 +806,87 @@ function checkGlow(rules) {
         fix: "colour is linear 0..1 (hex() converts sRGB); brightness goes in `strength`"
       });
 }
-function exportGlb2(input, o = {}) {
-  const glow = o.glow ?? input.glow ?? [];
-  checkGlow(glow);
+function checkLods(lods) {
+  const names = new Set(lods.map((l) => l.name));
+  const levels = lods.map((l) => l.lod);
+  if (lods.length === 0 || names.size !== 1 || levels.some((l, i) => i > 0 && l <= (levels[i - 1] ?? 0)))
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `exportLodGlb got LODs [${levels.join(", ")}] of [${[...names].join(", ")}]`,
+      fix: "pass compile(asset, { lod }) results of ONE asset, highest detail first: LOD0, LOD1, LOD2"
+    });
+}
+function prepare(input, o, glow) {
   const opt = o.optimize === false ? false : o.optimize === true ? {} : o.optimize ?? {};
   const merged = o.keepParts ? input : mergeToPivots2(input, glow.map((g) => g.parts));
   const { asset, report } = optimizeParts2(merged, opt);
   const glowRes = glow.map((g) => g.parts.map(globRe));
   const glowOf = (p, i) => glowLayer.get(merged.parts[i] ?? p) ?? (o.keepParts ? glowRes.findIndex((rs) => rs.some((r) => r.test(p.name))) : -1);
-  const mats = materialsFor(new Set(asset.parts.flatMap((p) => p.surface ? [p.surface] : [])), o.sheet !== undefined);
+  return { asset, report, glowOf };
+}
+function exportLodGlb2(lods, o = {}) {
+  checkLods(lods);
+  const top = lods[0];
+  const glow = o.glow ?? top.glow ?? [];
+  checkGlow(glow);
+  const preps = lods.map((l) => prepare(l, o, glow));
+  const withSheet = o.sheet !== undefined;
+  const mats = materialsFor(new Set(preps.flatMap((p) => p.asset.parts.flatMap((q) => q.surface ? [q.surface] : []))), withSheet);
   const glowAt = mats.materials.length;
-  const materials = [
-    ...mats.materials,
-    ...glow.map((g, i) => glowMaterial(g, i, o.sheet !== undefined))
-  ];
-  const bin = new BinWriter;
-  const meshes = [];
-  const nodes = [{ name: asset.name, children: [] }];
-  const index = new Map;
-  const samplers = [];
-  const channels = [];
-  const lights = [];
-  const attach = (parentId, id) => {
-    const parent = nodes[parentId];
-    if (!parent)
-      return;
-    parent["children"] = [...parent["children"] ?? [], id];
-  };
-  asset.parts.forEach((part, i) => {
-    const node = { name: part.name, translation: [...part.at] };
-    if (part.yaw)
-      node["rotation"] = [...quatFromAxisAngle2([0, 0, 1], part.yaw)];
-    if (part.emitter || part.socket) {
-      node["extras"] = {
-        ts23d: {
-          ...part.emitter ? { emitter: part.emitter } : {},
-          ...part.socket ? { socket: part.socket } : {}
-        }
-      };
-    }
-    if (part.mesh && part.mesh.indices.length > 0) {
+  const materials = [...mats.materials, ...glow.map((g, i) => glowMaterial(g, i, withSheet))];
+  const doc = newDoc(new BinWriter);
+  const roots = preps.map(({ asset, glowOf }, k) => writeHierarchy(doc, asset, k === 0 ? asset.name : `${asset.name}_LOD${asset.lod}`, {
+    withSheet,
+    animations: o.animations === true,
+    materialOf: (part, i) => {
       const g = glowOf(part, i);
-      const material = g >= 0 ? glowAt + g : mats.index.get(part.surface ?? "opaque") ?? 0;
-      meshes.push({
-        name: part.name,
-        primitives: [writePrimitive(bin, part.mesh, material, o.sheet !== undefined)]
-      });
-      node["mesh"] = meshes.length - 1;
+      return g >= 0 ? glowAt + g : mats.index.get(part.surface ?? "opaque") ?? 0;
     }
-    nodes.push(node);
-    const id = nodes.length - 1;
-    index.set(part.name, id);
-    attach(part.parent === null ? 0 : index.get(part.parent) ?? 0, id);
-    const lit = lightOf(part);
-    if (lit) {
-      lights.push(lit.light);
-      nodes.push({
-        name: `${part.name}_light`,
-        rotation: [...lit.rotation],
-        extensions: { [LIGHTS]: { light: lights.length - 1 } }
-      });
-      attach(id, nodes.length - 1);
-    }
-    if (part.motion && o.animations) {
-      const { sampler, channel } = motionChannel(bin, part.motion, id, part.at);
-      samplers.push(sampler);
-      channels.push({ ...channel, sampler: samplers.length - 1 });
-    }
-  });
-  const animations = channels.length ? [restClip(bin), { name: "run", samplers, channels }] : [];
+  }));
+  for (const r of roots) {
+    const node = doc.nodes[r];
+    if (node)
+      node["rotation"] = Z_UP_TO_Y_UP;
+  }
+  const coverage = [];
+  const rootNode = doc.nodes[0];
+  if (roots.length > 1 && rootNode) {
+    const c = o.lodCoverage ?? top.lodCoverage ?? defaultCoverage2(lods);
+    checkCoverage2(c, top.name);
+    coverage.push(...coverageFor2(lods.map((l) => l.lod), c));
+    rootNode["extensions"] = { [MSFT_LOD2]: { ids: roots.slice(1) } };
+    rootNode["extras"] = { [SCREEN_COVERAGE2]: coverage };
+  }
+  const { bin, lights, samplers, channels } = doc;
+  const animations = channels.length ? [restClip(bin, roots), { name: "run", samplers, channels }] : [];
   const geometry = bin.bytes();
   const tex = o.sheet ? sheetGltf(o.sheet, bin.views, geometry.byteLength) : null;
   const body = tex?.tail.byteLength ? concat(geometry, tex.tail) : geometry;
-  const meta = metadata(asset.name, o.meta ?? input.meta);
+  const meta = metadata(top.name, withCredits(top, o.meta ?? top.meta));
   const used = [
     ...mats.extensionsUsed,
     ...glow.some((g) => (g.strength ?? 4) !== 1) ? [EMISSIVE_STRENGTH] : [],
     ...lights.length ? [LIGHTS] : [],
+    ...coverage.length ? [MSFT_LOD2] : [],
     ...meta.used
   ].sort();
   const extensions = {
     ...lights.length ? { [LIGHTS]: { lights } } : {},
     ...meta.extensions ?? {}
   };
-  const root = nodes[0];
-  if (root)
-    root["rotation"] = Z_UP_TO_Y_UP;
   const gltf = {
     asset: meta.asset,
     extras: {
-      kind: asset.kind,
-      lod: asset.lod,
+      kind: top.kind,
+      lod: coverage.length ? lods.map((l) => l.lod) : top.lod,
       units: "metres",
       up: "Z (rotated to glTF Y-up at the root)"
     },
     ...used.length ? { extensionsUsed: used } : {},
     ...Object.keys(extensions).length ? { extensions } : {},
     scene: 0,
-    scenes: [{ name: asset.name, nodes: [0] }],
-    nodes,
-    meshes,
+    scenes: [{ name: top.name, nodes: [0] }],
+    nodes: doc.nodes,
+    meshes: doc.meshes,
     materials,
     ...tex ? tex.json : {},
     buffers: [{ byteLength: body.byteLength }],
@@ -747,9 +894,9 @@ function exportGlb2(input, o = {}) {
     accessors: bin.accessors,
     ...animations.length ? { animations } : {}
   };
-  return { glb: packGlb(gltf, body), report };
+  return { glb: packGlb(gltf, body), reports: preps.map((p) => p.report), coverage };
 }
-export { mergeToPivots2, summarize2, optimizeParts2, SHEET_MAPS2, sheetFileName2, sheetPngs2, toGlb2, exportGlb2 };
+export { MSFT_LOD2, SCREEN_COVERAGE2, defaultCoverage2, checkCoverage2, coverageFor2, mergeToPivots2, summarize2, optimizeParts2, SHEET_MAPS2, sheetFileName2, sheetPngs2, toGlb2, exportGlb2, toLodGlb2, exportLodGlb2 };
 
-//# debugId=635FF0E967FF13E664756E2164756E21
-//# sourceMappingURL=chunk-gcyp9b4d.js.map
+//# debugId=48DF0BBA03847F0964756E2164756E21
+//# sourceMappingURL=chunk-dbq4qf52.js.map