@threenative/assets 0.3.3 → 0.3.5

package/dist/apply-worker.js

@@ -4590,12 +4590,12 @@ var WriterContext = class {
       source: this.imageIndexMap.get(texture),
       sampler: this.samplerDefIndexMap.get(samplerKey)
     };
-    const textureKey = JSON.stringify(textureDef);
-    if (!this.textureDefIndexMap.has(textureKey)) {
-      this.textureDefIndexMap.set(textureKey, this.jsonDoc.json.textures.length);
+    const textureKey2 = JSON.stringify(textureDef);
+    if (!this.textureDefIndexMap.has(textureKey2)) {
+      this.textureDefIndexMap.set(textureKey2, this.jsonDoc.json.textures.length);
       this.jsonDoc.json.textures.push(textureDef);
     }
-    const textureInfoDef = { index: this.textureDefIndexMap.get(textureKey) };
+    const textureInfoDef = { index: this.textureDefIndexMap.get(textureKey2) };
     if (textureInfo.getTexCoord() !== 0) textureInfoDef.texCoord = textureInfo.getTexCoord();
     if (Object.keys(textureInfo.getExtras()).length > 0) textureInfoDef.extras = textureInfo.getExtras();
     this.textureInfoDefMap.set(textureInfo, textureInfoDef);
@@ -10789,7 +10789,7 @@ var TNDiscreteLod = class extends Extension {
 };
 function attachDiscreteLod(document, extension, primitive, chain) {
   const buffer = document.getRoot().listBuffers()[0] ?? document.createBuffer();
-  const property = extension.createDiscreteLod().setStrategy("discrete").setBaselineTriangles(chain.baselineTriangles).setLod0Triangles(chain.lod0Triangles).setErrorScale(chain.errorScale).setCounts([...chain.counts]).setErrors([...chain.errors]).setAbsoluteErrors([...chain.absoluteErrors]).setSharedVertexBuffers(true);
+  const property = extension.createDiscreteLod().setStrategy(chain.strategy ?? "discrete").setBaselineTriangles(chain.baselineTriangles).setLod0Triangles(chain.lod0Triangles).setErrorScale(chain.errorScale).setCounts([...chain.counts]).setErrors([...chain.errors]).setAbsoluteErrors([...chain.absoluteErrors]).setSharedVertexBuffers(true);
   for (const indices of chain.indices) {
     property.addIndices(
       document.createAccessor().setArray(Uint32Array.from(indices)).setType("SCALAR").setBuffer(buffer)
@@ -11324,6 +11324,15 @@ function listNodeScenes(node) {
   }
   return child.listParents().filter((parent2) => parent2 instanceof Scene);
 }
+function clearNodeParent(node) {
+  const scenes = listNodeScenes(node);
+  const parent = node.getParentNode();
+  if (!parent) return node;
+  node.setMatrix(node.getWorldMatrix());
+  parent.removeChild(node);
+  for (const scene of scenes) scene.addChild(node);
+  return node;
+}
 var ARRAY_TYPE2 = typeof Float32Array !== "undefined" ? Float32Array : Array;
 function invert$1(out, a) {
   var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
@@ -12191,6 +12200,12 @@ function hasModifier(prop, cache) {
   cache.set(prop, false);
   return false;
 }
+function dequantizeAttribute(attribute) {
+  const srcArray = attribute.getArray();
+  if (!srcArray) return;
+  const dstArray = dequantizeAttributeArray(srcArray, attribute.getComponentType(), attribute.getNormalized());
+  attribute.setArray(dstArray).setNormalized(false);
+}
 function dequantizeAttributeArray(srcArray, componentType, normalized) {
   const dstArray = new Float32Array(srcArray.length);
   for (let i = 0, il = srcArray.length; i < il; i++) if (normalized) dstArray[i] = MathUtils.decodeNormalizedInt(srcArray[i], componentType);
@@ -12572,6 +12587,121 @@ async function maybeGetPixels(texture) {
     return null;
   }
 }
+var NAME$19 = "instance";
+var INSTANCE_DEFAULTS = { min: 5 };
+function instance(_options = INSTANCE_DEFAULTS) {
+  const options = assignDefaults(INSTANCE_DEFAULTS, _options);
+  return createTransform(NAME$19, (doc) => {
+    const logger = doc.getLogger();
+    const root = doc.getRoot();
+    if (root.listAnimations().length) {
+      logger.warn(`${NAME$19}: Instancing is not currently supported for animated models.`);
+      logger.debug(`${NAME$19}: Complete.`);
+      return;
+    }
+    const batchExtension = doc.createExtension(EXTMeshGPUInstancing);
+    let numBatches = 0;
+    let numInstances = 0;
+    for (const scene of root.listScenes()) {
+      const meshInstances = /* @__PURE__ */ new Map();
+      scene.traverse((node) => {
+        const mesh = node.getMesh();
+        if (!mesh) return;
+        if (node.getExtension("EXT_mesh_gpu_instancing")) return;
+        meshInstances.set(mesh, (meshInstances.get(mesh) || /* @__PURE__ */ new Set()).add(node));
+      });
+      const modifiedNodes = [];
+      for (const mesh of Array.from(meshInstances.keys())) {
+        const nodes = Array.from(meshInstances.get(mesh));
+        if (nodes.length < options.min) continue;
+        if (nodes.some((node) => node.getSkin())) continue;
+        if (mesh.listPrimitives().some(hasVolume) && nodes.some(hasScale)) continue;
+        const batch = createBatch(doc, batchExtension, mesh, nodes.length);
+        const batchTranslation = batch.getAttribute("TRANSLATION");
+        const batchRotation = batch.getAttribute("ROTATION");
+        const batchScale = batch.getAttribute("SCALE");
+        const batchNode = doc.createNode().setMesh(mesh).setExtension("EXT_mesh_gpu_instancing", batch);
+        scene.addChild(batchNode);
+        let needsTranslation = false;
+        let needsRotation = false;
+        let needsScale = false;
+        for (let i = 0; i < nodes.length; i++) {
+          let t, r, s;
+          const node = nodes[i];
+          batchTranslation.setElement(i, t = node.getWorldTranslation());
+          batchRotation.setElement(i, r = node.getWorldRotation());
+          batchScale.setElement(i, s = node.getWorldScale());
+          if (!MathUtils.eq(t, [
+            0,
+            0,
+            0
+          ])) needsTranslation = true;
+          if (!MathUtils.eq(r, [
+            0,
+            0,
+            0,
+            1
+          ])) needsRotation = true;
+          if (!MathUtils.eq(s, [
+            1,
+            1,
+            1
+          ])) needsScale = true;
+        }
+        if (!needsTranslation) batchTranslation.dispose();
+        if (!needsRotation) batchRotation.dispose();
+        if (!needsScale) batchScale.dispose();
+        if (!needsTranslation && !needsRotation && !needsScale) {
+          batchNode.dispose();
+          batch.dispose();
+          continue;
+        }
+        for (const node of nodes) {
+          node.setMesh(null);
+          modifiedNodes.push(node);
+        }
+        numBatches++;
+        numInstances += nodes.length;
+      }
+      pruneUnusedNodes(modifiedNodes, logger);
+    }
+    if (numBatches > 0) logger.info(`${NAME$19}: Created ${numBatches} batches, with ${numInstances} total instances.`);
+    else logger.info(`${NAME$19}: No meshes with >=${options.min} parent nodes were found.`);
+    if (batchExtension.listProperties().length === 0) batchExtension.dispose();
+    logger.debug(`${NAME$19}: Complete.`);
+  });
+}
+function pruneUnusedNodes(nodes, logger) {
+  let node;
+  let unusedNodes = 0;
+  while (node = nodes.pop()) {
+    if (node.listChildren().length || node.getCamera() || node.getMesh() || node.getSkin() || node.listExtensions().length) continue;
+    const nodeParent = node.getParentNode();
+    if (nodeParent) nodes.push(nodeParent);
+    node.dispose();
+    unusedNodes++;
+  }
+  logger.debug(`${NAME$19}: Removed ${unusedNodes} unused nodes.`);
+}
+function hasVolume(prim) {
+  const material = prim.getMaterial();
+  return !!(material && material.getExtension("KHR_materials_volume"));
+}
+function hasScale(node) {
+  const scale3 = node.getWorldScale();
+  return !MathUtils.eq(scale3, [
+    1,
+    1,
+    1
+  ]);
+}
+function createBatch(doc, batchExtension, mesh, count) {
+  const buffer = mesh.listPrimitives()[0].getAttribute("POSITION").getBuffer();
+  const batchTranslation = doc.createAccessor().setType("VEC3").setArray(new Float32Array(3 * count)).setBuffer(buffer);
+  const batchRotation = doc.createAccessor().setType("VEC4").setArray(new Float32Array(4 * count)).setBuffer(buffer);
+  const batchScale = doc.createAccessor().setType("VEC3").setArray(new Float32Array(3 * count)).setBuffer(buffer);
+  return batchExtension.createInstancedMesh().setAttribute("TRANSLATION", batchTranslation).setAttribute("ROTATION", batchRotation).setAttribute("SCALE", batchScale);
+}
 var JOIN_PRIMITIVE_DEFAULTS = { skipValidation: false };
 var EMPTY_U32 = 2 ** 32 - 1;
 function joinPrimitives(prims, _options = {}) {
@@ -12656,7 +12786,145 @@ function remapIndices(srcIndices, remap, dstIndices, dstOffset) {
     }
   }
 }
+var NAME$18 = "join";
 var { ROOT, NODE, MESH, PRIMITIVE, ACCESSOR } = PropertyType;
+var _matrix = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0
+];
+var JOIN_DEFAULTS = {
+  keepMeshes: false,
+  keepNamed: false,
+  cleanup: true,
+  filter: () => true
+};
+function join(_options = JOIN_DEFAULTS) {
+  const options = assignDefaults(JOIN_DEFAULTS, _options);
+  return createTransform(NAME$18, async (document) => {
+    const root = document.getRoot();
+    const logger = document.getLogger();
+    const srcRestartModeCount = _getPrimRestartModeCount(document);
+    for (const scene of root.listScenes()) {
+      _joinLevel(document, scene, options);
+      scene.traverse((node) => _joinLevel(document, node, options));
+    }
+    if (_getPrimRestartModeCount(document) < srcRestartModeCount) document.createExtension(KHRMeshPrimitiveRestart).setRequired(true);
+    if (options.cleanup) await document.transform(prune({
+      propertyTypes: [
+        NODE,
+        MESH,
+        PRIMITIVE,
+        ACCESSOR
+      ],
+      keepAttributes: true,
+      keepIndices: true,
+      keepLeaves: false
+    }));
+    logger.debug(`${NAME$18}: Complete.`);
+  });
+}
+function _joinLevel(document, parent, options) {
+  const logger = document.getLogger();
+  const groups = {};
+  const children = parent.listChildren();
+  for (let nodeIndex = 0; nodeIndex < children.length; nodeIndex++) {
+    const node = children[nodeIndex];
+    if (!options.filter(node)) continue;
+    if (node.listParents().some((p) => p instanceof AnimationChannel)) continue;
+    const mesh = node.getMesh();
+    if (!mesh) continue;
+    if (node.getExtension("EXT_mesh_gpu_instancing")) continue;
+    if (node.getSkin()) continue;
+    for (const prim of mesh.listPrimitives()) {
+      if (prim.listTargets().length > 0) continue;
+      const material = prim.getMaterial();
+      if (material && material.getExtension("KHR_materials_volume")) continue;
+      compactPrimitive(prim);
+      dequantizeTransformableAttributes(prim);
+      let key = createPrimGroupKey(prim);
+      const isNamed = mesh.getName() || node.getName();
+      if (options.keepMeshes || options.keepNamed && isNamed) key += `|${nodeIndex}`;
+      if (!(key in groups)) groups[key] = {
+        prims: [],
+        primMeshes: [],
+        primNodes: [],
+        dstNode: node,
+        dstMesh: void 0
+      };
+      const group = groups[key];
+      group.prims.push(prim);
+      group.primNodes.push(node);
+    }
+  }
+  const joinGroups = Object.values(groups).filter(({ prims }) => prims.length > 1);
+  const srcNodes = new Set(joinGroups.flatMap((group) => group.primNodes));
+  for (const node of srcNodes) {
+    const mesh = node.getMesh();
+    if (mesh.listParents().some((parent2) => {
+      return parent2.propertyType !== ROOT && node !== parent2;
+    })) node.setMesh(mesh.clone());
+  }
+  for (const group of joinGroups) {
+    const { dstNode, primNodes } = group;
+    group.dstMesh = dstNode.getMesh();
+    group.primMeshes = primNodes.map((node) => node.getMesh());
+  }
+  for (const group of joinGroups) {
+    const { prims, primNodes, primMeshes, dstNode, dstMesh } = group;
+    const dstMatrix = dstNode.getMatrix();
+    for (let i = 0; i < prims.length; i++) {
+      const primNode = primNodes[i];
+      const primMesh = primMeshes[i];
+      let prim = prims[i];
+      primMesh.removePrimitive(prim);
+      if (isUsed(prim)) prim = prims[i] = _deepClonePrimitive(prims[i]);
+      if (primNode !== dstNode) {
+        multiply$2(_matrix, invert$1(_matrix, dstMatrix), primNode.getMatrix());
+        transformPrimitive(prim, _matrix);
+      }
+    }
+    const dstPrim = joinPrimitives(prims);
+    const dstVertexCount = dstPrim.listAttributes()[0].getCount();
+    dstMesh.addPrimitive(dstPrim);
+    logger.debug(`${NAME$18}: Joined Primitives (${prims.length}) containing ${formatLong(dstVertexCount)} vertices under Node "${dstNode.getName()}".`);
+  }
+}
+function _deepClonePrimitive(src) {
+  const dst = src.clone();
+  for (const semantic of dst.listSemantics()) dst.setAttribute(semantic, dst.getAttribute(semantic).clone());
+  const indices = dst.getIndices();
+  if (indices) dst.setIndices(indices.clone());
+  return dst;
+}
+function _getPrimRestartModeCount(document) {
+  let count = 0;
+  for (const mesh of document.getRoot().listMeshes()) for (const prim of mesh.listPrimitives()) if (isPrimitiveRestartMode(prim.getMode())) count++;
+  return count;
+}
+function dequantizeTransformableAttributes(prim) {
+  for (const semantic of [
+    "POSITION",
+    "NORMAL",
+    "TANGENT"
+  ]) {
+    const attribute = prim.getAttribute(semantic);
+    if (attribute) dequantizeAttribute(attribute);
+  }
+}
 function sortPrimitiveWeights(prim, limit = Infinity) {
   if (Number.isFinite(limit) && limit % 4 || limit <= 0) throw new Error(`Limit must be positive multiple of four.`);
   const vertexCount = prim.getAttribute("POSITION").getCount();
@@ -12964,7 +13232,7 @@ function transformBatch(document, batch, nodeTransform) {
     1,
     1
   ];
-  const instanceMatrix = [
+  const instanceMatrix2 = [
     1,
     0,
     0,
@@ -12984,9 +13252,9 @@ function transformBatch(document, batch, nodeTransform) {
   ];
   const transformMatrix = fromTransform(nodeTransform);
   for (let i = 0, count = tpl.getCount(); i < count; i++) {
-    MathUtils.compose(instanceTranslation ? instanceTranslation.getElement(i, t) : T_IDENTITY, instanceRotation ? instanceRotation.getElement(i, r) : R_IDENTITY, instanceScale ? instanceScale.getElement(i, s) : S_IDENTITY, instanceMatrix);
-    multiply$2(instanceMatrix, instanceMatrix, transformMatrix);
-    MathUtils.decompose(instanceMatrix, t, r, s);
+    MathUtils.compose(instanceTranslation ? instanceTranslation.getElement(i, t) : T_IDENTITY, instanceRotation ? instanceRotation.getElement(i, r) : R_IDENTITY, instanceScale ? instanceScale.getElement(i, s) : S_IDENTITY, instanceMatrix2);
+    multiply$2(instanceMatrix2, instanceMatrix2, transformMatrix);
+    MathUtils.decompose(instanceMatrix2, t, r, s);
     if (instanceTranslation) instanceTranslation.setElement(i, t);
     if (instanceRotation) instanceRotation.setElement(i, r);
     if (instanceScale) instanceScale.setElement(i, s);
@@ -13371,6 +13639,460 @@ function _simplifyPoints(document, prim, options) {
   return prim;
 }
 
+// src/content/dedupe-materials.ts
+function normalise(value) {
+  if (value === void 0) return "\0";
+  if (Array.isArray(value)) return value.map((entry) => normalise(entry)).join(",");
+  if (typeof value === "number") {
+    return Object.is(value, -0) ? "0" : String(value);
+  }
+  return String(value);
+}
+function materialSignature(material) {
+  const parts = [];
+  for (const [slot, texture] of Object.entries(material.textures).sort(
+    ([left], [right]) => left < right ? -1 : 1
+  ))
+    parts.push(`t:${slot}=${texture ?? "\0"}`);
+  for (const [name, value] of Object.entries(material.uniforms).sort(
+    ([left], [right]) => left < right ? -1 : 1
+  ))
+    parts.push(`u:${name}=${normalise(value)}`);
+  for (const [name, value] of Object.entries(material.flags).sort(
+    ([left], [right]) => left < right ? -1 : 1
+  ))
+    parts.push(`f:${name}=${normalise(value)}`);
+  return parts.join("|");
+}
+function dedupeMaterials(materials) {
+  const bySignature = /* @__PURE__ */ new Map();
+  for (let index = 0; index < materials.length; index += 1) {
+    const material = materials[index];
+    if (material === void 0) continue;
+    const signature = materialSignature(material);
+    const members = bySignature.get(signature);
+    const name = material.name ?? `material-${String(index)}`;
+    if (members === void 0) bySignature.set(signature, [name]);
+    else members.push(name);
+  }
+  const buckets = [...bySignature.entries()].map(([signature, members]) => ({
+    members,
+    signature
+  }));
+  return {
+    buckets,
+    census: {
+      buckets: buckets.length,
+      materials: materials.length,
+      singletons: buckets.filter((bucket) => bucket.members.length === 1).length
+    }
+  };
+}
+
+// src/content/census.ts
+function textureKey(texture) {
+  if (texture === null) return void 0;
+  const uri = texture.getURI();
+  if (uri !== "") return uri;
+  const name = texture.getName();
+  if (name !== "") return `name:${name}`;
+  const image = texture.getImage();
+  return image === null ? void 0 : `bytes:${String(image.byteLength)}:${String(image[0] ?? 0)}`;
+}
+function materialStateOf(material) {
+  const textures = {
+    baseColor: textureKey(material.getBaseColorTexture()),
+    emissive: textureKey(material.getEmissiveTexture()),
+    metallicRoughness: textureKey(material.getMetallicRoughnessTexture()),
+    normal: textureKey(material.getNormalTexture()),
+    occlusion: textureKey(material.getOcclusionTexture())
+  };
+  return {
+    flags: {
+      alphaMode: material.getAlphaMode(),
+      doubleSided: material.getDoubleSided()
+    },
+    name: material.getName(),
+    textures,
+    uniforms: {
+      alphaCutoff: material.getAlphaCutoff(),
+      baseColorFactor: [...material.getBaseColorFactor()],
+      emissiveFactor: [...material.getEmissiveFactor()],
+      metallic: material.getMetallicFactor(),
+      normalScale: material.getNormalScale(),
+      occlusionStrength: material.getOcclusionStrength(),
+      roughness: material.getRoughnessFactor()
+    }
+  };
+}
+
+// src/foliage.ts
+var CUTOUT_ALPHA_CUTOFF = 0.5;
+var VOLUME_EXTENSIONS = ["transmission", "volume", "displacement"];
+function cutoutSkipReason(material, primitives) {
+  if (material.getBaseColorTexture() === null) return "no-texture-alpha";
+  if ((material.getBaseColorFactor()[3] ?? 1) < 1) return "uniform-transparency";
+  for (const extension of material.listExtensions()) {
+    const name = extension.extensionName.toLowerCase();
+    if (VOLUME_EXTENSIONS.some((needle) => name.includes(needle))) return "volume-or-transmission";
+  }
+  if (primitives.some(vertexAlphaVaries)) return "vertex-colour-alpha";
+  return null;
+}
+function vertexAlphaVaries(primitive) {
+  const color = primitive.getAttribute("COLOR_0");
+  if (color === null || color.getElementSize() !== 4) return false;
+  const element = [0, 0, 0, 0];
+  for (let vertex = 0; vertex < color.getCount(); vertex += 1) {
+    color.getElement(vertex, element);
+    if (element[3] < 1) return true;
+  }
+  return false;
+}
+function usesMaterial(primitives, material) {
+  return primitives.filter((primitive) => primitive.getMaterial() === material);
+}
+function convertFoliageCutout(document) {
+  const root = document.getRoot();
+  const primitives = root.listMeshes().flatMap((mesh) => [...mesh.listPrimitives()]);
+  const converted = [];
+  const kept = [];
+  for (const material of root.listMaterials()) {
+    if (material.getAlphaMode() !== "BLEND") continue;
+    const name = material.getName();
+    const reason = cutoutSkipReason(material, usesMaterial(primitives, material));
+    if (reason !== null) {
+      kept.push({ name, reason });
+      continue;
+    }
+    material.setAlphaMode("MASK").setAlphaCutoff(CUTOUT_ALPHA_CUTOFF);
+    converted.push(name);
+  }
+  return { converted, kept };
+}
+function mergeIdenticalMaterials(document) {
+  const root = document.getRoot();
+  const materials = root.listMaterials();
+  const states = materials.map(materialStateOf);
+  const before = dedupeMaterials(states).census;
+  const groups = /* @__PURE__ */ new Map();
+  states.forEach((state, index) => {
+    const signature = materialSignature(state);
+    const group = groups.get(signature);
+    if (group === void 0) groups.set(signature, [index]);
+    else group.push(index);
+  });
+  const merged = [];
+  for (const group of groups.values()) {
+    const [keeper, ...victims] = group;
+    const keep = keeper === void 0 ? void 0 : materials[keeper];
+    if (keep === void 0) continue;
+    for (const index of victims) {
+      const victim = materials[index];
+      if (victim === void 0 || victim === keep) continue;
+      for (const mesh of root.listMeshes()) {
+        for (const primitive of mesh.listPrimitives()) {
+          if (primitive.getMaterial() === victim) primitive.setMaterial(keep);
+        }
+      }
+      merged.push(victim.getName());
+      victim.dispose();
+    }
+  }
+  const after = root.listMaterials();
+  return {
+    distinct: {
+      after: dedupeMaterials(after.map(materialStateOf)).census.buckets,
+      before: before.buckets
+    },
+    materials: { after: after.length, before: before.materials },
+    merged
+  };
+}
+
+// src/lod/cards.ts
+var MAX_CARD_TRIANGLES = 8;
+var CARD_KEEP_RATIOS = [0.5, 0.25];
+var TRIANGLE = 3;
+function findCards(positions, indices) {
+  const vertexCount = Math.floor(positions.length / 3);
+  const parent = new Int32Array(vertexCount);
+  for (let vertex = 0; vertex < vertexCount; vertex += 1) parent[vertex] = vertex;
+  const find = (start) => {
+    let root = start;
+    while (parent[root] !== root) root = parent[root];
+    let walk = start;
+    while (parent[walk] !== root) {
+      const next = parent[walk];
+      parent[walk] = root;
+      walk = next;
+    }
+    return root;
+  };
+  for (let triangle = 0; triangle + 2 < indices.length; triangle += TRIANGLE) {
+    const a = find(indices[triangle]);
+    const b = find(indices[triangle + 1]);
+    const c = find(indices[triangle + 2]);
+    if (a === c) continue;
+    const low = Math.min(a, b, c);
+    for (const root of [a, b, c]) if (root !== low) parent[root] = low;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (let triangle = 0; triangle + 2 < indices.length; triangle += TRIANGLE) {
+    const root = find(indices[triangle]);
+    const group = grouped.get(root);
+    if (group === void 0) grouped.set(root, [triangle]);
+    else group.push(triangle);
+    if ((group?.length ?? 1) > MAX_CARD_TRIANGLES) return null;
+  }
+  const cards = [];
+  for (const triangles of grouped.values()) {
+    if (triangles.length === 0) continue;
+    let area = 0;
+    let sx = 0;
+    let sy = 0;
+    let sz = 0;
+    let vertices = 0;
+    const seen = /* @__PURE__ */ new Set();
+    for (const triangle of triangles) {
+      for (let corner = 0; corner < TRIANGLE; corner += 1) {
+        const vertex = indices[triangle + corner];
+        if (seen.has(vertex)) continue;
+        seen.add(vertex);
+        vertices += 1;
+        sx += positions[vertex * 3];
+        sy += positions[vertex * 3 + 1];
+        sz += positions[vertex * 3 + 2];
+      }
+      const a = indices[triangle] * 3;
+      const b = indices[triangle + 1] * 3;
+      const c = indices[triangle + 2] * 3;
+      const ux = positions[b] - positions[a];
+      const uy = positions[b + 1] - positions[a + 1];
+      const uz = positions[b + 2] - positions[a + 2];
+      const vx = positions[c] - positions[a];
+      const vy = positions[c + 1] - positions[a + 1];
+      const vz = positions[c + 2] - positions[a + 2];
+      const nx = uy * vz - uz * vy;
+      const ny = uz * vx - ux * vz;
+      const nz = ux * vy - uy * vx;
+      area += Math.sqrt(nx * nx + ny * ny + nz * nz) / 2;
+    }
+    cards.push({
+      area,
+      centroid: vertices === 0 ? [0, 0, 0] : [sx / vertices, sy / vertices, sz / vertices],
+      triangles
+    });
+  }
+  return cards.length > 0 ? cards : null;
+}
+function positionKey(centroid, quantum) {
+  const q = (value) => Math.round(value / quantum) | 0;
+  let hash = q(centroid[0]) * 73856093 ^ q(centroid[1]) * 19349663 ^ q(centroid[2]) * 83492791;
+  hash = Math.imul(hash ^ hash >>> 15, 739982445);
+  hash = Math.imul(hash ^ hash >>> 12, 695872825);
+  return hash ^ hash >>> 15 | 0;
+}
+function placeCards(cards, cellSize) {
+  const placed = cards.map((card, index) => {
+    const [x, y, z] = card.centroid;
+    return {
+      card,
+      // One integer key per cell: the grid is a hash, not a sort order.
+      cell: Math.floor(x / cellSize) * 73856093 ^ Math.floor(y / cellSize) * 19349663 ^ Math.floor(z / cellSize) * 83492791,
+      first: index,
+      key: positionKey(card.centroid, cellSize / 32)
+    };
+  });
+  return { cells: new Set(placed.map((entry) => entry.cell)).size, placed };
+}
+function orderPlaced(a, b) {
+  return a.key - b.key || a.card.centroid[0] - b.card.centroid[0] || a.card.centroid[1] - b.card.centroid[1] || a.card.centroid[2] - b.card.centroid[2] || a.first - b.first;
+}
+function bucketsOf(placed) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const entry of placed) {
+    const bucket = buckets.get(entry.cell);
+    if (bucket === void 0) buckets.set(entry.cell, [entry]);
+    else bucket.push(entry);
+  }
+  const cells = [...buckets.keys()].sort((a, b) => a - b);
+  for (const cell of cells) buckets.get(cell).sort(orderPlaced);
+  return { buckets, cells };
+}
+function thinLevel(placed, keep, lod0Area, lod0Cells) {
+  const { buckets, cells: order } = bucketsOf(placed);
+  const kept = [];
+  let area = 0;
+  let cells = 0;
+  for (const cell of order) {
+    const bucket = buckets.get(cell);
+    const survivors = Math.max(1, Math.min(bucket.length, Math.round(keep * bucket.length)));
+    for (const entry of bucket.slice(0, survivors)) {
+      kept.push(entry.card);
+      area += entry.card.area;
+    }
+    cells += 1;
+  }
+  return {
+    cards: kept,
+    summary: {
+      areaCoverage: lod0Area === 0 ? 1 : area / lod0Area,
+      cards: kept.length,
+      cellCoverage: lod0Cells === 0 ? 1 : cells / lod0Cells,
+      keep
+    }
+  };
+}
+function indicesOf(cards, source) {
+  let length4 = 0;
+  for (const card of cards) length4 += card.triangles.length * TRIANGLE;
+  const out = new Uint32Array(length4);
+  let at = 0;
+  for (const card of cards)
+    for (const triangle of card.triangles) {
+      out[at] = source[triangle];
+      out[at + 1] = source[triangle + 1];
+      out[at + 2] = source[triangle + 2];
+      at += TRIANGLE;
+    }
+  return out;
+}
+function cardTriangles(card) {
+  return card.triangles.length;
+}
+function terminalCardLevel(cards, lod0Placed, lod0Cells, lod0Area, cellSize, target, previousTriangles) {
+  if (target >= previousTriangles) return null;
+  let factor = 1;
+  let { buckets, cells } = bucketsOf(lod0Placed);
+  const baseTriangles = () => cells.reduce(
+    (total, cell) => total + cardTriangles(buckets.get(cell)[0]?.card),
+    0
+  );
+  while (baseTriangles() > target && cells.length > 1) {
+    factor *= 2;
+    ({ buckets, cells } = bucketsOf(placeCards(cards, cellSize * factor).placed));
+  }
+  const kept = [];
+  const keptSet = /* @__PURE__ */ new Set();
+  let triangles = 0;
+  for (const cell of cells) {
+    const first = buckets.get(cell)[0];
+    kept.push(first.card);
+    keptSet.add(first.card);
+    triangles += cardTriangles(first.card);
+  }
+  for (const cell of cells) {
+    const bucket = buckets.get(cell);
+    for (let index = 1; index < bucket.length; index += 1) {
+      const card = bucket[index].card;
+      const cost = cardTriangles(card);
+      if (triangles + cost > target) continue;
+      kept.push(card);
+      keptSet.add(card);
+      triangles += cost;
+    }
+  }
+  if (kept.length === 0) return null;
+  const covered = /* @__PURE__ */ new Set();
+  for (const entry of lod0Placed) if (keptSet.has(entry.card)) covered.add(entry.cell);
+  let area = 0;
+  for (const card of kept) area += card.area;
+  return {
+    cards: kept,
+    factor,
+    summary: {
+      areaCoverage: lod0Area === 0 ? 1 : area / lod0Area,
+      cards: kept.length,
+      cellCoverage: lod0Cells === 0 ? 1 : covered.size / lod0Cells,
+      keep: kept.length / cards.length
+    }
+  };
+}
+function generateCardChain(positions, indices, maxLevels, minSaving, scale3, keepRatios = CARD_KEEP_RATIOS, terminalTriangles) {
+  const cards = findCards(positions, indices);
+  if (cards === null) return null;
+  const lod0Triangles = Math.floor(indices.length / TRIANGLE);
+  if (lod0Triangles <= 0) return null;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let minZ = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  let maxZ = Number.NEGATIVE_INFINITY;
+  for (let vertex = 0; vertex + 2 < positions.length; vertex += 3) {
+    const x = positions[vertex];
+    const y = positions[vertex + 1];
+    const z = positions[vertex + 2];
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (z < minZ) minZ = z;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+    if (z > maxZ) maxZ = z;
+  }
+  const diagonal = Math.hypot(maxX - minX, maxY - minY, maxZ - minZ);
+  const cellSize = Math.max(diagonal / Math.cbrt(cards.length), 1e-6);
+  const { cells: lod0Cells, placed } = placeCards(cards, cellSize);
+  const lod0Area = cards.reduce((total, card) => total + card.area, 0);
+  const levels = [];
+  const counts = [];
+  const errors = [];
+  const absoluteErrors = [];
+  const buffers = [];
+  let previousTriangles = lod0Triangles;
+  for (const keep of keepRatios.slice(0, Math.max(0, maxLevels - 1))) {
+    if (levels.length >= Math.max(0, maxLevels - 1)) break;
+    const level = thinLevel(placed, keep, lod0Area, lod0Cells);
+    if (level.cards.length === 0 || level.cards.length === cards.length) continue;
+    const buffer = indicesOf(level.cards, indices);
+    const triangles = Math.floor(buffer.length / TRIANGLE);
+    if (triangles >= previousTriangles) continue;
+    if ((previousTriangles - triangles) / previousTriangles < minSaving) continue;
+    const absoluteError = cellSize * (1 - keep);
+    levels.push(level.summary);
+    counts.push(triangles);
+    absoluteErrors.push(absoluteError);
+    errors.push(absoluteError / Math.max(scale3, 1e-6));
+    buffers.push(buffer);
+    previousTriangles = triangles;
+  }
+  if (levels.length === 0) return null;
+  if (terminalTriangles !== void 0 && terminalTriangles < previousTriangles) {
+    const terminal = terminalCardLevel(
+      cards,
+      placed,
+      lod0Cells,
+      lod0Area,
+      cellSize,
+      terminalTriangles,
+      previousTriangles
+    );
+    if (terminal !== null) {
+      const buffer = indicesOf(terminal.cards, indices);
+      const triangles = Math.floor(buffer.length / TRIANGLE);
+      if (triangles > 0 && triangles < previousTriangles) {
+        const absoluteError = cellSize * terminal.factor;
+        levels.push(terminal.summary);
+        counts.push(triangles);
+        absoluteErrors.push(absoluteError);
+        errors.push(absoluteError / Math.max(scale3, 1e-6));
+        buffers.push(buffer);
+        previousTriangles = triangles;
+      }
+    }
+  }
+  return {
+    absoluteErrors,
+    counts,
+    errors,
+    indices: buffers,
+    levels,
+    lod0Cards: cards.length,
+    lod0Triangles
+  };
+}
+
 // src/lod/eligibility.ts
 var SUPPORTED_ATTRIBUTES = /* @__PURE__ */ new Set([
   "COLOR_0",
@@ -13380,13 +14102,16 @@ var SUPPORTED_ATTRIBUTES = /* @__PURE__ */ new Set([
   "TEXCOORD_0",
   "TEXCOORD_1"
 ]);
+function sharedByLevels(semantic) {
+  return SUPPORTED_ATTRIBUTES.has(semantic) || semantic.startsWith("_");
+}
 var DEFORMING_ATTRIBUTES = /* @__PURE__ */ new Set(["JOINTS_0", "WEIGHTS_0"]);
 var TRIANGLES_MODE = 4;
-var TRIANGLE = 3;
+var TRIANGLE2 = 3;
 function triangleCount(primitive) {
   const position = primitive.getAttribute("POSITION");
   const drawn = primitive.getIndices()?.getCount() ?? position?.getCount() ?? 0;
-  return Math.floor(drawn / TRIANGLE);
+  return Math.floor(drawn / TRIANGLE2);
 }
 function finitePositions(primitive) {
   const position = primitive.getAttribute("POSITION");
@@ -13405,7 +14130,7 @@ function validIndices(primitive) {
   const indices = primitive.getIndices();
   if (indices === null) return position !== null && position.getCount() > 0;
   const array = indices.getArray();
-  if (array === null || array.length === 0 || array.length % TRIANGLE !== 0) return false;
+  if (array === null || array.length === 0 || array.length % TRIANGLE2 !== 0) return false;
   const vertices = position?.getCount() ?? 0;
   for (let index = 0; index < array.length; index += 1) {
     const value = array[index];
@@ -13415,7 +14140,8 @@ function validIndices(primitive) {
 }
 function unsupportedMaterial(material) {
   if (material === null) return false;
-  if (material.getAlphaMode() !== "OPAQUE") return true;
+  const alphaMode = material.getAlphaMode();
+  if (alphaMode !== "OPAQUE" && alphaMode !== "MASK") return true;
   for (const extension of material.listExtensions()) {
     const name = extension.extensionName.toLowerCase();
     if (name.includes("transmission") || name.includes("displacement") || name.includes("volume"))
@@ -13461,8 +14187,7 @@ function classifyPrimitive(primitive, flags) {
   const semantics = primitive.listSemantics();
   for (const semantic of semantics) {
     if (DEFORMING_ATTRIBUTES.has(semantic)) return { eligible: false, reason: "deforming" };
-    if (!SUPPORTED_ATTRIBUTES.has(semantic))
-      return { eligible: false, reason: "unsupported-attributes" };
+    if (!sharedByLevels(semantic)) return { eligible: false, reason: "unsupported-attributes" };
   }
   if (!semantics.includes("POSITION")) return { eligible: false, reason: "unsupported-topology" };
   if (!finitePositions(primitive) || !validIndices(primitive))
@@ -13483,8 +14208,7 @@ function classifyJoinCandidate(primitive, flags) {
   const semantics = primitive.listSemantics();
   for (const semantic of semantics) {
     if (DEFORMING_ATTRIBUTES.has(semantic)) return { eligible: false, reason: "deforming" };
-    if (!SUPPORTED_ATTRIBUTES.has(semantic))
-      return { eligible: false, reason: "unsupported-attributes" };
+    if (!sharedByLevels(semantic)) return { eligible: false, reason: "unsupported-attributes" };
   }
   if (!semantics.includes("POSITION")) return { eligible: false, reason: "unsupported-topology" };
   if (!finitePositions(primitive) || !validIndices(primitive))
@@ -13497,12 +14221,18 @@ function authoredLodName(name) {
 
 // src/lod/generate.ts
 var LOD_GENERATOR = "threenative-discrete-lod";
-var LOD_GENERATOR_VERSION = 1;
+var LOD_GENERATOR_VERSION = 3;
 var LOD_ARTIFACT_SCHEMA_VERSION = 1;
 var LOD_TOOLCHAIN = "meshoptimizer@1.1.1";
 var LOD_ERROR_TARGETS = [2e-3, 6e-3, 0.02, 0.06];
 var LOD_MIN_SAVING = 0.2;
 var DEFAULT_LOD_MAX_LEVELS = 4;
+var LOD_TERMINAL_MIN_TRIANGLES = 1500;
+var LOD_TERMINAL_KEEP_RATIO = 0.05;
+function terminalLevelTriangles(lod0Triangles) {
+  return Math.max(LOD_TERMINAL_MIN_TRIANGLES, Math.ceil(LOD_TERMINAL_KEEP_RATIO * lod0Triangles));
+}
+var TERMINAL_TARGET_ERROR = 1e9;
 var DEFAULT_LOD_MIN_TRIANGLES = 128;
 var DEFAULT_LOD_MIN_TRIANGLES_SCOPE = "asset";
 var DEFAULT_LOD_HYSTERESIS = 0.15;
@@ -13587,8 +14317,10 @@ function resolveLodPolicy(lod, asset, legacy = {}) {
     }
   }
   if (!enabled && reasons.length === 0) reasons.push("disabled");
+  const cutout = !globalOff && (assetBlock?.cutout ?? project?.cutout ?? true);
   const generationFingerprint = lodFingerprint({
     algorithm: `${LOD_GENERATOR}/${String(LOD_GENERATOR_VERSION)}`,
+    cutout,
     enabled,
     errorTargets: generation.errorTargets,
     join: generation.join,
@@ -13600,6 +14332,7 @@ function resolveLodPolicy(lod, asset, legacy = {}) {
     toolchain: LOD_TOOLCHAIN
   });
   return {
+    cutout,
     diagnostics,
     enabled,
     fingerprint: {
@@ -13669,7 +14402,7 @@ function sourceIndices(primitive, vertexCount) {
   return Uint32Array.from(indices.getArray());
 }
 function packAttributes(primitive, vertexCount) {
-  const semantics = primitive.listSemantics().filter((semantic) => semantic !== "POSITION");
+  const semantics = primitive.listSemantics().filter((semantic) => semantic !== "POSITION" && !semantic.startsWith("_"));
   const accessors = semantics.map((semantic) => ({ accessor: primitive.getAttribute(semantic), semantic })).filter(
     (entry) => entry.accessor !== null
   );
@@ -13725,6 +14458,16 @@ async function generateChain(primitive, maxLevels, errorTargets, minSaving) {
   if (kept.length === 0) return null;
   const keptSet = new Set(kept);
   const chain = candidates.filter((candidate) => keptSet.has(candidate));
+  const previous = chain[chain.length - 1];
+  const terminal = terminalLevel(
+    positions,
+    indices,
+    attributes,
+    terminalLevelTriangles(lod0Triangles),
+    previous.triangles,
+    previous.error
+  );
+  if (terminal !== null) chain.push(terminal);
   return {
     absoluteErrors: chain.map((level) => level.error * scale3),
     baselineTriangles: lod0Triangles,
@@ -13735,6 +14478,158 @@ async function generateChain(primitive, maxLevels, errorTargets, minSaving) {
     lod0Triangles
   };
 }
+function weldMesh(positions, indices, attributes) {
+  const vertexCount = Math.floor(positions.length / 3);
+  const seen = /* @__PURE__ */ new Map();
+  const remap = new Uint32Array(vertexCount);
+  const origin = [];
+  for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+    const key = `${positions[vertex * 3]},${positions[vertex * 3 + 1]},${positions[vertex * 3 + 2]}`;
+    const compact = seen.get(key);
+    if (compact === void 0) {
+      seen.set(key, origin.length);
+      remap[vertex] = origin.length;
+      origin.push(vertex);
+    } else remap[vertex] = compact;
+  }
+  const compactPositions = new Float32Array(origin.length * 3);
+  const compactAttributes = new Float32Array(origin.length * attributes.stride);
+  for (let compact = 0; compact < origin.length; compact += 1) {
+    const source = origin[compact];
+    for (let axis = 0; axis < 3; axis += 1)
+      compactPositions[compact * 3 + axis] = positions[source * 3 + axis];
+    for (let slot = 0; slot < attributes.stride; slot += 1)
+      compactAttributes[compact * attributes.stride + slot] = attributes.data[source * attributes.stride + slot];
+  }
+  const compactIndices = new Uint32Array(indices.length);
+  for (let index = 0; index < indices.length; index += 1)
+    compactIndices[index] = remap[indices[index]];
+  return {
+    attributes: compactAttributes,
+    indices: compactIndices,
+    origin: Uint32Array.from(origin),
+    positions: compactPositions
+  };
+}
+function terminalLevel(positions, indices, attributes, terminalTriangles, previousTriangles, previousError) {
+  if (terminalTriangles >= previousTriangles) return null;
+  const target = terminalTriangles * 3;
+  if (attributes.stride > 0) {
+    const [pruned, pruneError] = MeshoptSimplifier.simplifyWithAttributes(
+      indices,
+      positions,
+      3,
+      attributes.data,
+      attributes.stride,
+      attributes.weights,
+      null,
+      target,
+      TERMINAL_TARGET_ERROR,
+      ["Prune"]
+    );
+    const triangles2 = Math.floor(pruned.length / 3);
+    if (triangles2 > 0 && triangles2 <= terminalTriangles && triangles2 < previousTriangles)
+      return {
+        error: Math.max(pruneError, previousError),
+        indices: Uint32Array.from(pruned),
+        triangles: triangles2
+      };
+  }
+  const welded = weldMesh(positions, indices, attributes);
+  let compacted;
+  let weldedError;
+  if (attributes.stride === 0) {
+    [compacted, weldedError] = MeshoptSimplifier.simplify(
+      welded.indices,
+      welded.positions,
+      3,
+      target,
+      TERMINAL_TARGET_ERROR,
+      []
+    );
+  } else {
+    [compacted, weldedError] = MeshoptSimplifier.simplifyWithAttributes(
+      welded.indices,
+      welded.positions,
+      3,
+      welded.attributes,
+      attributes.stride,
+      new Array(attributes.stride).fill(0),
+      null,
+      target,
+      TERMINAL_TARGET_ERROR,
+      []
+    );
+  }
+  const triangles = Math.floor(compacted.length / 3);
+  if (triangles <= 0 || triangles >= previousTriangles) return null;
+  const mapped = new Uint32Array(compacted.length);
+  for (let index = 0; index < compacted.length; index += 1)
+    mapped[index] = welded.origin[compacted[index]];
+  return {
+    error: Math.max(weldedError, previousError),
+    indices: mapped,
+    triangles
+  };
+}
+function generateTerminalChain(primitive) {
+  const position = primitive.getAttribute("POSITION");
+  if (position === null) return null;
+  const positions = positionsOf(primitive);
+  if (positions === null) return null;
+  const vertexCount = position.getCount();
+  const indices = sourceIndices(primitive, vertexCount);
+  const lod0Triangles = Math.floor(indices.length / 3);
+  if (lod0Triangles <= 0) return null;
+  const scale3 = MeshoptSimplifier.getScale(positions, 3);
+  const attributes = packAttributes(primitive, vertexCount);
+  const terminal = terminalLevel(
+    positions,
+    indices,
+    attributes,
+    terminalLevelTriangles(lod0Triangles),
+    lod0Triangles,
+    0
+  );
+  if (terminal === null) return null;
+  return {
+    absoluteErrors: [terminal.error * scale3],
+    baselineTriangles: lod0Triangles,
+    counts: [terminal.triangles],
+    errorScale: scale3,
+    errors: [terminal.error],
+    indices: [terminal.indices],
+    lod0Triangles
+  };
+}
+function generateCardsChain(primitive, maxLevels, minSaving) {
+  if (primitive.getMaterial()?.getAlphaMode() !== "MASK") return null;
+  const positions = positionsOf(primitive);
+  if (positions === null) return null;
+  const vertexCount = Math.floor(positions.length / 3);
+  const indices = sourceIndices(primitive, vertexCount);
+  const scale3 = MeshoptSimplifier.getScale(positions, 3);
+  const chain = generateCardChain(
+    positions,
+    indices,
+    maxLevels,
+    minSaving,
+    scale3,
+    void 0,
+    terminalLevelTriangles(Math.floor(indices.length / 3))
+  );
+  if (chain === null) return null;
+  return {
+    absoluteErrors: [...chain.absoluteErrors],
+    baselineTriangles: chain.lod0Triangles,
+    cardLevels: chain.levels,
+    counts: [...chain.counts],
+    errorScale: scale3,
+    errors: [...chain.errors],
+    indices: [...chain.indices],
+    lod0Triangles: chain.lod0Triangles
+  };
+}
 function reachableNodes(document) {
   const visited = /* @__PURE__ */ new Set();
   const nodes = [];
@@ -13770,9 +14665,10 @@ function meshFlags(document, animated) {
   }
   return flags;
 }
-function emptySummary(policy, generatedSeconds) {
+function emptySummary(policy, generatedSeconds, cutout = { converted: [], kept: [] }) {
   return {
     byteOverhead: 0,
+    cutout,
     diagnostics: [...policy.diagnostics],
     enabled: policy.enabled,
     errorTargets: [...policy.generation.errorTargets],
@@ -13856,6 +14752,10 @@ async function buildJoinedRungs(document, policy, reason) {
   for (const node of nodes) {
     const mesh = node.getMesh();
     if (mesh === null || hasMeshBelow.has(node)) continue;
+    if (node.getExtension("EXT_mesh_gpu_instancing") !== null) {
+      reason("boundary-unsafe");
+      continue;
+    }
     if ((meshRefs.get(mesh) ?? 0) > 1) {
       reason("boundary-unsafe");
       continue;
@@ -14006,10 +14906,11 @@ async function generateDiscreteLod(document, lod, logicalPath, sourceDigest, leg
   const started = now();
   const policy = resolveLodPolicy(lod, logicalPath, legacy);
   const fingerprint = policy.fingerprint.generation;
-  if (!policy.enabled) return emptySummary(policy, (now() - started) / 1e3);
+  const cutout = policy.cutout ? convertFoliageCutout(document) : { converted: [], kept: [] };
+  if (!policy.enabled) return emptySummary(policy, (now() - started) / 1e3, cutout);
   const joinRequested = policy.generation.join;
   const discrete = policy.generation.maxLevels > 1;
-  if (!discrete && !joinRequested) return emptySummary(policy, (now() - started) / 1e3);
+  if (!discrete && !joinRequested) return emptySummary(policy, (now() - started) / 1e3, cutout);
   await MeshoptSimplifier.ready;
   const animated = animatedNodes(document);
   const flags = meshFlags(document, animated);
@@ -14044,12 +14945,19 @@ async function generateDiscreteLod(document, lod, logicalPath, sourceDigest, leg
       }
       const before = triangleCount(primitive);
       trianglesBefore += before;
-      const chain = await generateChain(
+      let chain = await generateChain(
         primitive,
         policy.generation.maxLevels,
         policy.generation.errorTargets,
         policy.generation.minSaving
       );
+      const thinned = chain === null ? generateCardsChain(primitive, policy.generation.maxLevels, policy.generation.minSaving) : null;
+      chain ??= thinned;
+      let strategy = thinned === null ? "discrete" : "cards";
+      if (chain === null) {
+        chain = generateTerminalChain(primitive);
+        strategy = "discrete";
+      }
       if (chain === null) {
         reasons.add("insufficient-reduction");
         skipped.push({
@@ -14061,7 +14969,10 @@ async function generateDiscreteLod(document, lod, logicalPath, sourceDigest, leg
         continue;
       }
       extension ??= document.createExtension(TNDiscreteLod).setRequired(false);
-      const property = attachDiscreteLod(document, extension, primitive, chain);
+      const property = attachDiscreteLod(document, extension, primitive, {
+        ...chain,
+        strategy
+      });
       byteOverhead += discreteLodBytes(property);
       levels = Math.max(levels, chain.counts.length);
       const finest = chain.counts[chain.counts.length - 1] ?? before;
@@ -14074,7 +14985,8 @@ async function generateDiscreteLod(document, lod, logicalPath, sourceDigest, leg
         })),
         mesh: mesh.getName(),
         primitive: primitiveIndex,
-        strategy: "discrete",
+        ...chain.cardLevels === void 0 ? {} : { cardLevels: chain.cardLevels },
+        strategy,
         trianglesBefore: before
       });
     }
@@ -14092,6 +15004,7 @@ async function generateDiscreteLod(document, lod, logicalPath, sourceDigest, leg
   extension?.setMetadata(metadata);
   return {
     byteOverhead,
+    cutout,
     diagnostics: [...policy.diagnostics],
     enabled: true,
     errorTargets: [...policy.generation.errorTargets],
@@ -14735,6 +15648,7 @@ ${result.stderr.trim().split("\n").slice(-12).join("\n")}`;
 }
 function blenderImportPass(options = {}) {
   return {
+    appliesTo: ["model"],
     configuration: { extensions: [...BLENDER_SOURCE_EXTENSIONS].sort() },
     name: BLENDER_IMPORT_PASS,
     async apply(input, logicalPath) {
@@ -15300,8 +16214,8 @@ async function BASIS(moduleArg = {}) {
   async function instantiateArrayBuffer(binaryFile, imports) {
     try {
       var binary = await getWasmBinary(binaryFile);
-      var instance = await WebAssembly.instantiate(binary, imports);
-      return instance;
+      var instance2 = await WebAssembly.instantiate(binary, imports);
+      return instance2;
     } catch (reason) {
       err(`failed to asynchronously prepare wasm: ${reason}`);
       abort(reason);
@@ -15324,8 +16238,8 @@ async function BASIS(moduleArg = {}) {
     return { a: wasmImports };
   }
   async function createWasm() {
-    function receiveInstance(instance, module) {
-      wasmExports = instance.exports;
+    function receiveInstance(instance2, module) {
+      wasmExports = instance2.exports;
       wasmMemory = wasmExports["_"];
       updateMemoryViews();
       wasmTable = wasmExports["ca"];
@@ -19370,6 +20284,7 @@ async function compressEmbeddedTextures(document, logicalPath, options = {}, rec
   const root = document.getRoot();
   const textures = root.listTextures();
   if (textures.length === 0) return void 0;
+  const decoderFree = options.decoderFree === true;
   const maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
   const quality = Math.min(255, Math.max(1, Math.round(options.quality ?? DEFAULT_ETC1S_QUALITY)));
   const keys = textureKeys(root);
@@ -19389,6 +20304,16 @@ async function compressEmbeddedTextures(document, logicalPath, options = {}, rec
         `TN_ASSETS_MODEL_TEXTURE_MISSING: '${logicalPath}' declares texture '${key}' with no image data.`
       );
     }
+    const recalledFree = decoderFree ? recalled.get(index) : void 0;
+    if (recalledFree !== void 0) {
+      const shape = imageShape(image, texture.getMimeType());
+      bytesBefore += recalledFree.sourceBytes;
+      bytesAfter += image.byteLength;
+      gpuBytesBefore += gpuBytes(shape.width, shape.height, "none");
+      gpuBytesAfter += gpuBytes(shape.width, shape.height, "none");
+      formats[key] = "none";
+      continue;
+    }
     if (texture.getMimeType() === "image/ktx2") {
       const shape = imageShape(image, "image/ktx2");
       const fromStore = recalled.get(index);
@@ -19430,6 +20355,32 @@ async function compressEmbeddedTextures(document, logicalPath, options = {}, rec
       formats[key] = "none";
       continue;
     }
+    if (decoderFree) {
+      const target2 = cappedSize(decoded.width, decoded.height, maxSize);
+      if (target2.width === decoded.width && target2.height === decoded.height) {
+        bytesAfter += image.byteLength;
+        gpuBytesAfter += gpuBytes(decoded.width, decoded.height, "none");
+        formats[key] = "none";
+        continue;
+      }
+      const data2 = resampleRgba(
+        decoded.data,
+        decoded.width,
+        decoded.height,
+        target2.width,
+        target2.height,
+        getTextureColorSpace(texture) === "srgb"
+      );
+      const png = new PNG({ height: target2.height, width: target2.width });
+      png.data = Buffer.from(data2);
+      const encoded2 = PNG.sync.write(png);
+      texture.setImage(encoded2).setMimeType("image/png");
+      bytesAfter += encoded2.byteLength;
+      gpuBytesAfter += gpuBytes(target2.width, target2.height, "none");
+      formats[key] = "none";
+      resized += 1;
+      continue;
+    }
     const target = cappedSize(decoded.width, decoded.height, maxSize);
     const srgb = getTextureColorSpace(texture) === "srgb";
     let data = decoded.data;
@@ -19525,6 +20476,7 @@ async function encodeLinearRgbaKtx2(data, width, height) {
 }
 function texturePass(options = {}) {
   return {
+    appliesTo: ["texture"],
     configuration: {
       encoder: KTX2_ENCODER_VERSION,
       keepSmallerSource: true,
@@ -19577,6 +20529,65 @@ function texturePass(options = {}) {
     name: "ktx2"
   };
 }
+function textureResizePass(options) {
+  const { maxSize } = options;
+  return {
+    appliesTo: ["texture"],
+    // Part of the compile cache key: a different cap — or a different set of excluded globs — must
+    // not re-serve the previous output.
+    configuration: { maxSize, overrides: options.overrides ?? [], resample: "png" },
+    name: "texture-resize",
+    apply: async (input, logicalPath) => {
+      if (classify2(logicalPath) !== "texture") return input;
+      if (matchingOverride(logicalPath, options.overrides)?.codec === "none") return input;
+      const stats = textureStats(input);
+      let decoded;
+      if (stats.width <= 0 || stats.height <= 0) {
+        if (!isPngOrJpeg(input)) return input;
+        decoded = await decodeForResize(input, logicalPath);
+      }
+      const width = decoded?.width ?? stats.width;
+      const height = decoded?.height ?? stats.height;
+      const target = cappedSize(width, height, maxSize);
+      if (target.width === width && target.height === height) return input;
+      const source = decoded ?? await decodeForResize(input, logicalPath);
+      const data = resampleRgba(
+        source.data,
+        source.width,
+        source.height,
+        target.width,
+        target.height,
+        !NORMAL_MAP_BASENAME.test(baseNameOf(logicalPath))
+      );
+      const png = new PNG({ height: target.height, width: target.width });
+      png.data = Buffer.from(data);
+      return {
+        buffer: PNG.sync.write(png),
+        entry: { resizedFrom: `${String(width)}x${String(height)}` },
+        // Emitted as PNG whatever the source extension was: the manifest records the logical
+        // path unchanged and the served output name carries the bytes' real container, so a
+        // `.jpg` logical path resolves to a `.png` output the loader sniffs by content.
+        outputExtension: ".png"
+      };
+    }
+  };
+}
+function isPngOrJpeg(bytes) {
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return true;
+  }
+  return bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10;
+}
+async function decodeForResize(input, logicalPath) {
+  try {
+    return await decodeImageBytes(input, logicalPath);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `TN_ASSETS_TEXTURE_UNDECODABLE: '${logicalPath}' could not be decoded to apply its size cap: ${detail}`
+    );
+  }
+}
 function resizeForEncoding(decoded, normalMap, maxSize) {
   const target = maxSize === void 0 ? { height: decoded.height, width: decoded.width } : cappedSize(decoded.width, decoded.height, Math.floor(maxSize / 4) * 4);
   const resized = target.width !== decoded.width || target.height !== decoded.height;
@@ -19610,8 +20621,8 @@ function rgbaHasAlpha2(rgba) {
 function chooseCodec2(logicalPath, alpha, options) {
   const normalMap = NORMAL_MAP_BASENAME.test(baseNameOf(logicalPath));
   const fallbackQuality = options.quality ?? DEFAULT_ETC1S_QUALITY2;
-  for (const override of options.overrides ?? []) {
-    if (!globMatch(override.glob, logicalPath)) continue;
+  const override = matchingOverride(logicalPath, options.overrides);
+  if (override !== void 0) {
     return {
       codec: override.codec,
       explicit: true,
@@ -19626,6 +20637,9 @@ function chooseCodec2(logicalPath, alpha, options) {
     quality: clampQuality(fallbackQuality)
   };
 }
+function matchingOverride(logicalPath, overrides) {
+  return overrides?.find((override) => globMatch(override.glob, logicalPath));
+}
 function encodeSettingsFor(choice) {
   if (choice.codec === "none") return {};
   if (choice.codec === "uastc") {
@@ -19711,7 +20725,7 @@ function chartCount(atlas) {
       parent.set(value, root);
       return root;
     };
-    const join = (left, right) => {
+    const join2 = (left, right) => {
       const leftRoot = rootOf(left);
       const rightRoot = rootOf(right);
       parent.set(leftRoot, rightRoot);
@@ -19724,8 +20738,8 @@ function chartCount(atlas) {
       parent.set(first, parent.get(first) ?? first);
       parent.set(second, parent.get(second) ?? second);
       parent.set(third, parent.get(third) ?? third);
-      join(first, second);
-      join(second, third);
+      join2(first, second);
+      join2(second, third);
     }
     charts += new Set([...parent.keys()].map(rootOf)).size;
   }
@@ -19848,6 +20862,7 @@ function lightmapPass(options) {
   const atlasSize = positiveInteger(options.atlasSize, "atlasSize");
   const padding = positiveInteger(options.padding, "padding");
   return {
+    appliesTo: ["model"],
     cacheKey: JSON.stringify({ atlasSize, padding }),
     name: "lightmap-uv2",
     async apply(input, logicalPath) {
@@ -20347,7 +21362,7 @@ async function bakeVirtualGeometry(document, options, now = () => Date.now()) {
     for (const primitive of mesh.listPrimitives()) {
       const indices = primitive.getIndices();
       const positions = positionsOf2(primitive);
-      if (indices === null || positions === null || primitive.getMode() !== 4) {
+      if (indices === null || positions === null || primitive.getMode() !== 4 || primitive.getAttribute("JOINTS_0") !== null) {
         skipped += 1;
         continue;
       }
@@ -20379,6 +21394,454 @@ async function bakeVirtualGeometry(document, options, now = () => Date.now()) {
     stopReason
   };
 }
+var DEFAULT_PROTECTED_PATTERN = "propeller|aileron|rudder|flap|elevator|gear|wheel|canopy|hook|crew|gunner|threenativepivot|torpedo|wingport|wingstarboard|cockpit controls";
+var EXT_MESH_GPU_INSTANCING2 = "EXT_mesh_gpu_instancing";
+function asBatch(node) {
+  return node.getExtension(EXT_MESH_GPU_INSTANCING2);
+}
+function sceneNodes(root) {
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const scene of root.listScenes()) {
+    scene.traverse((node) => {
+      if (seen.has(node)) return;
+      seen.add(node);
+      nodes.push(node);
+    });
+  }
+  return nodes;
+}
+function countPrimitives(nodes) {
+  let primitives = 0;
+  for (const node of nodes) {
+    const mesh = node.getMesh();
+    if (mesh !== null) primitives += mesh.listPrimitives().length;
+  }
+  return primitives;
+}
+function countCompactNodes(document) {
+  return sceneNodes(document.getRoot()).length;
+}
+function countCompactPrimitives(document) {
+  return countPrimitives(sceneNodes(document.getRoot()));
+}
+function sceneNodeNames(document) {
+  return sceneNodes(document.getRoot()).filter((node) => node.getMesh() !== null || node.listChildren().length > 0).map((node) => node.getName()).filter((name) => name !== "").sort();
+}
+function removedNames(before, after) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const name of after) counts.set(name, (counts.get(name) ?? 0) + 1);
+  const removed = [];
+  for (const name of before) {
+    const remaining = counts.get(name) ?? 0;
+    if (remaining > 0) counts.set(name, remaining - 1);
+    else removed.push(name);
+  }
+  return removed.sort();
+}
+function buildProtectedSet(document, options = {}) {
+  const root = document.getRoot();
+  const rules = /* @__PURE__ */ new Map();
+  const claim = (node, rule) => {
+    if (!rules.has(node)) rules.set(node, rule);
+  };
+  const allowList = new Set(options.protectedNames ?? []);
+  for (const node of sceneNodes(root)) {
+    const name = node.getName();
+    if (name !== "" && allowList.has(name)) claim(node, "allow-list");
+  }
+  for (const skin of root.listSkins()) {
+    for (const joint of skin.listJoints()) claim(joint, "skin-joint");
+  }
+  for (const animation of root.listAnimations()) {
+    for (const channel of animation.listChannels()) {
+      const target = channel.getTargetNode();
+      if (target !== null) claim(target, "animation-target");
+    }
+  }
+  const pattern = new RegExp(options.protectedPattern ?? DEFAULT_PROTECTED_PATTERN, "iu");
+  for (const node of sceneNodes(root)) {
+    const name = node.getName();
+    if (name !== "" && pattern.test(name)) claim(node, "regex");
+  }
+  for (const animation of root.listAnimations()) {
+    for (const channel of animation.listChannels()) {
+      const target = channel.getTargetNode();
+      if (target === null) continue;
+      let ancestor = target.getParentNode();
+      while (ancestor !== null) {
+        claim(ancestor, "animation-ancestor");
+        ancestor = ancestor.getParentNode();
+      }
+    }
+  }
+  const summary = [];
+  for (const [node, rule] of rules) {
+    summary.push({ name: node.getName() === "" ? "(unnamed)" : node.getName(), rule });
+  }
+  summary.sort(
+    (left, right) => left.name.localeCompare(right.name) || left.rule.localeCompare(right.rule)
+  );
+  return { nodes: rules, summary };
+}
+function detachProtectedMeshes(document, protectedNodes) {
+  const keep = keepInPlaceNodes(document, protectedNodes);
+  const detached = [];
+  for (const node of keep) {
+    const mesh = node.getMesh();
+    if (mesh === null || !isShared(mesh, node)) continue;
+    const clone = deepCloneMesh(document, mesh);
+    node.setMesh(clone);
+    detached.push({ clone, node, original: mesh });
+  }
+  return detached;
+}
+function restoreDetachedMeshes(detached) {
+  for (const { clone, node, original } of detached) {
+    if (node.getMesh() === clone) node.setMesh(original);
+    disposeMeshDeep(clone);
+  }
+}
+function disposeMeshDeep(mesh) {
+  for (const primitive of mesh.listPrimitives()) {
+    for (const semantic of primitive.listSemantics()) {
+      const attribute = primitive.getAttribute(semantic);
+      primitive.setAttribute(semantic, null);
+      attribute?.dispose();
+    }
+    const indices = primitive.getIndices();
+    primitive.setIndices(null);
+    indices?.dispose();
+    for (const target of primitive.listTargets()) {
+      for (const semantic of target.listSemantics()) {
+        const attribute = target.getAttribute(semantic);
+        target.setAttribute(semantic, null);
+        attribute?.dispose();
+      }
+      target.dispose();
+    }
+    primitive.dispose();
+  }
+  mesh.dispose();
+}
+function isShared(mesh, node) {
+  return mesh.listParents().some((parent) => parent !== node && parent.propertyType === PropertyType.NODE);
+}
+function isTrsExact(node) {
+  const world = node.getWorldMatrix();
+  const composed = composeTrsMatrix(
+    node.getWorldTranslation(),
+    node.getWorldRotation(),
+    node.getWorldScale()
+  );
+  for (let index = 0; index < 16; index += 1) {
+    const expected = world[index] ?? 0;
+    const actual = composed[index] ?? 0;
+    if (Math.abs(expected - actual) > 1e-4 * Math.max(1, Math.abs(expected))) return false;
+  }
+  return true;
+}
+function composeTrsMatrix(translation, rotation, scale3) {
+  const translationVector = [translation[0] ?? 0, translation[1] ?? 0, translation[2] ?? 0];
+  const rotationVector = [
+    rotation[0] ?? 0,
+    rotation[1] ?? 0,
+    rotation[2] ?? 0,
+    rotation[3] ?? 1
+  ];
+  const scaleVector = [scale3[0] ?? 1, scale3[1] ?? 1, scale3[2] ?? 1];
+  const out = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+  MathUtils.compose(translationVector, rotationVector, scaleVector, out);
+  return [...out];
+}
+function keepInPlaceNodes(document, protectedNodes) {
+  const keepInPlace = new Set(protectedNodes.keys());
+  const spreading = /* @__PURE__ */ new Set();
+  for (const [node, rule] of protectedNodes) {
+    if (rule !== "animation-ancestor") spreading.add(node);
+  }
+  for (const scene of document.getRoot().listScenes()) {
+    scene.traverse((node) => {
+      const parent = node.getParentNode();
+      if (parent === null) {
+        if (!isTrsExact(node)) {
+          keepInPlace.add(node);
+          spreading.add(node);
+        }
+        return;
+      }
+      if (spreading.has(parent) || !isTrsExact(parent) || !isTrsExact(node)) {
+        keepInPlace.add(node);
+        spreading.add(node);
+      }
+    });
+  }
+  return keepInPlace;
+}
+function flattenProtected(document, protectedNodes) {
+  const keepInPlace = keepInPlaceNodes(document, protectedNodes);
+  let reparented = 0;
+  for (const scene of document.getRoot().listScenes()) {
+    scene.traverse((node) => {
+      if (keepInPlace.has(node) || node.getParentNode() === null) return;
+      clearNodeParent(node);
+      reparented += 1;
+    });
+  }
+  return reparented;
+}
+function deepCloneMesh(document, mesh) {
+  const clone = document.createMesh(mesh.getName());
+  for (const primitive of mesh.listPrimitives()) {
+    const copy = document.createPrimitive();
+    for (const semantic of primitive.listSemantics()) {
+      const attribute = primitive.getAttribute(semantic);
+      if (attribute !== null) copy.setAttribute(semantic, attribute.clone());
+    }
+    const indices = primitive.getIndices();
+    if (indices !== null) copy.setIndices(indices.clone());
+    const material = primitive.getMaterial();
+    if (material !== null) copy.setMaterial(material);
+    for (const target of primitive.listTargets()) {
+      const targetCopy = document.createPrimitiveTarget();
+      for (const semantic of target.listSemantics()) {
+        const attribute = target.getAttribute(semantic);
+        if (attribute !== null) targetCopy.setAttribute(semantic, attribute.clone());
+      }
+      copy.addTarget(targetCopy);
+    }
+    clone.addPrimitive(copy);
+  }
+  return clone;
+}
+function instanceCount(batch) {
+  for (const semantic of batch.listSemantics()) {
+    const attribute = batch.getAttribute(semantic);
+    if (attribute !== null) return attribute.getCount();
+  }
+  return 0;
+}
+async function compactModel(document, options = {}) {
+  const root = document.getRoot();
+  const namesBefore = sceneNodeNames(document);
+  const nodesBefore = sceneNodes(root).length;
+  const primitivesBefore = countPrimitives(sceneNodes(root));
+  const { nodes: protectedNodes, summary: protectedSummary } = buildProtectedSet(document, options);
+  const flattenEnabled = options.flatten ?? true;
+  const joinEnabled = options.join ?? true;
+  const instanceOption = options.instance ?? true;
+  const instanceEnabled = instanceOption !== false;
+  const instanceMin = typeof instanceOption === "object" && instanceOption.min !== void 0 ? instanceOption.min : 2;
+  const reparented = flattenEnabled ? flattenProtected(document, protectedNodes) : 0;
+  const sharedBefore = /* @__PURE__ */ new Set();
+  for (const node of sceneNodes(root)) {
+    const mesh = node.getMesh();
+    if (mesh !== null && isShared(mesh, node)) sharedBefore.add(node);
+  }
+  let detached = [];
+  if (instanceEnabled && root.listAnimations().length === 0) {
+    detached = detachProtectedMeshes(document, protectedNodes);
+  }
+  let instanceSummary = {
+    batches: 0,
+    enabled: instanceEnabled,
+    instances: 0
+  };
+  if (instanceEnabled) {
+    await instance({ min: instanceMin })(document);
+    let batches = 0;
+    let instances = 0;
+    for (const node of sceneNodes(root)) {
+      const batch = asBatch(node);
+      if (batch === null) continue;
+      batches += 1;
+      instances += instanceCount(batch);
+    }
+    const reason = batches > 0 ? void 0 : root.listAnimations().length > 0 ? "animated model; EXT_mesh_gpu_instancing is not supported for animated models" : `no mesh was shared by >=${String(instanceMin)} nodes`;
+    instanceSummary = {
+      batches,
+      enabled: true,
+      instances,
+      ...reason === void 0 ? {} : { reason }
+    };
+  }
+  restoreDetachedMeshes(detached);
+  const primitivesBeforeJoin = countPrimitives(sceneNodes(root));
+  if (joinEnabled) {
+    const sourcePrimitives = collectPrimitives(root);
+    const exclusions = joinExclusions(root);
+    await join({
+      cleanup: false,
+      filter: (node) => !protectedNodes.has(node) && !sharedBefore.has(node) && !exclusions.has(node)
+    })(document);
+    for (const primitive of sourcePrimitives) {
+      if (primitive.listParents().some((parent) => parent.propertyType !== PropertyType.ROOT)) {
+        continue;
+      }
+      const accessors = accessorsOfPrimitive(primitive);
+      primitive.dispose();
+      for (const accessor of accessors) {
+        if (accessor.listParents().every((parent) => parent.propertyType === PropertyType.ROOT)) {
+          accessor.dispose();
+        }
+      }
+    }
+    for (const mesh of root.listMeshes()) {
+      if (mesh.listPrimitives().length === 0) mesh.dispose();
+    }
+  }
+  const primitivesAfterJoin = countPrimitives(sceneNodes(root));
+  const nodesAfter = sceneNodes(root).length;
+  const summary = {
+    flatten: { enabled: flattenEnabled, reparented },
+    instance: instanceSummary,
+    join: {
+      enabled: joinEnabled,
+      primitivesAfter: primitivesAfterJoin,
+      primitivesBefore: primitivesBeforeJoin
+    },
+    nodesAfter,
+    nodesBefore,
+    primitivesAfter: primitivesAfterJoin,
+    primitivesBefore,
+    removed: removedNames(namesBefore, sceneNodeNames(document)),
+    protected: protectedSummary
+  };
+  return summary;
+}
+function collectPrimitives(root) {
+  return root.listMeshes().flatMap((mesh) => mesh.listPrimitives());
+}
+function primitiveSignature(primitive) {
+  if (primitive.listTargets().length > 0) return null;
+  const position = primitive.getAttribute("POSITION");
+  if (position === null) return null;
+  const hash = createHash("sha1");
+  const min2 = position.getMin([0, 0, 0]);
+  const max2 = position.getMax([0, 0, 0]);
+  const extent = Math.max(
+    (max2[0] ?? 0) - (min2[0] ?? 0),
+    (max2[1] ?? 0) - (min2[1] ?? 0),
+    (max2[2] ?? 0) - (min2[2] ?? 0),
+    1e-9
+  );
+  for (const semantic of [...primitive.listSemantics()].sort()) {
+    const attribute = primitive.getAttribute(semantic);
+    if (attribute === null) continue;
+    hash.update(semantic);
+    hash.update(":");
+    const array = attribute.getArray();
+    const stride = attribute.getElementSize();
+    const normalized = attribute.getNormalized();
+    for (let index = 0; index < attribute.getCount(); index += 1) {
+      for (let axis = 0; axis < stride; axis += 1) {
+        let value = array[index * stride + axis] ?? 0;
+        if (semantic === "POSITION" && !normalized && axis < 3) {
+          value = (value - (min2[axis] ?? 0)) / extent;
+        }
+        hash.update(Math.round(value * 1e4).toString());
+        hash.update(",");
+      }
+    }
+  }
+  const indices = primitive.getIndices();
+  if (indices !== null) {
+    const array = indices.getArray();
+    hash.update("indices:");
+    for (let index = 0; index < indices.getCount(); index += 1) {
+      hash.update((array[index] ?? 0).toString());
+      hash.update(",");
+    }
+  }
+  return hash.digest("hex");
+}
+function meshShapeSignature(mesh) {
+  const signatures = [];
+  for (const primitive of mesh.listPrimitives()) {
+    const signature = primitiveSignature(primitive);
+    if (signature === null) return null;
+    signatures.push(signature);
+  }
+  signatures.sort();
+  return signatures.join("|");
+}
+function joinExclusions(root) {
+  const excluded = /* @__PURE__ */ new Set();
+  const signatures = /* @__PURE__ */ new Map();
+  const byNode = /* @__PURE__ */ new Map();
+  for (const node of sceneNodes(root)) {
+    if (listNodeScenes(node).length > 1) excluded.add(node);
+    const mesh = node.getMesh();
+    if (mesh === null) continue;
+    const signature = meshShapeSignature(mesh);
+    if (signature === null) continue;
+    byNode.set(node, signature);
+    signatures.set(signature, (signatures.get(signature) ?? 0) + 1);
+  }
+  for (const [node, signature] of byNode) {
+    if ((signatures.get(signature) ?? 0) > 1) excluded.add(node);
+  }
+  return excluded;
+}
+function accessorsOfPrimitive(primitive) {
+  const accessors = [];
+  for (const semantic of primitive.listSemantics()) {
+    const attribute = primitive.getAttribute(semantic);
+    if (attribute !== null) accessors.push(attribute);
+  }
+  const indices = primitive.getIndices();
+  if (indices !== null) accessors.push(indices);
+  for (const target of primitive.listTargets()) {
+    for (const semantic of target.listSemantics()) {
+      const attribute = target.getAttribute(semantic);
+      if (attribute !== null) accessors.push(attribute);
+    }
+  }
+  return accessors;
+}
+function compactRequested(options) {
+  if (options === false) return false;
+  if (options === void 0 || options === true) return true;
+  return options.flatten !== false || options.join !== false || options.instance !== false;
+}
+var COMPACT_VERSION = 8;
+function resolveCompactOptions(options) {
+  if (options === void 0 || options === true) {
+    return {
+      flatten: true,
+      instance: { min: 2 },
+      join: true,
+      protectedNames: [],
+      protectedPattern: DEFAULT_PROTECTED_PATTERN,
+      version: COMPACT_VERSION
+    };
+  }
+  if (options === false) {
+    return {
+      flatten: false,
+      instance: false,
+      join: false,
+      protectedNames: [],
+      protectedPattern: DEFAULT_PROTECTED_PATTERN,
+      version: COMPACT_VERSION
+    };
+  }
+  const instance2 = options.instance;
+  const min2 = typeof instance2 === "object" ? instance2.min ?? 2 : 2;
+  if (!Number.isSafeInteger(min2) || min2 < 2) {
+    throw new Error(
+      "TN_ASSETS_COMPACT_INVALID: assets.models.compact.instance.min must be an integer of at least 2."
+    );
+  }
+  return {
+    flatten: options.flatten !== false,
+    instance: instance2 === false ? false : { min: min2 },
+    join: options.join !== false,
+    protectedNames: options.protectedNames ?? [],
+    protectedPattern: options.protectedPattern ?? DEFAULT_PROTECTED_PATTERN,
+    version: COMPACT_VERSION
+  };
+}
 var SHARED_IMAGES_DIRECTORY = "shared/images";
 var KEY_LENGTH = 16;
 var EXTENSION_BY_MIME = {
@@ -20587,6 +22050,8 @@ async function readSharedGlb(io, buffer, resolve2) {
 // src/passes/model.ts
 var DRACO_EXTENSION2 = "KHR_draco_mesh_compression";
 var EXT_MESHOPT_EXTENSION = "EXT_meshopt_compression";
+var MATERIAL_MERGE_VERSION = 1;
+var MODEL_DEDUPE_VERSION = 1;
 var BBOX_TOLERANCE = 1e-3;
 var SIMPLIFY_BBOX_TOLERANCE = 0.01;
 var SIMPLIFY_RATIO_FLOOR = 0.5;
@@ -20624,6 +22089,27 @@ function primitiveTriangles(primitive) {
   const drawn = primitive.getIndices()?.getCount() ?? primitive.getAttribute("POSITION")?.getCount() ?? 0;
   return Math.floor(drawn / 3);
 }
+function instanceCount2(batch) {
+  for (const semantic of batch.listSemantics()) {
+    const attribute = batch.getAttribute(semantic);
+    if (attribute !== null) return attribute.getCount();
+  }
+  return 0;
+}
+function instanceMatrix(batch, index) {
+  return composeTrsMatrix(
+    readElement(batch.getAttribute("TRANSLATION"), index, [0, 0, 0]),
+    readElement(batch.getAttribute("ROTATION"), index, [0, 0, 0, 1]),
+    readElement(batch.getAttribute("SCALE"), index, [1, 1, 1])
+  );
+}
+function readElement(accessor, index, fallback) {
+  if (accessor === null) return [...fallback];
+  const array = accessor.getArray();
+  const size = accessor.getElementSize();
+  const base = index * size;
+  return fallback.map((_, axis) => array[base + axis] ?? 0);
+}
 function decodeElement(accessor, index) {
   const array = accessor.getArray();
   const base = index * accessor.getElementSize();
@@ -20721,36 +22207,43 @@ function reachableStats(root) {
     if (skin !== null) skins.add(skin);
     const mesh = node.getMesh();
     if (mesh !== null) {
-      const worldMatrix = node.getWorldMatrix();
+      const batch = node.getExtension("EXT_mesh_gpu_instancing");
+      const instanceMatrices = batch === null ? [node.getWorldMatrix()] : Array.from(
+        { length: instanceCount2(batch) },
+        (_, index) => multiplyMatrices(node.getWorldMatrix(), instanceMatrix(batch, index))
+      );
+      const skin2 = node.getSkin();
       let jointMatrices;
-      if (skin !== null) {
-        const inverseBinds = skin.getInverseBindMatrices();
-        jointMatrices = skin.listJoints().map((joint, index) => {
+      if (skin2 !== null) {
+        const inverseBinds = skin2.getInverseBindMatrices();
+        jointMatrices = skin2.listJoints().map((joint, index) => {
           const jointWorld = joint.getWorldMatrix();
           const ibm = inverseBinds?.getElement(index, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) ?? IDENTITY_MATRIX2;
           return multiplyMatrices(jointWorld, ibm);
         });
       }
-      for (const primitive of mesh.listPrimitives()) {
-        triangles += primitiveTriangles(primitive);
-        const position = primitive.getAttribute("POSITION");
-        if (position === null) continue;
-        vertices += position.getCount();
-        for (let index = 0; index < position.getCount(); index += 1) {
-          const [wx, wy, wz] = evaluateVertex(
-            position,
-            index,
-            primitive.getAttribute("JOINTS_0"),
-            primitive.getAttribute("WEIGHTS_0"),
-            skin !== null ? jointMatrices : void 0,
-            worldMatrix
-          );
-          minX = Math.min(minX, wx);
-          minY = Math.min(minY, wy);
-          minZ = Math.min(minZ, wz);
-          maxX = Math.max(maxX, wx);
-          maxY = Math.max(maxY, wy);
-          maxZ = Math.max(maxZ, wz);
+      for (const matrix of instanceMatrices) {
+        for (const primitive of mesh.listPrimitives()) {
+          triangles += primitiveTriangles(primitive);
+          const position = primitive.getAttribute("POSITION");
+          if (position === null) continue;
+          vertices += position.getCount();
+          for (let index = 0; index < position.getCount(); index += 1) {
+            const [wx, wy, wz] = evaluateVertex(
+              position,
+              index,
+              primitive.getAttribute("JOINTS_0"),
+              primitive.getAttribute("WEIGHTS_0"),
+              skin2 !== null ? jointMatrices : void 0,
+              matrix
+            );
+            minX = Math.min(minX, wx);
+            minY = Math.min(minY, wy);
+            minZ = Math.min(minZ, wz);
+            maxX = Math.max(maxX, wx);
+            maxY = Math.max(maxY, wy);
+            maxZ = Math.max(maxZ, wz);
+          }
         }
       }
     }
@@ -20934,6 +22427,7 @@ function lodCacheKey(lod) {
 }
 function modelPass(options = {}) {
   return {
+    appliesTo: ["model"],
     configuration: {
       passes: {
         dedup: options.passes?.dedup ?? true,
@@ -20951,8 +22445,18 @@ function modelPass(options = {}) {
       // Part of the compile cache key: change the cap or a codec and stale outputs must not
       // be re-served.
       simplify: options.simplify ?? null,
+      // The resolved compaction policy: a sub-pass switch, allow-list or regex edit changes the
+      // output, so it must change the cache key.
+      compact: resolveCompactOptions(options.compact),
       // Generation-only identity; runtime budget edits must not invalidate baked geometry.
       lod: lodCacheKey(options.lod),
+      // The material merge is unconditional and lossless, so the version string is the whole knob:
+      // it moves when the signature does, which invalidates every stale output at once.
+      materials: MATERIAL_MERGE_VERSION,
+      // Unconditional and lossless for the same reason: the cook shares one output between
+      // content-identical sources, so a bake published before this key existed named one output
+      // per copy and must not be re-served as if it had deduped.
+      dedupe: MODEL_DEDUPE_VERSION,
       // `"none"` and "absent" are different cache keys on purpose: absent bakes with defaults.
       virtual: options.virtual === "none" ? "none" : {
         ...options.virtual === void 0 ? {} : options.virtual,
@@ -20960,6 +22464,7 @@ function modelPass(options = {}) {
       },
       sharedImages: options.sharedImages !== void 0,
       textures: options.textures === "none" ? "none" : {
+        decoderFree: options.textures?.decoderFree ?? false,
         encoder: KTX2_ENCODER_VERSION,
         maxSize: options.textures?.maxSize ?? null,
         keepSmallerSource: true,
@@ -20970,7 +22475,7 @@ function modelPass(options = {}) {
     name: "model",
     // A mobile compile replaces these two decoder-backed sub-passes in the effective options;
     // geometry rewrites and shared-image emission remain plain glTF and stay enabled there.
-    needsRuntimeDecoder: (options.passes?.meshopt ?? true) || options.textures !== "none",
+    needsRuntimeDecoder: (options.passes?.meshopt ?? true) || options.textures !== "none" && options.textures?.decoderFree !== true,
     apply: async (input, logicalPath) => {
       if (classify2(logicalPath) !== "model") return input;
       const passes2 = options.passes ?? {};
@@ -20984,7 +22489,7 @@ function modelPass(options = {}) {
       const textureOptions = options.textures === "none" ? void 0 : options.textures ?? {};
       const virtualOptions = options.virtual === "none" ? void 0 : options.virtual ?? {};
       const lodOptions = options.lod === void 0 || options.lod === false || options.lod === "none" ? void 0 : options.lod;
-      const geometryActive = options.vertexLayout !== void 0 || Object.values(enabled).some(Boolean) || options.simplify !== void 0 || lodOptions !== void 0 || virtualOptions !== void 0;
+      const geometryActive = options.vertexLayout !== void 0 || Object.values(enabled).some(Boolean) || options.simplify !== void 0 || lodOptions !== void 0 || virtualOptions !== void 0 || compactRequested(options.compact);
       if (!geometryActive && textureOptions === void 0) return input;
       const document = await readDocument2(input, logicalPath);
       if (!geometryActive && document.getRoot().listTextures().length === 0) return input;
@@ -20995,8 +22500,21 @@ function modelPass(options = {}) {
       const source = reachableStats(document.getRoot());
       const jointFloor = jointComponentSizes(document.getRoot());
       if (enabled.dedup) await dedup()(document);
-      if (enabled.prune)
+      const namesBeforeCompact = compactRequested(options.compact) ? sceneNodeNames(document) : void 0;
+      let compact = compactRequested(options.compact) ? await compactModel(document, resolveCompactOptions(options.compact)) : void 0;
+      if (enabled.prune) {
         await prune({ keepAttributes: options.preserveLightmapUv === true })(document);
+        if (compact !== void 0 && namesBeforeCompact !== void 0) {
+          const nodes = countCompactNodes(document);
+          compact = {
+            ...compact,
+            nodesAfter: nodes,
+            primitivesAfter: countCompactPrimitives(document),
+            removed: removedNames(namesBeforeCompact, sceneNodeNames(document))
+          };
+        }
+      }
+      const materials = mergeIdenticalMaterials(document);
       if (options.simplify !== void 0) {
         await MeshoptSimplifier.ready;
         await simplify({
@@ -21063,9 +22581,11 @@ function modelPass(options = {}) {
       assertNoTextureDrift(sourceTextures, textureBindings(verified), logicalPath);
       if (lod !== void 0 && lod.generated > 0) validateDiscreteLod(verified);
       const entry = {
+        ...compact === void 0 ? {} : { compact },
         ...embeddedTextures === void 0 ? {} : { embeddedTextures },
         extensions: [...extensions].sort(),
         ...lod === void 0 ? {} : { lod },
+        materials,
         ...options.simplify === void 0 ? {} : {
           simplify: {
             achievedRatio: source.triangles === 0 ? 1 : output.triangles / source.triangles,
@@ -21097,6 +22617,7 @@ function sharedSettings(texture, textureOptions) {
     colorSpace: getTextureColorSpace(texture),
     slots: [...listTextureSlots(texture)].sort(),
     textures: textureOptions === void 0 ? "none" : {
+      decoderFree: textureOptions.decoderFree ?? false,
       encoder: KTX2_ENCODER_VERSION,
       keepSmallerSource: true,
       maxSize: textureOptions.maxSize ?? null,
@@ -21431,6 +22952,7 @@ function serialFor(logicalPath) {
 // src/passes/audio.ts
 function audioPass(options = {}) {
   return {
+    appliesTo: ["audio"],
     configuration: {
       normalise: options.normalise ?? "ceiling",
       overrides: options.overrides ?? [],
@@ -21653,6 +23175,8 @@ function buildInstances(specs, root) {
         });
       case "texture":
         return texturePass(spec.options);
+      case "texture-resize":
+        return textureResizePass(spec.options);
     }
   });
 }