@forgeax/engine-gltf 0.0.0-dev.8d955ade1c79

package/dist/cli-gltf.mjs

@@ -0,0 +1,2435 @@
+#!/usr/bin/env node
+import { realpath, stat, readFile, writeFile, readdir } from 'fs/promises';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { parseArgs } from 'util';
+import { reconcileMeshMaterialSlotTopology, err, MESH_MATERIAL_SLOT_SOURCE_OVERRIDE_PAYLOAD_SCHEMA, ok, ImportError, IMPORT_ERROR_HINTS } from '@forgeax/engine-types';
+import { vec3, quat, mat4 } from '@forgeax/engine-math';
+import { deriveAnimationTargetId } from '@forgeax/engine-animation/target-id';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+
+var GLTF_MESHOPT_MODES = ["ATTRIBUTES", "TRIANGLES", "INDICES"];
+var GLTF_MESHOPT_FILTERS = ["NONE", "OCTAHEDRAL", "QUATERNION", "EXPONENTIAL"];
+var gltfErrorPolicy = {
+  "gltf-malformed-header": {
+    expected: "GLB 12-byte header (magic 0x46546C67 + version=2 + length) plus mandatory JSON chunk",
+    hint: "verify .glb is not truncated; rerun: forgeax-engine-remote-gltf import <path>"
+  },
+  "gltf-version-unsupported": {
+    expected: 'asset.version === "2.0"',
+    hint: 'asset.version must be "2.0"; v1 or v3 not supported'
+  },
+  "gltf-buffer-out-of-bounds": {
+    expected: "accessor byte range within bufferView.byteLength",
+    hint: "rebuild .gltf with valid bufferViews; check accessor index; ensure accessor.byteOffset + EFFECTIVE_STRIDE * (count - 1) + element_size <= bufferView.byteLength"
+  },
+  "gltf-extension-unsupported": {
+    expected: "extension listed in v1 allowlist (see EXTENSION_ALLOWLIST in @forgeax/engine-gltf)",
+    hint: "see feat-future-gltf-extensions-allowlist; remove this extension or wait for the allowlist to expand"
+  },
+  "gltf-accessor-type-mismatch": {
+    expected: "dense fixed-stride accessor with supported componentType",
+    hint: "sparse: see feat-future-gltf-sparse-accessor; morph: see feat-future-gltf-morph; interleaved: see feat-future-gltf-mesh-multi-section"
+  },
+  "gltf-texture-load-failed": {
+    expected: "externalLoader resolved the URI into an ArrayBuffer without throwing",
+    hint: "check sidecar meta.json + textures/ directory + vite-plugin-pack /__pack/lookup route"
+  },
+  "gltf-meta-missing": {
+    expected: "sidecar <source>.meta.json (importer: 'gltf') present in same directory",
+    hint: "run: forgeax-engine-remote-gltf import <path>"
+  },
+  "gltf-instancing-count-mismatch": {
+    expected: "all instance attribute accessors share the same count",
+    hint: "EXT_mesh_gpu_instancing requires TRANSLATION/ROTATION/SCALE accessors to share count; see https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/EXT_mesh_gpu_instancing/README.md#extending-nodes-with-instance-attributes"
+  },
+  "gltf-image-mime-unsupported": {
+    expected: "image/mimeType is image/jpeg or image/png",
+    hint: "convert to JPG/PNG via external tool; only image/jpeg and image/png are supported"
+  },
+  "gltf-skin-joint-count-exceeded": {
+    expected: "skin.joints.length <= MAX_JOINTS (256)",
+    hint: "reduce joint count below MAX_JOINTS (256) or see OOS-skin-max-joints"
+  },
+  "gltf-animation-cubicspline-unsupported": {
+    expected: "animation sampler interpolation is LINEAR or STEP",
+    hint: "see OOS-skin-cubicspline; convert CUBICSPLINE to LINEAR/STEP in DCC tool"
+  },
+  "gltf-morph-unsupported": {
+    expected: "animation channel target path is one of translation, rotation, scale, or weights",
+    hint: "animation target path must be translation, rotation, scale, or weights"
+  },
+  "gltf-skin-joint-name-missing": {
+    expected: "every joint node has a non-empty name and belongs to an acyclic hierarchy",
+    hint: "ensure every joint node has a non-empty name and the node hierarchy is acyclic"
+  },
+  "gltf-image-extract-failed": {
+    expected: "image bytes extractable from bufferView / data-URI / external URI without corruption",
+    hint: "verify the bufferView byte range / data: URI base64 / external URI sibling file is intact next to the .gltf source; rerun: forgeax-engine-remote-gltf import <path>"
+  },
+  "gltf-skin-attr-asymmetric": {
+    expected: "mesh primitive declares JOINTS_0 and WEIGHTS_0 symmetrically (both present or both absent)",
+    hint: "glTF spec requires JOINTS_0 and WEIGHTS_0 to appear together for each skinned primitive; add the missing attribute or remove the present one in the DCC tool"
+  },
+  "gltf-animation-target-invalid": {
+    expected: "every animation channel resolves to one uniquely named scene node and stable target ID",
+    hint: "name every node in the animated hierarchy and ensure each animated full path is unique"
+  },
+  "gltf-meshopt-decoder-required": {
+    expected: "a required or compressed-only EXT_meshopt_compression bufferView has a ready decoder capability",
+    hint: "provide the build-only EXT_meshopt_compression decoder or author a valid core fallback bufferView"
+  },
+  "gltf-meshopt-decode-failed": {
+    expected: "the EXT_meshopt_compression declaration and decoder output are structurally valid",
+    hint: "the meshopt decoder accepts the declared compressed range and produces the declared byte count"
+  },
+  "gltf-morph-invalid": {
+    expected: "morph target and default-weight arrays are dense, bounded, and match the base vertex count",
+    hint: "re-export dense morph targets with at most eight targets/attributes and matching vertex/default-weight lengths"
+  },
+  "gltf-color-accessor-unsupported": {
+    expected: "COLOR_0 dense accessor uses VEC3/VEC4 FLOAT or normalized UBYTE/USHORT",
+    hint: "re-export COLOR_0 with a supported type/component/normalized combination; morph and sparse COLOR_0 remain deferred"
+  },
+  "gltf-color-accessor-malformed": {
+    expected: "COLOR_0 accessor is non-empty, finite, in range, and fully addressable",
+    hint: "repair the COLOR_0 accessor count, reference, range, or buffer bounds, then re-import the glTF source"
+  },
+  "gltf-mesh-bridge-invalid": {
+    expected: "a non-empty merged mesh with consistent morph and COLOR_0 cardinality",
+    hint: "repair the source primitive and re-import; inspect detail.reason and its typed facts"
+  }
+};
+var GLTF_ERROR_HINTS = Object.fromEntries(
+  Object.entries(gltfErrorPolicy).map(([code, policy]) => [code, policy.hint])
+);
+function gltfErr(code, detail) {
+  return {
+    code,
+    expected: gltfErrorPolicy[code].expected,
+    hint: gltfErrorPolicy[code].hint,
+    detail
+  };
+}
+
+// src/accessor/decode-accessor.ts
+var COMPONENT_TYPE = {
+  I8: 5120,
+  U8: 5121,
+  I16: 5122,
+  U16: 5123,
+  U32: 5125,
+  F32: 5126
+};
+var TYPE_COMPONENT_COUNT = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var COMPONENT_BYTE_SIZE = {
+  [COMPONENT_TYPE.I8]: 1,
+  [COMPONENT_TYPE.U8]: 1,
+  [COMPONENT_TYPE.I16]: 2,
+  [COMPONENT_TYPE.U16]: 2,
+  [COMPONENT_TYPE.U32]: 4,
+  [COMPONENT_TYPE.F32]: 4
+};
+function decodeF32Accessor(accessorIndex, accessor, allowedTypes, bufferViews, buffers) {
+  if (accessor.componentType !== COMPONENT_TYPE.F32 || !allowedTypes.includes(accessor.type)) {
+    return err(
+      gltfErr("gltf-accessor-type-mismatch", { accessorIndex, reason: "unknownComponentType" })
+    );
+  }
+  const bufferViewIndex = accessor.bufferView;
+  if (bufferViewIndex === void 0) {
+    return err(
+      gltfErr("gltf-buffer-out-of-bounds", {
+        accessor: accessorIndex,
+        byteOffset: 0,
+        byteLength: 0,
+        bufferIndex: 0
+      })
+    );
+  }
+  const bufferView = bufferViews[bufferViewIndex];
+  if (bufferView === void 0) {
+    return err(
+      gltfErr("gltf-buffer-out-of-bounds", {
+        accessor: accessorIndex,
+        byteOffset: 0,
+        byteLength: 0,
+        bufferIndex: bufferViewIndex
+      })
+    );
+  }
+  const buffer = buffers[bufferView.buffer];
+  if (buffer === void 0) {
+    return err(
+      gltfErr("gltf-buffer-out-of-bounds", {
+        accessor: accessorIndex,
+        byteOffset: bufferView.byteOffset ?? 0,
+        byteLength: bufferView.byteLength,
+        bufferIndex: bufferView.buffer
+      })
+    );
+  }
+  const decoded = decodeAccessor({
+    accessor: { ...accessor, bufferView: bufferViewIndex },
+    bufferView,
+    buffer,
+    accessorIndex,
+    role: "attribute"
+  });
+  if (!decoded.ok) return decoded;
+  if (decoded.value.kind !== "f32") {
+    return err(
+      gltfErr("gltf-accessor-type-mismatch", { accessorIndex, reason: "unknownComponentType" })
+    );
+  }
+  return ok(decoded.value.data);
+}
+function decodeAccessor(input, flags = {}) {
+  const { accessorIndex, accessor, bufferView, buffer, role } = input;
+  if (flags.morph === true) {
+    return err(
+      gltfErr("gltf-accessor-type-mismatch", {
+        accessorIndex,
+        reason: "morph"
+      })
+    );
+  }
+  if ("sparse" in accessor && accessor.sparse !== void 0) {
+    return err(
+      gltfErr("gltf-accessor-type-mismatch", {
+        accessorIndex,
+        reason: "sparse"
+      })
+    );
+  }
+  const componentByteSize = COMPONENT_BYTE_SIZE[accessor.componentType];
+  const componentCount = TYPE_COMPONENT_COUNT[accessor.type];
+  if (componentByteSize === void 0 || componentCount === void 0) {
+    return err(
+      gltfErr("gltf-accessor-type-mismatch", {
+        accessorIndex,
+        reason: "unknownComponentType"
+      })
+    );
+  }
+  const elementSize = componentByteSize * componentCount;
+  const byteStride = bufferView.byteStride;
+  if (byteStride !== void 0 && byteStride !== elementSize) {
+    return err(
+      gltfErr("gltf-accessor-type-mismatch", {
+        accessorIndex,
+        reason: "interleaved"
+      })
+    );
+  }
+  const accessorByteOffset = accessor.byteOffset ?? 0;
+  const bufferViewByteOffset = bufferView.byteOffset ?? 0;
+  const totalByteLength = elementSize * accessor.count;
+  if (accessorByteOffset + totalByteLength > bufferView.byteLength) {
+    return err(
+      gltfErr("gltf-buffer-out-of-bounds", {
+        accessor: accessorIndex,
+        byteOffset: bufferViewByteOffset + accessorByteOffset,
+        byteLength: totalByteLength,
+        bufferIndex: bufferView.buffer
+      })
+    );
+  }
+  const absoluteOffset = bufferViewByteOffset + accessorByteOffset;
+  if (absoluteOffset + totalByteLength > buffer.byteLength) {
+    return err(
+      gltfErr("gltf-buffer-out-of-bounds", {
+        accessor: accessorIndex,
+        byteOffset: absoluteOffset,
+        byteLength: totalByteLength,
+        bufferIndex: bufferView.buffer
+      })
+    );
+  }
+  if (role === "indices" && accessor.componentType === COMPONENT_TYPE.U8) {
+    const widened = new Uint16Array(accessor.count);
+    for (let i = 0; i < accessor.count; i++) {
+      widened[i] = buffer[absoluteOffset + i] ?? 0;
+    }
+    return ok({ kind: "u16", data: widened });
+  }
+  if (role === "joints" && accessor.componentType === COMPONENT_TYPE.U8) {
+    const totalValues = accessor.count * componentCount;
+    const widened = new Uint16Array(totalValues);
+    for (let i = 0; i < totalValues; i++) {
+      widened[i] = buffer[absoluteOffset + i] ?? 0;
+    }
+    return ok({ kind: "u16", data: widened });
+  }
+  if (accessor.componentType === COMPONENT_TYPE.F32) {
+    const out = new Float32Array(accessor.count * componentCount);
+    const src = new Float32Array(buffer.buffer, buffer.byteOffset + absoluteOffset, out.length);
+    out.set(src);
+    return ok({ kind: "f32", data: out });
+  }
+  if (accessor.componentType === COMPONENT_TYPE.U16) {
+    const out = new Uint16Array(accessor.count * componentCount);
+    const src = new Uint16Array(buffer.buffer, buffer.byteOffset + absoluteOffset, out.length);
+    out.set(src);
+    return ok({ kind: "u16", data: out });
+  }
+  if (accessor.componentType === COMPONENT_TYPE.U32) {
+    const out = new Uint32Array(accessor.count * componentCount);
+    const src = new Uint32Array(buffer.buffer, buffer.byteOffset + absoluteOffset, out.length);
+    out.set(src);
+    return ok({ kind: "u32", data: out });
+  }
+  if (accessor.componentType === COMPONENT_TYPE.I16) {
+    const out = new Float32Array(accessor.count * componentCount);
+    const src = new Int16Array(buffer.buffer, buffer.byteOffset + absoluteOffset, out.length);
+    for (let index = 0; index < src.length; index++) {
+      const value = src[index] ?? 0;
+      out[index] = accessor.normalized === true ? Math.max(-1, value / 32767) : value;
+    }
+    return ok({ kind: "f32", data: out });
+  }
+  return err(
+    gltfErr("gltf-accessor-type-mismatch", {
+      accessorIndex,
+      reason: "unknownComponentType"
+    })
+  );
+}
+
+// src/accessor/decode-color.ts
+var FLOAT = 5126;
+var UNSIGNED_BYTE = 5121;
+var UNSIGNED_SHORT = 5123;
+function unsupported(input, reason) {
+  return err(
+    gltfErr("gltf-color-accessor-unsupported", {
+      semantic: input.semantic,
+      accessorIndex: input.accessorIndex,
+      reason,
+      expectedType: "VEC3 or VEC4",
+      expectedComponent: "FLOAT or normalized UNSIGNED_BYTE/UNSIGNED_SHORT",
+      ...reason === "normalized" ? { expectedNormalized: true } : {}
+    })
+  );
+}
+function malformed(input, reason) {
+  return err(
+    gltfErr("gltf-color-accessor-malformed", {
+      semantic: input.semantic,
+      accessorIndex: input.accessorIndex,
+      reason,
+      ...reason === "count" ? { expectedCount: "matches POSITION vertex count and is greater than zero" } : {},
+      ...reason === "range" || reason === "finite" ? { expectedRange: "[0,1] finite linear values" } : {}
+    })
+  );
+}
+function decodeColorAccessor(input, flags = {}) {
+  const { accessor, bufferView, buffer } = input;
+  if (flags.morph === true) return unsupported(input, "morph");
+  if (accessor.sparse !== void 0) return unsupported(input, "sparse");
+  if (accessor.type !== "VEC3" && accessor.type !== "VEC4") return unsupported(input, "type");
+  if (!Number.isSafeInteger(accessor.count) || accessor.count <= 0)
+    return malformed(input, "count");
+  let componentByteSize;
+  if (accessor.componentType === FLOAT) componentByteSize = 4;
+  else if (accessor.componentType === UNSIGNED_BYTE) componentByteSize = 1;
+  else if (accessor.componentType === UNSIGNED_SHORT) componentByteSize = 2;
+  else return unsupported(input, "component");
+  if (accessor.componentType === FLOAT) {
+    if (accessor.normalized !== void 0) return unsupported(input, "normalized");
+  } else if (accessor.normalized !== true) {
+    return unsupported(input, "normalized");
+  }
+  const componentCount = accessor.type === "VEC3" ? 3 : 4;
+  const elementByteLength = componentByteSize * componentCount;
+  const byteStride = bufferView.byteStride ?? elementByteLength;
+  if (!Number.isSafeInteger(byteStride) || byteStride < elementByteLength || byteStride % componentByteSize !== 0) {
+    return malformed(input, "bounds");
+  }
+  if (input.bufferIndex !== void 0 && bufferView.buffer !== input.bufferIndex) {
+    return malformed(input, "reference");
+  }
+  const accessorByteOffset = accessor.byteOffset ?? 0;
+  const viewByteOffset = bufferView.byteOffset ?? 0;
+  const lastElementEnd = accessorByteOffset + byteStride * (accessor.count - 1) + elementByteLength;
+  if (!Number.isSafeInteger(accessorByteOffset) || accessorByteOffset < 0 || lastElementEnd > bufferView.byteLength) {
+    return malformed(input, "bounds");
+  }
+  const absoluteLastElementEnd = viewByteOffset + lastElementEnd;
+  if (!Number.isSafeInteger(viewByteOffset) || viewByteOffset < 0 || absoluteLastElementEnd > buffer.byteLength) {
+    return malformed(input, "bounds");
+  }
+  const output = new Float32Array(accessor.count * 4);
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const base = viewByteOffset + accessorByteOffset;
+  for (let vertex = 0; vertex < accessor.count; vertex++) {
+    const sourceOffset = base + vertex * byteStride;
+    for (let component = 0; component < componentCount; component++) {
+      const byteOffset = sourceOffset + component * componentByteSize;
+      let value;
+      if (accessor.componentType === FLOAT) value = view.getFloat32(byteOffset, true);
+      else if (accessor.componentType === UNSIGNED_BYTE) value = view.getUint8(byteOffset) / 255;
+      else value = view.getUint16(byteOffset, true) / 65535;
+      if (!Number.isFinite(value)) return malformed(input, "finite");
+      if (value < 0 || value > 1) return malformed(input, "range");
+      output[vertex * 4 + component] = value;
+    }
+    if (componentCount === 3) output[vertex * 4 + 3] = 1;
+  }
+  return ok(output);
+}
+
+// src/check-extensions.ts
+var EXTENSION_ALLOWLIST = [
+  "EXT_mesh_gpu_instancing",
+  "EXT_meshopt_compression"
+];
+var SUPPORTED_EXTENSIONS = [
+  ...EXTENSION_ALLOWLIST,
+  "KHR_lights_punctual",
+  "KHR_texture_transform"
+];
+function checkExtensions(json) {
+  const required = json.extensionsRequired ?? [];
+  for (const ext of required) {
+    if (!SUPPORTED_EXTENSIONS.includes(ext)) {
+      return err(
+        gltfErr("gltf-extension-unsupported", {
+          extension: ext,
+          source: "extensionsRequired"
+        })
+      );
+    }
+  }
+  const used = json.extensionsUsed ?? [];
+  const unsupportedUsed = [];
+  for (const ext of used) {
+    if (!SUPPORTED_EXTENSIONS.includes(ext)) {
+      unsupportedUsed.push(ext);
+    }
+  }
+  return ok({ unsupportedUsed });
+}
+
+// src/data-uri.ts
+var DATA_URI_BASE64_RE = /^data:[^;,]*(?:;[^,;]+)*;base64,(.*)$/;
+var Base64DecodeError = class extends Error {
+  constructor(cause) {
+    super(
+      `base64 payload decode failed: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+    this.name = "Base64DecodeError";
+  }
+};
+function dataUriBase64Payload(uri) {
+  const match = DATA_URI_BASE64_RE.exec(uri);
+  return match === null ? void 0 : match[1] ?? "";
+}
+function decodeBase64(b64) {
+  let binary;
+  try {
+    binary = atob(b64);
+  } catch (cause) {
+    throw new Base64DecodeError(cause);
+  }
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    out[i] = binary.charCodeAt(i);
+  }
+  return out;
+}
+
+// src/meshopt-decode.ts
+function viewBytes(view, buffers) {
+  const buffer = buffers[view.buffer];
+  const offset = view.byteOffset ?? 0;
+  if (buffer === void 0 || view.byteLength <= 0 || offset < 0 || offset + view.byteLength > buffer.length) {
+    return void 0;
+  }
+  return buffer.subarray(offset, offset + view.byteLength);
+}
+function validMode(mode) {
+  return GLTF_MESHOPT_MODES.some((candidate) => candidate === mode);
+}
+function validFilter(filter) {
+  return GLTF_MESHOPT_FILTERS.some((candidate) => candidate === filter);
+}
+function filterAllowed(mode, filter) {
+  return mode === "ATTRIBUTES" || filter === "NONE";
+}
+async function projectMeshoptBufferViews(inputViews, inputBuffers, extensionsRequired, capability) {
+  const buffers = [...inputBuffers];
+  const bufferViews = inputViews.map((view) => ({ ...view }));
+  let decodedCount = 0;
+  for (let index = 0; index < bufferViews.length; index++) {
+    const view = bufferViews[index];
+    if (view === void 0) continue;
+    const extension = view.extensions?.EXT_meshopt_compression;
+    if (extension === void 0) continue;
+    const filter = extension.filter ?? "NONE";
+    if (!validMode(extension.mode) || !validFilter(filter) || !filterAllowed(extension.mode, filter) || !Number.isInteger(extension.byteStride) || extension.byteStride <= 0 || !Number.isInteger(extension.count) || extension.count <= 0 || !Number.isInteger(extension.byteLength) || extension.byteLength <= 0) {
+      return err(
+        gltfErr("gltf-meshopt-decode-failed", {
+          bufferView: index,
+          actual: "invalid mode/filter/stride/count/byteLength",
+          mode: validMode(extension.mode) ? extension.mode : "ATTRIBUTES",
+          filter: validFilter(filter) ? filter : "NONE"
+        })
+      );
+    }
+    const fallback = viewBytes(view, buffers);
+    const required = extensionsRequired.includes("EXT_meshopt_compression");
+    if (capability === void 0 && !required && fallback !== void 0) continue;
+    if (capability === void 0) {
+      return err(
+        gltfErr("gltf-meshopt-decoder-required", {
+          bufferView: index,
+          actual: required ? "required" : "compressed-only",
+          hasCoreFallback: fallback !== void 0
+        })
+      );
+    }
+    const compressedBuffer = buffers[extension.buffer];
+    const compressedOffset = extension.byteOffset ?? 0;
+    if (compressedBuffer === void 0 || !Number.isInteger(compressedOffset) || compressedOffset < 0 || compressedOffset + extension.byteLength > compressedBuffer.length) {
+      return err(
+        gltfErr("gltf-meshopt-decode-failed", {
+          bufferView: index,
+          actual: "compressed range out of bounds",
+          mode: extension.mode,
+          filter
+        })
+      );
+    }
+    let decoded;
+    try {
+      decoded = await capability.decode({
+        source: compressedBuffer.subarray(
+          compressedOffset,
+          compressedOffset + extension.byteLength
+        ),
+        count: extension.count,
+        stride: extension.byteStride,
+        mode: extension.mode,
+        filter
+      });
+    } catch (cause) {
+      return err(
+        gltfErr("gltf-meshopt-decode-failed", {
+          bufferView: index,
+          actual: `decoder rejected compressed range: ${cause instanceof Error ? cause.message : String(cause)}`,
+          mode: extension.mode,
+          filter
+        })
+      );
+    }
+    const expectedLength = extension.count * extension.byteStride;
+    if (!(decoded instanceof Uint8Array) || decoded.byteLength !== expectedLength) {
+      return err(
+        gltfErr("gltf-meshopt-decode-failed", {
+          bufferView: index,
+          actual: `decoded byteLength=${decoded?.byteLength ?? "invalid"}, expected=${expectedLength}`,
+          mode: extension.mode,
+          filter
+        })
+      );
+    }
+    const decodedBufferIndex = buffers.length;
+    buffers.push(decoded);
+    const { extensions: _extensions, ...plainView } = view;
+    bufferViews[index] = {
+      ...plainView,
+      buffer: decodedBufferIndex,
+      byteOffset: 0,
+      byteLength: expectedLength
+    };
+    decodedCount++;
+  }
+  return ok({ bufferViews, buffers, decodedCount });
+}
+
+// src/node-path.ts
+function buildNodeParentMap(nodes) {
+  const parents = /* @__PURE__ */ new Map();
+  for (let index = 0; index < nodes.length; index++) {
+    for (const child of nodes[index]?.children ?? []) parents.set(child, index);
+  }
+  return parents;
+}
+function resolveNamedNodePath(nodes, parents, nodeIndex) {
+  const reversed = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = nodeIndex;
+  while (current !== void 0) {
+    if (visited.has(current)) {
+      return { ok: false, reason: "hierarchy-cycle", nodeIndex: current };
+    }
+    visited.add(current);
+    const name = nodes[current]?.name;
+    if (name === void 0 || name.length === 0) {
+      return { ok: false, reason: "name-missing", nodeIndex: current };
+    }
+    reversed.push(name);
+    current = parents.get(current);
+  }
+  return { ok: true, value: reversed.reverse() };
+}
+
+// src/parse-animation.ts
+var ANIMATION_ACCESSOR_TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
+function parseAnimation(animationsJson, nodesJson, accessors, bufferViews, buffers) {
+  if (animationsJson === void 0 || animationsJson.length === 0) {
+    return ok([]);
+  }
+  const clips = [];
+  const parentOf = buildNodeParentMap(nodesJson);
+  const nodeByPath = /* @__PURE__ */ new Map();
+  const pathById = /* @__PURE__ */ new Map();
+  for (let animIdx = 0; animIdx < animationsJson.length; animIdx++) {
+    const anim = animationsJson[animIdx];
+    if (anim === void 0) continue;
+    const decodedSamplers = [];
+    for (let sampIdx = 0; sampIdx < anim.samplers.length; sampIdx++) {
+      const sampler = anim.samplers[sampIdx];
+      if (sampler === void 0) continue;
+      const interpolation = sampler.interpolation ?? "LINEAR";
+      if (interpolation === "CUBICSPLINE") {
+        return err(
+          gltfErr("gltf-animation-cubicspline-unsupported", {
+            animationIndex: animIdx,
+            samplerIndex: sampIdx
+          })
+        );
+      }
+      if (interpolation !== "LINEAR" && interpolation !== "STEP") {
+        return err(
+          gltfErr("gltf-animation-cubicspline-unsupported", {
+            animationIndex: animIdx,
+            samplerIndex: sampIdx
+          })
+        );
+      }
+      const inputAcc = accessors[sampler.input];
+      if (inputAcc === void 0) {
+        return err(
+          gltfErr("gltf-buffer-out-of-bounds", {
+            accessor: sampler.input,
+            byteOffset: 0,
+            byteLength: 0,
+            bufferIndex: 0
+          })
+        );
+      }
+      const inputResult = decodeF32Accessor(
+        sampler.input,
+        inputAcc,
+        ANIMATION_ACCESSOR_TYPES,
+        bufferViews,
+        buffers
+      );
+      if (!inputResult.ok) return err(inputResult.error);
+      const outputAcc = accessors[sampler.output];
+      if (outputAcc === void 0) {
+        return err(
+          gltfErr("gltf-buffer-out-of-bounds", {
+            accessor: sampler.output,
+            byteOffset: 0,
+            byteLength: 0,
+            bufferIndex: 0
+          })
+        );
+      }
+      const outputResult = decodeF32Accessor(
+        sampler.output,
+        outputAcc,
+        ANIMATION_ACCESSOR_TYPES,
+        bufferViews,
+        buffers
+      );
+      if (!outputResult.ok) return err(outputResult.error);
+      decodedSamplers.push({
+        input: inputResult.value,
+        output: outputResult.value,
+        interpolation
+      });
+    }
+    const channels = [];
+    for (let chIdx = 0; chIdx < anim.channels.length; chIdx++) {
+      const ch = anim.channels[chIdx];
+      if (ch === void 0) continue;
+      const samplerRecord = decodedSamplers[ch.sampler];
+      if (samplerRecord === void 0) {
+        return err(
+          gltfErr("gltf-buffer-out-of-bounds", {
+            accessor: ch.sampler,
+            byteOffset: 0,
+            byteLength: 0,
+            bufferIndex: 0
+          })
+        );
+      }
+      const targetNodeIdx = ch.target.node;
+      const path = targetNodeIdx === void 0 ? { ok: false, reason: "name-missing", nodeIndex: -1 } : resolveNamedNodePath(nodesJson, parentOf, targetNodeIdx);
+      if (!path.ok) {
+        return err(
+          gltfErr("gltf-animation-target-invalid", {
+            reason: path.reason,
+            animationIndex: animIdx,
+            channelIndex: chIdx,
+            nodeIndex: path.nodeIndex
+          })
+        );
+      }
+      if (ch.target.path !== "weights" && ch.target.path !== "translation" && ch.target.path !== "rotation" && ch.target.path !== "scale") {
+        return err(
+          gltfErr("gltf-morph-unsupported", {
+            animationIndex: animIdx,
+            channelIndex: chIdx,
+            nodeIndex: ch.target.node ?? -1
+          })
+        );
+      }
+      const pathKey = JSON.stringify(path.value);
+      const previousNode = nodeByPath.get(pathKey);
+      if (previousNode !== void 0 && previousNode !== targetNodeIdx) {
+        return err(
+          gltfErr("gltf-animation-target-invalid", {
+            reason: "path-duplicate",
+            animationIndex: animIdx,
+            channelIndex: chIdx,
+            nodeIndex: targetNodeIdx
+          })
+        );
+      }
+      nodeByPath.set(pathKey, targetNodeIdx);
+      const targetId = deriveAnimationTargetId(path.value);
+      const previousPath = pathById.get(targetId);
+      if (previousPath !== void 0 && previousPath !== pathKey) {
+        return err(
+          gltfErr("gltf-animation-target-invalid", {
+            reason: "id-collision",
+            animationIndex: animIdx,
+            channelIndex: chIdx,
+            nodeIndex: targetNodeIdx
+          })
+        );
+      }
+      pathById.set(targetId, pathKey);
+      channels.push({
+        targetId,
+        targetNodeIndex: targetNodeIdx,
+        property: ch.target.path,
+        sampler: samplerRecord
+      });
+    }
+    let duration = 0;
+    for (const ch of channels) {
+      const input = ch.sampler.input;
+      if (input.length > 0) {
+        const last = input[input.length - 1];
+        if (last !== void 0 && last > duration) {
+          duration = last;
+        }
+      }
+    }
+    const name = anim.name?.trim();
+    clips.push({
+      ...name === void 0 || name.length === 0 ? {} : { name },
+      duration,
+      channels
+    });
+  }
+  return ok(clips);
+}
+
+// src/parse-gltf-header.ts
+function parseGltfHeader(json, filePath) {
+  if (json === null || typeof json !== "object" || !("asset" in json)) {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: 0
+      })
+    );
+  }
+  const asset = json.asset;
+  if (!asset || typeof asset !== "object" || typeof asset.version !== "string") {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: 0
+      })
+    );
+  }
+  if (asset.version !== "2.0") {
+    return err(
+      gltfErr("gltf-version-unsupported", {
+        filePath,
+        actualVersion: asset.version
+      })
+    );
+  }
+  return ok(json);
+}
+
+// src/parse-glb-chunks.ts
+var GLB_HEADER_SIZE = 12;
+var GLB_MAGIC = 1179937895;
+var CHUNK_HEADER_SIZE = 8;
+var CHUNK_TYPE_JSON = 1313821514;
+var CHUNK_TYPE_BIN = 5130562;
+function parseGlbChunks(buffer, filePath) {
+  if (buffer.byteLength < GLB_HEADER_SIZE) {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: 0
+      })
+    );
+  }
+  const view = new DataView(buffer);
+  const magic = view.getUint32(0, true);
+  if (magic !== GLB_MAGIC) {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: 0,
+        magic
+      })
+    );
+  }
+  const version = view.getUint32(4, true);
+  if (version !== 2) {
+    return err(
+      gltfErr("gltf-version-unsupported", {
+        filePath,
+        actualVersion: String(version)
+      })
+    );
+  }
+  const declaredLength = view.getUint32(8, true);
+  if (declaredLength !== buffer.byteLength) {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: 8
+      })
+    );
+  }
+  let offset = GLB_HEADER_SIZE;
+  if (offset + CHUNK_HEADER_SIZE > buffer.byteLength) {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: offset
+      })
+    );
+  }
+  const jsonChunkLength = view.getUint32(offset, true);
+  const jsonChunkType = view.getUint32(offset + 4, true);
+  if (jsonChunkType !== CHUNK_TYPE_JSON) {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: offset + 4
+      })
+    );
+  }
+  if (offset + CHUNK_HEADER_SIZE + jsonChunkLength > buffer.byteLength) {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: offset
+      })
+    );
+  }
+  const jsonChunk = new Uint8Array(buffer, offset + CHUNK_HEADER_SIZE, jsonChunkLength);
+  offset += CHUNK_HEADER_SIZE + jsonChunkLength;
+  let binChunk;
+  if (offset < buffer.byteLength) {
+    if (offset + CHUNK_HEADER_SIZE > buffer.byteLength) {
+      return err(
+        gltfErr("gltf-malformed-header", {
+          filePath,
+          byteOffset: offset
+        })
+      );
+    }
+    const binChunkLength = view.getUint32(offset, true);
+    const binChunkType = view.getUint32(offset + 4, true);
+    if (binChunkType !== CHUNK_TYPE_BIN) {
+      return err(
+        gltfErr("gltf-malformed-header", {
+          filePath,
+          byteOffset: offset + 4
+        })
+      );
+    }
+    if (offset + CHUNK_HEADER_SIZE + binChunkLength > buffer.byteLength) {
+      return err(
+        gltfErr("gltf-malformed-header", {
+          filePath,
+          byteOffset: offset
+        })
+      );
+    }
+    binChunk = new Uint8Array(buffer, offset + CHUNK_HEADER_SIZE, binChunkLength);
+  }
+  return ok({
+    version,
+    length: declaredLength,
+    jsonChunk,
+    ...binChunk === void 0 ? {} : { binChunk }
+  });
+}
+
+// src/parse-skin.ts
+var MAX_JOINTS = 256;
+var SKIN_ACCESSOR_TYPES = ["MAT4"];
+function identityMat4() {
+  const m = new Float32Array(16);
+  m[0] = 1;
+  m[5] = 1;
+  m[10] = 1;
+  m[15] = 1;
+  return m;
+}
+function resolveJointPath(nodeIndex, nodes, parentOf, skinIndex, jointPathIndex) {
+  const path = resolveNamedNodePath(nodes, parentOf, nodeIndex);
+  if (!path.ok) {
+    return err(
+      gltfErr("gltf-skin-joint-name-missing", {
+        reason: path.reason,
+        skinIndex,
+        jointPathIndex,
+        nodeIndex: path.nodeIndex
+      })
+    );
+  }
+  return ok(path.value);
+}
+function parseSkin(skinsJson, nodesJson, accessors, bufferViews, buffers) {
+  if (skinsJson === void 0 || skinsJson.length === 0) {
+    return ok([]);
+  }
+  const records = [];
+  const parentOf = buildNodeParentMap(nodesJson);
+  for (let skinIdx = 0; skinIdx < skinsJson.length; skinIdx++) {
+    const skin = skinsJson[skinIdx];
+    if (skin === void 0) continue;
+    const joints = skin.joints;
+    if (joints.length > MAX_JOINTS) {
+      return err(
+        gltfErr("gltf-skin-joint-count-exceeded", {
+          skinIndex: skinIdx,
+          jointCount: joints.length,
+          maxJoints: MAX_JOINTS
+        })
+      );
+    }
+    let ibm;
+    if (skin.inverseBindMatrices !== void 0) {
+      const ibmAccIdx = skin.inverseBindMatrices;
+      const ibmAcc = accessors[ibmAccIdx];
+      if (ibmAcc === void 0) {
+        return err(
+          gltfErr("gltf-buffer-out-of-bounds", {
+            accessor: ibmAccIdx,
+            byteOffset: 0,
+            byteLength: 0,
+            bufferIndex: 0
+          })
+        );
+      }
+      const ibmResult = decodeF32Accessor(
+        ibmAccIdx,
+        ibmAcc,
+        SKIN_ACCESSOR_TYPES,
+        bufferViews,
+        buffers
+      );
+      if (!ibmResult.ok) return err(ibmResult.error);
+      ibm = ibmResult.value;
+    } else {
+      ibm = new Float32Array(joints.length * 16);
+      for (let j = 0; j < joints.length; j++) {
+        ibm.set(identityMat4(), j * 16);
+      }
+    }
+    const jointPaths = [];
+    for (let j = 0; j < joints.length; j++) {
+      const jointNodeIndex = joints[j];
+      if (jointNodeIndex === void 0) continue;
+      const pathResult = resolveJointPath(jointNodeIndex, nodesJson, parentOf, skinIdx, j);
+      if (!pathResult.ok) return err(pathResult.error);
+      jointPaths.push(pathResult.value.join("/"));
+    }
+    records.push({
+      jointCount: joints.length,
+      inverseBindMatrices: ibm,
+      jointPaths
+    });
+  }
+  return ok(records);
+}
+
+// src/source-key.ts
+function sourceKeyForGltfOutput(item) {
+  const kind = item.kind.trim();
+  if (kind.length === 0) return void 0;
+  const name = item.name?.trim();
+  return name === void 0 || name.length === 0 ? kind : `${kind}:${name}`;
+}
+function deriveGltfSourceKeys(items) {
+  const keys = items.map((item) => sourceKeyForGltfOutput(item));
+  const missing = items.map((item, index) => keys[index] === void 0 ? item.sourceIndex : void 0).filter((index) => index !== void 0);
+  if (missing.length > 0) {
+    return {
+      ok: false,
+      error: {
+        code: "missing-source-key",
+        expected: "every glTF output needs a stable semantic kind or name",
+        hint: "publish a semantic kind/name key; do not use sourceIndex",
+        detail: { sourceIndices: missing }
+      }
+    };
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index];
+    if (key === void 0) continue;
+    const current = items[index];
+    if (current === void 0) continue;
+    const prior = seen.get(key);
+    if (prior !== void 0) {
+      const entry = (item) => {
+        const name = item.name?.trim();
+        return {
+          kind: item.kind.trim(),
+          name: name === void 0 || name.length === 0 ? null : name,
+          sourceIndex: item.sourceIndex
+        };
+      };
+      const ambiguous = key === current.kind.trim();
+      return {
+        ok: false,
+        error: {
+          code: ambiguous ? "ambiguous-source-key" : "duplicate-source-key",
+          expected: "sourceKey values must be unique within one glTF package",
+          hint: ambiguous ? "name each otherwise anonymous output; do not use sourceIndex" : "rename duplicate outputs before publishing topology facts",
+          detail: {
+            key,
+            sourceIndices: [prior.sourceIndex, current.sourceIndex],
+            entries: [entry(prior), entry(current)]
+          }
+        }
+      };
+    }
+    seen.set(key, current);
+  }
+  return { ok: true, keys, conflicts: [] };
+}
+
+// src/reimport-reuse-meta.ts
+function reimportReuseMeta(items, existingMeta) {
+  const sourceKeys = deriveGltfSourceKeys(items);
+  if (!sourceKeys.ok) return err(sourceKeys.error);
+  const stage1Index = /* @__PURE__ */ new Map();
+  const stage2Index = /* @__PURE__ */ new Map();
+  if (existingMeta !== void 0) {
+    for (const entry of existingMeta.subAssets) {
+      if (entry.sourceKey !== void 0) stage1Index.set(entry.sourceKey, entry);
+      stage2Index.set(`${entry.kind} ${entry.sourceIndex}`, entry);
+    }
+  }
+  const subAssets = [];
+  for (const item of items) {
+    const sourceKey = sourceKeyForGltfOutput(item);
+    const indexKey = `${item.kind} ${item.sourceIndex}`;
+    let reused;
+    if (sourceKey !== void 0) reused = stage1Index.get(sourceKey);
+    if (reused === void 0) {
+      reused = stage2Index.get(indexKey);
+    }
+    if (reused !== void 0) {
+      subAssets.push({
+        guid: reused.guid,
+        sourceIndex: item.sourceIndex,
+        kind: item.kind,
+        ...sourceKey === void 0 ? {} : { sourceKey },
+        ...item.name === void 0 ? {} : { name: item.name }
+      });
+    } else {
+      const fresh = AssetGuid.random();
+      subAssets.push({
+        guid: AssetGuid.format(fresh),
+        sourceIndex: item.sourceIndex,
+        kind: item.kind,
+        ...sourceKey === void 0 ? {} : { sourceKey },
+        ...item.name === void 0 ? {} : { name: item.name }
+      });
+    }
+  }
+  return ok({ subAssets });
+}
+var IDENTITY = {
+  translation: [0, 0, 0],
+  rotation: [0, 0, 0, 1],
+  scale: [1, 1, 1]
+};
+function tuple3(arr, fallback) {
+  if (arr === void 0 || arr.length < 3) return fallback;
+  return [arr[0] ?? fallback[0], arr[1] ?? fallback[1], arr[2] ?? fallback[2]];
+}
+function tuple4(arr, fallback) {
+  if (arr === void 0 || arr.length < 4) return fallback;
+  return [
+    arr[0] ?? fallback[0],
+    arr[1] ?? fallback[1],
+    arr[2] ?? fallback[2],
+    arr[3] ?? fallback[3]
+  ];
+}
+function decomposeNodeTransform(node, nodeIndex, diagnostics) {
+  const hasMatrix = node.matrix !== void 0 && node.matrix.length === 16;
+  const hasTrs = node.translation !== void 0 || node.rotation !== void 0 || node.scale !== void 0;
+  if (hasMatrix) {
+    if (hasTrs) {
+      console.error(`[warn] node[${nodeIndex}] has both matrix and TRS, matrix takes precedence`);
+      diagnostics.matrixTrsCoexistNodes.push(nodeIndex);
+    }
+    const out_t = vec3.create();
+    const out_r = quat.create();
+    const out_s = vec3.create(1, 1, 1);
+    const m = node.matrix;
+    mat4.decompose(out_t, out_r, out_s, m);
+    return {
+      translation: [out_t[0] ?? 0, out_t[1] ?? 0, out_t[2] ?? 0],
+      rotation: [out_r[0] ?? 0, out_r[1] ?? 0, out_r[2] ?? 0, out_r[3] ?? 1],
+      scale: [out_s[0] ?? 1, out_s[1] ?? 1, out_s[2] ?? 1]
+    };
+  }
+  if (!hasTrs) {
+    return IDENTITY;
+  }
+  return {
+    translation: tuple3(node.translation, IDENTITY.translation),
+    rotation: tuple4(node.rotation, IDENTITY.rotation),
+    scale: tuple3(node.scale, IDENTITY.scale)
+  };
+}
+
+// src/parse-gltf.ts
+function decodeNodeInstancing(nodeIndex, attributes, accessors, bufferViews, buffers) {
+  const tIdx = attributes.TRANSLATION;
+  const rIdx = attributes.ROTATION;
+  const sIdx = attributes.SCALE;
+  let count;
+  const setOrCheck = (label, n2) => {
+    if (count === void 0) {
+      count = n2;
+      return null;
+    }
+    if (n2 !== count) {
+      return gltfErr("gltf-instancing-count-mismatch", {
+        nodeIndex,
+        accessor: label,
+        expectedCount: count,
+        actualCount: n2
+      });
+    }
+    return null;
+  };
+  let tValues;
+  if (tIdx !== void 0) {
+    const acc = accessors[tIdx];
+    if (acc === void 0) return err(unknownAccessor(tIdx));
+    const e = setOrCheck("TRANSLATION", acc.count);
+    if (e !== null) return err(e);
+    const decoded = decodeAttributeAccessor(tIdx, acc, bufferViews, buffers);
+    if (!decoded.ok) return err(decoded.error);
+    tValues = decoded.value;
+  }
+  let rValues;
+  if (rIdx !== void 0) {
+    const acc = accessors[rIdx];
+    if (acc === void 0) return err(unknownAccessor(rIdx));
+    const e = setOrCheck("ROTATION", acc.count);
+    if (e !== null) return err(e);
+    const decoded = decodeAttributeAccessor(rIdx, acc, bufferViews, buffers);
+    if (!decoded.ok) return err(decoded.error);
+    rValues = decoded.value;
+  }
+  let sValues;
+  if (sIdx !== void 0) {
+    const acc = accessors[sIdx];
+    if (acc === void 0) return err(unknownAccessor(sIdx));
+    const e = setOrCheck("SCALE", acc.count);
+    if (e !== null) return err(e);
+    const decoded = decodeAttributeAccessor(sIdx, acc, bufferViews, buffers);
+    if (!decoded.ok) return err(decoded.error);
+    sValues = decoded.value;
+  }
+  const n = count ?? 0;
+  const transforms = new Float32Array(n * 16);
+  const tmp = mat4.create();
+  const tv = vec3.create();
+  const rv = quat.create();
+  rv[3] = 1;
+  const sv = vec3.create(1, 1, 1);
+  for (let i = 0; i < n; i++) {
+    if (tValues !== void 0) {
+      tv[0] = tValues[i * 3] ?? 0;
+      tv[1] = tValues[i * 3 + 1] ?? 0;
+      tv[2] = tValues[i * 3 + 2] ?? 0;
+    } else {
+      tv[0] = 0;
+      tv[1] = 0;
+      tv[2] = 0;
+    }
+    if (rValues !== void 0) {
+      rv[0] = rValues[i * 4] ?? 0;
+      rv[1] = rValues[i * 4 + 1] ?? 0;
+      rv[2] = rValues[i * 4 + 2] ?? 0;
+      rv[3] = rValues[i * 4 + 3] ?? 1;
+    } else {
+      rv[0] = 0;
+      rv[1] = 0;
+      rv[2] = 0;
+      rv[3] = 1;
+    }
+    if (sValues !== void 0) {
+      sv[0] = sValues[i * 3] ?? 1;
+      sv[1] = sValues[i * 3 + 1] ?? 1;
+      sv[2] = sValues[i * 3 + 2] ?? 1;
+    } else {
+      sv[0] = 1;
+      sv[1] = 1;
+      sv[2] = 1;
+    }
+    mat4.compose(tmp, tv, rv, sv);
+    for (let k = 0; k < 16; k++) {
+      transforms[i * 16 + k] = tmp[k] ?? 0;
+    }
+  }
+  return ok({ count: n, transforms });
+}
+function unknownAccessor(accessorIndex) {
+  return gltfErr("gltf-accessor-type-mismatch", {
+    accessorIndex,
+    reason: "unknownComponentType"
+  });
+}
+function decodeAttributeAccessor(accessorIndex, accessor, bufferViews, buffers) {
+  const view = bufferViews[accessor.bufferView ?? -1];
+  if (view === void 0) return err(unknownAccessor(accessorIndex));
+  const buf = buffers[view.buffer];
+  if (buf === void 0) return err(unknownAccessor(accessorIndex));
+  const decoded = decodeAccessor({
+    accessorIndex,
+    accessor,
+    bufferView: view,
+    buffer: buf,
+    role: "attribute"
+  });
+  if (!decoded.ok) return err(decoded.error);
+  if (decoded.value.kind !== "f32") return err(unknownAccessor(accessorIndex));
+  return ok(decoded.value.data);
+}
+function tuple2(values) {
+  if (values === void 0 || values.length < 2) return void 0;
+  return [values[0] ?? 0, values[1] ?? 0];
+}
+function parseTextureInfo(info, textures) {
+  const transformJson = info.extensions?.KHR_texture_transform;
+  const offset = tuple2(transformJson?.offset);
+  const scale = tuple2(transformJson?.scale);
+  const transform = offset === void 0 && transformJson?.rotation === void 0 && scale === void 0 ? void 0 : {
+    ...offset === void 0 ? {} : { offset },
+    ...transformJson?.rotation === void 0 ? {} : { rotation: transformJson.rotation },
+    ...scale === void 0 ? {} : { scale }
+  };
+  const sampler = textures[info.index]?.sampler;
+  return {
+    texture: info.index,
+    ...sampler === void 0 ? {} : { sampler },
+    ...info.texCoord === void 0 && transformJson?.texCoord === void 0 ? {} : { texCoord: transformJson?.texCoord ?? info.texCoord },
+    ...transform === void 0 ? {} : { transform }
+  };
+}
+async function resolveBuffer(buf, externalLoader, binChunk) {
+  if (buf.uri === void 0) {
+    if (binChunk === void 0) {
+      throw new Error("parseGltf: buffer 0 has no uri and no GLB BIN chunk available");
+    }
+    return binChunk;
+  }
+  const dataPayload = dataUriBase64Payload(buf.uri);
+  if (dataPayload !== void 0) {
+    return decodeBase64(dataPayload);
+  }
+  const arrayBuffer = await externalLoader(buf.uri);
+  return new Uint8Array(arrayBuffer);
+}
+function invalidBufferDataUriError(filePath, bufferIndex, cause) {
+  return new ImportError({
+    code: "source-validation-failed",
+    expected: `glTF buffer ${bufferIndex} data URI to contain a valid base64 payload`,
+    hint: IMPORT_ERROR_HINTS["source-validation-failed"],
+    detail: {
+      diagnostics: [
+        {
+          code: "gltf-buffer-data-uri-invalid",
+          severity: "error",
+          sourcePath: filePath,
+          sourceRange: { start: 0, end: 0, line: 1, column: 1 },
+          rule: "gltf-buffer-data-uri-base64",
+          expected: "a valid base64 payload after ;base64,",
+          actual: `buffer ${bufferIndex}: ${cause.message}`,
+          hint: "repair the buffer data URI or provide a valid external .bin sibling"
+        }
+      ]
+    }
+  });
+}
+function parsePunctualLights(json, filePath) {
+  const source = json.extensions?.KHR_lights_punctual?.lights ?? [];
+  const lights = [];
+  for (const light of source) {
+    const type = light?.type;
+    if (type !== "directional" && type !== "point" && type !== "spot") {
+      return err(gltfErr("gltf-malformed-header", { filePath, byteOffset: 0 }));
+    }
+    const color = light.color ?? [1, 1, 1];
+    if (color.length < 3 || color.slice(0, 3).some(
+      (value) => typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1
+    )) {
+      return err(gltfErr("gltf-malformed-header", { filePath, byteOffset: 0 }));
+    }
+    const intensity = light.intensity ?? 1;
+    if (typeof intensity !== "number" || !Number.isFinite(intensity) || intensity < 0) {
+      return err(gltfErr("gltf-malformed-header", { filePath, byteOffset: 0 }));
+    }
+    const range = light.range;
+    if (range !== void 0 && (typeof range !== "number" || !Number.isFinite(range) || range < 0)) {
+      return err(gltfErr("gltf-malformed-header", { filePath, byteOffset: 0 }));
+    }
+    let spot;
+    if (type === "spot") {
+      const innerConeAngle = light.spot?.innerConeAngle ?? 0;
+      const outerConeAngle = light.spot?.outerConeAngle ?? Math.PI / 4;
+      if (!Number.isFinite(innerConeAngle) || !Number.isFinite(outerConeAngle) || innerConeAngle < 0 || innerConeAngle >= outerConeAngle || outerConeAngle > Math.PI / 2) {
+        return err(gltfErr("gltf-malformed-header", { filePath, byteOffset: 0 }));
+      }
+      spot = { innerConeAngle, outerConeAngle };
+    }
+    lights.push({
+      type,
+      color: [color[0] ?? 1, color[1] ?? 1, color[2] ?? 1],
+      intensity,
+      ...range === void 0 || range === 0 ? {} : { range },
+      ...spot === void 0 ? {} : { spot }
+    });
+  }
+  return ok(lights);
+}
+async function parseGltfWithBin(json, ctx) {
+  const headerResult = parseGltfHeader(json, ctx.filePath);
+  if (!headerResult.ok) return err(headerResult.error);
+  const extResult = checkExtensions(json);
+  if (!extResult.ok) return err(extResult.error);
+  const unsupportedExtensions = extResult.value.unsupportedUsed;
+  const lightsResult = parsePunctualLights(json, ctx.filePath);
+  if (!lightsResult.ok) return err(lightsResult.error);
+  const meshesJson = json.meshes ?? [];
+  const buffersJson = json.buffers ?? [];
+  const buffers = [];
+  for (let i = 0; i < buffersJson.length; i++) {
+    const bufJson = buffersJson[i];
+    if (bufJson === void 0) continue;
+    try {
+      const bytes = await resolveBuffer(bufJson, ctx.externalLoader, ctx.binChunk);
+      buffers.push(bytes);
+    } catch (e) {
+      if (e instanceof Base64DecodeError) {
+        return err(invalidBufferDataUriError(ctx.filePath, i, e));
+      }
+      return err(
+        gltfErr("gltf-malformed-header", {
+          filePath: ctx.filePath,
+          byteOffset: 0
+        })
+      );
+    }
+  }
+  const accessors = json.accessors ?? [];
+  const rawBufferViews = json.bufferViews ?? [];
+  const projected = await projectMeshoptBufferViews(
+    rawBufferViews,
+    buffers,
+    json.extensionsRequired ?? [],
+    ctx.meshopt
+  );
+  if (!projected.ok) return err(projected.error);
+  const bufferViews = projected.value.bufferViews;
+  buffers.splice(0, buffers.length, ...projected.value.buffers);
+  const meshes = [];
+  const meshPrimitiveCount = /* @__PURE__ */ new Map();
+  for (let meshIndex = 0; meshIndex < meshesJson.length; meshIndex++) {
+    const meshJson = meshesJson[meshIndex];
+    if (meshJson === void 0) continue;
+    meshPrimitiveCount.set(meshIndex, meshJson.primitives.length);
+    for (const prim of meshJson.primitives) {
+      if (prim === void 0) continue;
+      const positionAccessorIndex = prim.attributes?.POSITION;
+      if (positionAccessorIndex === void 0) {
+        return err(
+          gltfErr("gltf-accessor-type-mismatch", {
+            accessorIndex: -1,
+            reason: "unknownComponentType"
+          })
+        );
+      }
+      const positionAccessor = accessors[positionAccessorIndex];
+      const positionBufferView = bufferViews[positionAccessor?.bufferView ?? -1];
+      if (positionAccessor === void 0 || positionBufferView === void 0) {
+        return err(
+          gltfErr("gltf-buffer-out-of-bounds", {
+            accessor: positionAccessorIndex,
+            byteOffset: 0,
+            byteLength: 0,
+            bufferIndex: positionBufferView?.buffer ?? 0
+          })
+        );
+      }
+      const positionBuffer = buffers[positionBufferView.buffer];
+      if (positionBuffer === void 0) {
+        return err(
+          gltfErr("gltf-buffer-out-of-bounds", {
+            accessor: positionAccessorIndex,
+            byteOffset: positionBufferView.byteOffset ?? 0,
+            byteLength: positionBufferView.byteLength,
+            bufferIndex: positionBufferView.buffer
+          })
+        );
+      }
+      const positionDecoded = decodeAccessor({
+        accessorIndex: positionAccessorIndex,
+        accessor: positionAccessor,
+        bufferView: positionBufferView,
+        buffer: positionBuffer,
+        role: "attribute"
+      });
+      if (!positionDecoded.ok) return err(positionDecoded.error);
+      if (positionDecoded.value.kind !== "f32") {
+        return err(
+          gltfErr("gltf-accessor-type-mismatch", {
+            accessorIndex: positionAccessorIndex,
+            reason: "unknownComponentType"
+          })
+        );
+      }
+      const positionsDecoded = positionDecoded.value.data;
+      const positions = new Float32Array(positionsDecoded.length);
+      positions.set(positionsDecoded);
+      const attrs = prim.attributes ?? {};
+      let colors0;
+      const colorIdx = attrs.COLOR_0;
+      if (colorIdx !== void 0) {
+        const colorAccessor = accessors[colorIdx];
+        const colorBufferView = bufferViews[colorAccessor?.bufferView ?? -1];
+        if (colorAccessor === void 0 || colorBufferView === void 0) {
+          return err(
+            gltfErr("gltf-color-accessor-malformed", {
+              semantic: "COLOR_0",
+              accessorIndex: colorIdx,
+              reason: "reference"
+            })
+          );
+        }
+        const colorBuffer = buffers[colorBufferView.buffer];
+        if (colorBuffer === void 0) {
+          return err(
+            gltfErr("gltf-color-accessor-malformed", {
+              semantic: "COLOR_0",
+              accessorIndex: colorIdx,
+              reason: "reference"
+            })
+          );
+        }
+        const decoded = decodeColorAccessor({
+          accessorIndex: colorIdx,
+          accessor: colorAccessor,
+          bufferView: colorBufferView,
+          buffer: colorBuffer,
+          bufferIndex: colorBufferView.buffer,
+          semantic: "COLOR_0"
+        });
+        if (!decoded.ok) return err(decoded.error);
+        if (decoded.value.length !== positions.length / 3 * 4) {
+          return err(
+            gltfErr("gltf-color-accessor-malformed", {
+              semantic: "COLOR_0",
+              accessorIndex: colorIdx,
+              reason: "count"
+            })
+          );
+        }
+        colors0 = decoded.value;
+      }
+      let normals;
+      const normalIdx = attrs.NORMAL;
+      if (normalIdx !== void 0) {
+        const acc = accessors[normalIdx];
+        if (acc !== void 0) {
+          const decoded = decodeAttributeAccessor(normalIdx, acc, bufferViews, buffers);
+          if (decoded.ok) {
+            const src = decoded.value;
+            const owned = new Float32Array(src.length);
+            owned.set(src);
+            normals = owned;
+          }
+        }
+      }
+      let texcoord0;
+      const texIdx = attrs.TEXCOORD_0;
+      if (texIdx !== void 0) {
+        const acc = accessors[texIdx];
+        if (acc !== void 0) {
+          const decoded = decodeAttributeAccessor(texIdx, acc, bufferViews, buffers);
+          if (decoded.ok) {
+            const src = decoded.value;
+            const owned = new Float32Array(src.length);
+            owned.set(src);
+            texcoord0 = owned;
+          }
+        }
+      }
+      let texcoord1;
+      let texcoord2;
+      let texcoord3;
+      let texcoord4;
+      let texcoord5;
+      let texcoord6;
+      let texcoord7;
+      for (let k = 1; k <= 7; k++) {
+        const tcIdx = attrs[`TEXCOORD_${k}`];
+        if (tcIdx === void 0) continue;
+        const acc = accessors[tcIdx];
+        if (acc !== void 0) {
+          const decoded = decodeAttributeAccessor(tcIdx, acc, bufferViews, buffers);
+          if (decoded.ok) {
+            const src = decoded.value;
+            const owned = new Float32Array(src.length);
+            owned.set(src);
+            if (k === 1) texcoord1 = owned;
+            else if (k === 2) texcoord2 = owned;
+            else if (k === 3) texcoord3 = owned;
+            else if (k === 4) texcoord4 = owned;
+            else if (k === 5) texcoord5 = owned;
+            else if (k === 6) texcoord6 = owned;
+            else texcoord7 = owned;
+          }
+        }
+      }
+      let tangents;
+      const tanIdx = attrs.TANGENT;
+      if (tanIdx !== void 0) {
+        const acc = accessors[tanIdx];
+        if (acc !== void 0) {
+          const decoded = decodeAttributeAccessor(tanIdx, acc, bufferViews, buffers);
+          if (decoded.ok) {
+            const src = decoded.value;
+            const owned = new Float32Array(src.length);
+            owned.set(src);
+            tangents = owned;
+          }
+        }
+      }
+      const rawTargets = prim.targets ?? [];
+      for (const target of rawTargets) {
+        const colorTarget = target.COLOR_0;
+        if (colorTarget !== void 0) {
+          return err(
+            gltfErr("gltf-color-accessor-unsupported", {
+              semantic: "COLOR_0",
+              accessorIndex: colorTarget,
+              reason: "morph"
+            })
+          );
+        }
+      }
+      const morphAttributeCount = rawTargets.reduce(
+        (count, target) => count + (target.POSITION === void 0 ? 0 : 1) + (target.NORMAL === void 0 ? 0 : 1) + (target.TANGENT === void 0 ? 0 : 1),
+        0
+      );
+      const morphError = (reason) => err(
+        gltfErr("gltf-morph-invalid", {
+          meshIndex,
+          primitiveIndex: meshJson.primitives.indexOf(prim),
+          reason,
+          targetCount: rawTargets.length,
+          attributeCount: morphAttributeCount,
+          vertexCount: positions.length / 3
+        })
+      );
+      if (rawTargets.length > 8) return morphError("target-count-exceeded");
+      if (morphAttributeCount > 8) return morphError("attribute-count-exceeded");
+      const morphTargets = [];
+      for (const target of rawTargets) {
+        const output = {};
+        for (const [key, accessorIndex] of Object.entries(target)) {
+          if (key !== "POSITION" && key !== "NORMAL" && key !== "TANGENT") continue;
+          const targetAccessor = accessors[accessorIndex];
+          if (targetAccessor === void 0) return morphError("attribute-length-mismatch");
+          const decoded = decodeAttributeAccessor(
+            accessorIndex,
+            targetAccessor,
+            bufferViews,
+            buffers
+          );
+          if (!decoded.ok) {
+            return morphError(
+              decoded.error.code === "gltf-accessor-type-mismatch" ? "sparse-or-unsupported-accessor" : "attribute-length-mismatch"
+            );
+          }
+          const expected = positions.length / 3 * (key === "TANGENT" ? 4 : 3);
+          if (decoded.value.length !== expected) return morphError("attribute-length-mismatch");
+          const owned = new Float32Array(decoded.value.length);
+          owned.set(decoded.value);
+          if (key === "POSITION") output.position = owned;
+          else if (key === "NORMAL") output.normal = owned;
+          else output.tangent = owned;
+        }
+        morphTargets.push(output);
+      }
+      const meshWeights = meshJson.weights;
+      if (meshWeights !== void 0 && meshWeights.length !== rawTargets.length) {
+        return morphError("weights-length-mismatch");
+      }
+      const jointsIdx = attrs.JOINTS_0;
+      const weightsIdx = attrs.WEIGHTS_0;
+      const hasJoints = jointsIdx !== void 0;
+      const hasWeights = weightsIdx !== void 0;
+      if (hasJoints !== hasWeights) {
+        const primitiveIndex = meshJson.primitives.indexOf(prim);
+        return err(
+          gltfErr("gltf-skin-attr-asymmetric", {
+            meshIndex,
+            primitiveIndex,
+            hasJoints,
+            hasWeights
+          })
+        );
+      }
+      let joints0;
+      let weights0;
+      if (hasJoints && hasWeights) {
+        const jointsAccessor = accessors[jointsIdx];
+        const jointsBufferView = bufferViews[jointsAccessor?.bufferView ?? -1];
+        if (jointsAccessor === void 0 || jointsBufferView === void 0) {
+          return err(unknownAccessor(jointsIdx));
+        }
+        const jointsBuffer = buffers[jointsBufferView.buffer];
+        if (jointsBuffer === void 0) return err(unknownAccessor(jointsIdx));
+        const jointsDecoded = decodeAccessor({
+          accessorIndex: jointsIdx,
+          accessor: jointsAccessor,
+          bufferView: jointsBufferView,
+          buffer: jointsBuffer,
+          role: "joints"
+        });
+        if (!jointsDecoded.ok) return err(jointsDecoded.error);
+        if (jointsDecoded.value.kind !== "u16") {
+          return err(
+            gltfErr("gltf-accessor-type-mismatch", {
+              accessorIndex: jointsIdx,
+              reason: "unknownComponentType"
+            })
+          );
+        }
+        const src = jointsDecoded.value.data;
+        const owned = new Uint16Array(src.length);
+        owned.set(src);
+        joints0 = owned;
+        const weightsAccessor = accessors[weightsIdx];
+        const weightsBufferView = bufferViews[weightsAccessor?.bufferView ?? -1];
+        if (weightsAccessor === void 0 || weightsBufferView === void 0) {
+          return err(unknownAccessor(weightsIdx));
+        }
+        const weightsBuffer = buffers[weightsBufferView.buffer];
+        if (weightsBuffer === void 0) return err(unknownAccessor(weightsIdx));
+        const weightsDecoded = decodeAccessor({
+          accessorIndex: weightsIdx,
+          accessor: weightsAccessor,
+          bufferView: weightsBufferView,
+          buffer: weightsBuffer,
+          role: "attribute"
+        });
+        if (!weightsDecoded.ok) return err(weightsDecoded.error);
+        if (weightsDecoded.value.kind !== "f32") {
+          return err(
+            gltfErr("gltf-accessor-type-mismatch", {
+              accessorIndex: weightsIdx,
+              reason: "unknownComponentType"
+            })
+          );
+        }
+        const wsrc = weightsDecoded.value.data;
+        const wowned = new Float32Array(wsrc.length);
+        wowned.set(wsrc);
+        weights0 = wowned;
+      }
+      let indices;
+      if (prim.indices !== void 0) {
+        const indexAccessor = accessors[prim.indices];
+        const indexBufferView = bufferViews[indexAccessor?.bufferView ?? -1];
+        if (indexAccessor === void 0 || indexBufferView === void 0) {
+          return err(
+            gltfErr("gltf-buffer-out-of-bounds", {
+              accessor: prim.indices,
+              byteOffset: 0,
+              byteLength: 0,
+              bufferIndex: indexBufferView?.buffer ?? 0
+            })
+          );
+        }
+        const indexBuffer = buffers[indexBufferView.buffer];
+        if (indexBuffer === void 0) {
+          return err(
+            gltfErr("gltf-buffer-out-of-bounds", {
+              accessor: prim.indices,
+              byteOffset: indexBufferView.byteOffset ?? 0,
+              byteLength: indexBufferView.byteLength,
+              bufferIndex: indexBufferView.buffer
+            })
+          );
+        }
+        const indexDecoded = decodeAccessor({
+          accessorIndex: prim.indices,
+          accessor: indexAccessor,
+          bufferView: indexBufferView,
+          buffer: indexBuffer,
+          role: "indices"
+        });
+        if (!indexDecoded.ok) return err(indexDecoded.error);
+        if (indexDecoded.value.kind === "u16") {
+          const src = indexDecoded.value.data;
+          const owned = new Uint16Array(src.length);
+          owned.set(src);
+          indices = owned;
+        } else if (indexDecoded.value.kind === "u32") {
+          const src = indexDecoded.value.data;
+          const owned = new Uint32Array(src.length);
+          owned.set(src);
+          indices = owned;
+        } else {
+          return err(
+            gltfErr("gltf-accessor-type-mismatch", {
+              accessorIndex: prim.indices,
+              reason: "unknownComponentType"
+            })
+          );
+        }
+      }
+      const meshIr = {
+        ...meshJson.name === void 0 ? {} : { name: meshJson.name },
+        positions,
+        ...normals === void 0 ? {} : { normals },
+        ...texcoord0 === void 0 ? {} : { texcoord0 },
+        ...texcoord1 === void 0 ? {} : { texcoord1 },
+        ...texcoord2 === void 0 ? {} : { texcoord2 },
+        ...texcoord3 === void 0 ? {} : { texcoord3 },
+        ...texcoord4 === void 0 ? {} : { texcoord4 },
+        ...texcoord5 === void 0 ? {} : { texcoord5 },
+        ...texcoord6 === void 0 ? {} : { texcoord6 },
+        ...texcoord7 === void 0 ? {} : { texcoord7 },
+        ...tangents === void 0 ? {} : { tangents },
+        ...colors0 === void 0 ? {} : { colors0 },
+        ...joints0 === void 0 ? {} : { joints0 },
+        ...weights0 === void 0 ? {} : { weights0 },
+        ...morphTargets.length === 0 ? {} : { morphTargets },
+        ...meshWeights === void 0 ? {} : { morphWeights: new Float32Array(meshWeights) },
+        ...indices === void 0 ? {} : { indices },
+        materialIndex: prim.material ?? null,
+        meshIndex
+      };
+      meshes.push(meshIr);
+    }
+  }
+  const texturesJson = json.textures ?? [];
+  const textures = [];
+  for (const texJson of texturesJson) {
+    const texIr = {
+      source: texJson.source ?? -1,
+      ...texJson.sampler === void 0 ? {} : { sampler: texJson.sampler },
+      ...texJson.name === void 0 ? {} : { name: texJson.name }
+    };
+    textures.push(texIr);
+  }
+  const imagesJson = json.images ?? [];
+  const images = [];
+  for (const imgJson of imagesJson) {
+    const mimeType = imgJson.mimeType;
+    if (mimeType !== void 0 && mimeType !== "image/jpeg" && mimeType !== "image/png") {
+      return err(gltfErr("gltf-image-mime-unsupported", { mimeType }));
+    }
+    const imgIr = {
+      ...imgJson.uri === void 0 ? {} : { uri: imgJson.uri },
+      ...imgJson.mimeType === void 0 ? {} : { mimeType: imgJson.mimeType },
+      ...imgJson.bufferView === void 0 ? {} : { bufferView: imgJson.bufferView },
+      ...imgJson.name === void 0 ? {} : { name: imgJson.name }
+    };
+    images.push(imgIr);
+  }
+  for (const img of images) {
+    if (img.uri !== void 0) {
+      if (dataUriBase64Payload(img.uri) !== void 0) continue;
+      try {
+        await ctx.externalLoader(img.uri);
+      } catch (_e) {
+        return err(gltfErr("gltf-texture-load-failed", { uri: img.uri }));
+      }
+    }
+  }
+  const samplersJson = json.samplers ?? [];
+  const samplers = [];
+  for (const sampJson of samplersJson) {
+    samplers.push({
+      ...sampJson.magFilter === void 0 ? {} : { magFilter: sampJson.magFilter },
+      ...sampJson.minFilter === void 0 ? {} : { minFilter: sampJson.minFilter },
+      wrapS: sampJson.wrapS ?? 10497,
+      // REPEAT (glTF default)
+      wrapT: sampJson.wrapT ?? 10497,
+      ...sampJson.name === void 0 ? {} : { name: sampJson.name }
+    });
+  }
+  const materialsJson = json.materials ?? [];
+  const materials = [];
+  for (const matJson of materialsJson) {
+    const pbr = matJson.pbrMetallicRoughness;
+    const baseColor = pbr?.baseColorFactor ?? [1, 1, 1, 1];
+    const baseColor4 = [
+      baseColor[0] ?? 1,
+      baseColor[1] ?? 1,
+      baseColor[2] ?? 1,
+      baseColor[3] ?? 1
+    ];
+    const alphaMode = matJson.alphaMode === "MASK" || matJson.alphaMode === "BLEND" ? matJson.alphaMode : void 0;
+    const alphaCutoff = alphaMode === "MASK" ? matJson.alphaCutoff ?? 0.5 : void 0;
+    const emissiveFactor = matJson.emissiveFactor;
+    const emissiveFactor3 = [
+      emissiveFactor?.[0] ?? 0,
+      emissiveFactor?.[1] ?? 0,
+      emissiveFactor?.[2] ?? 0
+    ];
+    materials.push({
+      ...matJson.name === void 0 ? {} : { name: matJson.name },
+      baseColorFactor: baseColor4,
+      ...emissiveFactor === void 0 ? {} : { emissiveFactor: emissiveFactor3 },
+      metallicFactor: pbr?.metallicFactor ?? 1,
+      roughnessFactor: pbr?.roughnessFactor ?? 1,
+      ...pbr?.baseColorTexture === void 0 ? {} : { baseColorTexture: parseTextureInfo(pbr.baseColorTexture, textures) },
+      ...pbr?.metallicRoughnessTexture === void 0 ? {} : { metallicRoughnessTexture: parseTextureInfo(pbr.metallicRoughnessTexture, textures) },
+      ...matJson.normalTexture === void 0 ? {} : {
+        normalTexture: {
+          ...parseTextureInfo(matJson.normalTexture, textures),
+          ...matJson.normalTexture.scale === void 0 ? {} : { scale: matJson.normalTexture.scale }
+        }
+      },
+      ...matJson.occlusionTexture === void 0 ? {} : {
+        occlusionTexture: {
+          ...parseTextureInfo(matJson.occlusionTexture, textures),
+          ...matJson.occlusionTexture.strength === void 0 ? {} : { strength: matJson.occlusionTexture.strength }
+        }
+      },
+      ...matJson.emissiveTexture === void 0 ? {} : { emissiveTexture: parseTextureInfo(matJson.emissiveTexture, textures) },
+      ...alphaMode === void 0 ? {} : { alphaMode },
+      ...alphaCutoff === void 0 ? {} : { alphaCutoff },
+      ...matJson.doubleSided === true ? { doubleSided: true } : {},
+      ...pbr?.baseColorTexture?.texCoord === void 0 || pbr.baseColorTexture.texCoord === 0 ? {} : { baseColorTexCoord: pbr.baseColorTexture.texCoord }
+    });
+  }
+  const diagnostics = {
+    nodeNames: [],
+    unsupportedExtensions: [...unsupportedExtensions],
+    matrixTrsCoexistNodes: []
+  };
+  const nodes = [];
+  const nodesJson = json.nodes ?? [];
+  for (let nodeIndex = 0; nodeIndex < nodesJson.length; nodeIndex++) {
+    const nodeJson = nodesJson[nodeIndex];
+    if (nodeJson === void 0) continue;
+    const transform = decomposeNodeTransform(nodeJson, nodeIndex, diagnostics);
+    if (nodeJson.name !== void 0) diagnostics.nodeNames.push(nodeJson.name);
+    const instancingExt = nodeJson.extensions?.EXT_mesh_gpu_instancing;
+    let instancing;
+    if (instancingExt !== void 0) {
+      const instancingResult = decodeNodeInstancing(
+        nodeIndex,
+        instancingExt.attributes ?? {},
+        accessors,
+        bufferViews,
+        buffers
+      );
+      if (!instancingResult.ok) return err(instancingResult.error);
+      instancing = instancingResult.value;
+    }
+    const nodeMorphWeights = nodeJson.weights === void 0 ? void 0 : new Float32Array(nodeJson.weights);
+    nodes.push({
+      ...nodeJson.name === void 0 ? {} : { name: nodeJson.name },
+      transform,
+      meshIndex: nodeJson.mesh ?? null,
+      skinIndex: nodeJson.skin ?? null,
+      children: nodeJson.children ?? [],
+      camera: nodeJson.camera ?? null,
+      lightIndex: nodeJson.extensions?.KHR_lights_punctual?.light ?? null,
+      ...instancing === void 0 ? {} : { instancing },
+      ...nodeMorphWeights === void 0 ? {} : { morphWeights: nodeMorphWeights }
+    });
+  }
+  const scenesJson = json.scenes ?? [];
+  const scenes = scenesJson.map((s) => ({
+    ...s.name === void 0 ? {} : { name: s.name },
+    nodes: s.nodes ?? []
+  }));
+  const defaultSceneIndex = json.scene ?? 0;
+  const skinsJson = json.skins;
+  const skinResult = parseSkin(skinsJson, nodesJson, accessors, bufferViews, buffers);
+  if (!skinResult.ok) return err(skinResult.error);
+  const skeletons = skinResult.value;
+  const animationsJson = json.animations;
+  const animResult = parseAnimation(animationsJson, nodesJson, accessors, bufferViews, buffers);
+  if (!animResult.ok) return err(animResult.error);
+  const animationClips = animResult.value;
+  return ok({
+    meshes,
+    materials,
+    nodes,
+    scenes,
+    skeletons,
+    animationClips,
+    textures: textures.length > 0 ? textures : void 0,
+    images: images.length > 0 ? images : void 0,
+    samplers: samplers.length > 0 ? samplers : void 0,
+    defaultSceneIndex,
+    diagnostics: {
+      nodeNames: diagnostics.nodeNames,
+      unsupportedExtensions: diagnostics.unsupportedExtensions,
+      matrixTrsCoexistNodes: diagnostics.matrixTrsCoexistNodes
+    },
+    meshPrimitiveCount,
+    lights: lightsResult.value
+  });
+}
+async function parseGltfForImporter(json, externalLoader, filePath, options = {}) {
+  if (json === null || typeof json !== "object") {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: 0
+      })
+    );
+  }
+  return parseGltfWithBin(json, {
+    externalLoader,
+    filePath,
+    ...options.meshopt === void 0 ? {} : { meshopt: options.meshopt }
+  });
+}
+function legacyParseResult(result, filePath, byteOffset) {
+  if (result.ok) return ok(result.value);
+  if (result.error instanceof ImportError) {
+    return err(gltfErr("gltf-malformed-header", { filePath, byteOffset }));
+  }
+  return err(result.error);
+}
+async function parseGltf(json, externalLoader, filePath, options = {}) {
+  const result = await parseGltfForImporter(json, externalLoader, filePath, options);
+  return legacyParseResult(result, filePath, 0);
+}
+async function parseGlbForImporter(buffer, filePath, options = {}) {
+  const chunksResult = parseGlbChunks(buffer, filePath);
+  if (!chunksResult.ok) return err(chunksResult.error);
+  let json;
+  try {
+    json = JSON.parse(new TextDecoder().decode(chunksResult.value.jsonChunk));
+  } catch (_e) {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: 12
+      })
+    );
+  }
+  if (json === null || typeof json !== "object") {
+    return err(
+      gltfErr("gltf-malformed-header", {
+        filePath,
+        byteOffset: 12
+      })
+    );
+  }
+  const externalLoader = async (uri) => {
+    throw new Error(`parseGlb: GLB containers must not reference external URIs (got ${uri})`);
+  };
+  return parseGltfWithBin(json, {
+    externalLoader,
+    ...chunksResult.value.binChunk === void 0 ? {} : { binChunk: chunksResult.value.binChunk },
+    filePath,
+    ...options.meshopt === void 0 ? {} : { meshopt: options.meshopt }
+  });
+}
+async function parseGlb(buffer, filePath, options = {}) {
+  const result = await parseGlbForImporter(buffer, filePath, options);
+  return legacyParseResult(result, filePath, 12);
+}
+function toAssetPack(doc, existingMeta, source) {
+  const items = [];
+  const seenMeshIndices = /* @__PURE__ */ new Set();
+  for (const m of doc.meshes) {
+    if (m === void 0) continue;
+    if (seenMeshIndices.has(m.meshIndex)) continue;
+    seenMeshIndices.add(m.meshIndex);
+    items.push({
+      kind: "mesh",
+      sourceIndex: m.meshIndex,
+      ...m.name === void 0 ? {} : { name: m.name }
+    });
+  }
+  for (let i = 0; i < doc.materials.length; i++) {
+    const m = doc.materials[i];
+    if (m === void 0) continue;
+    items.push({
+      kind: "material",
+      sourceIndex: i,
+      ...m.name === void 0 ? {} : { name: m.name }
+    });
+  }
+  for (let i = 0; i < doc.scenes.length; i++) {
+    const s = doc.scenes[i];
+    if (s === void 0) continue;
+    items.push({
+      kind: "scene",
+      sourceIndex: i,
+      ...s.name === void 0 ? {} : { name: s.name }
+    });
+  }
+  const images = doc.images ?? [];
+  for (let i = 0; i < images.length; i++) {
+    const img = images[i];
+    if (img === void 0) continue;
+    items.push({
+      kind: "texture",
+      sourceIndex: i,
+      ...img.name === void 0 ? {} : { name: img.name }
+    });
+  }
+  const samplers = doc.samplers ?? [];
+  for (let i = 0; i < samplers.length; i++) {
+    const sampler = samplers[i];
+    if (sampler === void 0) continue;
+    items.push({
+      kind: "sampler",
+      sourceIndex: i,
+      ...sampler.name === void 0 ? {} : { name: sampler.name }
+    });
+  }
+  for (let i = 0; i < doc.skeletons.length; i++) {
+    items.push({ kind: "skeleton", sourceIndex: i });
+  }
+  for (let i = 0; i < doc.skeletons.length; i++) {
+    items.push({ kind: "skin", sourceIndex: i });
+  }
+  for (let i = 0; i < doc.animationClips.length; i++) {
+    const clip = doc.animationClips[i];
+    if (clip === void 0) continue;
+    items.push({
+      kind: "animation-clip",
+      sourceIndex: i,
+      ...clip.name === void 0 ? {} : { name: clip.name }
+    });
+  }
+  const reuse = reimportReuseMeta(items, existingMeta);
+  if (!reuse.ok) return reuse;
+  const subAssetByKindIndex = new Map(
+    reuse.value.subAssets.map((entry) => [`${entry.kind}:${entry.sourceIndex}`, entry])
+  );
+  const sourceOverrides = {
+    ...existingMeta?.sourceOverrides ?? {}
+  };
+  for (const meshIndex of seenMeshIndices) {
+    const meshOutput = subAssetByKindIndex.get(`mesh:${meshIndex}`);
+    if (meshOutput?.sourceKey === void 0) continue;
+    const materialSlots = [];
+    const slotByMaterial = /* @__PURE__ */ new Map();
+    const usedNames = /* @__PURE__ */ new Set();
+    const uniqueName = (raw) => {
+      const base = raw.trim() || "Material";
+      let candidate = base;
+      let suffix = 2;
+      while (usedNames.has(candidate)) candidate = `${base}_${suffix++}`;
+      usedNames.add(candidate);
+      return candidate;
+    };
+    for (const primitive of doc.meshes.filter((mesh) => mesh.meshIndex === meshIndex)) {
+      const materialIndex = primitive.materialIndex;
+      if (slotByMaterial.has(materialIndex)) continue;
+      const materialOutput = materialIndex === null ? void 0 : subAssetByKindIndex.get(`material:${materialIndex}`);
+      slotByMaterial.set(materialIndex, materialSlots.length);
+      materialSlots.push({
+        slotName: uniqueName(
+          materialIndex === null ? "Default" : doc.materials[materialIndex]?.name ?? `Material_${materialIndex}`
+        ),
+        sourceKey: materialIndex === null ? "gltf:default" : materialOutput?.sourceKey ?? `gltf:material:${materialIndex}`,
+        ...materialOutput === void 0 ? {} : { defaultMaterialGuid: materialOutput.guid }
+      });
+    }
+    const previousPayload = existingMeta?.sourceOverrides?.[meshOutput.sourceKey];
+    const previousRaw = previousPayload?.materialSlots;
+    const previous = Array.isArray(previousRaw) ? previousRaw.filter(
+      (slot) => slot !== null && typeof slot === "object" && !Array.isArray(slot) && typeof slot.slotName === "string"
+    ) : [];
+    const reconciled = reconcileMeshMaterialSlotTopology(materialSlots, previous);
+    if (!reconciled.ok) {
+      return err({
+        code: "mesh-material-slot-topology-change",
+        expected: `unambiguous material slot identity for mesh ${meshOutput.guid}`,
+        hint: reconciled.error.hint,
+        detail: {
+          sourceIndices: reconciled.error.nextIndices,
+          previousIndices: reconciled.error.previousIndices
+        }
+      });
+    }
+    sourceOverrides[meshOutput.sourceKey] = {
+      ...previousPayload ?? {},
+      materialSlots: reconciled.slots
+    };
+  }
+  const meta = {
+    schemaVersion: 1,
+    kind: "external-asset-package",
+    importer: "gltf",
+    source,
+    subAssets: reuse.value.subAssets,
+    ...Object.keys(sourceOverrides).length === 0 ? {} : { sourceOverrides },
+    sourceOverrideDescriptors: reuse.value.subAssets.filter((entry) => entry.kind === "mesh" && entry.sourceKey !== void 0).map((entry) => ({
+      sourceKey: entry.sourceKey,
+      semantic: "mesh-material-slot-defaults",
+      payloadSchema: MESH_MATERIAL_SLOT_SOURCE_OVERRIDE_PAYLOAD_SCHEMA
+    })),
+    importSettings: {
+      defaultSceneIndex: doc.defaultSceneIndex,
+      ...typeof existingMeta?.importSettings.standardMaterialGuid === "string" ? { standardMaterialGuid: existingMeta.importSettings.standardMaterialGuid } : {},
+      ...existingMeta?.importSettings.downscaleMaxDimension !== void 0 ? { downscaleMaxDimension: existingMeta.importSettings.downscaleMaxDimension } : {},
+      diagnostics: {
+        nodeNames: doc.diagnostics.nodeNames,
+        unsupportedExtensions: doc.diagnostics.unsupportedExtensions,
+        matrixTrsCoexistNodes: doc.diagnostics.matrixTrsCoexistNodes
+      }
+    }
+  };
+  return ok({ meta, subAssets: reuse.value.subAssets });
+}
+
+// src/serialize-meta.ts
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) return value.map(sortKeysDeep);
+  if (value !== null && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = sortKeysDeep(obj[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function serializeMetaJson(meta) {
+  return `${JSON.stringify(sortKeysDeep(meta), null, 2)}
+`;
+}
+
+// src/cli-gltf.ts
+function emitError(ctx, err2) {
+  const payload = {
+    code: err2.code,
+    expected: err2.expected,
+    hint: err2.hint
+  };
+  if (err2.detail !== void 0) payload.detail = err2.detail;
+  ctx.stderrWrite(JSON.stringify(payload));
+  return 1;
+}
+function helpBody() {
+  return [
+    "forgeax-engine-remote-gltf \u2014 glTF / GLB sidecar importer (produces texture/mesh/material/scene sub-assets)",
+    "",
+    "Usage:",
+    "  forgeax-engine-remote-gltf import <path.gltf|path.glb>",
+    "  forgeax-engine-remote-gltf import --check <dir>",
+    "",
+    "Produces a sibling <source>.meta.json sidecar with sub-asset entries",
+    "for every glTF asset category: texture, mesh, material, scene.",
+    ""
+  ].join("\n");
+}
+async function runCliGltf(rest, ctx) {
+  const [sub, ...subRest] = rest;
+  if (sub === void 0 || sub === "--help" || sub === "-h") {
+    ctx.stdoutWrite(helpBody());
+    return 0;
+  }
+  if (sub !== "import") {
+    return emitError(ctx, {
+      code: "unknown-subcommand",
+      expected: "subcommand 'import'",
+      hint: "run 'forgeax-engine-remote-gltf --help' for usage",
+      detail: { subcommand: sub }
+    });
+  }
+  return runImport(subRest, ctx);
+}
+async function runImport(rest, ctx) {
+  let positionals;
+  let check = false;
+  try {
+    const parsed = parseArgs({
+      args: rest,
+      allowPositionals: true,
+      strict: true,
+      options: { check: { type: "boolean" } }
+    });
+    positionals = [...parsed.positionals];
+    check = parsed.values.check === true;
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return emitError(ctx, {
+      code: "cli-parse-error",
+      expected: "forgeax-engine-remote-gltf import [--check] <path>",
+      hint: "run 'forgeax-engine-remote-gltf --help' for usage",
+      detail: { message }
+    });
+  }
+  const target = positionals[0];
+  if (target === void 0) {
+    return emitError(ctx, {
+      code: "cli-parse-error",
+      expected: check ? "forgeax-engine-remote-gltf import --check <dir>" : "forgeax-engine-remote-gltf import <path.gltf|path.glb>",
+      hint: "pass a positional <gltf-or-glb> argument; with --check pass a directory"
+    });
+  }
+  if (check) {
+    return runCheck(target, ctx);
+  }
+  return runWrite(target, ctx);
+}
+var SCANNER_BLACKLIST_FALLBACK = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".forgeax-harness",
+  ".git",
+  "dist",
+  ".forgeax-asset-cache",
+  "forgeax-engine-assets",
+  "coverage"
+]);
+async function loadScannerBlacklist() {
+  try {
+    const mod = await import('@forgeax/engine-pack/scanner');
+    return mod.SCANNER_BLACKLIST ?? SCANNER_BLACKLIST_FALLBACK;
+  } catch {
+    return SCANNER_BLACKLIST_FALLBACK;
+  }
+}
+async function findGltfSources(dir, blacklist, out) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (blacklist.has(entry.name)) continue;
+      await findGltfSources(full, blacklist, out);
+    } else if (entry.isFile()) {
+      const lower = entry.name.toLowerCase();
+      if (lower.endsWith(".gltf") || lower.endsWith(".glb")) {
+        out.push(full);
+      }
+    }
+  }
+}
+function expectedMetaPathFor(filePath) {
+  return `${filePath}.meta.json`;
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runCheck(target, ctx) {
+  const root = resolve(target);
+  let st;
+  try {
+    st = await stat(root);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return emitError(ctx, {
+      code: "cli-parse-error",
+      expected: "forgeax-engine-remote-gltf import --check <dir>",
+      hint: "pass a directory that exists and is readable",
+      detail: { path: target, message }
+    });
+  }
+  const blacklist = await loadScannerBlacklist();
+  const found = [];
+  if (st.isDirectory()) {
+    await findGltfSources(root, blacklist, found);
+  } else if (st.isFile()) {
+    const lower = root.toLowerCase();
+    if (lower.endsWith(".gltf") || lower.endsWith(".glb")) {
+      found.push(root);
+    }
+  }
+  found.sort();
+  for (const sourcePath of found) {
+    const metaPath = expectedMetaPathFor(sourcePath);
+    if (!await fileExists(metaPath)) {
+      return emitError(ctx, {
+        code: "gltf-meta-missing",
+        expected: "sidecar <source>.meta.json (importer: 'gltf') present in same directory",
+        hint: GLTF_ERROR_HINTS["gltf-meta-missing"],
+        detail: { filePath: sourcePath, expectedMetaPath: metaPath }
+      });
+    }
+  }
+  return 0;
+}
+async function runWrite(target, ctx) {
+  const sourcePath = resolve(target);
+  const lower = sourcePath.toLowerCase();
+  const isGlb = lower.endsWith(".glb");
+  const isGltf = lower.endsWith(".gltf");
+  if (!isGlb && !isGltf) {
+    return emitError(ctx, {
+      code: "cli-parse-error",
+      expected: "<path>.gltf or <path>.glb",
+      hint: "pass a .gltf / .glb source file; for batch dry-run use --check <dir>",
+      detail: { path: target }
+    });
+  }
+  let docResult;
+  if (isGlb) {
+    let buf;
+    try {
+      buf = await readFile(sourcePath);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      return emitError(ctx, {
+        code: "cli-parse-error",
+        expected: "readable .glb at <path>",
+        hint: "check the file exists and the process has read access",
+        detail: { path: target, message }
+      });
+    }
+    const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    docResult = await parseGlb(ab, sourcePath);
+  } else {
+    let text;
+    try {
+      text = await readFile(sourcePath, "utf-8");
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      return emitError(ctx, {
+        code: "cli-parse-error",
+        expected: "readable .gltf at <path>",
+        hint: "check the file exists and the process has read access",
+        detail: { path: target, message }
+      });
+    }
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      return emitError(ctx, {
+        code: "gltf-malformed-header",
+        expected: "valid JSON document at the .gltf root",
+        hint: GLTF_ERROR_HINTS["gltf-malformed-header"],
+        detail: { filePath: sourcePath, byteOffset: 0, parseError: message }
+      });
+    }
+    const baseDir = dirname(sourcePath);
+    const externalLoader = async (uri) => {
+      const abs = resolve(baseDir, uri);
+      const buf = await readFile(abs);
+      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    };
+    docResult = await parseGltf(json, externalLoader, sourcePath);
+  }
+  if (!docResult.ok) {
+    return emitError(ctx, {
+      code: docResult.error.code,
+      expected: docResult.error.expected,
+      hint: docResult.error.hint,
+      detail: docResult.error.detail
+    });
+  }
+  const metaPath = expectedMetaPathFor(sourcePath);
+  let existingMeta;
+  if (await fileExists(metaPath)) {
+    try {
+      const raw = await readFile(metaPath, "utf-8");
+      existingMeta = JSON.parse(raw);
+    } catch {
+      existingMeta = void 0;
+    }
+  }
+  const sourceRelative = sourcePath.slice(dirname(sourcePath).length + 1);
+  const pack = toAssetPack(
+    docResult.value,
+    existingMeta,
+    sourceRelative
+  );
+  if (!pack.ok) {
+    return emitError(ctx, pack.error);
+  }
+  await writeFile(metaPath, serializeMetaJson(pack.value.meta), "utf-8");
+  return 0;
+}
+var isBinEntry = await (async () => {
+  const argv1 = process.argv[1];
+  if (typeof argv1 !== "string") return false;
+  const argv1Real = await realpath(argv1).catch(() => argv1);
+  const selfReal = await realpath(fileURLToPath(import.meta.url)).catch(
+    () => fileURLToPath(import.meta.url)
+  );
+  return argv1Real === selfReal;
+})();
+if (isBinEntry) {
+  const exitCode = await runCliGltf(process.argv.slice(2), {
+    stdoutWrite: (line) => process.stdout.write(`${line}
+`),
+    stderrWrite: (line) => process.stderr.write(`${line}
+`)
+  });
+  process.exit(exitCode);
+}
+
+export { runCliGltf };
+//# sourceMappingURL=cli-gltf.mjs.map
+//# sourceMappingURL=cli-gltf.mjs.map