@threenative/assets 0.3.0

package/dist/index.js

@@ -0,0 +1,3600 @@
+import { createHash } from 'crypto';
+import { rm, mkdir, writeFile, stat, readFile, realpath, copyFile, readdir, mkdtemp, rename } from 'fs/promises';
+import { createRequire } from 'module';
+import path from 'path';
+import { ImageUtils, NodeIO, Extension, PropertyType, ExtensionProperty, Accessor } from '@gltf-transform/core';
+import { EXTMeshoptCompression, ALL_EXTENSIONS, KHRTextureBasisu } from '@gltf-transform/extensions';
+import { Api } from 'xatlasjs/dist/node/api.mjs';
+import createXAtlasModule from 'xatlasjs/dist/node/xatlas.js';
+import { BufferGeometry, BufferAttribute, Ray, Vector3, DoubleSide } from 'three';
+import { MeshBVH } from 'three-mesh-bvh';
+import { read } from 'ktx-parse';
+import { encodeToKTX2 } from 'ktx2-encoder';
+import { PNG } from 'pngjs';
+import { dedup, prune, simplify, reorder, quantize, listTextureInfo, listTextureSlots, getTextureColorSpace } from '@gltf-transform/functions';
+import { MeshoptSimplifier, MeshoptEncoder, MeshoptDecoder, MeshoptClusterizer } from 'meshoptimizer';
+import { watch } from 'fs';
+import { tmpdir } from 'os';
+
+// src/compile.ts
+
+// src/png.ts
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function crc32(value) {
+  let crc = 4294967295;
+  for (const byte of value) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit += 1) {
+      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function parsePng(value) {
+  if (value.length < PNG_SIGNATURE.length || !value.subarray(0, 8).equals(PNG_SIGNATURE)) {
+    return void 0;
+  }
+  let offset = PNG_SIGNATURE.length;
+  let hasHeader = false;
+  let hasData = false;
+  let width = 0;
+  let height = 0;
+  let colorType = 0;
+  let hasTransparencyChunk = false;
+  while (offset + 12 <= value.length) {
+    const length2 = value.readUInt32BE(offset);
+    const chunkEnd = offset + 12 + length2;
+    if (chunkEnd > value.length) return void 0;
+    const type = value.toString("ascii", offset + 4, offset + 8);
+    const chunk = value.subarray(offset + 4, offset + 8 + length2);
+    if (crc32(chunk) !== value.readUInt32BE(offset + 8 + length2)) return void 0;
+    if (type === "IHDR") {
+      if (hasHeader || length2 !== 13) return void 0;
+      width = value.readUInt32BE(offset + 8);
+      height = value.readUInt32BE(offset + 12);
+      colorType = value.readUInt8(offset + 17);
+      if (width === 0 || height === 0) return void 0;
+      hasHeader = true;
+    } else if (type === "IDAT") {
+      hasData = true;
+    } else if (type === "tRNS") {
+      hasTransparencyChunk = true;
+    } else if (type === "IEND") {
+      if (length2 !== 0 || !hasHeader || !hasData || chunkEnd !== value.length) return void 0;
+      return {
+        width,
+        height,
+        hasAlpha: colorType === 4 || colorType === 6 || hasTransparencyChunk
+      };
+    }
+    offset = chunkEnd;
+  }
+  return void 0;
+}
+
+// src/health.ts
+var UNKNOWN_LICENSE = "unknown";
+var MODE_TRIANGLES = 4;
+var MODE_TRIANGLE_STRIPS = 5;
+var MODE_TRIANGLE_FANS = 6;
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isPowerOfTwo(value) {
+  return value > 0 && (value & value - 1) === 0;
+}
+function carriedLicense(asset) {
+  const copyright = asset.copyright?.trim();
+  return copyright !== void 0 && copyright.length > 0 ? copyright : UNKNOWN_LICENSE;
+}
+function marksCollider(name) {
+  return /collider/iu.test(name) || /(?:^|[-_. ])col(?:only|convcolonly|convcol)?$/iu.test(name);
+}
+function sniffImageMime(bytes) {
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  return parsePng(bytes) === void 0 ? void 0 : "image/png";
+}
+function textureStats(bytes, mimeType) {
+  const mime = mimeType ?? sniffImageMime(bytes);
+  let width = 0;
+  let height = 0;
+  let alpha = false;
+  if (mime !== void 0) {
+    if (mime === "image/png") {
+      const png = parsePng(bytes);
+      if (png !== void 0) {
+        ({ height, width } = png);
+        alpha = png.hasAlpha;
+      }
+    } else {
+      try {
+        const size = ImageUtils.getSize(bytes, mime);
+        if (size !== null) [width, height] = size;
+      } catch {
+      }
+    }
+  }
+  return {
+    alpha,
+    height,
+    powerOfTwo: isPowerOfTwo(width) && isPowerOfTwo(height),
+    width
+  };
+}
+async function parseModel(data, logicalPath) {
+  const io = new NodeIO().registerExtensions(ALL_EXTENSIONS);
+  try {
+    if (data.subarray(0, 4).toString("ascii") === "glTF") {
+      return await io.readJSON(await io.binaryToJSON(data));
+    }
+    const json = JSON.parse(data.toString("utf8"));
+    return await io.readJSON({ json, resources: {} });
+  } catch (error) {
+    throw new Error(
+      `TN_ASSETS_MODEL_UNREADABLE: could not parse '${logicalPath}' for the health report: ${messageOf(error)}. External buffer or image URIs are not measured; use a self-contained .glb.`
+    );
+  }
+}
+function primitiveTriangles(mode, indices, vertices) {
+  const drawn = indices ?? vertices ?? 0;
+  if (mode === MODE_TRIANGLES) return Math.floor(drawn / 3);
+  if (mode === MODE_TRIANGLE_STRIPS || mode === MODE_TRIANGLE_FANS) return Math.max(0, drawn - 2);
+  return 0;
+}
+async function parseModelStats(data, logicalPath) {
+  const root = (await parseModel(data, logicalPath)).getRoot();
+  let triangles = 0;
+  for (const mesh of root.listMeshes()) {
+    for (const prim of mesh.listPrimitives()) {
+      triangles += primitiveTriangles(
+        prim.getMode(),
+        prim.getIndices()?.getCount(),
+        prim.getAttribute("POSITION")?.getCount()
+      );
+    }
+  }
+  const colliderPresent = [...root.listNodes(), ...root.listMeshes()].some(
+    (property) => marksCollider(property.getName() ?? "")
+  ) || root.listScenes().some((scene) => marksCollider(scene.getName() ?? ""));
+  const rootNodes = new Set(root.listScenes().flatMap((scene) => scene.listChildren()));
+  let rootMotion = false;
+  for (const animation of root.listAnimations()) {
+    for (const channel of animation.listChannels()) {
+      const targetNode = channel.getTargetNode();
+      if (channel.getTargetPath() === "translation" && targetNode && rootNodes.has(targetNode)) {
+        rootMotion = true;
+      }
+    }
+  }
+  const textures = root.listTextures().map((texture) => {
+    const image = texture.getImage();
+    const bytes = image ? Buffer.from(image.buffer, image.byteOffset, image.byteLength) : Buffer.alloc(0);
+    return textureStats(bytes, texture.getMimeType());
+  });
+  return {
+    license: carriedLicense(root.getAsset()),
+    model: {
+      animationClips: root.listAnimations().length,
+      colliderPresent,
+      materials: root.listMaterials().length,
+      rootMotion,
+      textures,
+      triangles
+    }
+  };
+}
+function budgeted(draft, id, asset, value, noun, target) {
+  const exceeded = target !== void 0 && value > target;
+  draft.findings.push({
+    asset,
+    grade: exceeded ? "fail" : "ok",
+    id,
+    ...target === void 0 ? {} : { target },
+    message: `${value} ${noun}${exceeded ? `, above the declared target of ${target}` : ""}`,
+    value
+  });
+}
+function textureFindings(draft, asset, subject, texture, targets) {
+  const readable = texture.width > 0 && texture.height > 0;
+  const dimensionText = readable ? `${texture.width}x${texture.height}` : "unknown";
+  const exceeded = targets.maxTextureDimension !== void 0 && readable && Math.max(texture.width, texture.height) > targets.maxTextureDimension;
+  draft.findings.push({
+    asset,
+    grade: exceeded ? "fail" : "ok",
+    id: "texture.dimensions",
+    ...targets.maxTextureDimension === void 0 ? {} : { target: targets.maxTextureDimension },
+    message: readable ? `${dimensionText} pixels${exceeded ? `, above the declared target of ${targets.maxTextureDimension}` : ""}` : "dimensions unknown",
+    subject,
+    value: dimensionText
+  });
+  if (!readable) return;
+  draft.findings.push({
+    asset,
+    grade: texture.powerOfTwo ? "ok" : "warn",
+    id: "texture.powerOfTwo",
+    message: texture.powerOfTwo ? "power-of-two dimensions" : "dimensions are not power-of-two",
+    subject,
+    value: texture.powerOfTwo
+  });
+  draft.findings.push({
+    asset,
+    grade: "ok",
+    id: "texture.alpha",
+    message: texture.alpha ? "alpha channel present" : "no alpha channel",
+    subject,
+    value: texture.alpha
+  });
+}
+async function measureAsset(draft, input, targets) {
+  const kind = classify(input.logicalPath);
+  if (kind === "model") {
+    const { license, model } = await parseModelStats(input.data, input.logicalPath);
+    budgeted(
+      draft,
+      "triangles",
+      input.logicalPath,
+      model.triangles,
+      "triangles",
+      targets.maxTriangles
+    );
+    budgeted(
+      draft,
+      "materials",
+      input.logicalPath,
+      model.materials,
+      "material(s)",
+      targets.maxMaterials
+    );
+    draft.findings.push({
+      asset: input.logicalPath,
+      grade: model.colliderPresent ? "ok" : "warn",
+      id: "collider",
+      message: model.colliderPresent ? "collider node present" : "no collider found (name a node or mesh '-col' or 'collider')",
+      value: model.colliderPresent
+    });
+    draft.findings.push({
+      asset: input.logicalPath,
+      grade: "ok",
+      id: "rootMotion",
+      message: model.rootMotion ? "root motion detected in an animation clip" : "no root motion detected",
+      value: model.rootMotion
+    });
+    model.textures.forEach((texture, index) => {
+      textureFindings(draft, input.logicalPath, `tex${index}`, texture, targets);
+    });
+    return { asset: input.logicalPath, kind, license, model };
+  }
+  if (kind === "texture") {
+    const texture = textureStats(input.data);
+    textureFindings(draft, input.logicalPath, "tex0", texture, targets);
+    return { asset: input.logicalPath, kind, license: UNKNOWN_LICENSE, texture };
+  }
+  return { asset: input.logicalPath, kind, license: UNKNOWN_LICENSE };
+}
+async function runHealthReport(inputs, targets = {}) {
+  const draft = { entries: [], findings: [] };
+  for (const input of inputs) {
+    const entry = await measureAsset(draft, input, targets);
+    draft.entries.push(entry);
+    draft.findings.push({
+      asset: input.logicalPath,
+      grade: entry.license === UNKNOWN_LICENSE ? "warn" : "ok",
+      id: "license",
+      message: `license: ${entry.license}`,
+      value: entry.license
+    });
+  }
+  const summary = { fail: 0, ok: 0, warn: 0 };
+  for (const finding of draft.findings) summary[finding.grade] += 1;
+  return { ...draft, failed: summary.fail > 0, summary };
+}
+function formatHealthReport(report) {
+  const lines = report.findings.map((finding) => {
+    const where = finding.subject === void 0 ? finding.asset : `${finding.asset} ${finding.subject}`;
+    return `[${finding.grade}] ${where}: ${finding.message}`;
+  });
+  const { fail, ok, warn } = report.summary;
+  lines.push(
+    `asset health: ${report.entries.length} asset(s), ${ok} ok, ${warn} warn, ${fail} fail`
+  );
+  return lines;
+}
+function add(left, right) {
+  return [left[0] + right[0], left[1] + right[1], left[2] + right[2]];
+}
+function subtract(left, right) {
+  return [left[0] - right[0], left[1] - right[1], left[2] - right[2]];
+}
+function scale(value, amount) {
+  return [value[0] * amount, value[1] * amount, value[2] * amount];
+}
+function dot(left, right) {
+  return left[0] * right[0] + left[1] * right[1] + left[2] * right[2];
+}
+function cross(left, right) {
+  return [
+    left[1] * right[2] - left[2] * right[1],
+    left[2] * right[0] - left[0] * right[2],
+    left[0] * right[1] - left[1] * right[0]
+  ];
+}
+function length(value) {
+  return Math.sqrt(dot(value, value));
+}
+function normalize(value) {
+  const magnitude = length(value);
+  return magnitude === 0 ? [0, 1, 0] : scale(value, 1 / magnitude);
+}
+function transformPosition(matrix, value) {
+  return [
+    (matrix[0] ?? 1) * value[0] + (matrix[4] ?? 0) * value[1] + (matrix[8] ?? 0) * value[2] + (matrix[12] ?? 0),
+    (matrix[1] ?? 0) * value[0] + (matrix[5] ?? 1) * value[1] + (matrix[9] ?? 0) * value[2] + (matrix[13] ?? 0),
+    (matrix[2] ?? 0) * value[0] + (matrix[6] ?? 0) * value[1] + (matrix[10] ?? 1) * value[2] + (matrix[14] ?? 0)
+  ];
+}
+function transformDirection(matrix, value) {
+  return normalize([
+    (matrix[0] ?? 1) * value[0] + (matrix[4] ?? 0) * value[1] + (matrix[8] ?? 0) * value[2],
+    (matrix[1] ?? 0) * value[0] + (matrix[5] ?? 1) * value[1] + (matrix[9] ?? 0) * value[2],
+    (matrix[2] ?? 0) * value[0] + (matrix[6] ?? 0) * value[1] + (matrix[10] ?? 1) * value[2]
+  ]);
+}
+function transformNormal(matrix, value) {
+  const column0 = [matrix[0] ?? 1, matrix[1] ?? 0, matrix[2] ?? 0];
+  const column1 = [matrix[4] ?? 0, matrix[5] ?? 1, matrix[6] ?? 0];
+  const column2 = [matrix[8] ?? 0, matrix[9] ?? 0, matrix[10] ?? 1];
+  const determinant = dot(column0, cross(column1, column2));
+  const cofactor = add(
+    add(scale(cross(column1, column2), value[0]), scale(cross(column2, column0), value[1])),
+    scale(cross(column0, column1), value[2])
+  );
+  return normalize(scale(cofactor, determinant < 0 ? -1 : 1));
+}
+function reachableNodes(document) {
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (seen.has(node)) return;
+    seen.add(node);
+    nodes.push(node);
+    for (const child of node.listChildren()) visit(child);
+  };
+  for (const scene of document.getRoot().listScenes()) {
+    for (const child of scene.listChildren()) visit(child);
+  }
+  return nodes;
+}
+function accessorVec3(primitive, semantic, index) {
+  const accessor = primitive.getAttribute(semantic);
+  const array = accessor?.getArray();
+  if (array == null) return null;
+  const offset = index * 3;
+  return [array[offset] ?? 0, array[offset + 1] ?? 0, array[offset + 2] ?? 0];
+}
+function accessorVec2(primitive, semantic, index) {
+  const accessor = primitive.getAttribute(semantic);
+  const array = accessor?.getArray();
+  if (array == null) return null;
+  const offset = index * 2;
+  return [array[offset] ?? 0, array[offset + 1] ?? 0];
+}
+function triangleFrom(primitive, matrix, indices) {
+  const localPosition0 = accessorVec3(primitive, "POSITION", indices[0]);
+  const localPosition1 = accessorVec3(primitive, "POSITION", indices[1]);
+  const localPosition2 = accessorVec3(primitive, "POSITION", indices[2]);
+  const uv0 = accessorVec2(primitive, "TEXCOORD_1", indices[0]);
+  const uv1 = accessorVec2(primitive, "TEXCOORD_1", indices[1]);
+  const uv2 = accessorVec2(primitive, "TEXCOORD_1", indices[2]);
+  if (localPosition0 === null || localPosition1 === null || localPosition2 === null || uv0 === null || uv1 === null || uv2 === null) {
+    throw new Error(
+      "TN_ASSETS_LIGHTMAP_UV2_MISSING: a baked primitive lacks positions or TEXCOORD_1."
+    );
+  }
+  const positions = [
+    transformPosition(matrix, localPosition0),
+    transformPosition(matrix, localPosition1),
+    transformPosition(matrix, localPosition2)
+  ];
+  const faceNormal = normalize(
+    cross(subtract(positions[1], positions[0]), subtract(positions[2], positions[0]))
+  );
+  const normals = indices.map((index) => {
+    const local = accessorVec3(primitive, "NORMAL", index);
+    return local === null ? faceNormal : transformNormal(matrix, local);
+  });
+  return {
+    material: primitive.getMaterial()?.getName() ?? "",
+    normals,
+    positions,
+    uv: [uv0, uv1, uv2]
+  };
+}
+function sceneTriangles(document, nodes) {
+  const meshUses = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const mesh = node.getMesh();
+    if (mesh !== null) meshUses.set(mesh, (meshUses.get(mesh) ?? 0) + 1);
+  }
+  if ([...meshUses.values()].some((count) => count > 1)) {
+    throw new Error(
+      "TN_ASSETS_LIGHTMAP_INSTANCING_UNSUPPORTED: one mesh is used by multiple scene nodes."
+    );
+  }
+  const triangles = [];
+  for (const node of nodes) {
+    const mesh = node.getMesh();
+    if (mesh === null) continue;
+    for (const primitive of mesh.listPrimitives()) {
+      const indices = primitive.getIndices()?.getArray();
+      if (indices == null) {
+        throw new Error("TN_ASSETS_LIGHTMAP_GEOMETRY_UNSUPPORTED: bake input is not indexed.");
+      }
+      for (let offset = 0; offset < indices.length; offset += 3) {
+        const first = indices[offset];
+        const second = indices[offset + 1];
+        const third = indices[offset + 2];
+        if (first === void 0 || second === void 0 || third === void 0) continue;
+        triangles.push(triangleFrom(primitive, node.getWorldMatrix(), [first, second, third]));
+      }
+    }
+  }
+  return triangles;
+}
+function sceneLights(nodes) {
+  const lights = [];
+  for (const node of nodes) {
+    const light = node.getExtension("KHR_lights_punctual");
+    if (light === null) continue;
+    const matrix = node.getWorldMatrix();
+    lights.push({
+      color: light.getColor(),
+      direction: transformDirection(matrix, [0, 0, -1]),
+      innerConeAngle: light.getInnerConeAngle(),
+      intensity: light.getIntensity(),
+      outerConeAngle: light.getOuterConeAngle(),
+      position: transformPosition(matrix, [0, 0, 0]),
+      range: light.getRange(),
+      type: light.getType()
+    });
+  }
+  return lights;
+}
+function buildOcclusionIndex(triangles) {
+  const geometry = new BufferGeometry();
+  geometry.setAttribute(
+    "position",
+    new BufferAttribute(
+      new Float32Array(
+        triangles.flatMap((triangle) => triangle.positions.flatMap((position) => [...position]))
+      ),
+      3
+    )
+  );
+  const bvh = new MeshBVH(geometry);
+  const ray = new Ray();
+  return {
+    dispose() {
+      geometry.dispose();
+    },
+    hits(origin, direction, maximum) {
+      ray.origin.copy(new Vector3(...origin));
+      ray.direction.copy(new Vector3(...direction));
+      return bvh.raycastFirst(ray, DoubleSide, 1e-6, maximum) !== null;
+    }
+  };
+}
+function sampleLight(light, position) {
+  if (light.type === "directional") {
+    return {
+      direction: scale(light.direction, -1),
+      maximum: Number.POSITIVE_INFINITY,
+      strength: light.intensity
+    };
+  }
+  const offset = subtract(light.position, position);
+  const distance = length(offset);
+  if (distance === 0 || light.range !== null && distance > light.range) return null;
+  let strength = light.intensity / Math.max(distance * distance, 1e-6);
+  if (light.type === "spot") {
+    const fromLight = scale(normalize(offset), -1);
+    const cosine = dot(light.direction, fromLight);
+    const outer = Math.cos(light.outerConeAngle);
+    if (cosine <= outer) return null;
+    const inner = Math.cos(light.innerConeAngle);
+    strength *= inner === outer ? 1 : Math.min(1, (cosine - outer) / (inner - outer));
+  }
+  return { direction: scale(offset, 1 / distance), maximum: distance - 1e-5, strength };
+}
+function barycentric(point, triangle) {
+  const [a, b, c] = triangle;
+  const denominator = (b[1] - c[1]) * (a[0] - c[0]) + (c[0] - b[0]) * (a[1] - c[1]);
+  if (Math.abs(denominator) < 1e-12) return null;
+  const first = ((b[1] - c[1]) * (point[0] - c[0]) + (c[0] - b[0]) * (point[1] - c[1])) / denominator;
+  const second = ((c[1] - a[1]) * (point[0] - c[0]) + (a[0] - c[0]) * (point[1] - c[1])) / denominator;
+  const third = 1 - first - second;
+  return first >= -1e-7 && second >= -1e-7 && third >= -1e-7 ? [first, second, third] : null;
+}
+function interpolate(values, weights) {
+  return add(
+    add(scale(values[0], weights[0]), scale(values[1], weights[1])),
+    scale(values[2], weights[2])
+  );
+}
+function shadeTexel(position, normal, lights, occlusion) {
+  let color = [0, 0, 0];
+  let occluded = false;
+  const origin = add(position, scale(normal, 1e-5));
+  for (const light of lights) {
+    const sample = sampleLight(light, position);
+    if (sample === null) continue;
+    const lambert = Math.max(0, dot(normal, sample.direction));
+    if (lambert === 0) continue;
+    const blocked = occlusion.hits(origin, sample.direction, sample.maximum);
+    if (blocked) {
+      occluded = true;
+      continue;
+    }
+    color = add(color, scale(light.color, lambert * sample.strength));
+  }
+  return { color, occluded };
+}
+function rasterize(triangles, lights, occlusion, width, height) {
+  const pixels = new Uint8Array(width * height * 4);
+  const valid = new Uint8Array(width * height);
+  let occludedTexels = 0;
+  for (const triangle of triangles) {
+    const imageUv = triangle.uv.map(([u, v]) => [u * width, (1 - v) * height]);
+    const minX = Math.max(0, Math.floor(Math.min(...imageUv.map((value) => value[0]))));
+    const maxX = Math.min(width - 1, Math.ceil(Math.max(...imageUv.map((value) => value[0]))));
+    const minY = Math.max(0, Math.floor(Math.min(...imageUv.map((value) => value[1]))));
+    const maxY = Math.min(height - 1, Math.ceil(Math.max(...imageUv.map((value) => value[1]))));
+    for (let y = minY; y <= maxY; y += 1) {
+      for (let x = minX; x <= maxX; x += 1) {
+        const weights = barycentric([x + 0.5, y + 0.5], imageUv);
+        if (weights === null) continue;
+        const position = interpolate(triangle.positions, weights);
+        const normal = normalize(interpolate(triangle.normals, weights));
+        const shaded = shadeTexel(position, normal, lights, occlusion);
+        const pixel = y * width + x;
+        const offset = pixel * 4;
+        pixels[offset] = Math.round(Math.min(1, Math.max(0, shaded.color[0])) * 255);
+        pixels[offset + 1] = Math.round(Math.min(1, Math.max(0, shaded.color[1])) * 255);
+        pixels[offset + 2] = Math.round(Math.min(1, Math.max(0, shaded.color[2])) * 255);
+        pixels[offset + 3] = 255;
+        valid[pixel] = 1;
+        if (shaded.occluded) occludedTexels += 1;
+      }
+    }
+  }
+  return { occludedTexels, pixels, valid };
+}
+function dilate(pixels, valid, width, height, steps) {
+  let filled = 0;
+  for (let step = 0; step < steps; step += 1) {
+    const sourcePixels = pixels.slice();
+    const sourceValid = valid.slice();
+    for (let y = 0; y < height; y += 1) {
+      for (let x = 0; x < width; x += 1) {
+        const pixel = y * width + x;
+        if (sourceValid[pixel] === 1) continue;
+        let source = -1;
+        for (let yOffset = -1; yOffset <= 1 && source < 0; yOffset += 1) {
+          for (let xOffset = -1; xOffset <= 1; xOffset += 1) {
+            const neighborX = x + xOffset;
+            const neighborY = y + yOffset;
+            if (neighborX < 0 || neighborX >= width || neighborY < 0 || neighborY >= height)
+              continue;
+            const candidate = neighborY * width + neighborX;
+            if (sourceValid[candidate] === 1) {
+              source = candidate;
+              break;
+            }
+          }
+        }
+        if (source < 0) continue;
+        pixels.set(sourcePixels.subarray(source * 4, source * 4 + 4), pixel * 4);
+        valid[pixel] = 1;
+        filled += 1;
+      }
+    }
+  }
+  return filled;
+}
+function bakeStaticLightmap(document, width, height, padding) {
+  const nodes = reachableNodes(document);
+  const triangles = sceneTriangles(document, nodes);
+  const lights = sceneLights(nodes);
+  if (lights.length === 0) {
+    throw new Error(
+      "TN_ASSETS_LIGHTMAP_LIGHTS_MISSING: the static scene contains no punctual light."
+    );
+  }
+  const occlusion = buildOcclusionIndex(triangles);
+  const raster = rasterize(triangles, lights, occlusion, width, height);
+  occlusion.dispose();
+  const validTexels = raster.valid.reduce((sum, value) => sum + (value === 1 ? 1 : 0), 0);
+  const dilatedTexels = dilate(raster.pixels, raster.valid, width, height, padding);
+  return {
+    dilatedTexels,
+    height,
+    materialTargets: [...new Set(triangles.map((triangle) => triangle.material))].sort(),
+    occludedTexels: raster.occludedTexels,
+    pixels: raster.pixels,
+    validTexels,
+    width
+  };
+}
+async function decodeImageBytes(bytes, logicalPath) {
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    const { decode } = await import('jpeg-js');
+    const image = decode(bytes, { useTArray: true });
+    assertRgba(image.data.length, image.width, image.height, logicalPath);
+    return { data: new Uint8Array(image.data), height: image.height, width: image.width };
+  }
+  if (parsePng(bytes) !== void 0) {
+    const image = PNG.sync.read(bytes);
+    assertRgba(image.data.length, image.width, image.height, logicalPath);
+    return { data: new Uint8Array(image.data), height: image.height, width: image.width };
+  }
+  throw new Error(
+    `TN_ASSETS_TEXTURE_CONTAINER: '${logicalPath}' is not a PNG or JPEG the KTX2 encoder can read; convert it to .png or .jpg.`
+  );
+}
+function assertRgba(length2, width, height, logicalPath) {
+  if (width <= 0 || height <= 0 || length2 !== width * height * 4) {
+    throw new Error(
+      `TN_ASSETS_TEXTURE_UNDECODABLE: '${logicalPath}' did not decode to 8-bit RGBA (${width}x${height}, ${length2} bytes).`
+    );
+  }
+}
+
+// src/passes/glob.ts
+function globMatch(glob, logicalPath) {
+  return new RegExp(`^${globSource(glob)}$`, "u").test(logicalPath);
+}
+function globSource(glob) {
+  let source = "";
+  let index = 0;
+  for (; ; ) {
+    const char = glob[index];
+    if (char === void 0) break;
+    if (char === "*") {
+      if (glob[index + 1] === "*") {
+        let end = index;
+        while (glob[end] === "*") end += 1;
+        if (glob[end] === "/") {
+          index = end + 1;
+          source += "(?:[^/]+/)*";
+          continue;
+        }
+        index = end;
+        source += ".*";
+        continue;
+      }
+      index += 1;
+      source += "[^/]*";
+      continue;
+    }
+    if (char === "?") {
+      index += 1;
+      source += "[^/]";
+      continue;
+    }
+    index += 1;
+    source += char.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  }
+  return source;
+}
+
+// src/passes/texture.ts
+var TRANSCODE_TARGETS = {
+  etc1s: ["bc1", "etc2"],
+  uastc: ["astc4x4", "bc7"]
+};
+var DEFAULT_ETC1S_QUALITY = 150;
+var BLOCK_SIZE = 4;
+var NORMAL_MAP_BASENAME = /(?:^|[_-])(?:normal|nrm)$/iu;
+async function encodeLinearRgbaKtx2(data, width, height) {
+  const encoded = await encodeToKTX2(new Uint8Array([0]), {
+    generateMipmap: true,
+    imageDecoder: async () => ({ data, height, width }),
+    isPerceptual: false,
+    isSetKTX2SRGBTransferFunc: false,
+    isUASTC: false,
+    qualityLevel: DEFAULT_ETC1S_QUALITY
+  });
+  const container = read(encoded);
+  if (container.levelCount < 2) {
+    throw new Error(
+      `TN_ASSETS_MIP_CHAIN_INCOMPLETE: generated lightmap encoded without a mip chain (${String(container.levelCount)} level(s)).`
+    );
+  }
+  return Buffer.from(encoded);
+}
+function texturePass(options = {}) {
+  return {
+    configuration: {
+      overrides: options.overrides ?? [],
+      quality: options.quality ?? DEFAULT_ETC1S_QUALITY
+    },
+    apply: async (input, logicalPath) => {
+      if (classify(logicalPath) !== "texture") return input;
+      const stats = textureStats(input);
+      if (stats.width <= 0 || stats.height <= 0) {
+        throw new Error(
+          `TN_ASSETS_TEXTURE_UNREADABLE: '${logicalPath}' has no readable PNG/JPEG header; the KTX2 pass cannot encode it.`
+        );
+      }
+      const decoded = await decodeImageBytes(input, logicalPath);
+      const choice = chooseCodec(logicalPath, rgbaHasAlpha(decoded.data), options);
+      if (choice.codec === "none") return input;
+      assertBlockAligned(logicalPath, choice.codec, decoded.width, decoded.height);
+      const encoded = await encodeToKTX2(
+        new Uint8Array(input.buffer, input.byteOffset, input.byteLength),
+        {
+          generateMipmap: true,
+          imageDecoder: async () => decoded,
+          ...encodeSettingsFor(choice)
+        }
+      );
+      const container = read(encoded);
+      if (container.levelCount < 2) {
+        throw new Error(
+          `TN_ASSETS_MIP_CHAIN_INCOMPLETE: '${logicalPath}' encoded without a mip chain (${String(container.levelCount)} level(s)).`
+        );
+      }
+      return {
+        buffer: Buffer.from(encoded),
+        entry: { format: choice.codec, transcodeTargets: TRANSCODE_TARGETS[choice.codec] },
+        outputExtension: ".ktx2"
+      };
+    },
+    name: "ktx2"
+  };
+}
+function assertBlockAligned(logicalPath, codec, width, height) {
+  if (width % BLOCK_SIZE === 0 && height % BLOCK_SIZE === 0) return;
+  throw new Error(
+    `TN_ASSETS_TEXTURE_BLOCK_SIZE: '${logicalPath}' is ${width}x${height}, which is not a multiple of the ${BLOCK_SIZE}x${BLOCK_SIZE} block the ${codec} codec transcodes to (${TRANSCODE_TARGETS[codec].join(", ")}); WebGPU rejects such a texture at draw time. Resize the source to a multiple of ${BLOCK_SIZE}, or declare a texture override with codec "none" for it.`
+  );
+}
+function rgbaHasAlpha(rgba) {
+  for (let offset = 3; offset < rgba.length; offset += 4) {
+    if ((rgba[offset] ?? 255) !== 255) return true;
+  }
+  return false;
+}
+function chooseCodec(logicalPath, alpha, options) {
+  const normalMap = NORMAL_MAP_BASENAME.test(baseNameOf(logicalPath));
+  const fallbackQuality = options.quality ?? DEFAULT_ETC1S_QUALITY;
+  for (const override of options.overrides ?? []) {
+    if (!globMatch(override.glob, logicalPath)) continue;
+    return {
+      codec: override.codec,
+      normalMap,
+      quality: clampQuality(override.quality ?? fallbackQuality)
+    };
+  }
+  return {
+    codec: alpha || normalMap ? "uastc" : "etc1s",
+    normalMap,
+    quality: clampQuality(fallbackQuality)
+  };
+}
+function encodeSettingsFor(choice) {
+  if (choice.codec === "none") return {};
+  if (choice.codec === "uastc") {
+    return {
+      isUASTC: true,
+      ...!choice.normalMap ? {} : (
+        // Quality is an ETC1S knob (qualityLevel 1–255); UASTC runs documented defaults.
+        { isPerceptual: false, isNormalMap: true, isSetKTX2SRGBTransferFunc: false }
+      )
+    };
+  }
+  return { isUASTC: false, qualityLevel: choice.quality };
+}
+function clampQuality(quality) {
+  return Math.min(255, Math.max(1, Math.round(quality)));
+}
+function baseNameOf(logicalPath) {
+  const file = logicalPath.replaceAll("\\", "/").split("/").pop() ?? logicalPath;
+  const dot2 = file.lastIndexOf(".");
+  return dot2 <= 0 ? file : file.slice(0, dot2);
+}
+
+// src/passes/lightmap.ts
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`TN_ASSETS_LIGHTMAP_CONFIG_INVALID: ${label} must be a positive integer.`);
+  }
+  return value;
+}
+function remapArray(source, itemSize, oldIndexes) {
+  const Constructor = source.constructor;
+  const target = new Constructor(oldIndexes.length * itemSize);
+  for (let targetIndex = 0; targetIndex < oldIndexes.length; targetIndex += 1) {
+    const sourceIndex = oldIndexes[targetIndex] ?? 0;
+    for (let component = 0; component < itemSize; component += 1) {
+      target[targetIndex * itemSize + component] = source[sourceIndex * itemSize + component] ?? 0;
+    }
+  }
+  return target;
+}
+function replaceAccessor(document, buffer, source, array) {
+  return document.createAccessor(source.getName()).setType(source.getType()).setNormalized(source.getNormalized()).setArray(array).setBuffer(buffer);
+}
+async function readDocument(input, logicalPath) {
+  try {
+    return await new NodeIO().registerExtensions(ALL_EXTENSIONS).readBinary(input);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `TN_ASSETS_LIGHTMAP_UNREADABLE: could not parse '${logicalPath}' as a self-contained GLB: ${detail}`
+    );
+  }
+}
+async function createAtlasApi() {
+  const XAtlas = Api(createXAtlasModule);
+  const wasmPath = createRequire(import.meta.url).resolve("xatlasjs/dist/node/xatlas.wasm");
+  let loaded = () => {
+  };
+  const ready = new Promise((resolve) => {
+    loaded = resolve;
+  });
+  const api = new XAtlas(loaded, () => wasmPath);
+  await ready;
+  return api;
+}
+function primitivesOf(document) {
+  const rows = [];
+  for (const [meshIndex, mesh] of document.getRoot().listMeshes().entries()) {
+    for (const [primitiveIndex, primitive] of mesh.listPrimitives().entries()) {
+      rows.push({ key: `${String(meshIndex)}:${String(primitiveIndex)}`, primitive });
+    }
+  }
+  return rows;
+}
+function chartCount(atlas) {
+  let charts = 0;
+  for (const mesh of atlas.meshes) {
+    const parent = /* @__PURE__ */ new Map();
+    const rootOf = (value) => {
+      const parentValue = parent.get(value) ?? value;
+      if (parentValue === value) return value;
+      const root = rootOf(parentValue);
+      parent.set(value, root);
+      return root;
+    };
+    const join = (left, right) => {
+      const leftRoot = rootOf(left);
+      const rightRoot = rootOf(right);
+      parent.set(leftRoot, rightRoot);
+    };
+    for (let offset = 0; offset < mesh.index.length; offset += 3) {
+      const first = mesh.index[offset];
+      const second = mesh.index[offset + 1];
+      const third = mesh.index[offset + 2];
+      if (first === void 0 || second === void 0 || third === void 0) continue;
+      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);
+    }
+    charts += new Set([...parent.keys()].map(rootOf)).size;
+  }
+  return charts;
+}
+function assertStatic(document, logicalPath) {
+  const hasMorphTargets = document.getRoot().listMeshes().some((mesh) => mesh.listPrimitives().some((primitive) => primitive.listTargets().length > 0));
+  if (document.getRoot().listAnimations().length > 0 || document.getRoot().listSkins().length > 0 || hasMorphTargets) {
+    throw new Error(
+      `TN_ASSETS_LIGHTMAP_UNSUPPORTED_ANIMATION: '${logicalPath}' contains animated, skinned, or morphed content.`
+    );
+  }
+}
+function addPrimitive(api, row, logicalPath) {
+  const positions = row.primitive.getAttribute("POSITION")?.getArray();
+  if (!(positions instanceof Float32Array)) {
+    throw new Error(
+      `TN_ASSETS_LIGHTMAP_GEOMETRY_UNSUPPORTED: '${logicalPath}' needs Float32 positions.`
+    );
+  }
+  const sourceIndices = row.primitive.getIndices()?.getArray();
+  const vertexCount = positions.length / 3;
+  if (vertexCount > 65535) {
+    throw new Error(
+      `TN_ASSETS_LIGHTMAP_GEOMETRY_UNSUPPORTED: '${logicalPath}' exceeds xatlasjs's 65,535-vertex Uint16 limit.`
+    );
+  }
+  const indices = sourceIndices == null ? Uint16Array.from({ length: vertexCount }, (_, index) => index) : sourceIndices instanceof Uint16Array ? sourceIndices : Uint16Array.from(sourceIndices);
+  const normals = row.primitive.getAttribute("NORMAL")?.getArray();
+  const uv0 = row.primitive.getAttribute("TEXCOORD_0")?.getArray();
+  api.addMesh(
+    indices,
+    positions,
+    normals instanceof Float32Array ? normals : null,
+    uv0 instanceof Float32Array ? uv0 : null,
+    row.key,
+    normals instanceof Float32Array,
+    false
+  );
+}
+function remapAttributes(document, buffer, row, result) {
+  for (const semantic of row.primitive.listSemantics()) {
+    const source = row.primitive.getAttribute(semantic);
+    const sourceArray = source?.getArray();
+    if (source === null || sourceArray === null) continue;
+    const remapped = semantic === "POSITION" ? result.vertex.vertices : remapArray(sourceArray, source.getElementSize(), result.oldIndexes);
+    row.primitive.setAttribute(semantic, replaceAccessor(document, buffer, source, remapped));
+  }
+}
+function writeAtlas(document, rows, atlas) {
+  const buffer = document.getRoot().listBuffers()[0] ?? document.createBuffer("lightmap");
+  const rowsByKey = new Map(rows.map((row) => [row.key, row]));
+  for (const result of atlas.meshes) {
+    const row = rowsByKey.get(result.mesh);
+    if (row === void 0) {
+      throw new Error(`TN_ASSETS_LIGHTMAP_ATLAS_INVALID: missing primitive '${result.mesh}'.`);
+    }
+    remapAttributes(document, buffer, row, result);
+    row.primitive.setAttribute(
+      "TEXCOORD_1",
+      document.createAccessor("lightmap-uv").setType("VEC2").setArray(result.vertex.coords1).setBuffer(buffer)
+    );
+    row.primitive.setIndices(
+      document.createAccessor("lightmap-indices").setType("SCALAR").setArray(result.index).setBuffer(buffer)
+    );
+  }
+}
+async function bakeUv2(document, rows, atlasSize, padding, logicalPath) {
+  const startedAt = performance.now();
+  const api = await createAtlasApi();
+  api.createAtlas();
+  try {
+    for (const row of rows) addPrimitive(api, row, logicalPath);
+    const atlas = api.generateAtlas(
+      {},
+      { blockAlign: true, padding, resolution: atlasSize, texelsPerUnit: 0 }
+    );
+    writeAtlas(document, rows, atlas);
+    const bake = bakeStaticLightmap(document, atlas.width, atlas.height, padding);
+    const lightmap = await encodeLinearRgbaKtx2(bake.pixels, bake.width, bake.height);
+    return {
+      auxiliaryOutputs: [
+        {
+          buffer: lightmap,
+          extension: ".ktx2",
+          manifestField: "lightmaps",
+          metadata: {
+            bytesBefore: bake.pixels.byteLength,
+            dilatedTexels: bake.dilatedTexels,
+            format: "etc1s",
+            materialTargets: bake.materialTargets,
+            occludedTexels: bake.occludedTexels,
+            texCoord: 1,
+            validTexels: bake.validTexels
+          },
+          role: "lightmap"
+        }
+      ],
+      buffer: Buffer.from(
+        await new NodeIO().registerExtensions(ALL_EXTENSIONS).writeBinary(document)
+      ),
+      entry: {
+        lightmapBakeMs: performance.now() - startedAt,
+        lightmapAtlas: {
+          atlasCount: atlas.atlasCount,
+          chartCount: chartCount(atlas),
+          height: atlas.height,
+          padding,
+          skippedMeshes: [],
+          texelsPerUnit: atlas.texelsPerUnit,
+          width: atlas.width
+        }
+      }
+    };
+  } finally {
+    api.destroyAtlas();
+  }
+}
+function lightmapPass(options) {
+  const atlasSize = positiveInteger(options.atlasSize, "atlasSize");
+  const padding = positiveInteger(options.padding, "padding");
+  return {
+    cacheKey: JSON.stringify({ atlasSize, padding }),
+    name: "lightmap-uv2",
+    async apply(input, logicalPath) {
+      if (!/\.glb$/iu.test(logicalPath)) return input;
+      const document = await readDocument(input, logicalPath);
+      assertStatic(document, logicalPath);
+      const rows = primitivesOf(document);
+      if (rows.length === 0) return input;
+      return bakeUv2(document, rows, atlasSize, padding, logicalPath);
+    }
+  };
+}
+
+// src/virtual/partition.ts
+function edgeKey(a, b) {
+  return a < b ? a * 4294967296 + b : b * 4294967296 + a;
+}
+function clusterBoundaryEdges(indices, start, count) {
+  const seen = /* @__PURE__ */ new Map();
+  for (let offset = start; offset < start + count; offset += 3) {
+    for (let corner = 0; corner < 3; corner += 1) {
+      const key = edgeKey(
+        indices[offset + corner],
+        indices[offset + (corner + 1) % 3]
+      );
+      seen.set(key, (seen.get(key) ?? 0) + 1);
+    }
+  }
+  const boundary = [];
+  for (const [key, uses] of seen) if (uses === 1) boundary.push(key);
+  return boundary;
+}
+function clusterAdjacency(indices, ranges) {
+  const owners = /* @__PURE__ */ new Map();
+  const boundaries = [];
+  for (let cluster = 0; cluster < ranges.length; cluster += 1) {
+    const range = ranges[cluster];
+    const boundary = clusterBoundaryEdges(indices, range.start, range.count);
+    boundaries.push(boundary);
+    for (const key of boundary) {
+      const list = owners.get(key);
+      if (list === void 0) owners.set(key, [cluster]);
+      else list.push(cluster);
+    }
+  }
+  const neighbours = ranges.map(() => []);
+  const weights = ranges.map(() => []);
+  const index = ranges.map(() => /* @__PURE__ */ new Map());
+  for (let cluster = 0; cluster < boundaries.length; cluster += 1) {
+    for (const key of boundaries[cluster]) {
+      for (const other of owners.get(key) ?? []) {
+        if (other === cluster) continue;
+        const slot = index[cluster].get(other);
+        if (slot === void 0) {
+          index[cluster].set(
+            other,
+            neighbours[cluster].length
+          );
+          neighbours[cluster].push(other);
+          weights[cluster].push(1);
+        } else {
+          const list = weights[cluster];
+          list[slot] = list[slot] + 1;
+        }
+      }
+    }
+  }
+  return { neighbours, weights };
+}
+function partitionClusters(adjacency, options) {
+  const clusterCount = adjacency.neighbours.length;
+  if (!Number.isInteger(options.targetSize) || options.targetSize < 2)
+    throw new Error("partitionClusters targetSize must be an integer of at least two.");
+  if (options.centres.length !== clusterCount * 3)
+    throw new Error(
+      `partitionClusters needs one centre per cluster: ${options.centres.length / 3} centres for ${clusterCount} clusters.`
+    );
+  const groupOf = new Int32Array(clusterCount).fill(-1);
+  const groups = [];
+  for (let seed = 0; seed < clusterCount; seed += 1) {
+    if (groupOf[seed] !== -1) continue;
+    const group = [seed];
+    groupOf[seed] = groups.length;
+    const candidates = /* @__PURE__ */ new Map();
+    const offer = (member) => {
+      const neighbours = adjacency.neighbours[member];
+      const weights = adjacency.weights[member];
+      for (let slot = 0; slot < neighbours.length; slot += 1) {
+        const other = neighbours[slot];
+        if (groupOf[other] !== -1) continue;
+        candidates.set(other, (candidates.get(other) ?? 0) + weights[slot]);
+      }
+    };
+    offer(seed);
+    while (group.length < options.targetSize && candidates.size > 0) {
+      let best = -1;
+      let bestWeight = -1;
+      for (const [candidate, weight] of candidates) {
+        if (weight > bestWeight || weight === bestWeight && candidate < best) {
+          best = candidate;
+          bestWeight = weight;
+        }
+      }
+      candidates.delete(best);
+      if (groupOf[best] !== -1) continue;
+      groupOf[best] = groups.length;
+      group.push(best);
+      offer(best);
+    }
+    groups.push(group);
+  }
+  return mergeUndersizedGroups(groups, groupOf, options);
+}
+function mergeUndersizedGroups(groups, groupOf, options) {
+  if (groups.length < 2) return groups;
+  const half = Math.max(1, Math.floor(options.targetSize / 2));
+  const centre = (group) => {
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    for (const cluster of group) {
+      x += options.centres[cluster * 3];
+      y += options.centres[cluster * 3 + 1];
+      z += options.centres[cluster * 3 + 2];
+    }
+    return [x / group.length, y / group.length, z / group.length];
+  };
+  const centres = groups.map(centre);
+  const merged = groups.map((group) => [...group]);
+  for (let index = 0; index < merged.length; index += 1) {
+    const group = merged[index];
+    if (group === void 0 || group.length >= half) continue;
+    let best = -1;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (let other = 0; other < merged.length; other += 1) {
+      const candidate = merged[other];
+      if (other === index || candidate === void 0) continue;
+      if (candidate.length + group.length > options.targetSize * 2) continue;
+      const [ax, ay, az] = centres[index];
+      const [bx, by, bz] = centres[other];
+      const distance = (ax - bx) ** 2 + (ay - by) ** 2 + (az - bz) ** 2;
+      if (distance < bestDistance || distance === bestDistance && other < best) {
+        best = other;
+        bestDistance = distance;
+      }
+    }
+    if (best === -1) continue;
+    merged[best].push(...group);
+    merged[index] = void 0;
+  }
+  const result = merged.filter((group) => group !== void 0);
+  for (let index = 0; index < result.length; index += 1)
+    for (const cluster of result[index]) groupOf[cluster] = index;
+  for (const group of result) group.sort((a, b) => a - b);
+  return result;
+}
+
+// src/virtual/dag.ts
+var DEFAULT_CONE_WEIGHT = 0;
+var DEFAULT_GROUP_SIZE = 4;
+var DEFAULT_MAX_LEVELS = 32;
+var DEFAULT_MAX_TRIANGLES = 128;
+var DEFAULT_MAX_VERTICES = 128;
+var DEFAULT_MIN_TRIANGLES = 96;
+var DEFAULT_SIMPLIFY_RATIO = 0.5;
+var UNBOUNDED_ERROR = 1e9;
+var MIN_LEVEL_REDUCTION = 0.02;
+var Uint32Sink = class {
+  data;
+  used = 0;
+  constructor(capacity) {
+    this.data = new Uint32Array(Math.max(capacity, 3));
+  }
+  get length() {
+    return this.used;
+  }
+  push(value) {
+    if (this.used === this.data.length) {
+      const grown = new Uint32Array(this.data.length * 2);
+      grown.set(this.data);
+      this.data = grown;
+    }
+    this.data[this.used] = value;
+    this.used += 1;
+  }
+  /** A view over what has been written. Valid until the next `push` that grows the buffer. */
+  view() {
+    return this.data.subarray(0, this.used);
+  }
+  toArray() {
+    return this.data.slice(0, this.used);
+  }
+};
+function unite(a, b) {
+  if (b.radius <= 0) return a;
+  if (a.radius <= 0) return b;
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const dz = b.z - a.z;
+  const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (distance + b.radius <= a.radius) return a;
+  if (distance + a.radius <= b.radius) return b;
+  const radius = (a.radius + b.radius + distance) / 2;
+  const step = distance === 0 ? 0 : (radius - a.radius) / distance;
+  return { radius, x: a.x + dx * step, y: a.y + dy * step, z: a.z + dz * step };
+}
+function assertMesh(indices, positions) {
+  if (indices.length === 0 || indices.length % 3 !== 0)
+    throw new Error(
+      `buildClusterDag needs a non-empty triangle list: got ${indices.length} indices.`
+    );
+  if (positions.length === 0 || positions.length % 3 !== 0)
+    throw new Error(
+      `buildClusterDag needs tightly packed vec3 positions: got ${positions.length} floats.`
+    );
+  const vertexCount = positions.length / 3;
+  for (let slot = 0; slot < indices.length; slot += 1)
+    if (indices[slot] >= vertexCount)
+      throw new Error(
+        `buildClusterDag index ${indices[slot]} at ${slot} is outside the ${vertexCount}-vertex buffer.`
+      );
+}
+function resolveOptions(options) {
+  const simplifyRatio = options.simplifyRatio ?? DEFAULT_SIMPLIFY_RATIO;
+  if (simplifyRatio <= 0 || simplifyRatio >= 1)
+    throw new Error(`buildClusterDag simplifyRatio must be inside (0, 1): got ${simplifyRatio}.`);
+  return {
+    coneWeight: options.coneWeight ?? DEFAULT_CONE_WEIGHT,
+    groupSize: options.groupSize ?? DEFAULT_GROUP_SIZE,
+    // LockBorder holds the group's rim still — meshoptimizer computes that rim on the welded
+    // topology, which is why split seam vertices do not leak through it. ErrorAbsolute puts the
+    // reported error in the mesh's own units so levels are comparable. Sparse keeps the simplifier's
+    // cost proportional to the group rather than to the whole vertex buffer.
+    lockFlags: options.unlockGroupBoundary ? ["ErrorAbsolute", "Sparse"] : ["LockBorder", "ErrorAbsolute", "Sparse"],
+    maxLevels: options.maxLevels ?? DEFAULT_MAX_LEVELS,
+    maxTriangles: options.maxTriangles ?? DEFAULT_MAX_TRIANGLES,
+    maxVertices: options.maxVertices ?? DEFAULT_MAX_VERTICES,
+    minTriangles: options.minTriangles ?? DEFAULT_MIN_TRIANGLES,
+    simplifyRatio
+  };
+}
+var ClusterDagBuilder = class {
+  constructor(positions, sourceIndexCount, options) {
+    this.positions = positions;
+    this.settings = resolveOptions(options);
+    this.sink = new Uint32Sink(sourceIndexCount * 2);
+    this.weld = MeshoptSimplifier.generatePositionRemap(positions, 3);
+  }
+  positions;
+  clusters = [];
+  groups = [];
+  levels = [];
+  settings;
+  sink;
+  /** Vertices that share a position are one vertex for adjacency: a UV seam splits the vertex
+   * buffer but not the surface, and two clusters that meet along one do touch. */
+  weld;
+  build(indices) {
+    let current = this.emit(this.clusterize(indices), 0, 0, null);
+    this.levels.push({
+      clusterCount: current.length,
+      promoted: 0,
+      triangleCount: this.triangles(current)
+    });
+    let stopReason = current.length <= 1 ? "root" : "cap";
+    for (let level = 0; current.length > 1 && level < this.settings.maxLevels; level += 1) {
+      const previous = this.triangles(current);
+      const fold = this.foldLevel(current, level);
+      const triangleCount = this.triangles(fold.next);
+      this.levels.push({
+        clusterCount: fold.next.length,
+        promoted: fold.promoted,
+        triangleCount
+      });
+      current = fold.next;
+      if (current.length <= 1) {
+        stopReason = "root";
+        break;
+      }
+      if (!fold.simplifiedAny || triangleCount > previous * (1 - MIN_LEVEL_REDUCTION)) {
+        stopReason = "stalled";
+        break;
+      }
+    }
+    return {
+      clusters: this.clusters.map((cluster) => ({ ...cluster })),
+      groups: this.groups,
+      indices: this.sink.toArray(),
+      levels: this.levels,
+      roots: current.slice(),
+      stopReason
+    };
+  }
+  triangles(ids) {
+    let total = 0;
+    for (const id of ids) total += this.cluster(id).count / 3;
+    return total;
+  }
+  cluster(id) {
+    return this.clusters[id];
+  }
+  clusterize(source) {
+    return MeshoptClusterizer.buildMeshletsFlex(
+      source,
+      this.positions,
+      3,
+      this.settings.maxVertices,
+      this.settings.minTriangles,
+      this.settings.maxTriangles,
+      this.settings.coneWeight
+    );
+  }
+  emit(buffers, level, error, sourceSphere) {
+    const bounds = MeshoptClusterizer.computeMeshletBounds(buffers, this.positions, 3);
+    const emitted = [];
+    for (let meshlet = 0; meshlet < buffers.meshletCount; meshlet += 1) {
+      const extracted = MeshoptClusterizer.extractMeshlet(buffers, meshlet);
+      const start = this.sink.length;
+      for (let corner = 0; corner < extracted.triangles.length; corner += 1)
+        this.sink.push(extracted.vertices[extracted.triangles[corner]]);
+      const bound = bounds[meshlet];
+      const own = {
+        radius: bound.radius,
+        x: bound.centerX,
+        y: bound.centerY,
+        z: bound.centerZ
+      };
+      emitted.push(this.clusters.length);
+      this.clusters.push({
+        bounds: {
+          centerX: bound.centerX,
+          centerY: bound.centerY,
+          centerZ: bound.centerZ,
+          coneAxisX: bound.coneAxisX,
+          coneAxisY: bound.coneAxisY,
+          coneAxisZ: bound.coneAxisZ,
+          coneCutoff: bound.coneCutoff,
+          radius: bound.radius
+        },
+        count: extracted.triangles.length,
+        error,
+        group: -1,
+        level,
+        parentError: Number.POSITIVE_INFINITY,
+        parentSphere: own,
+        sourceSphere: sourceSphere ?? own,
+        start
+      });
+    }
+    return emitted;
+  }
+  /** The level's clusters as the partitioner wants them: welded index space, ranges, centres. */
+  partition(current) {
+    const view = this.sink.view();
+    const welded = new Uint32Array(view.length);
+    for (let slot = 0; slot < view.length; slot += 1)
+      welded[slot] = this.weld[view[slot]];
+    const ranges = current.map((id) => ({
+      count: this.cluster(id).count,
+      start: this.cluster(id).start
+    }));
+    const centres = new Float32Array(current.length * 3);
+    for (let slot = 0; slot < current.length; slot += 1) {
+      const bounds = this.cluster(current[slot]).bounds;
+      centres[slot * 3] = bounds.centerX;
+      centres[slot * 3 + 1] = bounds.centerY;
+      centres[slot * 3 + 2] = bounds.centerZ;
+    }
+    return partitionClusters(clusterAdjacency(welded, ranges), {
+      centres,
+      targetSize: this.settings.groupSize
+    });
+  }
+  gather(members) {
+    const view = this.sink.view();
+    let size = 0;
+    for (const member of members) size += this.cluster(member).count;
+    const group = new Uint32Array(size);
+    let cursor = 0;
+    for (const member of members) {
+      const cluster = this.cluster(member);
+      group.set(view.subarray(cluster.start, cluster.start + cluster.count), cursor);
+      cursor += cluster.count;
+    }
+    return group;
+  }
+  /**
+   * Simplifies one group and emits its parents, or reports that it would not shrink.
+   *
+   * A group that refuses to simplify hands its members back unchanged. They carry their own geometry
+   * upward and keep `parentError` at infinity until a level that *can* simplify them groups them —
+   * dropping them here is what would turn a stalled group into a hole at high thresholds.
+   */
+  foldGroup(members, level) {
+    const groupIndices = this.gather(members);
+    const target = Math.max(
+      3,
+      Math.floor(groupIndices.length / 3 * this.settings.simplifyRatio) * 3
+    );
+    const [simplified, simplifyError] = MeshoptSimplifier.simplify(
+      groupIndices,
+      this.positions,
+      3,
+      target,
+      UNBOUNDED_ERROR,
+      this.settings.lockFlags
+    );
+    if (simplified.length >= groupIndices.length) return null;
+    let error = simplifyError;
+    let sphere = { radius: 0, x: 0, y: 0, z: 0 };
+    for (const member of members) {
+      const cluster = this.cluster(member);
+      error = Math.max(error, cluster.error);
+      sphere = unite(unite(sphere, cluster.sourceSphere), {
+        radius: cluster.bounds.radius,
+        x: cluster.bounds.centerX,
+        y: cluster.bounds.centerY,
+        z: cluster.bounds.centerZ
+      });
+    }
+    const groupId = this.groups.length;
+    for (const member of members) {
+      const cluster = this.cluster(member);
+      cluster.group = groupId;
+      cluster.parentError = error;
+      cluster.parentSphere = sphere;
+    }
+    const parents = this.emit(this.clusterize(simplified), level + 1, error, sphere);
+    this.groups.push({ children: [...members], error, level, parents, simplifyError, sphere });
+    return parents;
+  }
+  foldLevel(current, level) {
+    const next = [];
+    let promoted = 0;
+    let simplifiedAny = false;
+    for (const local of this.partition(current)) {
+      const members = local.map((slot) => current[slot]);
+      const parents = this.foldGroup(members, level);
+      if (parents === null) {
+        next.push(...members);
+        promoted += members.length;
+        continue;
+      }
+      simplifiedAny = true;
+      next.push(...parents);
+    }
+    return { next, promoted, simplifiedAny };
+  }
+};
+async function buildClusterDag(indices, positions, options = {}) {
+  assertMesh(indices, positions);
+  await MeshoptClusterizer.ready;
+  await MeshoptSimplifier.ready;
+  return new ClusterDagBuilder(positions, indices.length, options).build(indices);
+}
+var TN_VIRTUAL_GEOMETRY = "TN_virtual_geometry";
+var ROOT_PARENT_ERROR = 34028234663852886e22;
+var NO_GROUP = 4294967295;
+var VIRTUAL_ACCESSOR = "TN_VIRTUAL_GEOMETRY";
+var VirtualGeometry = class extends ExtensionProperty {
+  static EXTENSION_NAME = TN_VIRTUAL_GEOMETRY;
+  init() {
+    this.extensionName = TN_VIRTUAL_GEOMETRY;
+    this.propertyType = "VirtualGeometry";
+    this.parentTypes = [PropertyType.PRIMITIVE];
+  }
+  getDefaults() {
+    return Object.assign(super.getDefaults(), {
+      clusterBounds: null,
+      clusterCones: null,
+      clusterErrors: null,
+      clusterGroups: null,
+      clusterParentSpheres: null,
+      clusterRanges: null,
+      clusterSourceSpheres: null,
+      indices: null,
+      levelTriangles: [],
+      stopReason: "root"
+    });
+  }
+  /** Cluster-ordered triangles for every level. */
+  getIndices() {
+    return this.getRef("indices");
+  }
+  setIndices(accessor) {
+    return this.setRef("indices", accessor, { usage: VIRTUAL_ACCESSOR });
+  }
+  /** Per cluster: start and index count into `indices`. */
+  getClusterRanges() {
+    return this.getRef("clusterRanges");
+  }
+  setClusterRanges(accessor) {
+    return this.setRef("clusterRanges", accessor, { usage: VIRTUAL_ACCESSOR });
+  }
+  /** Per cluster: its own object-space error, and its parent group's. */
+  getClusterErrors() {
+    return this.getRef("clusterErrors");
+  }
+  setClusterErrors(accessor) {
+    return this.setRef("clusterErrors", accessor, { usage: VIRTUAL_ACCESSOR });
+  }
+  /** Per cluster: bounding sphere, centre and radius. */
+  getClusterBounds() {
+    return this.getRef("clusterBounds");
+  }
+  setClusterBounds(accessor) {
+    return this.setRef("clusterBounds", accessor, { usage: VIRTUAL_ACCESSOR });
+  }
+  /** Per cluster: normal cone axis and cutoff. */
+  getClusterCones() {
+    return this.getRef("clusterCones");
+  }
+  setClusterCones(accessor) {
+    return this.setRef("clusterCones", accessor, { usage: VIRTUAL_ACCESSOR });
+  }
+  /** Per cluster: the group it folds into, and the group that produced it. `NO_GROUP` for neither. */
+  getClusterGroups() {
+    return this.getRef("clusterGroups");
+  }
+  setClusterGroups(accessor) {
+    return this.setRef("clusterGroups", accessor, { usage: VIRTUAL_ACCESSOR });
+  }
+  /**
+   * Per cluster: the sphere its own error is projected through at run time — the sphere of the
+   * group that produced it.
+   */
+  getClusterSourceSpheres() {
+    return this.getRef("clusterSourceSpheres");
+  }
+  setClusterSourceSpheres(accessor) {
+    return this.setRef("clusterSourceSpheres", accessor, { usage: VIRTUAL_ACCESSOR });
+  }
+  /**
+   * Per cluster: the sphere its parent error is projected through — the sphere of the group it
+   * folds into, shared with every sibling so they flip together.
+   *
+   * Two spheres rather than one because a screen-space cut cracks without them: a group's sphere
+   * encloses every child's, so the parent's projected error can never fall below a child's however
+   * the camera moves.
+   */
+  getClusterParentSpheres() {
+    return this.getRef("clusterParentSpheres");
+  }
+  setClusterParentSpheres(accessor) {
+    return this.setRef("clusterParentSpheres", accessor, { usage: VIRTUAL_ACCESSOR });
+  }
+  getLevelTriangles() {
+    return this.get("levelTriangles");
+  }
+  setLevelTriangles(levels) {
+    return this.set("levelTriangles", levels);
+  }
+  getStopReason() {
+    return this.get("stopReason");
+  }
+  setStopReason(reason) {
+    return this.set("stopReason", reason);
+  }
+};
+var TNVirtualGeometry = class extends Extension {
+  static EXTENSION_NAME = TN_VIRTUAL_GEOMETRY;
+  extensionName = TN_VIRTUAL_GEOMETRY;
+  prewriteTypes = [PropertyType.ACCESSOR];
+  createVirtualGeometry() {
+    return new VirtualGeometry(this.document.getGraph());
+  }
+  read(context) {
+    const meshDefs = context.jsonDoc.json.meshes ?? [];
+    meshDefs.forEach((meshDef, meshIndex) => {
+      (meshDef.primitives ?? []).forEach((primitiveDef, primitiveIndex) => {
+        const def = primitiveDef.extensions?.[TN_VIRTUAL_GEOMETRY];
+        if (def === void 0) return;
+        const virtual = this.createVirtualGeometry().setIndices(context.accessors[def.indices]).setClusterRanges(context.accessors[def.clusterRanges]).setClusterErrors(context.accessors[def.clusterErrors]).setClusterBounds(context.accessors[def.clusterBounds]).setClusterCones(context.accessors[def.clusterCones]).setClusterGroups(context.accessors[def.clusterGroups]).setClusterSourceSpheres(context.accessors[def.clusterSourceSpheres]).setClusterParentSpheres(context.accessors[def.clusterParentSpheres]).setLevelTriangles([...def.levelTriangles]).setStopReason(def.stopReason);
+        const mesh = context.meshes[meshIndex];
+        const primitive = mesh?.listPrimitives()[primitiveIndex];
+        primitive?.setExtension(TN_VIRTUAL_GEOMETRY, virtual);
+      });
+    });
+    return this;
+  }
+  /**
+   * These accessors belong to no primitive, so the writer would otherwise have no usage for them
+   * and no reason to lay them out. Grouping them by parent keeps one primitive's DAG in one buffer
+   * view, which is what PRD-285's streaming will want to fetch a range of.
+   */
+  prewrite(context) {
+    context.accessorUsageGroupedByParent.add(VIRTUAL_ACCESSOR);
+    for (const property of this.properties) {
+      for (const accessor of accessorsOf(property))
+        context.addAccessorToUsageGroup(accessor, VIRTUAL_ACCESSOR);
+    }
+    return this;
+  }
+  write(context) {
+    for (const mesh of this.document.getRoot().listMeshes()) {
+      for (const primitive of mesh.listPrimitives()) {
+        const virtual = primitive.getExtension(TN_VIRTUAL_GEOMETRY);
+        if (virtual === null) continue;
+        const meshIndex = context.meshIndexMap.get(mesh);
+        if (meshIndex === void 0) continue;
+        const primitiveIndex = mesh.listPrimitives().indexOf(primitive);
+        const primitiveDef = context.jsonDoc.json.meshes?.[meshIndex]?.primitives?.[primitiveIndex];
+        if (primitiveDef === void 0) continue;
+        const index = (accessor, field) => {
+          const slot = accessor === null ? void 0 : context.accessorIndexMap.get(accessor);
+          if (slot === void 0)
+            throw new Error(
+              `TN_VIRTUAL_GEOMETRY_ACCESSOR_MISSING: '${field}' on mesh '${mesh.getName()}' has no index in the written file.`
+            );
+          return slot;
+        };
+        primitiveDef.extensions = primitiveDef.extensions ?? {};
+        primitiveDef.extensions[TN_VIRTUAL_GEOMETRY] = {
+          clusterBounds: index(virtual.getClusterBounds(), "clusterBounds"),
+          clusterCones: index(virtual.getClusterCones(), "clusterCones"),
+          clusterErrors: index(virtual.getClusterErrors(), "clusterErrors"),
+          clusterGroups: index(virtual.getClusterGroups(), "clusterGroups"),
+          clusterParentSpheres: index(virtual.getClusterParentSpheres(), "clusterParentSpheres"),
+          clusterRanges: index(virtual.getClusterRanges(), "clusterRanges"),
+          clusterSourceSpheres: index(virtual.getClusterSourceSpheres(), "clusterSourceSpheres"),
+          indices: index(virtual.getIndices(), "indices"),
+          levelTriangles: virtual.getLevelTriangles(),
+          stopReason: virtual.getStopReason()
+        };
+      }
+    }
+    return this;
+  }
+};
+function accessorsOf(virtual) {
+  return [
+    virtual.getIndices(),
+    virtual.getClusterRanges(),
+    virtual.getClusterErrors(),
+    virtual.getClusterBounds(),
+    virtual.getClusterCones(),
+    virtual.getClusterGroups(),
+    virtual.getClusterSourceSpheres(),
+    virtual.getClusterParentSpheres()
+  ].filter((accessor) => accessor !== null);
+}
+function attachVirtualGeometry(document, extension, primitive, dag) {
+  const buffer = document.getRoot().listBuffers()[0] ?? document.createBuffer();
+  const count = dag.clusters.length;
+  const ranges = new Uint32Array(count * 2);
+  const errors = new Float32Array(count * 2);
+  const bounds = new Float32Array(count * 4);
+  const cones = new Float32Array(count * 4);
+  const groups = new Uint32Array(count * 2);
+  const sourceSpheres = new Float32Array(count * 4);
+  const parentSpheres = new Float32Array(count * 4);
+  const sourceGroups = new Uint32Array(count).fill(NO_GROUP);
+  for (let group = 0; group < dag.groups.length; group += 1)
+    for (const parent of dag.groups[group].parents)
+      sourceGroups[parent] = group;
+  for (let cluster = 0; cluster < count; cluster += 1) {
+    const record = dag.clusters[cluster];
+    ranges[cluster * 2] = record.start;
+    ranges[cluster * 2 + 1] = record.count;
+    errors[cluster * 2] = record.error;
+    errors[cluster * 2 + 1] = Number.isFinite(record.parentError) ? record.parentError : ROOT_PARENT_ERROR;
+    bounds[cluster * 4] = record.bounds.centerX;
+    bounds[cluster * 4 + 1] = record.bounds.centerY;
+    bounds[cluster * 4 + 2] = record.bounds.centerZ;
+    bounds[cluster * 4 + 3] = record.bounds.radius;
+    cones[cluster * 4] = record.bounds.coneAxisX;
+    cones[cluster * 4 + 1] = record.bounds.coneAxisY;
+    cones[cluster * 4 + 2] = record.bounds.coneAxisZ;
+    cones[cluster * 4 + 3] = record.bounds.coneCutoff;
+    groups[cluster * 2] = record.group === -1 ? NO_GROUP : record.group;
+    groups[cluster * 2 + 1] = sourceGroups[cluster];
+    sourceSpheres[cluster * 4] = record.sourceSphere.x;
+    sourceSpheres[cluster * 4 + 1] = record.sourceSphere.y;
+    sourceSpheres[cluster * 4 + 2] = record.sourceSphere.z;
+    sourceSpheres[cluster * 4 + 3] = record.sourceSphere.radius;
+    parentSpheres[cluster * 4] = record.parentSphere.x;
+    parentSpheres[cluster * 4 + 1] = record.parentSphere.y;
+    parentSpheres[cluster * 4 + 2] = record.parentSphere.z;
+    parentSpheres[cluster * 4 + 3] = record.parentSphere.radius;
+  }
+  const accessor = (array, type) => document.createAccessor().setArray(array).setType(type).setBuffer(buffer);
+  const virtual = extension.createVirtualGeometry().setIndices(accessor(dag.indices.slice(), "SCALAR")).setClusterRanges(accessor(ranges, "VEC2")).setClusterErrors(accessor(errors, "VEC2")).setClusterBounds(accessor(bounds, "VEC4")).setClusterCones(accessor(cones, "VEC4")).setClusterGroups(accessor(groups, "VEC2")).setClusterSourceSpheres(accessor(sourceSpheres, "VEC4")).setClusterParentSpheres(accessor(parentSpheres, "VEC4")).setLevelTriangles(dag.levels.map((level) => level.triangleCount)).setStopReason(dag.stopReason);
+  primitive.setExtension(TN_VIRTUAL_GEOMETRY, virtual);
+  return virtual;
+}
+function virtualGeometryBytes(virtual) {
+  let bytes = 0;
+  for (const accessor of accessorsOf(virtual)) {
+    const array = accessor.getArray();
+    bytes += array === null ? 0 : array.byteLength;
+  }
+  return bytes;
+}
+
+// src/virtual/bake.ts
+var VIRTUAL_BAKE_VERSION = 3;
+var DEFAULT_MIN_SOURCE_TRIANGLES = 65536;
+function positionsOf(primitive) {
+  const position = primitive.getAttribute("POSITION");
+  if (position === null || position.getType() !== "VEC3") return null;
+  const array = position.getArray();
+  if (array === null) return null;
+  if (array instanceof Float32Array && !position.getNormalized()) return array;
+  const floats = new Float32Array(position.getCount() * 3);
+  const element = [0, 0, 0];
+  for (let vertex = 0; vertex < position.getCount(); vertex += 1) {
+    position.getElement(vertex, element);
+    floats[vertex * 3] = element[0];
+    floats[vertex * 3 + 1] = element[1];
+    floats[vertex * 3 + 2] = element[2];
+  }
+  return floats;
+}
+var WORST_FIRST = ["cap", "stalled", "root"];
+function worse(left, right) {
+  return WORST_FIRST.indexOf(left) <= WORST_FIRST.indexOf(right) ? left : right;
+}
+async function bakeVirtualGeometry(document, options, now = () => Date.now()) {
+  const started = now();
+  const minSourceTriangles = options.minSourceTriangles ?? DEFAULT_MIN_SOURCE_TRIANGLES;
+  const dagOptions = {
+    ...options.groupSize === void 0 ? {} : { groupSize: options.groupSize },
+    ...options.maxTriangles === void 0 ? {} : { maxTriangles: options.maxTriangles },
+    ...options.minTriangles === void 0 ? {} : { minTriangles: options.minTriangles },
+    ...options.simplifyRatio === void 0 ? {} : { simplifyRatio: options.simplifyRatio }
+  };
+  let extension = null;
+  let clusters = 0;
+  let levels = 0;
+  let payloadBytes = 0;
+  let primitives = 0;
+  let skipped = 0;
+  let stopReason = "root";
+  for (const mesh of document.getRoot().listMeshes()) {
+    for (const primitive of mesh.listPrimitives()) {
+      const indices = primitive.getIndices();
+      const positions = positionsOf(primitive);
+      if (indices === null || positions === null || primitive.getMode() !== 4) {
+        skipped += 1;
+        continue;
+      }
+      if (indices.getCount() / 3 < minSourceTriangles) {
+        skipped += 1;
+        continue;
+      }
+      const dag = await buildClusterDag(
+        Uint32Array.from(indices.getArray()),
+        positions,
+        dagOptions
+      );
+      extension ??= document.createExtension(TNVirtualGeometry).setRequired(false);
+      const virtual = attachVirtualGeometry(document, extension, primitive, dag);
+      clusters += dag.clusters.length;
+      levels = Math.max(levels, dag.levels.length);
+      payloadBytes += virtualGeometryBytes(virtual);
+      primitives += 1;
+      stopReason = worse(stopReason, dag.stopReason);
+    }
+  }
+  return {
+    bakeSeconds: (now() - started) / 1e3,
+    clusters,
+    levels,
+    payloadBytes,
+    primitives,
+    skipped,
+    stopReason
+  };
+}
+var DEFAULT_MAX_SIZE = 2048;
+var DEFAULT_ETC1S_QUALITY2 = 150;
+var BLOCK_SIZE2 = 4;
+var MIP_FACTOR = 4 / 3;
+var GPU_BYTES_PER_PIXEL = {
+  // BC1 from ETC1S, BC7 from UASTC, RGBA8 for anything left uncompressed.
+  etc1s: 0.5,
+  none: 4,
+  uastc: 1
+};
+var NORMAL_SLOTS = /* @__PURE__ */ new Set(["clearcoatNormalTexture", "normalTexture"]);
+var CORE_SLOTS = [
+  "baseColorTexture",
+  "emissiveTexture",
+  "metallicRoughnessTexture",
+  "normalTexture",
+  "occlusionTexture"
+];
+function coreSlotTexture(material, slot) {
+  switch (slot) {
+    case "baseColorTexture":
+      return material.getBaseColorTexture();
+    case "emissiveTexture":
+      return material.getEmissiveTexture();
+    case "metallicRoughnessTexture":
+      return material.getMetallicRoughnessTexture();
+    case "normalTexture":
+      return material.getNormalTexture();
+    default:
+      return material.getOcclusionTexture();
+  }
+}
+function coreSlotTexCoord(material, slot) {
+  switch (slot) {
+    case "baseColorTexture":
+      return material.getBaseColorTextureInfo()?.getTexCoord();
+    case "emissiveTexture":
+      return material.getEmissiveTextureInfo()?.getTexCoord();
+    case "metallicRoughnessTexture":
+      return material.getMetallicRoughnessTextureInfo()?.getTexCoord();
+    case "normalTexture":
+      return material.getNormalTextureInfo()?.getTexCoord();
+    default:
+      return material.getOcclusionTextureInfo()?.getTexCoord();
+  }
+}
+function textureKeys(root) {
+  const textures = root.listTextures();
+  const seen = /* @__PURE__ */ new Map();
+  return textures.map((texture, index) => {
+    const name = texture.getName();
+    const base = name === "" ? `texture#${String(index)}` : name;
+    const count = seen.get(base) ?? 0;
+    seen.set(base, count + 1);
+    return count === 0 ? base : `${base}#${String(index)}`;
+  });
+}
+function imageShape(bytes, mimeType) {
+  if (mimeType === "image/ktx2") {
+    const container = read(bytes);
+    return {
+      height: container.pixelHeight,
+      levels: container.levelCount,
+      width: container.pixelWidth
+    };
+  }
+  const stats = textureStats(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+  return { height: stats.height, levels: 1, width: stats.width };
+}
+function textureBindings(root) {
+  const textures = root.listTextures();
+  const keys = textureKeys(root);
+  return {
+    materials: root.listMaterials().flatMap((material, materialIndex) => {
+      const name = material.getName();
+      const label = name === "" ? `material#${String(materialIndex)}` : name;
+      return CORE_SLOTS.flatMap((slot) => {
+        const texture = coreSlotTexture(material, slot);
+        if (texture === null) return [];
+        const index = textures.indexOf(texture);
+        const texCoord = coreSlotTexCoord(material, slot) ?? 0;
+        return [`${label}.${slot}=${String(index)}@uv${String(texCoord)}`];
+      });
+    }),
+    textures: textures.map((texture, index) => {
+      const image = texture.getImage();
+      const mimeType = texture.getMimeType();
+      const shape = image === null ? { height: 0, levels: 0, width: 0 } : imageShape(image, mimeType);
+      return {
+        height: shape.height,
+        key: keys[index] ?? `texture#${String(index)}`,
+        levels: shape.levels,
+        mimeType,
+        slots: [...listTextureSlots(texture)].sort(),
+        texCoords: [...new Set(listTextureInfo(texture).map((info) => info.getTexCoord()))].sort(
+          (left, right) => left - right
+        ),
+        width: shape.width
+      };
+    })
+  };
+}
+function describeBinding(binding) {
+  return `${binding.key} (${binding.mimeType} ${String(binding.width)}x${String(binding.height)}, slots ${binding.slots.join("+") || "none"}, uv ${binding.texCoords.join("+") || "none"})`;
+}
+function assertNoTextureDrift(source, output, logicalPath) {
+  const failures = [];
+  if (source.textures.length !== output.textures.length) {
+    failures.push(
+      `texture count ${String(source.textures.length)} -> ${String(output.textures.length)}`
+    );
+  }
+  const count = Math.min(source.textures.length, output.textures.length);
+  for (let index = 0; index < count; index += 1) {
+    const before = source.textures[index];
+    const after = output.textures[index];
+    if (before === void 0 || after === void 0) continue;
+    if (before.key !== after.key) {
+      failures.push(`texture ${String(index)} renamed ${before.key} -> ${after.key}`);
+      continue;
+    }
+    if (after.levels === 0) {
+      failures.push(`${before.key} lost its image`);
+      continue;
+    }
+    if (before.slots.join(",") !== after.slots.join(",")) {
+      failures.push(`${describeBinding(before)} -> slots ${after.slots.join("+") || "none"}`);
+    }
+    if (before.texCoords.join(",") !== after.texCoords.join(",")) {
+      failures.push(`${describeBinding(before)} -> uv ${after.texCoords.join("+") || "none"}`);
+    }
+  }
+  const missing = source.materials.filter((binding) => !output.materials.includes(binding));
+  const added = output.materials.filter((binding) => !source.materials.includes(binding));
+  if (missing.length > 0) failures.push(`material bindings lost: ${missing.join(", ")}`);
+  if (added.length > 0) failures.push(`material bindings appeared: ${added.join(", ")}`);
+  if (failures.length > 0) {
+    throw new Error(
+      `TN_ASSETS_MODEL_TEXTURE_DRIFT: embedded-texture self-verification failed for '${logicalPath}': ${failures.join("; ")}.`
+    );
+  }
+}
+var SRGB_TO_LINEAR = new Float32Array(256);
+for (let value = 0; value < 256; value += 1) {
+  const channel = value / 255;
+  SRGB_TO_LINEAR[value] = channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb(channel) {
+  const encoded = channel <= 31308e-7 ? channel * 12.92 : 1.055 * channel ** (1 / 2.4) - 0.055;
+  return Math.max(0, Math.min(255, Math.round(encoded * 255)));
+}
+function resampleRgba(data, width, height, targetWidth, targetHeight, srgb) {
+  const output = new Uint8Array(targetWidth * targetHeight * 4);
+  const scaleX = width / targetWidth;
+  const scaleY = height / targetHeight;
+  for (let ty = 0; ty < targetHeight; ty += 1) {
+    const y0 = ty * scaleY;
+    const y1 = (ty + 1) * scaleY;
+    for (let tx = 0; tx < targetWidth; tx += 1) {
+      const x0 = tx * scaleX;
+      const x1 = (tx + 1) * scaleX;
+      let red = 0;
+      let green = 0;
+      let blue = 0;
+      let alpha = 0;
+      let total = 0;
+      for (let sy = Math.floor(y0); sy < Math.min(height, Math.ceil(y1)); sy += 1) {
+        const weightY = Math.min(y1, sy + 1) - Math.max(y0, sy);
+        if (weightY <= 0) continue;
+        for (let sx = Math.floor(x0); sx < Math.min(width, Math.ceil(x1)); sx += 1) {
+          const weightX = Math.min(x1, sx + 1) - Math.max(x0, sx);
+          if (weightX <= 0) continue;
+          const weight = weightX * weightY;
+          const offset = (sy * width + sx) * 4;
+          const r = data[offset] ?? 0;
+          const g = data[offset + 1] ?? 0;
+          const b = data[offset + 2] ?? 0;
+          red += (srgb ? SRGB_TO_LINEAR[r] ?? 0 : r) * weight;
+          green += (srgb ? SRGB_TO_LINEAR[g] ?? 0 : g) * weight;
+          blue += (srgb ? SRGB_TO_LINEAR[b] ?? 0 : b) * weight;
+          alpha += (data[offset + 3] ?? 255) * weight;
+          total += weight;
+        }
+      }
+      const divisor = total === 0 ? 1 : total;
+      const target = (ty * targetWidth + tx) * 4;
+      output[target] = srgb ? linearToSrgb(red / divisor) : Math.round(red / divisor);
+      output[target + 1] = srgb ? linearToSrgb(green / divisor) : Math.round(green / divisor);
+      output[target + 2] = srgb ? linearToSrgb(blue / divisor) : Math.round(blue / divisor);
+      output[target + 3] = Math.round(alpha / divisor);
+    }
+  }
+  return output;
+}
+function cappedSize(width, height, maxSize) {
+  const longest = Math.max(width, height);
+  if (longest <= maxSize) return { height, width };
+  const scale2 = maxSize / longest;
+  const snap = (value) => Math.max(BLOCK_SIZE2, Math.round(value * scale2 / BLOCK_SIZE2) * BLOCK_SIZE2);
+  return { height: snap(height), width: snap(width) };
+}
+function rgbaHasAlpha2(rgba) {
+  for (let offset = 3; offset < rgba.length; offset += 4) {
+    if ((rgba[offset] ?? 255) !== 255) return true;
+  }
+  return false;
+}
+function chooseCodec2(slots, alpha, options) {
+  for (const override of options.overrides ?? []) {
+    if (slots.includes(override.slot)) return override.codec;
+  }
+  if (slots.some((slot) => NORMAL_SLOTS.has(slot))) return "uastc";
+  return alpha ? "uastc" : "etc1s";
+}
+function gpuBytes(width, height, codec) {
+  return Math.round(width * height * (GPU_BYTES_PER_PIXEL[codec] ?? 4) * MIP_FACTOR);
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function compressEmbeddedTextures(document, logicalPath, options = {}) {
+  const root = document.getRoot();
+  const textures = root.listTextures();
+  if (textures.length === 0) return void 0;
+  const maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+  const quality = Math.min(255, Math.max(1, Math.round(options.quality ?? DEFAULT_ETC1S_QUALITY2)));
+  const keys = textureKeys(root);
+  const formats = {};
+  let bytesBefore = 0;
+  let bytesAfter = 0;
+  let gpuBytesBefore = 0;
+  let gpuBytesAfter = 0;
+  let resized = 0;
+  let compressed = 0;
+  for (const [index, texture] of textures.entries()) {
+    const key = keys[index] ?? `texture#${String(index)}`;
+    const image = texture.getImage();
+    if (image === null) {
+      throw new Error(
+        `TN_ASSETS_MODEL_TEXTURE_MISSING: '${logicalPath}' declares texture '${key}' with no image data.`
+      );
+    }
+    if (texture.getMimeType() === "image/ktx2") {
+      const shape = imageShape(image, "image/ktx2");
+      bytesBefore += image.byteLength;
+      bytesAfter += image.byteLength;
+      const already = gpuBytes(shape.width, shape.height, "uastc");
+      gpuBytesBefore += already;
+      gpuBytesAfter += already;
+      continue;
+    }
+    const slots = listTextureSlots(texture);
+    let decoded;
+    try {
+      decoded = await decodeImageBytes(
+        Buffer.from(image.buffer, image.byteOffset, image.byteLength),
+        `${logicalPath}#${key}`
+      );
+    } catch (error) {
+      throw new Error(
+        `TN_ASSETS_MODEL_TEXTURE_UNDECODABLE: could not decode embedded texture '${key}' of '${logicalPath}': ${messageOf2(error)}`
+      );
+    }
+    const codec = chooseCodec2(slots, rgbaHasAlpha2(decoded.data), options);
+    bytesBefore += image.byteLength;
+    gpuBytesBefore += gpuBytes(decoded.width, decoded.height, "none");
+    if (codec === "none") {
+      bytesAfter += image.byteLength;
+      gpuBytesAfter += gpuBytes(decoded.width, decoded.height, "none");
+      formats[key] = "none";
+      continue;
+    }
+    const target = cappedSize(decoded.width, decoded.height, maxSize);
+    const srgb = getTextureColorSpace(texture) === "srgb";
+    let data = decoded.data;
+    if (target.width !== decoded.width || target.height !== decoded.height) {
+      data = resampleRgba(
+        decoded.data,
+        decoded.width,
+        decoded.height,
+        target.width,
+        target.height,
+        srgb
+      );
+      resized += 1;
+    }
+    if (target.width % BLOCK_SIZE2 !== 0 || target.height % BLOCK_SIZE2 !== 0) {
+      throw new Error(
+        `TN_ASSETS_MODEL_TEXTURE_BLOCK_SIZE: embedded texture '${key}' of '${logicalPath}' is ${String(target.width)}x${String(target.height)}, which is not a multiple of the ${String(BLOCK_SIZE2)}x${String(BLOCK_SIZE2)} block the ${codec} codec transcodes to; WebGPU rejects such a texture at draw time. Resize the source to a multiple of ${String(BLOCK_SIZE2)} inside the model, or declare an override with codec "none" for its slot.`
+      );
+    }
+    const normalMap = slots.some((slot) => NORMAL_SLOTS.has(slot));
+    const encoded = await encodeToKTX2(new Uint8Array([0]), {
+      generateMipmap: true,
+      imageDecoder: async () => ({ data, height: target.height, width: target.width }),
+      isPerceptual: srgb,
+      isSetKTX2SRGBTransferFunc: srgb,
+      ...codec === "uastc" ? { isUASTC: true, ...normalMap ? { isNormalMap: true } : {} } : { isUASTC: false, qualityLevel: quality }
+    });
+    const container = read(encoded);
+    if (container.levelCount < 2) {
+      throw new Error(
+        `TN_ASSETS_MIP_CHAIN_INCOMPLETE: embedded texture '${key}' of '${logicalPath}' encoded without a mip chain (${String(container.levelCount)} level(s)).`
+      );
+    }
+    texture.setImage(encoded).setMimeType("image/ktx2");
+    formats[key] = codec;
+    bytesAfter += encoded.byteLength;
+    gpuBytesAfter += gpuBytes(target.width, target.height, codec);
+    compressed += 1;
+  }
+  if (compressed > 0) {
+    document.createExtension(KHRTextureBasisu).setRequired(true);
+  }
+  return {
+    bytesAfter,
+    bytesBefore,
+    count: textures.length,
+    formats,
+    gpuBytesAfter,
+    gpuBytesBefore,
+    resized
+  };
+}
+
+// src/passes/model.ts
+var DRACO_EXTENSION = "KHR_draco_mesh_compression";
+var BBOX_TOLERANCE = 1e-3;
+var SIMPLIFY_BBOX_TOLERANCE = 0.01;
+var SIMPLIFY_RATIO_FLOOR = 0.5;
+var DEFAULT_SIMPLIFY_ERROR = 1e-3;
+var DEFAULT_POSITION_BITS = 16;
+var DEFAULT_NORMAL_BITS = 8;
+var DEFAULT_UV_BITS = 12;
+function peekExtensions(input) {
+  try {
+    const json = input.subarray(0, 4).toString("ascii") === "glTF" ? JSON.parse(
+      input.subarray(20, 20 + input.readUInt32LE(12)).toString("utf8")
+    ) : JSON.parse(input.toString("utf8"));
+    return /* @__PURE__ */ new Set([...json.extensionsUsed ?? [], ...json.extensionsRequired ?? []]);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function jsonOfGlb(binary) {
+  return JSON.parse(
+    binary.subarray(20, 20 + binary.readUInt32LE(12)).toString("utf8")
+  );
+}
+async function createIo() {
+  await MeshoptDecoder.ready;
+  const io = new NodeIO().registerExtensions([...ALL_EXTENSIONS, TNVirtualGeometry]).registerDependencies({ "meshopt.decoder": MeshoptDecoder });
+  return io;
+}
+async function readDocument2(input, logicalPath) {
+  let io = await createIo();
+  if (peekExtensions(input).has(DRACO_EXTENSION)) {
+    const { createDecoderModule } = await import('draco3dgltf');
+    io = io.registerDependencies({ "draco3d.decoder": await createDecoderModule() });
+  }
+  try {
+    const document = input.subarray(0, 4).toString("ascii") === "glTF" ? await io.readJSON(await io.binaryToJSON(input)) : await io.readJSON({
+      json: JSON.parse(input.toString("utf8")),
+      resources: {}
+    });
+    return document;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `TN_ASSETS_MODEL_UNREADABLE: could not parse '${logicalPath}' for the model pass: ${detail}. External buffer or image URIs are not supported; use a self-contained .glb.`
+    );
+  }
+}
+async function writeDocument(document, logicalPath) {
+  await MeshoptEncoder.ready;
+  const io = new NodeIO().registerExtensions([...ALL_EXTENSIONS, TNVirtualGeometry]).registerDependencies({ "meshopt.encoder": MeshoptEncoder });
+  try {
+    const buffer = Buffer.from(await io.writeBinary(document));
+    return { buffer, extensions: jsonOfGlb(buffer).extensionsUsed ?? [] };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`TN_ASSETS_MODEL_WRITE_FAILED: could not write '${logicalPath}': ${detail}`);
+  }
+}
+function primitiveTriangles2(primitive) {
+  const drawn = primitive.getIndices()?.getCount() ?? primitive.getAttribute("POSITION")?.getCount() ?? 0;
+  return Math.floor(drawn / 3);
+}
+function decodeElement(accessor, index) {
+  const array = accessor.getArray();
+  const base = index * accessor.getElementSize();
+  const x = array[base] ?? 0;
+  const y = array[base + 1] ?? 0;
+  const z = array[base + 2] ?? 0;
+  if (!accessor.getNormalized()) return [x, y, z];
+  switch (accessor.getComponentType()) {
+    case Accessor.ComponentType.BYTE:
+      return [Math.max(x / 127, -1), Math.max(y / 127, -1), Math.max(z / 127, -1)];
+    case Accessor.ComponentType.UNSIGNED_BYTE:
+      return [x / 255, y / 255, z / 255];
+    case Accessor.ComponentType.SHORT:
+      return [Math.max(x / 32767, -1), Math.max(y / 32767, -1), Math.max(z / 32767, -1)];
+    case Accessor.ComponentType.UNSIGNED_SHORT:
+      return [x / 65535, y / 65535, z / 65535];
+    default:
+      return [x, y, z];
+  }
+}
+function normalizedWeightScale(accessor) {
+  switch (accessor.getComponentType()) {
+    case Accessor.ComponentType.BYTE:
+      return 1 / 127;
+    case Accessor.ComponentType.UNSIGNED_BYTE:
+      return 1 / 255;
+    case Accessor.ComponentType.SHORT:
+      return 1 / 32767;
+    case Accessor.ComponentType.UNSIGNED_SHORT:
+      return 1 / 65535;
+    default:
+      return 1;
+  }
+}
+function evaluateVertex(position, index, joints, weights, jointMatrices, fallbackMatrix) {
+  const [x, y, z] = decodeElement(position, index);
+  if (jointMatrices === void 0 || joints === null || weights === null) {
+    return transformPoint(fallbackMatrix, x, y, z);
+  }
+  const jointArray = joints.getArray();
+  const weightArray = weights.getArray();
+  const weightScale = weights.getNormalized() ? normalizedWeightScale(weights) : 1;
+  let wx = 0;
+  let wy = 0;
+  let wz = 0;
+  for (let slot = 0; slot < 4; slot += 1) {
+    const base = index * 4 + slot;
+    const weight = (weightArray[base] ?? 0) * weightScale;
+    if (weight === 0) continue;
+    const matrix = jointMatrices[jointArray[base] ?? 0];
+    if (matrix === void 0) continue;
+    const point = transformPoint(matrix, x, y, z);
+    wx += point[0] * weight;
+    wy += point[1] * weight;
+    wz += point[2] * weight;
+  }
+  if (wx === 0 && wy === 0 && wz === 0) return transformPoint(fallbackMatrix, x, y, z);
+  return [wx, wy, wz];
+}
+function transformPoint(m, x, y, z) {
+  const c = (index) => m[index] ?? 0;
+  return [
+    c(0) * x + c(4) * y + c(8) * z + c(12),
+    c(1) * x + c(5) * y + c(9) * z + c(13),
+    c(2) * x + c(6) * y + c(10) * z + c(14)
+  ];
+}
+function multiplyMatrices(a, b) {
+  const out = new Array(16);
+  for (let column = 0; column < 4; column += 1) {
+    for (let row = 0; row < 4; row += 1) {
+      const c = (index) => a[index] ?? 0;
+      const d = (index) => b[index] ?? 0;
+      out[column * 4 + row] = c(row) * d(column * 4) + c(4 + row) * d(column * 4 + 1) + c(8 + row) * d(column * 4 + 2) + c(12 + row) * d(column * 4 + 3);
+    }
+  }
+  return out;
+}
+var IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+function reachableStats(root) {
+  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;
+  let triangles = 0;
+  let vertices = 0;
+  const skins = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    if (visited.has(node)) return;
+    visited.add(node);
+    const skin = node.getSkin();
+    if (skin !== null) skins.add(skin);
+    const mesh = node.getMesh();
+    if (mesh !== null) {
+      const worldMatrix = node.getWorldMatrix();
+      let jointMatrices;
+      if (skin !== null) {
+        const inverseBinds = skin.getInverseBindMatrices();
+        jointMatrices = skin.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_MATRIX;
+          return multiplyMatrices(jointWorld, ibm);
+        });
+      }
+      for (const primitive of mesh.listPrimitives()) {
+        triangles += primitiveTriangles2(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);
+        }
+      }
+    }
+    node.listChildren().forEach(walk);
+  };
+  root.listScenes().flatMap((scene) => scene.listChildren()).forEach(walk);
+  let joints = 0;
+  const seenJoints = /* @__PURE__ */ new Set();
+  for (const skin of skins) {
+    for (const joint of skin.listJoints()) {
+      if (seenJoints.has(joint)) continue;
+      seenJoints.add(joint);
+      joints += 1;
+    }
+  }
+  const finite = Number.isFinite(minX) && Number.isFinite(maxZ);
+  return {
+    boundingBox: finite ? { max: [maxX, maxY, maxZ], min: [minX, minY, minZ] } : void 0,
+    // A clip survives when something reachable is still animated by it.
+    clips: root.listAnimations().filter(
+      (animation) => animation.listChannels().some((channel) => {
+        const targetNode = channel.getTargetNode();
+        return targetNode !== null && visited.has(targetNode);
+      })
+    ).length,
+    joints,
+    triangles,
+    vertices
+  };
+}
+function jointComponentSizes(root) {
+  let joints = 0;
+  let weights = 0;
+  for (const mesh of root.listMeshes()) {
+    for (const primitive of mesh.listPrimitives()) {
+      const jointsAccessor = primitive.getAttribute("JOINTS_0");
+      if (jointsAccessor !== null) {
+        const size = jointsAccessor.getComponentSize();
+        joints = joints === 0 ? size : Math.min(joints, size);
+      }
+      const weightsAccessor = primitive.getAttribute("WEIGHTS_0");
+      if (weightsAccessor !== null) {
+        const size = weightsAccessor.getComponentSize();
+        weights = weights === 0 ? size : Math.min(weights, size);
+      }
+    }
+  }
+  return { joints, weights };
+}
+function bboxDrift(left, right) {
+  const leftBox = left.boundingBox;
+  const rightBox = right.boundingBox;
+  if (leftBox === void 0 || rightBox === void 0) {
+    return leftBox === rightBox ? 0 : void 0;
+  }
+  const component = (box, corner, axis) => box?.[corner][axis] ?? 0;
+  const scale2 = Math.max(
+    ...[0, 1, 2].map((axis) => component(leftBox, "max", axis) - component(leftBox, "min", axis)),
+    1e-6
+  );
+  return Math.max(
+    ...[0, 1, 2].map(
+      (axis) => Math.max(
+        Math.abs(component(leftBox, "min", axis) - component(rightBox, "min", axis)),
+        Math.abs(component(leftBox, "max", axis) - component(rightBox, "max", axis))
+      ) / scale2
+    )
+  );
+}
+function assertNoDrift(source, output, logicalPath) {
+  const failures = [];
+  if (source.triangles !== output.triangles) {
+    failures.push(`triangles ${source.triangles} -> ${output.triangles}`);
+  }
+  if (source.vertices !== output.vertices) {
+    failures.push(`vertices ${source.vertices} -> ${output.vertices}`);
+  }
+  if (source.joints !== output.joints) {
+    failures.push(`joints ${source.joints} -> ${output.joints}`);
+  }
+  if (source.clips !== output.clips) {
+    failures.push(`animation clips ${source.clips} -> ${output.clips}`);
+  }
+  const bbox = bboxDrift(source, output);
+  if (bbox === void 0) {
+    failures.push("bounding box lost");
+  } else if (bbox > BBOX_TOLERANCE) {
+    failures.push(
+      `bounding box drifted ${(bbox * 100).toFixed(3)}% (tolerance ${(BBOX_TOLERANCE * 100).toFixed(1)}%)`
+    );
+  }
+  if (failures.length > 0) {
+    throw new Error(
+      `TN_ASSETS_MODEL_DRIFT: self-verification failed for '${logicalPath}': ${failures.join("; ")}.`
+    );
+  }
+}
+function assertSimplifiedWithinBounds(source, output, ratio, logicalPath) {
+  const failures = [];
+  if (source.joints !== output.joints) {
+    failures.push(`joints ${source.joints} -> ${output.joints}`);
+  }
+  if (source.clips !== output.clips) {
+    failures.push(`animation clips ${source.clips} -> ${output.clips}`);
+  }
+  if (output.triangles > source.triangles) {
+    failures.push(`triangles grew ${source.triangles} -> ${output.triangles}`);
+  }
+  const floor = Math.floor(source.triangles * ratio * SIMPLIFY_RATIO_FLOOR);
+  if (output.triangles < floor) {
+    failures.push(
+      `triangles ${source.triangles} -> ${output.triangles}, below the ${String(floor)} floor for ratio ${String(ratio)}`
+    );
+  }
+  const bbox = bboxDrift(source, output);
+  if (bbox === void 0) {
+    failures.push("bounding box lost");
+  } else if (bbox > SIMPLIFY_BBOX_TOLERANCE) {
+    failures.push(
+      `bounding box drifted ${(bbox * 100).toFixed(3)}% (simplify tolerance ${(SIMPLIFY_BBOX_TOLERANCE * 100).toFixed(1)}%)`
+    );
+  }
+  if (failures.length > 0) {
+    throw new Error(
+      `TN_ASSETS_MODEL_SIMPLIFY_DRIFT: self-verification failed for '${logicalPath}': ${failures.join("; ")}.`
+    );
+  }
+}
+function snapPositions(root, bits) {
+  const levels = 2 ** bits - 1;
+  for (const mesh of root.listMeshes()) {
+    for (const primitive of mesh.listPrimitives()) {
+      const position = primitive.getAttribute("POSITION");
+      if (position === null || position.getNormalized()) continue;
+      const array = position.getArray();
+      const min = position.getMin([0, 0, 0]);
+      const max = position.getMax([0, 0, 0]);
+      const stride = position.getElementSize();
+      const output = new Float32Array(array.length);
+      for (let index = 0; index < position.getCount(); index += 1) {
+        for (let axis = 0; axis < stride; axis += 1) {
+          const source = array[index * stride + axis] ?? 0;
+          const low = min[axis] ?? 0;
+          const high = max[axis] ?? 0;
+          const span = high - low;
+          const fraction = span === 0 ? 0 : (source - low) / span;
+          output[index * stride + axis] = low + Math.round(fraction * levels) / levels * span;
+        }
+      }
+      position.setArray(output);
+    }
+  }
+}
+function modelPass(options = {}) {
+  return {
+    configuration: {
+      passes: {
+        dedup: options.passes?.dedup ?? true,
+        meshopt: options.passes?.meshopt ?? true,
+        prune: options.passes?.prune ?? true,
+        quantize: options.passes?.quantize ?? true,
+        reorder: options.passes?.reorder ?? true
+      },
+      quantize: {
+        normalBits: options.quantize?.normalBits ?? DEFAULT_NORMAL_BITS,
+        positionBits: options.quantize?.positionBits ?? DEFAULT_POSITION_BITS,
+        uvBits: options.quantize?.uvBits ?? DEFAULT_UV_BITS
+      },
+      // Part of the compile cache key: change the cap or a codec and stale outputs must not
+      // be re-served.
+      simplify: options.simplify ?? null,
+      // `"none"` and "absent" are different cache keys on purpose: absent bakes with defaults.
+      virtual: options.virtual === "none" ? "none" : {
+        ...options.virtual === void 0 ? {} : options.virtual,
+        bakeVersion: VIRTUAL_BAKE_VERSION
+      },
+      textures: options.textures === "none" ? "none" : {
+        maxSize: options.textures?.maxSize ?? null,
+        overrides: options.textures?.overrides ?? [],
+        quality: options.textures?.quality ?? null
+      }
+    },
+    name: "model",
+    apply: async (input, logicalPath) => {
+      if (classify(logicalPath) !== "model") return input;
+      const passes = options.passes ?? {};
+      const enabled = {
+        dedup: passes.dedup ?? true,
+        meshopt: passes.meshopt ?? true,
+        prune: passes.prune ?? true,
+        quantize: passes.quantize ?? true,
+        reorder: passes.reorder ?? true
+      };
+      const textureOptions = options.textures === "none" ? void 0 : options.textures ?? {};
+      const virtualOptions = options.virtual === "none" ? void 0 : options.virtual ?? {};
+      const geometryActive = Object.values(enabled).some(Boolean) || options.simplify !== void 0 || virtualOptions !== void 0;
+      if (!geometryActive && textureOptions === void 0) return input;
+      const document = await readDocument2(input, logicalPath);
+      if (!geometryActive && document.getRoot().listTextures().length === 0) return input;
+      for (const extension of document.getRoot().listExtensionsUsed()) {
+        if (extension.extensionName === DRACO_EXTENSION) extension.dispose();
+      }
+      const source = reachableStats(document.getRoot());
+      const jointFloor = jointComponentSizes(document.getRoot());
+      if (enabled.dedup) await dedup()(document);
+      if (enabled.prune)
+        await prune({ keepAttributes: options.preserveLightmapUv === true })(document);
+      if (options.simplify !== void 0) {
+        await MeshoptSimplifier.ready;
+        await simplify({
+          error: options.simplify.error ?? DEFAULT_SIMPLIFY_ERROR,
+          ratio: options.simplify.ratio,
+          simplifier: MeshoptSimplifier
+        })(document);
+      }
+      if (enabled.reorder || enabled.meshopt) await MeshoptEncoder.ready;
+      if (enabled.reorder) await reorder({ encoder: MeshoptEncoder })(document);
+      const virtual = virtualOptions === void 0 ? void 0 : await bakeVirtualGeometry(document, virtualOptions);
+      if (enabled.quantize) {
+        const requestedBits = options.quantize?.positionBits ?? DEFAULT_POSITION_BITS;
+        if (requestedBits < 8) snapPositions(document.getRoot(), requestedBits);
+        await quantize({
+          quantizeColor: 8,
+          quantizeNormal: options.quantize?.normalBits ?? DEFAULT_NORMAL_BITS,
+          quantizePosition: Math.max(requestedBits, 8),
+          quantizeTexcoord: options.quantize?.uvBits ?? DEFAULT_UV_BITS,
+          pattern: /^(?!JOINTS|WEIGHTS)/u,
+          normalizeWeights: false
+        })(document);
+      }
+      const sourceTextures = textureBindings(document.getRoot());
+      const embeddedTextures = textureOptions === void 0 ? void 0 : await compressEmbeddedTextures(document, logicalPath, textureOptions);
+      if (enabled.meshopt) {
+        document.createExtension(EXTMeshoptCompression).setRequired(true).setEncoderOptions({ method: EXTMeshoptCompression.EncoderMethod.QUANTIZE });
+      }
+      const narrowed = jointComponentSizes(document.getRoot());
+      const narrowedSemantics = [];
+      if (jointFloor.joints > narrowed.joints) {
+        narrowedSemantics.push(
+          `JOINTS (${String(jointFloor.joints)} -> ${String(narrowed.joints)} bytes)`
+        );
+      }
+      if (jointFloor.weights > narrowed.weights) {
+        narrowedSemantics.push(
+          `WEIGHTS (${String(jointFloor.weights)} -> ${String(narrowed.weights)} bytes)`
+        );
+      }
+      if (narrowedSemantics.length > 0) {
+        throw new Error(
+          `TN_ASSETS_MODEL_JOINT_QUANTIZED: '${logicalPath}' narrowed joint data storage for ${narrowedSemantics.join(", ")} per component; joint data is never quantized below the source declaration.`
+        );
+      }
+      const { buffer, extensions } = await writeDocument(document, logicalPath);
+      const verified = (await readDocument2(buffer, logicalPath)).getRoot();
+      const output = reachableStats(verified);
+      if (options.simplify === void 0) {
+        assertNoDrift(source, output, logicalPath);
+      } else {
+        assertSimplifiedWithinBounds(source, output, options.simplify.ratio, logicalPath);
+      }
+      assertNoTextureDrift(sourceTextures, textureBindings(verified), logicalPath);
+      const entry = {
+        ...embeddedTextures === void 0 ? {} : { embeddedTextures },
+        extensions: [...extensions].sort(),
+        ...options.simplify === void 0 ? {} : {
+          simplify: {
+            achievedRatio: source.triangles === 0 ? 1 : output.triangles / source.triangles,
+            error: options.simplify.error ?? DEFAULT_SIMPLIFY_ERROR,
+            requestedRatio: options.simplify.ratio,
+            trianglesAfter: output.triangles,
+            trianglesBefore: source.triangles
+          }
+        },
+        triangles: output.triangles,
+        vertices: output.vertices,
+        ...virtual === void 0 ? {} : { virtual }
+      };
+      return { buffer, entry: { ...entry } };
+    }
+  };
+}
+
+// src/report.ts
+function formatTextureSizes(rows) {
+  if (rows.length === 0) return [];
+  const lines = rows.map(
+    (row) => `texture ${row.logicalPath}${row.format === void 0 ? "" : ` (${row.format})`}: ${row.before} -> ${row.after} bytes ${deltaLabel(row.before, row.after)}`
+  );
+  const before = rows.reduce((total, row) => total + row.before, 0);
+  const after = rows.reduce((total, row) => total + row.after, 0);
+  lines.push(`textures total: ${before} -> ${after} bytes ${deltaLabel(before, after)}`);
+  return lines;
+}
+function simplifyLine(row) {
+  const simplify2 = row.simplify;
+  if (simplify2 === void 0) return [];
+  const kept = simplify2.achievedRatio * 100;
+  const requested = simplify2.requestedRatio * 100;
+  const short = simplify2.achievedRatio > simplify2.requestedRatio * 1.01 ? ` \u2014 the error tolerance ${simplify2.error} stopped it short` : "";
+  return [
+    `simplified ${row.logicalPath}: ${simplify2.trianglesBefore} -> ${simplify2.trianglesAfter} triangles (${kept.toFixed(1)}% kept, requested ${requested.toFixed(1)}%)${short}`
+  ];
+}
+function virtualLine(row) {
+  const virtual = row.virtual;
+  if (virtual === void 0) return [];
+  if (virtual.primitives === 0)
+    return [
+      `virtual ${row.logicalPath}: no primitive was dense enough to cluster (${virtual.skipped} skipped)`
+    ];
+  const warning = virtual.stopReason === "cap" ? " \u2014 a DAG hit the level cap and is unfinished" : "";
+  return [
+    `virtual ${row.logicalPath}: ${virtual.clusters} cluster(s) over ${virtual.levels} level(s) on ${virtual.primitives} primitive(s), ${virtual.skipped} skipped, ${virtual.payloadBytes} payload bytes, bake ${virtual.bakeSeconds.toFixed(1)} s, stopped at ${virtual.stopReason}${warning}`
+  ];
+}
+function extensionLabel(row) {
+  const extensions = row.extensions ?? [];
+  return extensions.length === 0 ? "" : ` (${extensions.join(", ")})`;
+}
+function formatModelSizes(rows) {
+  if (rows.length === 0) return [];
+  const lines = rows.flatMap((row) => {
+    const geometry = row.triangles === void 0 ? "" : `, ${String(row.triangles)} triangle(s)`;
+    const model = `model ${row.logicalPath}${extensionLabel(row)}: ${row.before} -> ${row.after} bytes ${deltaLabel(row.before, row.after)}${geometry}`;
+    const embedded = row.embeddedTextures;
+    const images = embedded === void 0 ? [] : [
+      `embedded textures ${row.logicalPath}: ${embedded.count} image(s), ${embedded.bytesBefore} -> ${embedded.bytesAfter} bytes ${deltaLabel(embedded.bytesBefore, embedded.bytesAfter)}, GPU ${embedded.gpuBytesBefore} -> ${embedded.gpuBytesAfter} bytes ${deltaLabel(embedded.gpuBytesBefore, embedded.gpuBytesAfter)}, ${embedded.resized} resized`
+    ];
+    const reduced = [...simplifyLine(row), ...virtualLine(row)];
+    if (row.lightmap === void 0) return [model, ...reduced, ...images];
+    const map = row.lightmap;
+    return [
+      model,
+      ...reduced,
+      ...images,
+      `lightmap ${row.logicalPath}: atlas ${map.atlasWidth}x${map.atlasHeight}, ${map.validTexels} valid + ${map.dilatedTexels} dilated texels, ${map.occludedTexels} occluded, ${map.bytesBefore} -> ${map.bytesAfter} bytes ${deltaLabel(map.bytesBefore, map.bytesAfter)}, bake ${map.bakeMs.toFixed(1)} ms`
+    ];
+  });
+  const before = rows.reduce((total, row) => total + row.before, 0);
+  const after = rows.reduce((total, row) => total + row.after, 0);
+  lines.push(`models total: ${before} -> ${after} bytes ${deltaLabel(before, after)}`);
+  return lines;
+}
+function deltaLabel(before, after) {
+  if (before <= 0) return `(${after} bytes)`;
+  const percent = ((1 - after / before) * 100).toFixed(1);
+  return `(-${percent}%)`;
+}
+
+// src/compile.ts
+var MANIFEST_NAME = "assets.manifest.json";
+var DEFAULT_SOURCE = "assets";
+var DEFAULT_OUTPUT = "public";
+var BASIS_DIRECTORY = "basis";
+var BASISU_EXTENSION = "KHR_texture_basisu";
+var PIPELINE_VERSION = 7;
+var KIND_BY_EXTENSION = {
+  glb: "model",
+  gltf: "model",
+  jpeg: "texture",
+  jpg: "texture",
+  mp3: "audio",
+  ogg: "audio",
+  png: "texture",
+  wav: "audio",
+  webp: "texture"
+};
+var CODECS = ["etc1s", "none", "uastc"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function simplifyRow(value) {
+  if (!isRecord(value)) return void 0;
+  const keys = [
+    "achievedRatio",
+    "error",
+    "requestedRatio",
+    "trianglesAfter",
+    "trianglesBefore"
+  ];
+  if (keys.some((key) => typeof value[key] !== "number")) return void 0;
+  return {
+    achievedRatio: value.achievedRatio,
+    error: value.error,
+    requestedRatio: value.requestedRatio,
+    trianglesAfter: value.trianglesAfter,
+    trianglesBefore: value.trianglesBefore
+  };
+}
+function embeddedTextureRow(value) {
+  if (!isRecord(value)) return void 0;
+  const numbers = [
+    "bytesAfter",
+    "bytesBefore",
+    "count",
+    "gpuBytesAfter",
+    "gpuBytesBefore",
+    "resized"
+  ];
+  if (numbers.some((key) => typeof value[key] !== "number")) return void 0;
+  const formats = isRecord(value.formats) ? Object.fromEntries(
+    Object.entries(value.formats).filter(([, codec]) => typeof codec === "string")
+  ) : void 0;
+  return {
+    bytesAfter: value.bytesAfter,
+    bytesBefore: value.bytesBefore,
+    count: value.count,
+    ...formats === void 0 ? {} : { formats },
+    gpuBytesAfter: value.gpuBytesAfter,
+    gpuBytesBefore: value.gpuBytesBefore,
+    resized: value.resized
+  };
+}
+function nonEmptyString(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`TN_ASSETS_CONFIG_INVALID: ${label} must be a non-empty string.`);
+  }
+  return value;
+}
+function messageOf3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var TARGET_KEYS = ["maxMaterials", "maxTriangles", "maxTextureDimension"];
+function positiveTarget(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(
+      `TN_ASSETS_CONFIG_INVALID: assets.targets.${label} must be a positive integer.`
+    );
+  }
+  return value;
+}
+function validateTargets(raw) {
+  if (!isRecord(raw)) {
+    throw new Error("TN_ASSETS_CONFIG_INVALID: assets.targets must be an object.");
+  }
+  for (const key of Object.keys(raw)) {
+    if (!TARGET_KEYS.includes(key)) {
+      throw new Error(`TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.targets.${key} is not recognised.`);
+    }
+  }
+  return {
+    ...raw.maxMaterials === void 0 ? {} : { maxMaterials: positiveTarget(raw.maxMaterials, "maxMaterials") },
+    ...raw.maxTriangles === void 0 ? {} : { maxTriangles: positiveTarget(raw.maxTriangles, "maxTriangles") },
+    ...raw.maxTextureDimension === void 0 ? {} : { maxTextureDimension: positiveTarget(raw.maxTextureDimension, "maxTextureDimension") }
+  };
+}
+function textureQuality(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > 255) {
+    throw new Error(`TN_ASSETS_CONFIG_INVALID: ${label} must be an integer between 1 and 255.`);
+  }
+  return value;
+}
+function validateTextureOverrides(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("TN_ASSETS_CONFIG_INVALID: assets.textures.overrides must be an array.");
+  }
+  return raw.map((item, index) => {
+    if (!isRecord(item)) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_INVALID: assets.textures.overrides[${String(index)}] must be an object.`
+      );
+    }
+    for (const key of Object.keys(item)) {
+      if (key !== "glob" && key !== "codec" && key !== "quality") {
+        throw new Error(
+          `TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.textures.overrides.${key} is not recognised.`
+        );
+      }
+    }
+    const glob = nonEmptyString(item.glob, `assets.textures.overrides[${String(index)}].glob`);
+    if (!CODECS.includes(item.codec)) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_INVALID: assets.textures.overrides[${String(index)}].codec must be one of ${CODECS.join(", ")}; received '${String(item.codec)}'.`
+      );
+    }
+    return {
+      codec: item.codec,
+      glob,
+      ...item.quality === void 0 ? {} : {
+        quality: textureQuality(
+          item.quality,
+          `assets.textures.overrides[${String(index)}].quality`
+        )
+      }
+    };
+  });
+}
+function parseTexturesConfig(raw) {
+  if (raw === void 0) return {};
+  if (raw === "none") return void 0;
+  if (!isRecord(raw)) {
+    throw new Error('TN_ASSETS_CONFIG_INVALID: assets.textures must be "none" or an object.');
+  }
+  for (const key of Object.keys(raw)) {
+    if (key !== "quality" && key !== "overrides") {
+      throw new Error(`TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.textures.${key} is not recognised.`);
+    }
+  }
+  return {
+    ...raw.quality === void 0 ? {} : { quality: textureQuality(raw.quality, "assets.textures.quality") },
+    ...raw.overrides === void 0 ? {} : { overrides: validateTextureOverrides(raw.overrides) }
+  };
+}
+function parseModelsConfig(raw) {
+  if (raw === void 0) return {};
+  if (raw === "none") return void 0;
+  if (!isRecord(raw)) {
+    throw new Error('TN_ASSETS_CONFIG_INVALID: assets.models must be "none" or an object.');
+  }
+  const allowed = ["lightmap", "passes", "quantize", "simplify", "textures", "virtual"];
+  for (const key of Object.keys(raw)) {
+    if (!allowed.includes(key)) {
+      throw new Error(`TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.models.${key} is not recognised.`);
+    }
+  }
+  const passes = raw.passes === void 0 ? {} : parseModelPasses(raw.passes);
+  const quantize2 = raw.quantize === void 0 ? {} : parseModelQuantize(raw.quantize);
+  const lightmap = raw.lightmap === void 0 ? void 0 : parseLightmap(raw.lightmap);
+  const simplify2 = raw.simplify === void 0 ? void 0 : parseModelSimplify(raw.simplify);
+  const textures = raw.textures === void 0 ? void 0 : parseModelTextures(raw.textures);
+  const virtual = raw.virtual === void 0 ? void 0 : parseModelVirtual(raw.virtual);
+  return {
+    ...lightmap === void 0 ? {} : { lightmap },
+    ...Object.keys(passes).length === 0 ? {} : { passes },
+    ...Object.keys(quantize2).length === 0 ? {} : { quantize: quantize2 },
+    ...simplify2 === void 0 ? {} : { simplify: simplify2 },
+    ...textures === void 0 ? {} : { textures },
+    ...virtual === void 0 ? {} : { virtual }
+  };
+}
+var MODEL_TEXTURE_KEYS = ["maxSize", "overrides", "quality"];
+function positiveInteger2(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(
+      `TN_ASSETS_CONFIG_INVALID: assets.models.textures.${label} must be a positive integer.`
+    );
+  }
+  return value;
+}
+function parseModelTextures(raw) {
+  if (raw === "none") return "none";
+  if (!isRecord(raw)) {
+    throw new Error(
+      'TN_ASSETS_CONFIG_INVALID: assets.models.textures must be "none" or an object.'
+    );
+  }
+  for (const key of Object.keys(raw)) {
+    if (!MODEL_TEXTURE_KEYS.includes(key)) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.models.textures.${key} is not recognised.`
+      );
+    }
+  }
+  return {
+    ...raw.maxSize === void 0 ? {} : { maxSize: positiveInteger2(raw.maxSize, "maxSize") },
+    ...raw.overrides === void 0 ? {} : { overrides: validateModelTextureOverrides(raw.overrides) },
+    ...raw.quality === void 0 ? {} : { quality: textureQuality(raw.quality, "assets.models.textures.quality") }
+  };
+}
+function validateModelTextureOverrides(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("TN_ASSETS_CONFIG_INVALID: assets.models.textures.overrides must be an array.");
+  }
+  return raw.map((item, index) => {
+    const label = `assets.models.textures.overrides[${String(index)}]`;
+    if (!isRecord(item)) throw new Error(`TN_ASSETS_CONFIG_INVALID: ${label} must be an object.`);
+    for (const key of Object.keys(item)) {
+      if (key !== "slot" && key !== "codec") {
+        throw new Error(
+          `TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.models.textures.overrides.${key} is not recognised.`
+        );
+      }
+    }
+    if (!CODECS.includes(item.codec)) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_INVALID: ${label}.codec must be one of ${CODECS.join(", ")}; received '${String(item.codec)}'.`
+      );
+    }
+    return {
+      codec: item.codec,
+      slot: nonEmptyString(item.slot, `${label}.slot`)
+    };
+  });
+}
+function parseModelSimplify(raw) {
+  if (!isRecord(raw)) {
+    throw new Error("TN_ASSETS_CONFIG_INVALID: assets.models.simplify must be an object.");
+  }
+  for (const key of Object.keys(raw)) {
+    if (key !== "error" && key !== "ratio") {
+      throw new Error(
+        `TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.models.simplify.${key} is not recognised.`
+      );
+    }
+  }
+  if (typeof raw.ratio !== "number" || !(raw.ratio > 0) || raw.ratio > 1) {
+    throw new Error(
+      "TN_ASSETS_CONFIG_INVALID: assets.models.simplify.ratio must be a number greater than 0 and at most 1."
+    );
+  }
+  if (raw.error !== void 0 && (typeof raw.error !== "number" || raw.error < 0)) {
+    throw new Error(
+      "TN_ASSETS_CONFIG_INVALID: assets.models.simplify.error must be a non-negative number."
+    );
+  }
+  return {
+    ratio: raw.ratio,
+    ...raw.error === void 0 ? {} : { error: raw.error }
+  };
+}
+function parseModelVirtual(raw) {
+  if (raw === "none") return "none";
+  if (!isRecord(raw)) {
+    throw new Error('TN_ASSETS_CONFIG_INVALID: assets.models.virtual must be "none" or an object.');
+  }
+  const counts = ["groupSize", "maxTriangles", "minSourceTriangles", "minTriangles"];
+  for (const key of Object.keys(raw)) {
+    if (key !== "simplifyRatio" && !counts.includes(key)) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.models.virtual.${key} is not recognised.`
+      );
+    }
+  }
+  const parsed = {};
+  for (const key of counts) {
+    const value = raw[key];
+    if (value === void 0) continue;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_INVALID: assets.models.virtual.${key} must be a positive integer.`
+      );
+    }
+    parsed[key] = value;
+  }
+  if (raw.simplifyRatio !== void 0) {
+    if (typeof raw.simplifyRatio !== "number" || !(raw.simplifyRatio > 0) || !(raw.simplifyRatio < 1))
+      throw new Error(
+        "TN_ASSETS_CONFIG_INVALID: assets.models.virtual.simplifyRatio must be a number between 0 and 1, exclusive."
+      );
+    parsed.simplifyRatio = raw.simplifyRatio;
+  }
+  return parsed;
+}
+function parseLightmap(raw) {
+  if (!isRecord(raw)) {
+    throw new Error("TN_ASSETS_CONFIG_INVALID: assets.models.lightmap must be an object.");
+  }
+  for (const key of Object.keys(raw)) {
+    if (key !== "atlasSize" && key !== "padding") {
+      throw new Error(
+        `TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.models.lightmap.${key} is not recognised.`
+      );
+    }
+  }
+  if (!Number.isSafeInteger(raw.atlasSize) || raw.atlasSize <= 0) {
+    throw new Error(
+      "TN_ASSETS_CONFIG_INVALID: assets.models.lightmap.atlasSize must be a positive integer."
+    );
+  }
+  if (!Number.isSafeInteger(raw.padding) || raw.padding <= 0) {
+    throw new Error(
+      "TN_ASSETS_CONFIG_INVALID: assets.models.lightmap.padding must be a positive integer."
+    );
+  }
+  return { atlasSize: raw.atlasSize, padding: raw.padding };
+}
+var MODEL_PASS_KEYS = ["dedup", "meshopt", "prune", "quantize", "reorder"];
+function parseModelPasses(raw) {
+  if (!isRecord(raw)) {
+    throw new Error("TN_ASSETS_CONFIG_INVALID: assets.models.passes must be an object.");
+  }
+  for (const key of Object.keys(raw)) {
+    if (!MODEL_PASS_KEYS.includes(key)) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.models.passes.${key} is not recognised.`
+      );
+    }
+    if (typeof raw[key] !== "boolean") {
+      throw new Error(`TN_ASSETS_CONFIG_INVALID: assets.models.passes.${key} must be a boolean.`);
+    }
+  }
+  return raw;
+}
+var MODEL_QUANTIZE_KEYS = ["normalBits", "positionBits", "uvBits"];
+function parseModelQuantize(raw) {
+  if (!isRecord(raw)) {
+    throw new Error("TN_ASSETS_CONFIG_INVALID: assets.models.quantize must be an object.");
+  }
+  for (const key of Object.keys(raw)) {
+    if (!MODEL_QUANTIZE_KEYS.includes(key)) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.models.quantize.${key} is not recognised.`
+      );
+    }
+    if (typeof raw[key] !== "number" || !Number.isSafeInteger(raw[key]) || raw[key] < 1 || raw[key] > 16) {
+      throw new Error(
+        `TN_ASSETS_CONFIG_INVALID: assets.models.quantize.${key} must be an integer between 1 and 16 bits.`
+      );
+    }
+  }
+  return raw;
+}
+function resolveLayout(cwd, options) {
+  const config = options.config ?? {};
+  if (!isRecord(config)) {
+    throw new Error("TN_ASSETS_CONFIG_INVALID: assets must be an object when declared.");
+  }
+  for (const key of Object.keys(config)) {
+    if (key !== "source" && key !== "output" && key !== "targets" && key !== "textures" && key !== "models") {
+      throw new Error(`TN_ASSETS_CONFIG_UNKNOWN_KEY: assets.${key} is not recognised.`);
+    }
+  }
+  const source = options.source ?? config.source ?? DEFAULT_SOURCE;
+  const output = options.output ?? config.output ?? DEFAULT_OUTPUT;
+  const sourceRoot = path.resolve(cwd, nonEmptyString(source, "assets.source"));
+  const outputRoot = path.resolve(cwd, nonEmptyString(output, "assets.output"));
+  const nested = sourceRoot === outputRoot || sourceRoot.startsWith(`${outputRoot}${path.sep}`) || outputRoot.startsWith(`${sourceRoot}${path.sep}`);
+  if (nested) {
+    throw new Error(
+      `TN_ASSETS_OVERLAP: source '${sourceRoot}' and output '${outputRoot}' must be disjoint directories.`
+    );
+  }
+  const textures = parseTexturesConfig(config.textures);
+  const models = parseModelsConfig(config.models);
+  const lightmap = models?.lightmap;
+  const builtinPasses = options.passes === void 0 ? [
+    ...textures !== void 0 ? [texturePass(textures)] : [],
+    ...lightmap !== void 0 ? [lightmapPass(lightmap)] : [],
+    ...models !== void 0 ? [modelPass({ ...models, preserveLightmapUv: lightmap !== void 0 })] : []
+  ] : [];
+  return {
+    outputRoot,
+    passes: [...builtinPasses, ...options.passes ?? []],
+    sourceRoot,
+    targets: config.targets === void 0 ? {} : validateTargets(config.targets),
+    texturesActive: textures !== void 0 && options.passes === void 0
+  };
+}
+async function scanDirectory(sourceRoot, directory) {
+  const entries = await readdir(path.join(sourceRoot, directory), { withFileTypes: true });
+  entries.sort((left, right) => left.name < right.name ? -1 : 1);
+  const files = [];
+  const subdirectories = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const logical = directory === "" ? entry.name : `${directory}/${entry.name}`;
+    if (entry.isDirectory()) {
+      subdirectories.push(logical);
+      continue;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink()) {
+      throw new Error(
+        `TN_ASSETS_INPUT_UNREADABLE: '${logical}' under '${sourceRoot}' is neither a file nor a directory.`
+      );
+    }
+    files.push(logical);
+  }
+  return { files, subdirectories };
+}
+async function walkSources(sourceRoot) {
+  const logicalPaths = [];
+  const seenFiles = /* @__PURE__ */ new Set();
+  const visitedDirectories = /* @__PURE__ */ new Set();
+  const queue = [""];
+  while (queue.length > 0) {
+    const directory = queue.shift();
+    if (directory === void 0) break;
+    const canonical = await realpath(path.join(sourceRoot, directory));
+    if (visitedDirectories.has(canonical)) {
+      throw new Error(
+        `TN_ASSETS_DUPLICATE_LOGICAL_PATH: '${directory}' resolves to an already-visited directory; duplicate logical path under '${sourceRoot}'.`
+      );
+    }
+    visitedDirectories.add(canonical);
+    const scanned = await scanDirectory(sourceRoot, directory);
+    queue.push(...scanned.subdirectories);
+    for (const logical of scanned.files) {
+      if (seenFiles.has(logical)) {
+        throw new Error(
+          `TN_ASSETS_DUPLICATE_LOGICAL_PATH: '${logical}' was listed twice; duplicate logical path under '${sourceRoot}'.`
+        );
+      }
+      seenFiles.add(logical);
+      logicalPaths.push(logical);
+    }
+  }
+  return logicalPaths.sort();
+}
+function classify(logicalPath) {
+  const extension = path.extname(logicalPath).slice(1).toLowerCase();
+  return KIND_BY_EXTENSION[extension] ?? "other";
+}
+function outputNameFor(logicalPath, digest, extension) {
+  const sourceExtension = path.extname(logicalPath);
+  const base = path.basename(logicalPath, sourceExtension);
+  const directory = path.dirname(logicalPath);
+  const name = `${base}.${digest}${extension ?? sourceExtension.toLowerCase()}`;
+  return directory === "." ? name : `${directory}/${name}`;
+}
+function sameTargets(left, right) {
+  if (left === void 0 || right === void 0) return left === right;
+  return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function sameEntry(existing, entry) {
+  return existing.output === entry.output && existing.kind === entry.kind && JSON.stringify(existing.lightmapAtlas) === JSON.stringify(entry.lightmapAtlas) && JSON.stringify(existing.lightmaps) === JSON.stringify(entry.lightmaps) && JSON.stringify(existing.embeddedTextures) === JSON.stringify(entry.embeddedTextures) && JSON.stringify(existing.simplify) === JSON.stringify(entry.simplify) && existing.bytes === entry.bytes && existing.bytesBefore === entry.bytesBefore && existing.bytesAfter === entry.bytesAfter && existing.format === entry.format && sameTargets(existing.transcodeTargets, entry.transcodeTargets) && sameTargets(existing.extensions, entry.extensions) && existing.triangles === entry.triangles && existing.vertices === entry.vertices && existing.passes.length === entry.passes.length && existing.passes.every((name, index) => name === entry.passes[index]);
+}
+function resolveAuxiliaryOutputs(logical, outputs) {
+  const sourceExtension = path.extname(logical);
+  const stem = logical.slice(0, -sourceExtension.length);
+  return outputs.map((auxiliary) => {
+    const digest = createHash("sha256").update(auxiliary.buffer).digest("hex").slice(0, 8);
+    const output = outputNameFor(
+      `${stem}.${auxiliary.role}${auxiliary.extension}`,
+      digest,
+      auxiliary.extension
+    );
+    return {
+      buffer: auxiliary.buffer,
+      manifestField: auxiliary.manifestField,
+      metadata: {
+        ...auxiliary.metadata ?? {},
+        bytes: auxiliary.buffer.length,
+        output
+      },
+      output
+    };
+  });
+}
+function auxiliaryManifestFields(outputs) {
+  const fields = {};
+  for (const output of outputs) {
+    const field = fields[output.manifestField] ?? [];
+    field.push(output.metadata);
+    fields[output.manifestField] = field;
+  }
+  return fields;
+}
+async function readExistingManifest(manifestPath) {
+  let raw;
+  try {
+    raw = await readFile(manifestPath, "utf8");
+  } catch {
+    return { entries: {}, raw: void 0 };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `TN_ASSETS_MANIFEST_INVALID: '${manifestPath}' is not valid JSON: ${messageOf3(error)}`
+    );
+  }
+  if (!isRecord(parsed) || parsed.version !== 1 || !isRecord(parsed.entries)) {
+    throw new Error(`TN_ASSETS_MANIFEST_INVALID: '${manifestPath}' must hold version 1 entries.`);
+  }
+  return { entries: parsed.entries, raw };
+}
+async function hasSourceDirectory(sourceRoot) {
+  let info;
+  try {
+    info = await stat(sourceRoot);
+  } catch {
+    return false;
+  }
+  if (!info.isDirectory()) {
+    throw new Error(`TN_ASSETS_SOURCE_INVALID: asset source '${sourceRoot}' is not a directory.`);
+  }
+  return true;
+}
+async function outputExists(outputAbsolute) {
+  let info;
+  try {
+    info = await stat(outputAbsolute);
+  } catch {
+    return false;
+  }
+  return info.isFile();
+}
+async function readInput(sourceRoot, logical) {
+  try {
+    return await readFile(path.join(sourceRoot, logical));
+  } catch (error) {
+    throw new Error(
+      `TN_ASSETS_INPUT_UNREADABLE: could not read '${logical}' under '${sourceRoot}': ${messageOf3(error)}`
+    );
+  }
+}
+async function applyPasses(passes, input, logical) {
+  let buffer = input;
+  const auxiliaryOutputs = [];
+  let entry;
+  let extension;
+  for (const pass of passes) {
+    let result;
+    try {
+      result = await pass.apply(buffer, logical);
+    } catch (error) {
+      throw new Error(
+        `TN_ASSETS_PASS_FAILED: pass '${pass.name}' failed for '${logical}': ${messageOf3(error)}`
+      );
+    }
+    if (Buffer.isBuffer(result)) {
+      buffer = result;
+      continue;
+    }
+    buffer = result.buffer;
+    if (result.auxiliaryOutputs !== void 0) auxiliaryOutputs.push(...result.auxiliaryOutputs);
+    if (result.entry !== void 0) entry = { ...entry ?? {}, ...result.entry };
+    if (result.outputExtension !== void 0) extension = result.outputExtension;
+  }
+  return { auxiliaryOutputs, buffer, entry, extension };
+}
+async function writeOutput(outputRoot, entry, buffer) {
+  const outputAbsolute = path.join(outputRoot, entry.output);
+  await mkdir(path.dirname(outputAbsolute), { recursive: true });
+  await writeFile(outputAbsolute, buffer);
+}
+async function writeManifest(manifestPath, outputRoot, raw, entries) {
+  const manifest = { version: 1, entries: {} };
+  for (const logical of Object.keys(entries).sort()) {
+    const entry = entries[logical];
+    if (entry !== void 0) manifest.entries[logical] = entry;
+  }
+  const serialized = `${JSON.stringify(manifest, null, 2)}
+`;
+  if (serialized === raw) return;
+  await mkdir(outputRoot, { recursive: true });
+  await writeFile(manifestPath, serialized, "utf8");
+}
+function resolveBasisTranscoder(cwd) {
+  try {
+    const javascriptPath = createRequire(path.join(cwd, "package.json")).resolve(
+      "three/examples/jsm/libs/basis/basis_transcoder.js"
+    );
+    return { javascriptPath, wasmPath: javascriptPath.replace(/\.js$/u, ".wasm") };
+  } catch (error) {
+    throw new Error(
+      `TN_ASSETS_TRANSCODER_MISSING: could not resolve three's Basis transcoder from '${cwd}': ${messageOf3(error)}. The runtime KTX2 loader needs it copied next to the compiled assets.`
+    );
+  }
+}
+async function copyBasisTranscoder(outputRoot, transcoder) {
+  const target = path.join(outputRoot, BASIS_DIRECTORY);
+  try {
+    await mkdir(target, { recursive: true });
+    await copyFile(transcoder.javascriptPath, path.join(target, "basis_transcoder.js"));
+    await copyFile(transcoder.wasmPath, path.join(target, "basis_transcoder.wasm"));
+  } catch (error) {
+    throw new Error(
+      `TN_ASSETS_TRANSCODER_MISSING: could not copy the Basis transcoder into '${target}': ${messageOf3(error)}`
+    );
+  }
+}
+async function compileAssets(options = {}) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const layout = resolveLayout(cwd, options);
+  if (!await hasSourceDirectory(layout.sourceRoot)) return { skipped: 0, written: 0 };
+  const manifestPath = path.join(layout.outputRoot, MANIFEST_NAME);
+  const previous = await readExistingManifest(manifestPath);
+  const passNames = layout.passes.map((pass) => pass.name);
+  const passCacheKeys = layout.passes.map((pass) => pass.cacheKey ?? null);
+  const passConfiguration = JSON.stringify({
+    ...passCacheKeys.some((key) => key !== null) ? { passCacheKeys } : {},
+    pipelineVersion: PIPELINE_VERSION,
+    passes: passNames,
+    options: layout.passes.map((pass) => pass.configuration ?? null)
+  });
+  const entries = {};
+  const healthInputs = [];
+  const textureRows = [];
+  const modelRows = [];
+  let written = 0;
+  let skipped = 0;
+  let textureCount = 0;
+  let compressedModelCount = 0;
+  const logicals = await walkSources(layout.sourceRoot);
+  if (logicals.length === 0) {
+    if (previous.raw !== void 0) await rm(manifestPath, { force: true });
+    const report2 = await runHealthReport([], layout.targets);
+    return options.health === true ? { report: report2, skipped: 0, written: 0 } : { skipped: 0, written: 0 };
+  }
+  for (const logical of logicals) {
+    const input = await readInput(layout.sourceRoot, logical);
+    const applied = await applyPasses(layout.passes, input, logical);
+    const auxiliaryOutputs = resolveAuxiliaryOutputs(logical, applied.auxiliaryOutputs);
+    const auxiliaryFields = auxiliaryManifestFields(auxiliaryOutputs);
+    const digest = createHash("sha256").update(input).update(passConfiguration, "utf8").digest("hex");
+    const entry = {
+      bytes: applied.buffer.length,
+      kind: classify(logical),
+      output: outputNameFor(logical, digest.slice(0, 8), applied.extension),
+      passes: [...passNames],
+      ...auxiliaryFields,
+      ...applied.entry === void 0 ? {} : {
+        bytesAfter: applied.buffer.length,
+        bytesBefore: input.length,
+        embeddedTextures: embeddedTextureRow(applied.entry.embeddedTextures),
+        simplify: simplifyRow(applied.entry.simplify),
+        extensions: Array.isArray(applied.entry.extensions) ? applied.entry.extensions : void 0,
+        format: typeof applied.entry.format === "string" ? applied.entry.format : void 0,
+        lightmapAtlas: isRecord(applied.entry.lightmapAtlas) ? applied.entry.lightmapAtlas : void 0,
+        triangles: typeof applied.entry.triangles === "number" ? applied.entry.triangles : void 0,
+        transcodeTargets: Array.isArray(applied.entry.transcodeTargets) ? applied.entry.transcodeTargets : void 0,
+        vertices: typeof applied.entry.vertices === "number" ? applied.entry.vertices : void 0
+      }
+    };
+    entries[logical] = entry;
+    if (entry.extensions?.includes(BASISU_EXTENSION) === true) compressedModelCount += 1;
+    healthInputs.push({ data: input, logicalPath: logical });
+    if (entry.bytesBefore !== void 0) {
+      if (entry.triangles !== void 0) {
+        const lightmapOutput = auxiliaryOutputs.find(
+          (output) => output.manifestField === "lightmaps"
+        );
+        const lightmapMetadata = lightmapOutput?.metadata;
+        const lightmapAtlas = applied.entry?.lightmapAtlas;
+        const lightmap = lightmapOutput !== void 0 && isRecord(lightmapMetadata) && isRecord(lightmapAtlas) && typeof applied.entry?.lightmapBakeMs === "number" ? {
+          atlasHeight: Number(lightmapAtlas.height),
+          atlasWidth: Number(lightmapAtlas.width),
+          bakeMs: applied.entry.lightmapBakeMs,
+          bytesAfter: lightmapOutput.buffer.length,
+          bytesBefore: Number(lightmapMetadata.bytesBefore),
+          dilatedTexels: Number(lightmapMetadata.dilatedTexels),
+          occludedTexels: Number(lightmapMetadata.occludedTexels),
+          validTexels: Number(lightmapMetadata.validTexels)
+        } : void 0;
+        modelRows.push({
+          after: entry.bytes,
+          before: entry.bytesBefore,
+          ...entry.embeddedTextures === void 0 ? {} : { embeddedTextures: entry.embeddedTextures },
+          ...entry.simplify === void 0 ? {} : { simplify: entry.simplify },
+          extensions: entry.extensions,
+          logicalPath: logical,
+          ...lightmap === void 0 ? {} : { lightmap },
+          triangles: entry.triangles
+        });
+      } else {
+        textureRows.push({
+          after: entry.bytes,
+          before: entry.bytesBefore,
+          format: entry.format,
+          logicalPath: logical
+        });
+        textureCount += 1;
+      }
+    }
+    const existing = previous.entries[logical];
+    if (existing !== void 0 && sameEntry(existing, entry) && await outputExists(path.join(layout.outputRoot, entry.output)) && (await Promise.all(
+      auxiliaryOutputs.map(
+        (output) => outputExists(path.join(layout.outputRoot, output.output))
+      )
+    )).every(Boolean)) {
+      skipped += 1;
+      continue;
+    }
+    await writeOutput(layout.outputRoot, entry, applied.buffer);
+    for (const output of auxiliaryOutputs) {
+      await mkdir(path.dirname(path.join(layout.outputRoot, output.output)), { recursive: true });
+      await writeFile(path.join(layout.outputRoot, output.output), output.buffer);
+    }
+    written += 1;
+  }
+  if (layout.texturesActive && textureCount > 0 || compressedModelCount > 0) {
+    const basisJs = path.join(layout.outputRoot, BASIS_DIRECTORY, "basis_transcoder.js");
+    if (written > 0 || !await outputExists(basisJs)) {
+      await copyBasisTranscoder(
+        layout.outputRoot,
+        options.transcoder ?? resolveBasisTranscoder(cwd)
+      );
+    }
+  }
+  const report = await runHealthReport(healthInputs, layout.targets);
+  for (const line of formatHealthReport(report)) console.log(line);
+  for (const line of formatTextureSizes(textureRows)) console.log(line);
+  for (const line of formatModelSizes(modelRows)) console.log(line);
+  if (report.failed) {
+    const failedAssets = report.findings.filter((finding) => finding.grade === "fail").map((finding) => finding.asset);
+    throw new Error(
+      `TN_ASSETS_HEALTH_FAILED: ${failedAssets.length} declared asset target(s) exceeded: ${[...new Set(failedAssets)].join(", ")}`
+    );
+  }
+  await writeManifest(manifestPath, layout.outputRoot, previous.raw, entries);
+  return options.health === true ? { report, skipped, written } : { skipped, written };
+}
+var MANIFEST_NAME2 = "assets.manifest.json";
+var DEFAULT_SOURCE2 = "assets";
+var DEFAULT_OUTPUT2 = "public";
+var DEFAULT_DEBOUNCE_MS = 100;
+function messageOf4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function resolveWatchLayout(cwd, options) {
+  const source = options.source ?? options.config?.source ?? DEFAULT_SOURCE2;
+  const output = options.output ?? options.config?.output ?? DEFAULT_OUTPUT2;
+  const sourceRoot = path.resolve(cwd, source);
+  const outputRoot = path.resolve(cwd, output);
+  return { manifestPath: path.join(outputRoot, MANIFEST_NAME2), outputRoot, sourceRoot };
+}
+function readManifest(manifestPath) {
+  const fail = (reason) => new Error(`TN_ASSETS_MANIFEST_INVALID: '${manifestPath}' ${reason}.`);
+  return readFile(manifestPath, "utf8").then(
+    (raw) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        throw fail("is not valid JSON");
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || parsed.version !== 1 || typeof parsed.entries !== "object" || parsed.entries === null || Array.isArray(parsed.entries)) {
+        throw fail("must hold version 1 entries");
+      }
+      return { entries: parsed.entries, raw };
+    },
+    () => ({ entries: {}, raw: void 0 })
+  );
+}
+async function writeManifestAtomically(manifestPath, entries, raw) {
+  const ordered = {};
+  for (const key of Object.keys(entries).sort()) ordered[key] = entries[key];
+  const serialized = `${JSON.stringify({ version: 1, entries: ordered }, null, 2)}
+`;
+  if (serialized === raw) return;
+  const temporary = `${manifestPath}.${process.pid}.tmp`;
+  await writeFile(temporary, serialized, "utf8");
+  await rename(temporary, manifestPath);
+}
+async function recompileOne(layout, compileOptions, logical) {
+  const scratch = await mkdtemp(path.join(tmpdir(), "threenative-watch-"));
+  try {
+    const stagedInput = path.join(scratch, DEFAULT_SOURCE2, logical);
+    await mkdir(path.dirname(stagedInput), { recursive: true });
+    await writeFile(stagedInput, await readFile(path.join(layout.sourceRoot, logical)));
+    await compileAssets({
+      cwd: scratch,
+      output: "out",
+      source: DEFAULT_SOURCE2,
+      ...compileOptions.config === void 0 ? {} : { config: compileOptions.config },
+      ...compileOptions.passes === void 0 ? {} : { passes: compileOptions.passes },
+      ...compileOptions.transcoder === void 0 ? {} : { transcoder: compileOptions.transcoder }
+    });
+    const scratchManifest = JSON.parse(
+      await readFile(path.join(scratch, "out", MANIFEST_NAME2), "utf8")
+    );
+    const entry = scratchManifest.entries[logical];
+    if (entry === void 0 || entry.output === void 0) {
+      throw new Error("compiled without producing a manifest entry");
+    }
+    const destination = path.join(layout.outputRoot, entry.output);
+    await mkdir(path.dirname(destination), { recursive: true });
+    await writeFile(destination, await readFile(path.join(scratch, "out", entry.output)));
+    return entry;
+  } finally {
+    await rm(scratch, { force: true, recursive: true });
+  }
+}
+function watchAssets(options = {}) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const layout = resolveWatchLayout(cwd, options);
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  const transcoder = options.transcoder ?? (() => {
+    try {
+      return resolveBasisTranscoder(cwd);
+    } catch {
+      return void 0;
+    }
+  })();
+  const compileOptions = {
+    config: options.config,
+    cwd,
+    output: options.output,
+    passes: options.passes,
+    source: options.source,
+    ...transcoder === void 0 ? {} : { transcoder }
+  };
+  const logFailure = (message) => {
+    process.stderr.write(`TN_ASSETS_WATCH_FAILED: ${message}
+`);
+  };
+  let watcher;
+  let timer;
+  let flushing = Promise.resolve();
+  let fullReconcileQueued = false;
+  let closed = false;
+  const queue = /* @__PURE__ */ new Set();
+  const armDebounce = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      void runFlush();
+    }, debounceMs);
+  };
+  const queueFullReconcile = () => {
+    fullReconcileQueued = true;
+    armDebounce();
+  };
+  const queueEvent = (filename) => {
+    const logical = filename.split(path.sep).join("/").replace(/^\.\//u, "");
+    if (logical.length === 0 || logical.split("/").some((segment) => segment.startsWith("."))) {
+      return;
+    }
+    void stat(path.join(layout.sourceRoot, logical)).then(
+      (info) => {
+        if (!info.isFile()) return;
+        queue.add(logical);
+        armDebounce();
+      },
+      () => {
+        queue.delete(logical);
+        queueFullReconcile();
+      }
+    );
+  };
+  const fullRebuild = async () => {
+    try {
+      await compileAssets(compileOptions);
+    } catch (error) {
+      logFailure(`full reconcile failed: ${messageOf4(error)}`);
+    }
+  };
+  const mergeEntries = async (merged) => {
+    if (merged.size === 0) return;
+    try {
+      const current = await readManifest(layout.manifestPath);
+      for (const [logical, entry] of merged) current.entries[logical] = entry;
+      await writeManifestAtomically(layout.manifestPath, current.entries, current.raw);
+    } catch (error) {
+      logFailure(`manifest update deferred: ${messageOf4(error)}`);
+    }
+  };
+  const reportBurst = (compiled, failed) => {
+    if (options.onChange === void 0 || compiled.length === 0 && failed.length === 0) return;
+    try {
+      options.onChange({ compiled, failed });
+    } catch (error) {
+      logFailure(`onChange listener threw: ${messageOf4(error)}`);
+    }
+  };
+  const flush = async (batch, reconcileAll) => {
+    if (reconcileAll) await fullRebuild();
+    const compiled = [];
+    const failed = [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const logical of batch) {
+      try {
+        merged.set(logical, await recompileOne(layout, compileOptions, logical));
+        compiled.push(logical);
+      } catch (error) {
+        failed.push(logical);
+        logFailure(`could not recompile '${logical}': ${messageOf4(error)}`);
+      }
+    }
+    await mergeEntries(merged);
+    reportBurst(compiled, failed);
+  };
+  const runFlush = () => {
+    const batch = [...queue].sort();
+    queue.clear();
+    const reconcileAll = fullReconcileQueued;
+    fullReconcileQueued = false;
+    flushing = flushing.then(async () => {
+      if (!closed) {
+        try {
+          await flush(batch, reconcileAll);
+        } catch (error) {
+          logFailure(`burst failed: ${messageOf4(error)}`);
+        }
+      }
+    });
+  };
+  const startWatching = () => {
+    try {
+      watcher = watch(layout.sourceRoot, { recursive: true }, (_eventType, filename) => {
+        if (closed) return;
+        if (typeof filename !== "string" || filename.length === 0) {
+          queueFullReconcile();
+          return;
+        }
+        queueEvent(filename);
+      });
+    } catch {
+      return;
+    }
+    watcher.on("error", (error) => {
+      logFailure(messageOf4(error));
+      queueFullReconcile();
+    });
+  };
+  const ready = (async () => {
+    try {
+      await compileAssets(compileOptions);
+    } catch (error) {
+      logFailure(`initial compile failed: ${messageOf4(error)}`);
+    }
+    if (!closed) startWatching();
+  })();
+  return {
+    ready,
+    close: () => {
+      if (closed) return;
+      closed = true;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      watcher?.close();
+      watcher = void 0;
+    }
+  };
+}
+
+export { compileAssets, formatHealthReport, formatModelSizes, formatTextureSizes, lightmapPass, modelPass, parsePng, resolveBasisTranscoder, runHealthReport, texturePass, watchAssets };