@aura3d/engine 1.0.0

package/dist/assets/GLTFLoader.js

@@ -0,0 +1,2735 @@
+import { PointLight, composeMat4, decomposeMat4, invertMat4, multiplyMat4, Renderable, Scene, SpotLight } from "../scene/index.js";
+import { AnimationClip, AnimationTrack, Skeleton } from "../animation/browser-index.js";
+import { evaluateGLTFExtensionSupport } from "./GLTFExtensionSupport.js";
+const DEFAULT_GLTF_MATERIAL_NAME = "default-material";
+const RUNTIME_MATERIAL_KEY_MARKER = "#aura3d-runtime:";
+const DISPOSE_GLTF_ASSET = Symbol("disposeGLTFAsset");
+const MAX_RENDERABLE_SKIN_JOINTS = 64;
+function createSpecularFromSpecularGlossiness(extension) {
+    if (!extension)
+        return undefined;
+    return {
+        factor: 1,
+        colorFactor: extension.specularFactor,
+        colorTexture: extension.specularGlossinessTexture
+    };
+}
+export class GLTFLoader {
+    options;
+    type = "gltf";
+    constructor(options = {}) {
+        this.options = options;
+    }
+    canLoad(request) {
+        return /\.(?:gltf|glb)(?:\?.*)?$/i.test(request.url) || request.url.startsWith("data:model/gltf");
+    }
+    async load(request, context) {
+        context.throwIfAborted(request.url);
+        const document = await loadDocument(request);
+        let json = document.json;
+        if (json.asset?.version && !json.asset.version.startsWith("2.")) {
+            throw new Error(`Unsupported glTF version: ${json.asset.version}`);
+        }
+        const extensionSupport = evaluateGLTFExtensionSupport(json.extensionsUsed, json.extensionsRequired);
+        const unsupportedRequiredExtensions = extensionSupport.unsupportedRequired;
+        if (unsupportedRequiredExtensions.length > 0) {
+            throw new Error(`Unsupported required glTF extensions: ${unsupportedRequiredExtensions.join(", ")}`);
+        }
+        const rawBuffers = await Promise.all((json.buffers ?? []).map((buffer, index) => loadBuffer(buffer, index, document, request)));
+        const prepared = await prepareBufferViews(json, rawBuffers, this.options.meshoptDecoder);
+        const buffers = prepared.buffers;
+        json = prepared.json;
+        const accessorCache = createGLTFAccessorReadCache();
+        const meshQuantizationEnabled = usesGLTFExtension(json, "KHR_mesh_quantization");
+        const images = createImageAssets(json, buffers);
+        const textures = createTextureAssets(json);
+        const materials = createMaterialAssets(json, textures);
+        const materialVariants = createMaterialVariantAssets(json);
+        const scenes = createSceneAssets(json);
+        const defaultScene = resolveDefaultSceneIndex(json);
+        const cameras = createCameraAssets(json);
+        const lights = createLightAssets(json);
+        const skins = createSkinAssets(json, buffers, accessorCache);
+        const nodeInstanceTransforms = createNodeInstanceTransforms(json, buffers, accessorCache);
+        const meshes = await Promise.all((json.meshes ?? []).flatMap((mesh, meshIndex) => {
+            validateMeshDescriptor(mesh, meshIndex);
+            return mesh.primitives.map(async (primitive, primitiveIndex) => {
+                validatePrimitiveDescriptor(primitive, meshIndex, primitiveIndex);
+                validatePrimitiveAttributeAccessors(json, primitive, meshQuantizationEnabled, meshIndex, primitiveIndex);
+                const positionAccessorIndex = primitive.attributes.POSITION;
+                if (positionAccessorIndex === undefined) {
+                    throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} is missing POSITION`);
+                }
+                const dracoPrimitive = await decodeDracoPrimitive(json, buffers, primitive, meshIndex, primitiveIndex, this.options.dracoDecoder);
+                const positions = dracoPrimitive?.attributes.POSITION ?? readAccessor(json, buffers, positionAccessorIndex, accessorCache);
+                const normals = readPrimitiveAttribute(json, buffers, primitive, dracoPrimitive, "NORMAL", accessorCache);
+                const texcoordSets = readTexcoordSets(json, buffers, primitive, positions.length, meshIndex, primitiveIndex, dracoPrimitive, accessorCache);
+                const texcoords = texcoordSets[0] ?? [];
+                const tangents = readPrimitiveAttribute(json, buffers, primitive, dracoPrimitive, "TANGENT", accessorCache);
+                const colors = readPrimitiveAttribute(json, buffers, primitive, dracoPrimitive, "COLOR_0", accessorCache);
+                const joints = readPrimitiveAttribute(json, buffers, primitive, dracoPrimitive, "JOINTS_0", accessorCache);
+                const weights = readPrimitiveAttribute(json, buffers, primitive, dracoPrimitive, "WEIGHTS_0", accessorCache);
+                const indices = dracoPrimitive
+                    ? dracoPrimitive.indices?.map((index) => [index])
+                    : primitive.indices === undefined ? undefined : readAccessor(json, buffers, primitive.indices, accessorCache);
+                validateAttributeCount("NORMAL", normals, positions.length, meshIndex, primitiveIndex);
+                validateAttributeCount("TANGENT", tangents, positions.length, meshIndex, primitiveIndex);
+                validateAttributeCount("COLOR_0", colors, positions.length, meshIndex, primitiveIndex);
+                validateAttributeCount("JOINTS_0", joints, positions.length, meshIndex, primitiveIndex);
+                validateAttributeCount("WEIGHTS_0", weights, positions.length, meshIndex, primitiveIndex);
+                const primitiveMaterialIndex = resolvePrimitiveMaterialIndex(primitive, materials, meshIndex, primitiveIndex);
+                const primitiveMaterial = primitiveMaterialIndex === undefined ? undefined : materials[primitiveMaterialIndex];
+                const primitiveMaterialVariants = resolvePrimitiveMaterialVariants(primitive, materialVariants, materials, meshIndex, primitiveIndex);
+                validateMaterialTexCoordSets(primitiveMaterial, texcoordSets, meshIndex, primitiveIndex);
+                const typedPositions = positions.map((position) => [position[0] ?? 0, position[1] ?? 0, position[2] ?? 0]);
+                const typedNormals = normals.map((normal) => [normal[0] ?? 0, normal[1] ?? 0, normal[2] ?? 0]);
+                const typedTangents = tangents.map((tangent) => [tangent[0] ?? 0, tangent[1] ?? 0, tangent[2] ?? 0, tangent[3] ?? 1]);
+                const typedColors = colors.map((color) => [color[0] ?? 1, color[1] ?? 1, color[2] ?? 1, color[3] ?? 1]);
+                const typedJoints = joints.map((joint) => [joint[0] ?? 0, joint[1] ?? 0, joint[2] ?? 0, joint[3] ?? 0]);
+                const typedWeights = weights.map((weight) => normalizeSkinWeights([
+                    weight[0] ?? 0,
+                    weight[1] ?? 0,
+                    weight[2] ?? 0,
+                    weight[3] ?? 0
+                ], meshIndex, primitiveIndex));
+                const morphTargets = readMorphTargets(json, buffers, primitive, positions.length, meshIndex, primitiveIndex, accessorCache);
+                const resolvedPrimitive = resolvePrimitiveMode(primitive, indices?.map((index) => index[0] ?? 0), positions.length, meshIndex, primitiveIndex);
+                const geometry = createGeometryAsset(typedPositions, resolvedPrimitive.indices);
+                return {
+                    name: meshPrimitiveName(mesh, meshIndex, primitiveIndex),
+                    sourceMeshIndex: meshIndex,
+                    primitiveIndex,
+                    topology: resolvedPrimitive.topology,
+                    geometry,
+                    positions: typedPositions,
+                    normals: typedNormals,
+                    texcoords,
+                    texcoordSets,
+                    tangents: typedTangents,
+                    colors: typedColors,
+                    joints: typedJoints,
+                    weights: typedWeights,
+                    morphTargets,
+                    morphWeights: resolveMorphWeights(mesh, meshIndex, primitiveIndex, morphTargets.length),
+                    indices: resolvedPrimitive.indices,
+                    material: materialName(primitiveMaterial, primitiveMaterialIndex),
+                    materialIndex: primitiveMaterialIndex,
+                    materialVariants: primitiveMaterialVariants,
+                    skinIndex: findSkinForMesh(json, meshIndex)
+                };
+            });
+        }));
+        const animations = createAnimationClips(json, buffers, accessorCache);
+        const loadProfile = createGLTFLoaderLoadProfileDiagnostics(document, buffers, images, accessorCache);
+        const loaderDiagnostics = createGLTFLoaderDiagnostics(json, {
+            images,
+            textures,
+            materials,
+            meshes,
+            animations,
+            skins
+        }, loadProfile);
+        let disposed = false;
+        const assertAlive = () => {
+            if (disposed) {
+                throw new Error(`glTF asset ${request.url} has been disposed`);
+            }
+        };
+        const asset = {
+            url: request.url,
+            get disposed() {
+                return disposed;
+            },
+            loaderDiagnostics,
+            images,
+            textures,
+            materials,
+            materialVariants,
+            scenes,
+            defaultScene,
+            meshes,
+            cameras,
+            lights,
+            skins,
+            animations,
+            createScene: (options) => {
+                assertAlive();
+                return createScene(json, meshes, cameras, lights, skins, nodeInstanceTransforms, materialVariants, options);
+            },
+            toJSON: () => {
+                assertAlive();
+                return serializeGLTFAsset(request.url, loaderDiagnostics, images, textures, materials, materialVariants, scenes, defaultScene, meshes, cameras, lights, skins, animations);
+            },
+            [DISPOSE_GLTF_ASSET]: () => {
+                disposed = true;
+            }
+        };
+        return asset;
+    }
+    dispose(asset) {
+        asset[DISPOSE_GLTF_ASSET]?.();
+    }
+}
+function createGLTFAccessorReadCache() {
+    return {
+        rowsByAccessor: new Map(),
+        dataViews: new Map(),
+        profile: {
+            accessorReadCount: 0,
+            uniqueAccessorReadCount: 0,
+            accessorCacheHitCount: 0,
+            accessorRowsRead: 0,
+            accessorValuesRead: 0,
+            accessorReadMs: 0,
+            dataViewCacheEntries: 0,
+            largestAccessors: []
+        }
+    };
+}
+function createGLTFLoaderLoadProfileDiagnostics(document, buffers, images, accessorCache) {
+    const profile = accessorCache.profile;
+    const embeddedImageBytes = images.reduce((sum, image) => sum + (image.data?.byteLength ?? 0), 0);
+    return {
+        schemaVersion: "gltf-loader-load-profile",
+        documentBytes: document.byteLength,
+        binaryChunkBytes: document.binaryChunk?.byteLength ?? 0,
+        bufferBytes: buffers.reduce((sum, buffer) => sum + buffer.byteLength, 0),
+        imageBytes: embeddedImageBytes,
+        embeddedImageBytes,
+        externalImageCount: images.filter((image) => Boolean(image.uri) && !image.uri.startsWith("data:")).length,
+        bufferViewImageCount: images.filter((image) => image.data !== undefined).length,
+        accessorReadCount: profile.accessorReadCount,
+        uniqueAccessorReadCount: profile.uniqueAccessorReadCount,
+        accessorCacheHitCount: profile.accessorCacheHitCount,
+        accessorRowsRead: profile.accessorRowsRead,
+        accessorValuesRead: profile.accessorValuesRead,
+        accessorReadMs: roundDiagnosticMs(profile.accessorReadMs),
+        dataViewCacheEntries: profile.dataViewCacheEntries,
+        largestAccessors: [...profile.largestAccessors]
+    };
+}
+function roundDiagnosticMs(value) {
+    return Math.round(value * 1000) / 1000;
+}
+function nowMs() {
+    const performance = globalThis.performance;
+    return performance && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function createGeometryAsset(positions, indices) {
+    const min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+    const max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+    for (const position of positions) {
+        min[0] = Math.min(min[0], position[0]);
+        min[1] = Math.min(min[1], position[1]);
+        min[2] = Math.min(min[2], position[2]);
+        max[0] = Math.max(max[0], position[0]);
+        max[1] = Math.max(max[1], position[1]);
+        max[2] = Math.max(max[2], position[2]);
+    }
+    return { vertexCount: positions.length, indexCount: indices?.length ?? 0, bounds: { min, max } };
+}
+function createGLTFLoaderDiagnostics(json, asset, loadProfile) {
+    const extensionsUsed = [...new Set([...(json.extensionsUsed ?? []), ...(json.extensionsRequired ?? [])])].sort();
+    const extensionSupport = evaluateGLTFExtensionSupport(json.extensionsUsed, json.extensionsRequired);
+    const materialFeatures = [...new Set(asset.materials.flatMap(materialFeatureNames))].sort();
+    const textureSlots = [...new Set(asset.materials.flatMap(materialTextureSlotNames))].sort();
+    const unsupportedFeatures = collectUnsupportedFeatureDiagnostics(json);
+    const compression = {
+        draco: usesGLTFExtension(json, "KHR_draco_mesh_compression"),
+        meshopt: usesGLTFMeshoptExtension(json),
+        ktx2Basis: usesGLTFExtension(json, "KHR_texture_basisu") || asset.images.some((image) => /\.ktx2(?:[?#]|$)/i.test(image.uri ?? "") || image.mimeType === "image/ktx2")
+    };
+    const features = new Set([
+        "gltf",
+        ...extensionsUsed.map((extension) => `extension:${extension}`),
+        ...materialFeatures.map((feature) => `material:${feature}`),
+        ...textureSlots.map((slot) => `texture-slot:${slot}`)
+    ]);
+    if (asset.meshes.length > 0)
+        features.add("mesh");
+    if (asset.meshes.some((mesh) => mesh.geometry.indexCount > 0))
+        features.add("indexed-geometry");
+    if (asset.meshes.some((mesh) => mesh.normals.length > 0))
+        features.add("normals");
+    if (asset.meshes.some((mesh) => mesh.tangents.length > 0))
+        features.add("tangents");
+    if (asset.meshes.some((mesh) => mesh.colors.length > 0))
+        features.add("vertex-colors");
+    if (asset.meshes.some((mesh) => mesh.texcoordSets.some((set) => set.length > 0)))
+        features.add("texcoords");
+    if (asset.meshes.some((mesh) => mesh.texcoordSets.length > 1))
+        features.add("multi-uv");
+    if (asset.meshes.some((mesh) => mesh.morphTargets.length > 0))
+        features.add("morph-targets");
+    if (asset.meshes.some((mesh) => mesh.skinIndex !== undefined || mesh.joints.length > 0 || mesh.weights.length > 0))
+        features.add("skinning");
+    if (asset.skins.some((skin) => skin.joints.length > MAX_RENDERABLE_SKIN_JOINTS))
+        features.add("skinning-palette-limit-fallback");
+    if ((json.skins ?? []).some((skin) => skin.inverseBindMatrices === undefined))
+        features.add("skinning-default-inverse-bind-matrices");
+    for (const unsupportedFeature of unsupportedFeatures)
+        features.add(`unsupported:${unsupportedFeature}`);
+    if (asset.animations.length > 0)
+        features.add("animations");
+    if (asset.skins.length > 0)
+        features.add("skins");
+    if (asset.textures.length > 0)
+        features.add("textures");
+    if (compression.draco)
+        features.add("compression:draco");
+    if (compression.meshopt)
+        features.add("compression:meshopt");
+    if (compression.ktx2Basis)
+        features.add("compression:ktx2-basis");
+    return {
+        schemaVersion: "gltf-loader-diagnostics",
+        features: [...features].sort(),
+        extensionsUsed,
+        extensionsRequired: [...(json.extensionsRequired ?? [])].sort(),
+        unsupportedExtensions: extensionSupport.notAcceptedUsed,
+        extensionSupport,
+        unsupportedFeatures,
+        meshCount: asset.meshes.length,
+        primitiveCount: asset.meshes.length,
+        vertexCount: asset.meshes.reduce((sum, mesh) => sum + mesh.geometry.vertexCount, 0),
+        indexCount: asset.meshes.reduce((sum, mesh) => sum + mesh.geometry.indexCount, 0),
+        materialCount: asset.materials.length,
+        textureCount: asset.textures.length,
+        imageCount: asset.images.length,
+        animationCount: asset.animations.length,
+        skinCount: asset.skins.length,
+        morphTargetCount: asset.meshes.reduce((sum, mesh) => sum + mesh.morphTargets.length, 0),
+        materialFeatures,
+        textureSlots,
+        compression,
+        ...(loadProfile ? { loadProfile } : {})
+    };
+}
+function collectUnsupportedFeatureDiagnostics(json) {
+    const unsupported = new Set();
+    for (const mesh of json.meshes ?? []) {
+        for (const primitive of mesh.primitives) {
+            if (primitive.attributes.JOINTS_1 !== undefined || primitive.attributes.WEIGHTS_1 !== undefined) {
+                unsupported.add("skinning-extra-influences:JOINTS_1/WEIGHTS_1");
+            }
+        }
+    }
+    return [...unsupported].sort();
+}
+function materialFeatureNames(material) {
+    return [
+        material.unlit ? "unlit" : undefined,
+        material.metallicFactor > 0 ? "metallic" : undefined,
+        material.roughnessFactor < 1 ? "roughness" : undefined,
+        material.emissiveFactor.some((value) => value > 0) || material.emissiveStrength !== 1 ? "emissive" : undefined,
+        material.alphaMode !== "OPAQUE" ? `alpha-${material.alphaMode.toLowerCase()}` : undefined,
+        material.doubleSided ? "double-sided" : undefined,
+        material.normalTexture ? "normal-texture" : undefined,
+        material.occlusionTexture ? "occlusion-texture" : undefined,
+        material.clearcoat ? "clearcoat" : undefined,
+        material.transmission ? "transmission" : undefined,
+        material.diffuseTransmission ? "diffuse-transmission" : undefined,
+        material.volume ? "volume" : undefined,
+        material.ior !== undefined ? "ior" : undefined,
+        material.specular ? "specular" : undefined,
+        material.sheen ? "sheen" : undefined,
+        material.anisotropy ? "anisotropy" : undefined,
+        material.iridescence ? "iridescence" : undefined,
+        material.dispersion !== undefined ? "dispersion" : undefined,
+        material.pbrSpecularGlossiness ? "pbr-specular-glossiness" : undefined
+    ].filter((feature) => feature !== undefined);
+}
+function materialTextureSlotNames(material) {
+    return [
+        material.baseColorTexture ? "base-color" : undefined,
+        material.metallicRoughnessTexture ? "metallic-roughness" : undefined,
+        material.normalTexture ? "normal" : undefined,
+        material.occlusionTexture ? "occlusion" : undefined,
+        material.emissiveTexture ? "emissive" : undefined,
+        material.clearcoat?.texture ? "clearcoat" : undefined,
+        material.clearcoat?.roughnessTexture ? "clearcoat-roughness" : undefined,
+        material.clearcoat?.normalTexture ? "clearcoat-normal" : undefined,
+        material.transmission?.texture ? "transmission" : undefined,
+        material.diffuseTransmission?.texture ? "diffuse-transmission" : undefined,
+        material.diffuseTransmission?.colorTexture ? "diffuse-transmission-color" : undefined,
+        material.volume?.thicknessTexture ? "volume-thickness" : undefined,
+        material.specular?.texture ? "specular" : undefined,
+        material.specular?.colorTexture ? "specular-color" : undefined,
+        material.sheen?.colorTexture ? "sheen-color" : undefined,
+        material.sheen?.roughnessTexture ? "sheen-roughness" : undefined,
+        material.anisotropy?.texture ? "anisotropy" : undefined,
+        material.iridescence?.texture ? "iridescence" : undefined,
+        material.iridescence?.thicknessTexture ? "iridescence-thickness" : undefined
+    ].filter((slot) => slot !== undefined);
+}
+function validateAttributeCount(semantic, values, vertexCount, meshIndex, primitiveIndex) {
+    if (values.length > 0 && values.length !== vertexCount) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} ${semantic} count mismatch`);
+    }
+}
+function validateMeshDescriptor(mesh, meshIndex) {
+    if (!Array.isArray(mesh.primitives) || mesh.primitives.length === 0) {
+        throw new Error(`glTF mesh ${meshIndex} primitives must be a non-empty array`);
+    }
+}
+function validatePrimitiveDescriptor(primitive, meshIndex, primitiveIndex) {
+    if (!isObjectRecord(primitive.attributes) || Array.isArray(primitive.attributes)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} attributes must be an object`);
+    }
+    for (const [semantic, accessorIndex] of Object.entries(primitive.attributes)) {
+        if (!Number.isInteger(accessorIndex) || accessorIndex < 0) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} attribute ${semantic} accessor must be a non-negative integer`);
+        }
+    }
+    if (primitive.indices !== undefined && (!Number.isInteger(primitive.indices) || primitive.indices < 0)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} indices accessor must be a non-negative integer`);
+    }
+    if (primitive.mode !== undefined && (!Number.isInteger(primitive.mode) || primitive.mode < 0)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} mode must be a non-negative integer`);
+    }
+    const variantExtension = primitive.extensions?.KHR_materials_variants;
+    if (variantExtension !== undefined && (!Array.isArray(variantExtension.mappings) || variantExtension.mappings.length === 0)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_materials_variants.mappings must be a non-empty array`);
+    }
+}
+function readTexcoordSets(json, buffers, primitive, vertexCount, meshIndex, primitiveIndex, decodedPrimitive, accessorCache) {
+    const sets = [];
+    for (const [semantic, accessorIndex] of Object.entries(primitive.attributes)) {
+        const match = /^TEXCOORD_(\d+)$/.exec(semantic);
+        if (!match)
+            continue;
+        const setIndex = Number(match[1]);
+        if (!Number.isInteger(setIndex)) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} ${semantic} has invalid texture coordinate set index`);
+        }
+        const values = decodedPrimitive?.attributes[semantic] ?? readAccessor(json, buffers, accessorIndex, accessorCache);
+        validateAttributeCount(semantic, values, vertexCount, meshIndex, primitiveIndex);
+        sets[setIndex] = values.map((texcoord) => [texcoord[0] ?? 0, texcoord[1] ?? 0]);
+    }
+    const normalized = [];
+    for (let index = 0; index < sets.length; index += 1) {
+        normalized[index] = sets[index] ?? [];
+    }
+    return normalized;
+}
+function readPrimitiveAttribute(json, buffers, primitive, decodedPrimitive, semantic, accessorCache) {
+    const decoded = decodedPrimitive?.attributes[semantic];
+    if (decoded)
+        return normalizeDecodedPrimitiveAttribute(json, primitive, semantic, decoded);
+    return readOptionalAccessor(json, buffers, primitive.attributes[semantic], accessorCache);
+}
+function normalizeDecodedPrimitiveAttribute(json, primitive, semantic, rows) {
+    const copied = rows.map((row) => [...row]);
+    const accessorIndex = primitive.attributes[semantic];
+    const accessor = accessorIndex === undefined ? undefined : json.accessors?.[accessorIndex];
+    if (!accessor?.normalized || !semantic.startsWith("COLOR_")) {
+        return copied;
+    }
+    const normalizer = normalizedComponentScale(accessor.componentType);
+    if (!normalizer) {
+        return copied;
+    }
+    const needsNormalization = copied.some((row) => row.some((value) => Math.abs(value) > 1));
+    if (!needsNormalization) {
+        return copied.map((row) => row.map(clampColorChannel));
+    }
+    return copied.map((row) => row.map((value) => clampColorChannel(normalizer(value))));
+}
+function normalizedComponentScale(componentType) {
+    if (componentType === 5120)
+        return (value) => Math.max(value / 127, -1);
+    if (componentType === 5121)
+        return (value) => value / 255;
+    if (componentType === 5122)
+        return (value) => Math.max(value / 32767, -1);
+    if (componentType === 5123)
+        return (value) => value / 65535;
+    return null;
+}
+function clampColorChannel(value) {
+    return Math.max(0, Math.min(1, value));
+}
+async function decodeDracoPrimitive(json, buffers, primitive, meshIndex, primitiveIndex, dracoDecoder) {
+    const extension = primitive.extensions?.KHR_draco_mesh_compression;
+    if (!extension)
+        return undefined;
+    if (!usesGLTFExtension(json, "KHR_draco_mesh_compression")) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} uses KHR_draco_mesh_compression but the extension is not declared`);
+    }
+    if (!dracoDecoder) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression requires a dracoDecoder`);
+    }
+    validateDracoDescriptor(extension, meshIndex, primitiveIndex);
+    const { view, buffer } = getBufferView(json, buffers, extension.bufferView);
+    const start = view.byteOffset ?? 0;
+    const source = new Uint8Array(buffer, start, view.byteLength);
+    const decoded = await dracoDecoder(source, {
+        meshIndex,
+        primitiveIndex,
+        bufferViewIndex: extension.bufferView,
+        attributes: { ...extension.attributes }
+    });
+    validateDecodedDracoPrimitive(decoded, primitive, meshIndex, primitiveIndex);
+    return decoded;
+}
+function validateDracoDescriptor(extension, meshIndex, primitiveIndex) {
+    if (!Number.isInteger(extension.bufferView) || extension.bufferView < 0) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression bufferView must be a non-negative integer`);
+    }
+    if (!isObjectRecord(extension.attributes) || Array.isArray(extension.attributes)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression attributes must be an object`);
+    }
+    if (!Number.isInteger(extension.attributes.POSITION) || extension.attributes.POSITION < 0) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression requires POSITION attribute mapping`);
+    }
+    for (const [semantic, attributeId] of Object.entries(extension.attributes)) {
+        if (!Number.isInteger(attributeId) || attributeId < 0) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression attribute ${semantic} id must be a non-negative integer`);
+        }
+    }
+}
+function validateDecodedDracoPrimitive(decoded, primitive, meshIndex, primitiveIndex) {
+    if (!isObjectRecord(decoded.attributes) || Array.isArray(decoded.attributes)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression decoder must return attributes`);
+    }
+    const positions = decoded.attributes.POSITION;
+    if (!Array.isArray(positions) || positions.length === 0) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression decoder must return POSITION rows`);
+    }
+    for (const [semantic, rows] of Object.entries(decoded.attributes)) {
+        if (primitive.attributes[semantic] === undefined) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression decoded unexpected attribute ${semantic}`);
+        }
+        if (!Array.isArray(rows) || rows.length !== positions.length) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression decoded ${semantic} count must match POSITION count`);
+        }
+        for (const [rowIndex, row] of rows.entries()) {
+            if (!Array.isArray(row) || row.some((value) => !Number.isFinite(value))) {
+                throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression decoded ${semantic} row ${rowIndex} must contain finite values`);
+            }
+        }
+    }
+    if (decoded.indices !== undefined) {
+        for (const index of decoded.indices) {
+            if (!Number.isInteger(index) || index < 0 || index >= positions.length) {
+                throw new RangeError(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_draco_mesh_compression decoded index ${index} is outside vertex count ${positions.length}`);
+            }
+        }
+    }
+}
+function validateMaterialTexCoordSets(material, texcoordSets, meshIndex, primitiveIndex) {
+    if (!material)
+        return;
+    for (const textureInfo of materialTextureInfos(material)) {
+        if (textureInfo.texCoord > 0 && (texcoordSets[textureInfo.texCoord]?.length ?? 0) === 0) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} material ${material.name} references missing TEXCOORD_${textureInfo.texCoord}`);
+        }
+    }
+}
+function materialTextureInfos(material) {
+    return [
+        material.baseColorTexture,
+        material.metallicRoughnessTexture,
+        material.normalTexture,
+        material.occlusionTexture,
+        material.emissiveTexture,
+        material.clearcoat?.texture,
+        material.clearcoat?.roughnessTexture,
+        material.clearcoat?.normalTexture,
+        material.transmission?.texture,
+        material.diffuseTransmission?.texture,
+        material.diffuseTransmission?.colorTexture,
+        material.volume?.thicknessTexture,
+        material.specular?.texture,
+        material.specular?.colorTexture,
+        material.sheen?.colorTexture,
+        material.sheen?.roughnessTexture,
+        material.anisotropy?.texture,
+        material.iridescence?.texture,
+        material.iridescence?.thicknessTexture
+    ].filter((info) => info !== undefined);
+}
+function resolvePrimitiveMode(primitive, rawIndices, vertexCount, meshIndex, primitiveIndex) {
+    const mode = primitive.mode ?? 4;
+    const source = rawIndices ?? [...Array(vertexCount).keys()];
+    validatePrimitiveIndices(source, vertexCount, meshIndex, primitiveIndex);
+    switch (mode) {
+        case 1:
+            if (source.length % 2 !== 0)
+                throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} LINES index count must be even`);
+            return { topology: "lines", indices: rawIndices };
+        case 2:
+            return { topology: "lines", indices: expandLineLoop(source) };
+        case 3:
+            return { topology: "lines", indices: expandLineStrip(source) };
+        case 4:
+            if (source.length % 3 !== 0)
+                throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} TRIANGLES index count must be a multiple of 3`);
+            return { topology: "triangles", indices: rawIndices };
+        case 5:
+            return { topology: "triangles", indices: expandTriangleStrip(source) };
+        case 6:
+            return { topology: "triangles", indices: expandTriangleFan(source) };
+        case 0:
+            return { topology: "points", indices: rawIndices };
+        default:
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} has unsupported primitive mode ${mode}`);
+    }
+}
+function validatePrimitiveIndices(indices, vertexCount, meshIndex, primitiveIndex) {
+    for (const index of indices) {
+        if (!Number.isInteger(index) || index < 0 || index >= vertexCount) {
+            throw new RangeError(`glTF mesh ${meshIndex} primitive ${primitiveIndex} index ${index} is outside vertex count ${vertexCount}`);
+        }
+    }
+}
+function expandLineStrip(indices) {
+    const expanded = [];
+    for (let index = 0; index < indices.length - 1; index += 1) {
+        expanded.push(indices[index], indices[index + 1]);
+    }
+    return expanded;
+}
+function expandLineLoop(indices) {
+    if (indices.length < 2)
+        return [];
+    const expanded = [...expandLineStrip(indices)];
+    expanded.push(indices[indices.length - 1], indices[0]);
+    return expanded;
+}
+function expandTriangleStrip(indices) {
+    const expanded = [];
+    for (let index = 0; index < indices.length - 2; index += 1) {
+        if (index % 2 === 0) {
+            expanded.push(indices[index], indices[index + 1], indices[index + 2]);
+        }
+        else {
+            expanded.push(indices[index + 1], indices[index], indices[index + 2]);
+        }
+    }
+    return expanded;
+}
+function expandTriangleFan(indices) {
+    const expanded = [];
+    for (let index = 1; index < indices.length - 1; index += 1) {
+        expanded.push(indices[0], indices[index], indices[index + 1]);
+    }
+    return expanded;
+}
+function readMorphTargets(json, buffers, primitive, vertexCount, meshIndex, primitiveIndex, accessorCache) {
+    if (primitive.targets === undefined) {
+        return [];
+    }
+    if (!Array.isArray(primitive.targets)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} targets must be an array`);
+    }
+    return primitive.targets.map((target, targetIndex) => {
+        validateMorphTargetDescriptor(target, meshIndex, primitiveIndex, targetIndex);
+        const positions = readOptionalAccessor(json, buffers, target.POSITION, accessorCache);
+        const normals = readOptionalAccessor(json, buffers, target.NORMAL, accessorCache);
+        const tangents = readOptionalAccessor(json, buffers, target.TANGENT, accessorCache);
+        if (positions.length > 0 && positions.length !== vertexCount) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} morph target ${targetIndex} POSITION count mismatch`);
+        }
+        if (normals.length > 0 && normals.length !== vertexCount) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} morph target ${targetIndex} NORMAL count mismatch`);
+        }
+        if (tangents.length > 0 && tangents.length !== vertexCount) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} morph target ${targetIndex} TANGENT count mismatch`);
+        }
+        return {
+            positions: positions.map((position) => [position[0] ?? 0, position[1] ?? 0, position[2] ?? 0]),
+            normals: normals.map((normal) => [normal[0] ?? 0, normal[1] ?? 0, normal[2] ?? 0]),
+            tangents: tangents.map((tangent) => [tangent[0] ?? 0, tangent[1] ?? 0, tangent[2] ?? 0])
+        };
+    });
+}
+function validateMorphTargetDescriptor(target, meshIndex, primitiveIndex, targetIndex) {
+    if (!isObjectRecord(target) || Array.isArray(target)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} morph target ${targetIndex} must be an object`);
+    }
+    for (const key of Object.keys(target)) {
+        if (key !== "POSITION" && key !== "NORMAL" && key !== "TANGENT") {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} morph target ${targetIndex} attribute ${key} is unsupported`);
+        }
+        const accessorIndex = target[key];
+        if (!Number.isInteger(accessorIndex) || accessorIndex < 0) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} morph target ${targetIndex} ${key} accessor must be a non-negative integer`);
+        }
+    }
+}
+function resolveMorphWeights(mesh, meshIndex, primitiveIndex, targetCount) {
+    if (mesh.weights === undefined) {
+        return Array.from({ length: targetCount }, () => 0);
+    }
+    if (!Array.isArray(mesh.weights)) {
+        throw new Error(`glTF mesh ${meshIndex} weights must be an array`);
+    }
+    if (mesh.weights.length !== targetCount) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} weights count must match morph target count`);
+    }
+    if (mesh.weights.some((weight) => !Number.isFinite(weight))) {
+        throw new Error(`glTF mesh ${meshIndex} weights must contain finite numbers`);
+    }
+    return [...mesh.weights];
+}
+function createImageAssets(json, buffers) {
+    const avifEnabled = usesGLTFExtension(json, "EXT_texture_avif");
+    const webpEnabled = usesGLTFExtension(json, "EXT_texture_webp");
+    const basisuEnabled = usesGLTFExtension(json, "KHR_texture_basisu");
+    return (json.images ?? []).map((image, index) => {
+        if (image.uri && image.bufferView !== undefined) {
+            throw new Error(`glTF image ${index} cannot define both uri and bufferView`);
+        }
+        if (!image.uri && image.bufferView === undefined) {
+            throw new Error(`glTF image ${index} must define uri or bufferView`);
+        }
+        if (image.bufferView !== undefined && !image.mimeType) {
+            throw new Error(`glTF image ${index} with bufferView requires mimeType`);
+        }
+        validateImageMimeType(image, index, avifEnabled, webpEnabled, basisuEnabled);
+        return {
+            name: image.name ?? `image-${index}`,
+            uri: image.uri,
+            mimeType: image.mimeType,
+            data: image.bufferView === undefined ? undefined : readBufferViewBytes(json, buffers, image.bufferView)
+        };
+    });
+}
+function validateImageMimeType(image, index, avifEnabled, webpEnabled, basisuEnabled) {
+    if (image.mimeType !== undefined && !isSupportedImageMimeType(image.mimeType, avifEnabled, webpEnabled, basisuEnabled)) {
+        throw new Error(`glTF image ${index} mimeType must be ${supportedImageMimeTypeMessage(avifEnabled, webpEnabled, basisuEnabled)}`);
+    }
+    if (image.uri?.startsWith("data:")) {
+        const separator = image.uri.indexOf(",");
+        if (separator < 0) {
+            throw new Error(`glTF image ${index} data uri must include a comma separator`);
+        }
+        const mediaType = image.uri.slice(5, separator).split(";")[0]?.toLowerCase();
+        if (!isSupportedImageMimeType(mediaType, avifEnabled, webpEnabled, basisuEnabled)) {
+            throw new Error(`glTF image ${index} data uri media type must be ${supportedImageMimeTypeMessage(avifEnabled, webpEnabled, basisuEnabled)}`);
+        }
+    }
+}
+function isSupportedImageMimeType(mimeType, avifEnabled, webpEnabled, basisuEnabled) {
+    return mimeType === "image/png" || mimeType === "image/jpeg" || (avifEnabled && mimeType === "image/avif") || (webpEnabled && mimeType === "image/webp") || (basisuEnabled && mimeType === "image/ktx2");
+}
+function supportedImageMimeTypeMessage(avifEnabled, webpEnabled, basisuEnabled) {
+    return ["image/png", "image/jpeg", ...(avifEnabled ? ["image/avif"] : []), ...(webpEnabled ? ["image/webp"] : []), ...(basisuEnabled ? ["image/ktx2"] : [])].join(", or ");
+}
+function createTextureAssets(json) {
+    return (json.textures ?? []).map((texture, index) => {
+        const source = validateTextureDescriptor(json, texture, index);
+        const sampler = texture.sampler;
+        return {
+            name: texture.name ?? `texture-${index}`,
+            source,
+            sampler,
+            ...(sampler === undefined ? {} : { samplerDescriptor: createSamplerAsset(json.samplers[sampler], sampler) })
+        };
+    });
+}
+function validateTextureDescriptor(json, texture, index) {
+    const avifSource = texture.extensions?.EXT_texture_avif?.source;
+    if (avifSource !== undefined && !usesGLTFExtension(json, "EXT_texture_avif")) {
+        throw new Error(`glTF texture ${index} uses EXT_texture_avif but the extension is not declared`);
+    }
+    const webpSource = texture.extensions?.EXT_texture_webp?.source;
+    if (webpSource !== undefined && !usesGLTFExtension(json, "EXT_texture_webp")) {
+        throw new Error(`glTF texture ${index} uses EXT_texture_webp but the extension is not declared`);
+    }
+    const basisuSource = texture.extensions?.KHR_texture_basisu?.source;
+    if (basisuSource !== undefined && !usesGLTFExtension(json, "KHR_texture_basisu")) {
+        throw new Error(`glTF texture ${index} uses KHR_texture_basisu but the extension is not declared`);
+    }
+    const source = basisuSource ?? avifSource ?? webpSource ?? texture.source;
+    if (source === undefined) {
+        throw new Error(`glTF texture ${index} references missing image source undefined`);
+    }
+    if (!Number.isInteger(source) || source < 0) {
+        throw new Error(`glTF texture ${index} source must be a non-negative integer`);
+    }
+    if (!json.images?.[source]) {
+        throw new Error(`glTF texture ${index} references missing image source ${source}`);
+    }
+    if (texture.sampler !== undefined) {
+        if (!Number.isInteger(texture.sampler) || texture.sampler < 0) {
+            throw new Error(`glTF texture ${index} sampler must be a non-negative integer`);
+        }
+        if (!json.samplers?.[texture.sampler]) {
+            throw new Error(`glTF texture ${index} references missing sampler ${texture.sampler}`);
+        }
+    }
+    return source;
+}
+function createSamplerAsset(sampler, samplerIndex) {
+    return {
+        minFilter: minFilterFromGLTF(sampler.minFilter, samplerIndex),
+        magFilter: magFilterFromGLTF(sampler.magFilter, samplerIndex),
+        addressU: addressModeFromGLTF(sampler.wrapS, samplerIndex, "wrapS"),
+        addressV: addressModeFromGLTF(sampler.wrapT, samplerIndex, "wrapT")
+    };
+}
+function minFilterFromGLTF(value, samplerIndex) {
+    if (value === undefined)
+        return "linear-mipmap-linear";
+    if (value === 9728)
+        return "nearest";
+    if (value === 9729)
+        return "linear";
+    if (value === 9984)
+        return "nearest-mipmap-nearest";
+    if (value === 9985)
+        return "linear-mipmap-nearest";
+    if (value === 9986)
+        return "nearest-mipmap-linear";
+    if (value === 9987)
+        return "linear-mipmap-linear";
+    throw new Error(`glTF sampler ${samplerIndex} minFilter has unsupported value ${value}`);
+}
+function magFilterFromGLTF(value, samplerIndex) {
+    if (value === undefined)
+        return "linear";
+    if (value === 9728)
+        return "nearest";
+    if (value === 9729)
+        return "linear";
+    throw new Error(`glTF sampler ${samplerIndex} magFilter has unsupported value ${value}`);
+}
+function addressModeFromGLTF(value, samplerIndex, field) {
+    if (value === undefined || value === 10497)
+        return "repeat";
+    if (value === 33071)
+        return "clamp-to-edge";
+    if (value === 33648)
+        return "mirror-repeat";
+    throw new Error(`glTF sampler ${samplerIndex} ${field} has unsupported value ${value}`);
+}
+function createSceneAssets(json) {
+    return (json.scenes ?? []).map((scene, index) => {
+        return {
+            name: scene.name ?? `scene-${index}`,
+            nodeIndices: [...(scene.nodes ?? [])]
+        };
+    });
+}
+function resolveDefaultSceneIndex(json) {
+    return json.scene ?? 0;
+}
+function createMaterialAssets(json, textures) {
+    return (json.materials ?? []).map((material, index) => {
+        const pbr = material.pbrMetallicRoughness;
+        const pbrSpecularGlossiness = resolvePBRSpecularGlossiness(material, textures, index).pbrSpecularGlossiness;
+        const specular = resolveSpecular(material, textures, index).specular ?? createSpecularFromSpecularGlossiness(pbrSpecularGlossiness);
+        return {
+            name: material.name ?? `material-${index}`,
+            unlit: material.extensions?.KHR_materials_unlit !== undefined,
+            baseColorFactor: pbrSpecularGlossiness?.diffuseFactor ?? resolveColor4(pbr?.baseColorFactor, [1, 1, 1, 1], `material ${index} baseColorFactor`),
+            baseColorTexture: pbrSpecularGlossiness?.diffuseTexture ?? resolveTextureInfo(textures, pbr?.baseColorTexture, `material ${index} baseColorTexture`),
+            metallicFactor: pbrSpecularGlossiness ? 0 : resolveUnit(pbr?.metallicFactor, 1, `material ${index} metallicFactor`),
+            roughnessFactor: pbrSpecularGlossiness ? 1 - pbrSpecularGlossiness.glossinessFactor : resolveUnit(pbr?.roughnessFactor, 1, `material ${index} roughnessFactor`),
+            metallicRoughnessTexture: pbrSpecularGlossiness
+                ? undefined
+                : resolveTextureInfo(textures, pbr?.metallicRoughnessTexture, `material ${index} metallicRoughnessTexture`),
+            normalTexture: withDefaultScale(resolveTextureInfo(textures, material.normalTexture, `material ${index} normalTexture`), material.normalTexture?.scale),
+            occlusionTexture: withDefaultStrength(resolveTextureInfo(textures, material.occlusionTexture, `material ${index} occlusionTexture`), material.occlusionTexture?.strength),
+            emissiveTexture: resolveTextureInfo(textures, material.emissiveTexture, `material ${index} emissiveTexture`),
+            emissiveFactor: resolveColor3(material.emissiveFactor, [0, 0, 0], `material ${index} emissiveFactor`),
+            emissiveStrength: resolveEmissiveStrength(material, index),
+            ...(resolveClearcoat(material, textures, index)),
+            ...(resolveTransmission(material, textures, index)),
+            ...(resolveDiffuseTransmission(material, textures, pbrSpecularGlossiness, index)),
+            ...(resolveVolume(material, textures, index)),
+            ...(resolveIOR(material, index)),
+            ...(specular ? { specular } : {}),
+            ...(pbrSpecularGlossiness ? { pbrSpecularGlossiness } : {}),
+            ...(resolveSheen(material, textures, index)),
+            ...(resolveAnisotropy(material, textures, index)),
+            ...(resolveIridescence(material, textures, index)),
+            ...(resolveDispersion(material, index)),
+            alphaMode: resolveAlphaMode(material.alphaMode, index),
+            alphaCutoff: resolveUnit(material.alphaCutoff, 0.5, `material ${index} alphaCutoff`),
+            doubleSided: material.doubleSided ?? false
+        };
+    });
+}
+function createMaterialVariantAssets(json) {
+    if (!usesGLTFExtension(json, "KHR_materials_variants"))
+        return [];
+    const variants = json.extensions?.KHR_materials_variants?.variants;
+    if (!Array.isArray(variants) || variants.length === 0) {
+        throw new Error("glTF KHR_materials_variants.variants must be a non-empty array when the extension is declared");
+    }
+    return variants.map((variant, index) => {
+        if (!isObjectRecord(variant)) {
+            throw new Error(`glTF KHR_materials_variants variant ${index} must be an object`);
+        }
+        return { name: typeof variant.name === "string" && variant.name.length > 0 ? variant.name : `variant-${index}` };
+    });
+}
+function resolvePrimitiveMaterialVariants(primitive, variants, materials, meshIndex, primitiveIndex) {
+    const mappings = primitive.extensions?.KHR_materials_variants?.mappings;
+    if (!mappings)
+        return [];
+    if (variants.length === 0) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} uses KHR_materials_variants but the extension is not declared`);
+    }
+    const resolved = [];
+    for (let mappingIndex = 0; mappingIndex < mappings.length; mappingIndex += 1) {
+        const mapping = mappings[mappingIndex];
+        if (!Number.isInteger(mapping.material) || mapping.material < 0) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_materials_variants mapping ${mappingIndex} material must be a non-negative integer`);
+        }
+        const material = materials[mapping.material];
+        if (!material) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_materials_variants mapping ${mappingIndex} references missing material ${mapping.material}`);
+        }
+        if (!Array.isArray(mapping.variants) || mapping.variants.length === 0) {
+            throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_materials_variants mapping ${mappingIndex} variants must be a non-empty array`);
+        }
+        for (const variantIndex of mapping.variants) {
+            if (!Number.isInteger(variantIndex) || variantIndex < 0) {
+                throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_materials_variants mapping ${mappingIndex} variant must be a non-negative integer`);
+            }
+            const variant = variants[variantIndex];
+            if (!variant) {
+                throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} KHR_materials_variants mapping ${mappingIndex} references missing variant ${variantIndex}`);
+            }
+            resolved.push({
+                variantIndex,
+                variant: variant.name,
+                materialIndex: mapping.material,
+                material: material.name
+            });
+        }
+    }
+    return resolved;
+}
+function resolveAlphaMode(value, materialIndex) {
+    if (value === undefined)
+        return "OPAQUE";
+    if (value === "OPAQUE" || value === "MASK" || value === "BLEND")
+        return value;
+    throw new Error(`glTF material ${materialIndex} alphaMode must be OPAQUE, MASK, or BLEND`);
+}
+function resolveTextureInfo(textures, info, label) {
+    if (!info)
+        return undefined;
+    if (!Number.isInteger(info.index) || info.index < 0) {
+        throw new Error(`glTF ${label} index must be a non-negative integer`);
+    }
+    const texture = textures[info.index];
+    if (!texture) {
+        throw new Error(`glTF ${label} references missing texture ${info.index}`);
+    }
+    const transform = info.extensions?.KHR_texture_transform;
+    const texCoord = transform?.texCoord ?? info.texCoord ?? 0;
+    if (!Number.isInteger(texCoord) || texCoord < 0) {
+        throw new RangeError(`glTF ${label} texCoord must be a non-negative integer`);
+    }
+    return {
+        texture: info.index,
+        image: texture.source,
+        texCoord,
+        ...(transform ? { transform: resolveTextureTransform(transform) } : {})
+    };
+}
+function usesGLTFExtension(json, extension) {
+    return Boolean(json.extensionsRequired?.includes(extension) || json.extensionsUsed?.includes(extension));
+}
+function usesGLTFMeshoptExtension(json) {
+    return GLTF_MESHOPT_EXTENSION_NAMES.some((extension) => usesGLTFExtension(json, extension));
+}
+const GLTF_MESHOPT_EXTENSION_NAMES = ["EXT_meshopt_compression", "KHR_meshopt_compression"];
+function validatePrimitiveAttributeAccessors(json, primitive, meshQuantizationEnabled, meshIndex, primitiveIndex) {
+    for (const [semantic, accessorIndex] of Object.entries(primitive.attributes)) {
+        if (semantic !== "POSITION" && semantic !== "NORMAL" && semantic !== "TANGENT") {
+            continue;
+        }
+        const accessor = json.accessors?.[accessorIndex];
+        if (!accessor) {
+            continue;
+        }
+        if (!isAccessorComponentType(accessor.componentType)) {
+            continue;
+        }
+        validateQuantizedAttributeComponentType(accessor.componentType, semantic, meshQuantizationEnabled, meshIndex, primitiveIndex);
+    }
+}
+function validateQuantizedAttributeComponentType(componentType, semantic, meshQuantizationEnabled, meshIndex, primitiveIndex) {
+    if (componentType === 5126) {
+        return;
+    }
+    if (!meshQuantizationEnabled) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} ${semantic} accessor uses non-FLOAT componentType ${componentType}; declare KHR_mesh_quantization to import quantized attributes`);
+    }
+    if (componentType === 5120 || componentType === 5121 || componentType === 5122 || componentType === 5123) {
+        return;
+    }
+    throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} ${semantic} accessor componentType ${componentType} is unsupported for KHR_mesh_quantization`);
+}
+function normalizeSkinWeights(weights, meshIndex, primitiveIndex) {
+    if (weights.some((weight) => !Number.isFinite(weight) || weight < 0)) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} WEIGHTS_0 must contain finite non-negative values`);
+    }
+    const sum = weights[0] + weights[1] + weights[2] + weights[3];
+    if (sum <= 0) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} WEIGHTS_0 must sum to a positive value`);
+    }
+    if (Math.abs(sum - 1) <= 1e-5)
+        return weights;
+    return [
+        weights[0] / sum,
+        weights[1] / sum,
+        weights[2] / sum,
+        weights[3] / sum
+    ];
+}
+function createCameraAssets(json) {
+    return (json.cameras ?? []).map((camera, index) => {
+        if (camera.type === "perspective") {
+            if (!camera.perspective) {
+                throw new Error(`glTF camera ${index} perspective camera requires perspective data`);
+            }
+            const yfov = resolveCameraPositive(camera.perspective.yfov, `camera ${index} perspective.yfov`);
+            if (yfov >= Math.PI) {
+                throw new RangeError(`glTF camera ${index} perspective.yfov must be less than PI`);
+            }
+            const znear = resolveCameraPositive(camera.perspective.znear, `camera ${index} perspective.znear`);
+            const zfar = camera.perspective.zfar === undefined
+                ? 1000
+                : resolveCameraPositive(camera.perspective.zfar, `camera ${index} perspective.zfar`);
+            if (zfar <= znear) {
+                throw new RangeError(`glTF camera ${index} perspective.zfar must be greater than znear`);
+            }
+            const aspectRatio = resolveCameraPositive(camera.perspective.aspectRatio ?? 1, `camera ${index} perspective.aspectRatio`);
+            return {
+                name: camera.name ?? `camera-${index}`,
+                type: "perspective",
+                perspective: { aspectRatio, yfov, znear, zfar }
+            };
+        }
+        if (camera.type === "orthographic") {
+            if (!camera.orthographic) {
+                throw new Error(`glTF camera ${index} orthographic camera requires orthographic data`);
+            }
+            const xmag = resolveCameraPositive(camera.orthographic.xmag, `camera ${index} orthographic.xmag`);
+            const ymag = resolveCameraPositive(camera.orthographic.ymag, `camera ${index} orthographic.ymag`);
+            const znear = resolveCameraPositive(camera.orthographic.znear, `camera ${index} orthographic.znear`);
+            const zfar = resolveCameraPositive(camera.orthographic.zfar, `camera ${index} orthographic.zfar`);
+            if (zfar <= znear) {
+                throw new RangeError(`glTF camera ${index} orthographic.zfar must be greater than znear`);
+            }
+            return {
+                name: camera.name ?? `camera-${index}`,
+                type: "orthographic",
+                orthographic: { xmag, ymag, znear, zfar }
+            };
+        }
+        throw new Error(`glTF camera ${index} has unsupported type ${String(camera.type)}`);
+    });
+}
+function resolveCameraPositive(value, label) {
+    const resolved = value;
+    if (resolved === undefined || !Number.isFinite(resolved) || resolved <= 0) {
+        throw new RangeError(`glTF ${label} must be finite and positive`);
+    }
+    return resolved;
+}
+function createLightAssets(json) {
+    return (json.extensions?.KHR_lights_punctual?.lights ?? []).map((light, index) => {
+        const color = resolveColor3(light.color, [1, 1, 1], `light ${index} color`);
+        const intensity = resolveNonNegative(light.intensity, 1, `light ${index} intensity`);
+        if (light.type !== "directional" && light.type !== "point" && light.type !== "spot") {
+            throw new Error(`glTF light ${index} has unsupported type ${String(light.type)}`);
+        }
+        if (light.type === "directional") {
+            return { name: light.name ?? `light-${index}`, type: "directional", color, intensity };
+        }
+        const range = resolvePositive(light.range, 10, `light ${index} range`);
+        if (light.type === "point") {
+            return { name: light.name ?? `light-${index}`, type: "point", color, intensity, range };
+        }
+        const outerConeAngle = resolveConeAngle(light.spot?.outerConeAngle, Math.PI / 4, `light ${index} spot.outerConeAngle`, false);
+        const innerConeAngle = resolveConeAngle(light.spot?.innerConeAngle, 0, `light ${index} spot.innerConeAngle`, true);
+        if (innerConeAngle > outerConeAngle) {
+            throw new RangeError(`glTF light ${index} spot.innerConeAngle must be less than or equal to outerConeAngle`);
+        }
+        return {
+            name: light.name ?? `light-${index}`,
+            type: "spot",
+            color,
+            intensity,
+            range,
+            spot: { innerConeAngle, outerConeAngle }
+        };
+    });
+}
+function resolveConeAngle(value, fallback, label, allowZero) {
+    const resolved = value ?? fallback;
+    const valid = allowZero ? resolved >= 0 : resolved > 0;
+    if (!Number.isFinite(resolved) || !valid || resolved >= Math.PI / 2) {
+        const lower = allowZero ? "[0" : "(0";
+        throw new RangeError(`glTF ${label} must be finite and within ${lower}, PI / 2)`);
+    }
+    return resolved;
+}
+function resolveEmissiveStrength(material, materialIndex) {
+    const strength = material.extensions?.KHR_materials_emissive_strength?.emissiveStrength ?? 1;
+    if (!Number.isFinite(strength) || strength < 0) {
+        throw new RangeError(`glTF material ${materialIndex} KHR_materials_emissive_strength.emissiveStrength must be finite and non-negative`);
+    }
+    return strength;
+}
+function resolveClearcoat(material, textures, materialIndex) {
+    const extension = material.extensions?.KHR_materials_clearcoat;
+    if (!extension)
+        return {};
+    return {
+        clearcoat: {
+            factor: resolveUnit(extension.clearcoatFactor, 0, `material ${materialIndex} KHR_materials_clearcoat.clearcoatFactor`),
+            texture: resolveTextureInfo(textures, extension.clearcoatTexture, `material ${materialIndex} KHR_materials_clearcoat.clearcoatTexture`),
+            roughnessFactor: resolveUnit(extension.clearcoatRoughnessFactor, 0, `material ${materialIndex} KHR_materials_clearcoat.clearcoatRoughnessFactor`),
+            roughnessTexture: resolveTextureInfo(textures, extension.clearcoatRoughnessTexture, `material ${materialIndex} KHR_materials_clearcoat.clearcoatRoughnessTexture`),
+            normalTexture: withDefaultScale(resolveTextureInfo(textures, extension.clearcoatNormalTexture, `material ${materialIndex} KHR_materials_clearcoat.clearcoatNormalTexture`), extension.clearcoatNormalTexture?.scale)
+        }
+    };
+}
+function resolveTransmission(material, textures, materialIndex) {
+    const extension = material.extensions?.KHR_materials_transmission;
+    if (!extension)
+        return {};
+    return {
+        transmission: {
+            factor: resolveUnit(extension.transmissionFactor, 0, `material ${materialIndex} KHR_materials_transmission.transmissionFactor`),
+            texture: resolveTextureInfo(textures, extension.transmissionTexture, `material ${materialIndex} KHR_materials_transmission.transmissionTexture`)
+        }
+    };
+}
+function resolveDiffuseTransmission(material, textures, pbrSpecularGlossiness, materialIndex) {
+    const extension = material.extensions?.KHR_materials_diffuse_transmission;
+    if (!extension)
+        return {};
+    if (material.extensions?.KHR_materials_unlit !== undefined) {
+        throw new Error(`glTF material ${materialIndex} KHR_materials_diffuse_transmission must not be combined with KHR_materials_unlit`);
+    }
+    if (pbrSpecularGlossiness) {
+        throw new Error(`glTF material ${materialIndex} KHR_materials_diffuse_transmission must not be combined with KHR_materials_pbrSpecularGlossiness`);
+    }
+    return {
+        diffuseTransmission: {
+            factor: resolveUnit(extension.diffuseTransmissionFactor, 0, `material ${materialIndex} KHR_materials_diffuse_transmission.diffuseTransmissionFactor`),
+            texture: resolveTextureInfo(textures, extension.diffuseTransmissionTexture, `material ${materialIndex} KHR_materials_diffuse_transmission.diffuseTransmissionTexture`),
+            colorFactor: resolveColor3(extension.diffuseTransmissionColorFactor, [1, 1, 1], `material ${materialIndex} KHR_materials_diffuse_transmission.diffuseTransmissionColorFactor`),
+            colorTexture: resolveTextureInfo(textures, extension.diffuseTransmissionColorTexture, `material ${materialIndex} KHR_materials_diffuse_transmission.diffuseTransmissionColorTexture`)
+        }
+    };
+}
+function resolveVolume(material, textures, materialIndex) {
+    const extension = material.extensions?.KHR_materials_volume;
+    if (!extension)
+        return {};
+    return {
+        volume: {
+            thicknessFactor: resolveNonNegative(extension.thicknessFactor, 0, `material ${materialIndex} KHR_materials_volume.thicknessFactor`),
+            thicknessTexture: resolveTextureInfo(textures, extension.thicknessTexture, `material ${materialIndex} KHR_materials_volume.thicknessTexture`),
+            attenuationDistance: resolvePositive(extension.attenuationDistance, Number.POSITIVE_INFINITY, `material ${materialIndex} KHR_materials_volume.attenuationDistance`),
+            attenuationColor: resolveColor3(extension.attenuationColor, [1, 1, 1], `material ${materialIndex} KHR_materials_volume.attenuationColor`)
+        }
+    };
+}
+function resolveIOR(material, materialIndex) {
+    const extension = material.extensions?.KHR_materials_ior;
+    if (!extension)
+        return {};
+    const ior = extension.ior ?? 1.5;
+    if (!Number.isFinite(ior) || ior < 1) {
+        throw new RangeError(`glTF material ${materialIndex} KHR_materials_ior.ior must be finite and at least 1`);
+    }
+    return { ior };
+}
+function resolveSpecular(material, textures, materialIndex) {
+    const extension = material.extensions?.KHR_materials_specular;
+    if (!extension)
+        return {};
+    return {
+        specular: {
+            factor: resolveUnit(extension.specularFactor, 1, `material ${materialIndex} KHR_materials_specular.specularFactor`),
+            texture: resolveTextureInfo(textures, extension.specularTexture, `material ${materialIndex} KHR_materials_specular.specularTexture`),
+            colorFactor: resolveNonNegativeColor3(extension.specularColorFactor, [1, 1, 1], `material ${materialIndex} KHR_materials_specular.specularColorFactor`),
+            colorTexture: resolveTextureInfo(textures, extension.specularColorTexture, `material ${materialIndex} KHR_materials_specular.specularColorTexture`)
+        }
+    };
+}
+function resolvePBRSpecularGlossiness(material, textures, materialIndex) {
+    const extension = material.extensions?.KHR_materials_pbrSpecularGlossiness;
+    if (!extension)
+        return {};
+    return {
+        pbrSpecularGlossiness: {
+            diffuseFactor: resolveColor4(extension.diffuseFactor, [1, 1, 1, 1], `material ${materialIndex} KHR_materials_pbrSpecularGlossiness.diffuseFactor`),
+            diffuseTexture: resolveTextureInfo(textures, extension.diffuseTexture, `material ${materialIndex} KHR_materials_pbrSpecularGlossiness.diffuseTexture`),
+            specularFactor: resolveColor3(extension.specularFactor, [1, 1, 1], `material ${materialIndex} KHR_materials_pbrSpecularGlossiness.specularFactor`),
+            glossinessFactor: resolveUnit(extension.glossinessFactor, 1, `material ${materialIndex} KHR_materials_pbrSpecularGlossiness.glossinessFactor`),
+            specularGlossinessTexture: resolveTextureInfo(textures, extension.specularGlossinessTexture, `material ${materialIndex} KHR_materials_pbrSpecularGlossiness.specularGlossinessTexture`)
+        }
+    };
+}
+function resolveSheen(material, textures, materialIndex) {
+    const extension = material.extensions?.KHR_materials_sheen;
+    if (!extension)
+        return {};
+    return {
+        sheen: {
+            colorFactor: resolveColor3(extension.sheenColorFactor, [0, 0, 0], `material ${materialIndex} KHR_materials_sheen.sheenColorFactor`),
+            colorTexture: resolveTextureInfo(textures, extension.sheenColorTexture, `material ${materialIndex} KHR_materials_sheen.sheenColorTexture`),
+            roughnessFactor: resolveUnit(extension.sheenRoughnessFactor, 0, `material ${materialIndex} KHR_materials_sheen.sheenRoughnessFactor`),
+            roughnessTexture: resolveTextureInfo(textures, extension.sheenRoughnessTexture, `material ${materialIndex} KHR_materials_sheen.sheenRoughnessTexture`)
+        }
+    };
+}
+function resolveAnisotropy(material, textures, materialIndex) {
+    const extension = material.extensions?.KHR_materials_anisotropy;
+    if (!extension)
+        return {};
+    return {
+        anisotropy: {
+            strength: resolveUnit(extension.anisotropyStrength, 0, `material ${materialIndex} KHR_materials_anisotropy.anisotropyStrength`),
+            rotation: resolveFiniteNumber(extension.anisotropyRotation, 0, `material ${materialIndex} KHR_materials_anisotropy.anisotropyRotation`),
+            texture: resolveTextureInfo(textures, extension.anisotropyTexture, `material ${materialIndex} KHR_materials_anisotropy.anisotropyTexture`)
+        }
+    };
+}
+function resolveIridescence(material, textures, materialIndex) {
+    const extension = material.extensions?.KHR_materials_iridescence;
+    if (!extension)
+        return {};
+    const thicknessMinimum = resolveNonNegative(extension.iridescenceThicknessMinimum, 100, `material ${materialIndex} KHR_materials_iridescence.iridescenceThicknessMinimum`);
+    const thicknessMaximum = resolveNonNegative(extension.iridescenceThicknessMaximum, 400, `material ${materialIndex} KHR_materials_iridescence.iridescenceThicknessMaximum`);
+    if (thicknessMaximum < thicknessMinimum) {
+        throw new RangeError(`glTF material ${materialIndex} KHR_materials_iridescence.iridescenceThicknessMaximum must be greater than or equal to iridescenceThicknessMinimum`);
+    }
+    return {
+        iridescence: {
+            factor: resolveUnit(extension.iridescenceFactor, 0, `material ${materialIndex} KHR_materials_iridescence.iridescenceFactor`),
+            texture: resolveTextureInfo(textures, extension.iridescenceTexture, `material ${materialIndex} KHR_materials_iridescence.iridescenceTexture`),
+            ior: resolveIridescenceIOR(extension.iridescenceIor, materialIndex),
+            thicknessMinimum,
+            thicknessMaximum,
+            thicknessTexture: resolveTextureInfo(textures, extension.iridescenceThicknessTexture, `material ${materialIndex} KHR_materials_iridescence.iridescenceThicknessTexture`)
+        }
+    };
+}
+function resolveIridescenceIOR(value, materialIndex) {
+    const ior = value ?? 1.3;
+    if (!Number.isFinite(ior) || ior < 1 || ior > 3) {
+        throw new RangeError(`glTF material ${materialIndex} KHR_materials_iridescence.iridescenceIor must be finite and within [1, 3]`);
+    }
+    return ior;
+}
+function resolveDispersion(material, materialIndex) {
+    const extension = material.extensions?.KHR_materials_dispersion;
+    if (!extension)
+        return {};
+    return {
+        dispersion: resolveNonNegative(extension.dispersion, 0, `material ${materialIndex} KHR_materials_dispersion.dispersion`)
+    };
+}
+function resolveTextureTransform(transform) {
+    return {
+        offset: resolveFiniteVec2(transform.offset, [0, 0], "KHR_texture_transform.offset"),
+        scale: resolveFiniteVec2(transform.scale, [1, 1], "KHR_texture_transform.scale"),
+        rotation: resolveFiniteNumber(transform.rotation, 0, "KHR_texture_transform.rotation")
+    };
+}
+function withDefaultScale(info, scale) {
+    return info ? { ...info, scale: resolveNonNegative(scale, 1, "normalTexture.scale") } : undefined;
+}
+function withDefaultStrength(info, strength) {
+    return info ? { ...info, strength: resolveUnit(strength, 1, "occlusionTexture.strength") } : undefined;
+}
+function resolveColor4(value, fallback, label) {
+    const channels = value ?? fallback;
+    if (channels.length !== 4 || channels.some((channel) => !Number.isFinite(channel) || channel < 0 || channel > 1)) {
+        throw new RangeError(`glTF ${label} must contain four finite values in [0, 1]`);
+    }
+    return [channels[0], channels[1], channels[2], channels[3]];
+}
+function resolveColor3(value, fallback, label) {
+    const channels = value ?? fallback;
+    if (channels.length !== 3 || channels.some((channel) => !Number.isFinite(channel) || channel < 0 || channel > 1)) {
+        throw new RangeError(`glTF ${label} must contain three finite values in [0, 1]`);
+    }
+    return [channels[0], channels[1], channels[2]];
+}
+function resolveNonNegativeColor3(value, fallback, label) {
+    const channels = value ?? fallback;
+    if (channels.length !== 3 || channels.some((channel) => !Number.isFinite(channel) || channel < 0)) {
+        throw new RangeError(`glTF ${label} must contain three finite non-negative values`);
+    }
+    return [channels[0], channels[1], channels[2]];
+}
+function resolveUnit(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isFinite(resolved) || resolved < 0 || resolved > 1) {
+        throw new RangeError(`glTF ${label} must be finite and within [0, 1]`);
+    }
+    return resolved;
+}
+function resolveNonNegative(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isFinite(resolved) || resolved < 0) {
+        throw new RangeError(`glTF ${label} must be finite and non-negative`);
+    }
+    return resolved;
+}
+function resolvePositive(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (resolved === Number.POSITIVE_INFINITY)
+        return resolved;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        throw new RangeError(`glTF ${label} must be finite and positive`);
+    }
+    return resolved;
+}
+function resolveFiniteNumber(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isFinite(resolved)) {
+        throw new RangeError(`glTF ${label} must be finite`);
+    }
+    return resolved;
+}
+function resolveFiniteVec2(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (resolved.length !== 2 || resolved.some((channel) => !Number.isFinite(channel))) {
+        throw new RangeError(`glTF ${label} must contain two finite values`);
+    }
+    return [resolved[0], resolved[1]];
+}
+function createSkinAssets(json, buffers, accessorCache) {
+    if (!json.skins || json.skins.length === 0)
+        return [];
+    const nodeWorldMatrices = computeGLTFNodeWorldMatrices(json);
+    const nodeNameForIndex = createGLTFNodeNameResolver(json);
+    return (json.skins ?? []).map((skin, skinIndex) => {
+        if (skin.joints.length === 0) {
+            throw new Error(`glTF skin ${skinIndex} requires at least one joint`);
+        }
+        validateSkinDescriptor(json, skin, skinIndex);
+        const parentByNode = parentIndexByNode(json);
+        const inverseBindMatrices = skin.inverseBindMatrices === undefined
+            ? []
+            : readAccessor(json, buffers, skin.inverseBindMatrices, accessorCache).map(toMat4);
+        if (inverseBindMatrices.length > 0 && inverseBindMatrices.length !== skin.joints.length) {
+            throw new Error(`glTF skin ${skinIndex} inverseBindMatrices count must match joints count`);
+        }
+        const jointSet = new Set(skin.joints);
+        const orderedJoints = orderSkinJoints(json, skin.joints);
+        const boneIndexByNode = new Map();
+        for (let index = 0; index < orderedJoints.length; index += 1) {
+            boneIndexByNode.set(orderedJoints[index], index);
+        }
+        const skeleton = new Skeleton(orderedJoints.map((nodeIndex) => {
+            const node = json.nodes?.[nodeIndex];
+            if (!node) {
+                throw new Error(`glTF skin ${skinIndex} references missing joint node ${nodeIndex}`);
+            }
+            const parentNode = parentByNode.get(nodeIndex);
+            const parentIndex = parentNode !== undefined && jointSet.has(parentNode) ? boneIndexByNode.get(parentNode) ?? -1 : -1;
+            const transform = resolveNodeTransform(node, nodeIndex);
+            return {
+                name: nodeNameForIndex(nodeIndex),
+                parentIndex,
+                translation: transform.translation,
+                rotation: transform.rotation,
+                scale: transform.scale,
+                inverseBindMatrix: inverseBindMatrices[skin.joints.indexOf(nodeIndex)] ?? identityMat4()
+            };
+        }));
+        return {
+            name: skin.name ?? `skin-${skinIndex}`,
+            joints: skin.joints,
+            jointNames: skin.joints.map((nodeIndex) => nodeNameForIndex(nodeIndex)),
+            inverseBindMatrices: skin.joints.map((nodeIndex) => inverseBindMatrices[skin.joints.indexOf(nodeIndex)] ?? identityMat4()),
+            skeletonRoot: skin.skeleton,
+            skeleton,
+            jointBindMatrices: skin.joints.map((nodeIndex) => multiplyLoaderMat4(nodeWorldMatrices.get(nodeIndex) ?? identityMat4(), inverseBindMatrices[skin.joints.indexOf(nodeIndex)] ?? identityMat4())),
+            ...(skin.joints.length <= MAX_RENDERABLE_SKIN_JOINTS ? { skinningPalette: buildGLTFSkinningPalette(skeleton, orderedJoints, skin.joints) } : {})
+        };
+    });
+}
+function computeGLTFNodeWorldMatrices(json) {
+    const nodes = json.nodes ?? [];
+    const parents = parentIndexByNode(json);
+    const matrices = new Map();
+    const visiting = new Set();
+    const resolve = (nodeIndex) => {
+        const existing = matrices.get(nodeIndex);
+        if (existing)
+            return existing;
+        if (visiting.has(nodeIndex)) {
+            throw new Error(`glTF node graph contains a cycle at node ${nodeIndex}`);
+        }
+        const node = nodes[nodeIndex];
+        if (!node)
+            return identityMat4();
+        visiting.add(nodeIndex);
+        const transform = resolveNodeTransform(node, nodeIndex);
+        const local = composeLoaderMat4(transform.translation, transform.rotation, transform.scale);
+        const parent = parents.get(nodeIndex);
+        const world = parent === undefined ? local : multiplyLoaderMat4(resolve(parent), local);
+        matrices.set(nodeIndex, world);
+        visiting.delete(nodeIndex);
+        return world;
+    };
+    for (let index = 0; index < nodes.length; index += 1) {
+        resolve(index);
+    }
+    return matrices;
+}
+function buildGLTFSkinningPalette(skeleton, orderedJoints, gltfJoints) {
+    const orderedPalette = skeleton.matrixPalette();
+    const paletteByNode = new Map();
+    for (let index = 0; index < orderedJoints.length; index += 1) {
+        paletteByNode.set(orderedJoints[index], orderedPalette[index]);
+    }
+    const matrices = new Float32Array(gltfJoints.length * 16);
+    for (let index = 0; index < gltfJoints.length; index += 1) {
+        const matrix = paletteByNode.get(gltfJoints[index]);
+        if (!matrix) {
+            throw new Error(`glTF skin references missing ordered joint ${gltfJoints[index]}`);
+        }
+        matrices.set(matrix, index * 16);
+    }
+    return { jointCount: gltfJoints.length, matrices };
+}
+function validateSkinDescriptor(json, skin, skinIndex) {
+    const seen = new Set();
+    for (const joint of skin.joints) {
+        if (!Number.isInteger(joint) || joint < 0) {
+            throw new Error(`glTF skin ${skinIndex} joint indices must be non-negative integers`);
+        }
+        if (seen.has(joint)) {
+            throw new Error(`glTF skin ${skinIndex} contains duplicate joint ${joint}`);
+        }
+        seen.add(joint);
+    }
+    if (skin.skeleton !== undefined && (!Number.isInteger(skin.skeleton) || skin.skeleton < 0 || !json.nodes?.[skin.skeleton])) {
+        throw new Error(`glTF skin ${skinIndex} references missing skeleton node ${skin.skeleton}`);
+    }
+    if (skin.inverseBindMatrices !== undefined && (!Number.isInteger(skin.inverseBindMatrices) || skin.inverseBindMatrices < 0)) {
+        throw new Error(`glTF skin ${skinIndex} inverseBindMatrices must reference a non-negative accessor index`);
+    }
+}
+function createNodeInstanceTransforms(json, buffers, accessorCache) {
+    const transforms = new Map();
+    for (const [nodeIndex, node] of (json.nodes ?? []).entries()) {
+        const extension = node.extensions?.EXT_mesh_gpu_instancing;
+        if (!extension)
+            continue;
+        if (!isObjectRecord(extension.attributes) || Array.isArray(extension.attributes)) {
+            throw new Error(`glTF node ${nodeIndex} EXT_mesh_gpu_instancing.attributes must be an object`);
+        }
+        const allowed = new Set(["TRANSLATION", "ROTATION", "SCALE"]);
+        for (const semantic of Object.keys(extension.attributes)) {
+            if (!allowed.has(semantic)) {
+                throw new Error(`glTF node ${nodeIndex} EXT_mesh_gpu_instancing attribute ${semantic} is unsupported`);
+            }
+            const accessorIndex = extension.attributes[semantic];
+            if (!Number.isInteger(accessorIndex) || accessorIndex < 0) {
+                throw new Error(`glTF node ${nodeIndex} EXT_mesh_gpu_instancing ${semantic} accessor must be a non-negative integer`);
+            }
+        }
+        const translations = readOptionalAccessor(json, buffers, extension.attributes.TRANSLATION, accessorCache);
+        const rotations = readOptionalAccessor(json, buffers, extension.attributes.ROTATION, accessorCache);
+        const scales = readOptionalAccessor(json, buffers, extension.attributes.SCALE, accessorCache);
+        const instanceCount = firstPositiveLength([translations.length, rotations.length, scales.length]);
+        if (instanceCount === 0) {
+            throw new Error(`glTF node ${nodeIndex} EXT_mesh_gpu_instancing requires TRANSLATION, ROTATION, or SCALE attributes`);
+        }
+        validateInstanceAttributeCount("TRANSLATION", translations.length, instanceCount, nodeIndex);
+        validateInstanceAttributeCount("ROTATION", rotations.length, instanceCount, nodeIndex);
+        validateInstanceAttributeCount("SCALE", scales.length, instanceCount, nodeIndex);
+        const packed = new Float32Array(instanceCount * 16);
+        for (let instanceIndex = 0; instanceIndex < instanceCount; instanceIndex += 1) {
+            const translation = toInstanceVec3(translations[instanceIndex], [0, 0, 0], `node ${nodeIndex} EXT_mesh_gpu_instancing TRANSLATION`);
+            const rotation = toInstanceQuat(rotations[instanceIndex], [0, 0, 0, 1], `node ${nodeIndex} EXT_mesh_gpu_instancing ROTATION`);
+            const scale = toInstanceVec3(scales[instanceIndex], [1, 1, 1], `node ${nodeIndex} EXT_mesh_gpu_instancing SCALE`);
+            packed.set(composeMat4(translation, rotation, scale), instanceIndex * 16);
+        }
+        transforms.set(nodeIndex, packed);
+    }
+    return transforms;
+}
+function firstPositiveLength(lengths) {
+    return lengths.find((length) => length > 0) ?? 0;
+}
+function validateInstanceAttributeCount(semantic, count, instanceCount, nodeIndex) {
+    if (count > 0 && count !== instanceCount) {
+        throw new Error(`glTF node ${nodeIndex} EXT_mesh_gpu_instancing ${semantic} count must match instance count`);
+    }
+}
+function toInstanceVec3(row, fallback, label) {
+    if (!row)
+        return fallback;
+    if (row.length < 3 || row.slice(0, 3).some((value) => !Number.isFinite(value))) {
+        throw new Error(`glTF ${label} must contain three finite values`);
+    }
+    return [row[0], row[1], row[2]];
+}
+function toInstanceQuat(row, fallback, label) {
+    if (!row)
+        return fallback;
+    if (row.length < 4 || row.slice(0, 4).some((value) => !Number.isFinite(value))) {
+        throw new Error(`glTF ${label} must contain four finite values`);
+    }
+    return [row[0], row[1], row[2], row[3]];
+}
+function createAnimationClips(json, buffers, accessorCache) {
+    const nodeNameForIndex = createGLTFNodeNameResolver(json);
+    return (json.animations ?? []).map((animation, animationIndex) => {
+        const tracks = animation.channels.flatMap((channel, channelIndex) => {
+            const sampler = animation.samplers[channel.sampler];
+            if (!sampler) {
+                throw new Error(`glTF animation ${animationIndex} channel ${channelIndex} references missing sampler ${channel.sampler}`);
+            }
+            if (isOptionalAnimationPointerChannel(json, channel)) {
+                return [];
+            }
+            if (channel.target.node === undefined || !json.nodes?.[channel.target.node]) {
+                throw new Error(`glTF animation ${animationIndex} channel ${channelIndex} references missing target node ${channel.target.node ?? "undefined"}`);
+            }
+            const interpolation = resolveAnimationInterpolation(sampler.interpolation, animationIndex, channelIndex);
+            const path = resolveAnimationTargetPath(channel.target.path, animationIndex, channelIndex);
+            const times = readAccessor(json, buffers, sampler.input, accessorCache).map((row) => row[0] ?? 0);
+            const output = readAccessor(json, buffers, sampler.output, accessorCache);
+            const values = animationKeyframesForSampler(path, times, output, interpolation, animationIndex, channelIndex, morphWeightCountForAnimationTarget(json, channel.target.node));
+            const valueType = valueTypeForAnimationPath(path);
+            return [new AnimationTrack({
+                    target: `${nodeNameForIndex(channel.target.node)}.${path}`,
+                    valueType,
+                    keyframes: values
+                })];
+        });
+        return new AnimationClip({ name: animation.name ?? `animation-${animationIndex}`, tracks });
+    });
+}
+function isOptionalAnimationPointerChannel(json, channel) {
+    return channel.target.path === "pointer" &&
+        json.extensionsUsed?.includes("KHR_animation_pointer") === true &&
+        json.extensionsRequired?.includes("KHR_animation_pointer") !== true &&
+        typeof channel.target.extensions?.KHR_animation_pointer?.pointer === "string";
+}
+function resolveAnimationInterpolation(value, animationIndex, channelIndex) {
+    if (value === undefined || value === "LINEAR" || value === "STEP" || value === "CUBICSPLINE") {
+        return value ?? "LINEAR";
+    }
+    throw new Error(`glTF animation ${animationIndex} channel ${channelIndex} interpolation ${value} is unsupported`);
+}
+function resolveAnimationTargetPath(path, animationIndex, channelIndex) {
+    if (path === "translation" || path === "rotation" || path === "scale" || path === "weights") {
+        return path;
+    }
+    throw new Error(`glTF animation ${animationIndex} channel ${channelIndex} target path ${path} is unsupported`);
+}
+function animationKeyframesForSampler(path, times, output, interpolation, animationIndex, channelIndex, morphWeightCount) {
+    const normalizedOutput = path === "weights" ? normalizeWeightAnimationOutput(times, output, interpolation, animationIndex, channelIndex, morphWeightCount) : output;
+    if (interpolation !== "CUBICSPLINE") {
+        if (times.length !== normalizedOutput.length) {
+            throw new Error(`glTF animation ${animationIndex} channel ${channelIndex} input/output count mismatch`);
+        }
+        const samples = sanitizeAnimationSamples(times, normalizedOutput, 1);
+        const mode = interpolation === "STEP" ? "step" : "linear";
+        return samples.times.map((time, index) => ({
+            time,
+            value: animationValueForPath(path, samples.output[index]),
+            interpolation: mode
+        }));
+    }
+    if (normalizedOutput.length !== times.length * 3) {
+        throw new Error(`glTF animation ${animationIndex} channel ${channelIndex} CUBICSPLINE output count must be three times input count`);
+    }
+    const samples = sanitizeAnimationSamples(times, normalizedOutput, 3);
+    return samples.times.map((time, index) => {
+        const offset = index * 3;
+        return {
+            time,
+            inTangent: animationValueForPath(path, samples.output[offset]),
+            value: animationValueForPath(path, samples.output[offset + 1]),
+            outTangent: animationValueForPath(path, samples.output[offset + 2]),
+            interpolation: "cubicspline"
+        };
+    });
+}
+function sanitizeAnimationSamples(times, output, rowsPerSample) {
+    const cleanTimes = [];
+    const cleanOutput = [];
+    let previous = -Number.MAX_VALUE;
+    for (let index = 0; index < times.length; index += 1) {
+        const time = times[index] ?? 0;
+        if (!Number.isFinite(time) || time < 0 || time <= previous) {
+            continue;
+        }
+        cleanTimes.push(time);
+        for (let row = 0; row < rowsPerSample; row += 1) {
+            const value = output[index * rowsPerSample + row];
+            if (value !== undefined)
+                cleanOutput.push(value);
+        }
+        previous = time;
+    }
+    return cleanTimes.length > 0 ? { times: cleanTimes, output: cleanOutput } : { times, output };
+}
+function morphWeightCountForAnimationTarget(json, nodeIndex) {
+    const node = nodeIndex === undefined ? undefined : json.nodes?.[nodeIndex];
+    const mesh = node?.mesh === undefined ? undefined : json.meshes?.[node.mesh];
+    if (!mesh)
+        return undefined;
+    if (mesh.weights && mesh.weights.length > 0)
+        return mesh.weights.length;
+    return Math.max(0, ...mesh.primitives.map((primitive) => primitive.targets?.length ?? 0)) || undefined;
+}
+function normalizeWeightAnimationOutput(times, output, interpolation, animationIndex, channelIndex, morphWeightCount) {
+    const samplesPerTime = interpolation === "CUBICSPLINE" ? 3 : 1;
+    const expectedRows = times.length * samplesPerTime;
+    if (output.length === expectedRows)
+        return output;
+    if (times.length === 0 || output.length % expectedRows !== 0) {
+        return output;
+    }
+    const width = morphWeightCount ?? (output.length / expectedRows);
+    if (!Number.isInteger(width) || width <= 0 || output.length !== expectedRows * width) {
+        throw new Error(`glTF animation ${animationIndex} channel ${channelIndex} weights output count does not match morph target count`);
+    }
+    const grouped = [];
+    for (let sampleIndex = 0; sampleIndex < expectedRows; sampleIndex += 1) {
+        const values = [];
+        for (let component = 0; component < width; component += 1) {
+            values.push(output[sampleIndex * width + component]?.[0] ?? 0);
+        }
+        grouped.push(values);
+    }
+    return grouped;
+}
+async function loadDocument(request) {
+    const binary = request.url.startsWith("data:model/gltf-binary") || /\.glb(?:\?.*)?$/i.test(request.url);
+    if (request.url.startsWith("data:")) {
+        const data = decodeDataUri(request.url);
+        if (binary) {
+            return parseGLB(data, request.url);
+        }
+        const text = new TextDecoder().decode(data);
+        return { json: JSON.parse(text), url: request.url, byteLength: data.byteLength };
+    }
+    if (typeof fetch !== "function") {
+        throw new Error("GLTFLoader requires fetch for non-data URLs");
+    }
+    const response = await fetch(request.url, { signal: request.signal });
+    if (!response.ok) {
+        throw new Error(`glTF request failed with ${response.status}`);
+    }
+    if (binary) {
+        return parseGLB(await readResponseBytes(response, request.url, "document", request), request.url);
+    }
+    const bytes = await readResponseBytes(response, request.url, "document", request);
+    return { json: JSON.parse(new TextDecoder().decode(bytes)), url: request.url, byteLength: bytes.byteLength };
+}
+async function loadBuffer(buffer, index, document, request) {
+    validateBufferDescriptor(index, buffer);
+    if (!buffer.uri) {
+        if (index === 0 && document.binaryChunk) {
+            if (buffer.byteLength > document.binaryChunk.byteLength) {
+                throw new Error(`glTF buffer 0 declares ${buffer.byteLength} bytes but GLB BIN chunk has ${document.binaryChunk.byteLength}`);
+            }
+            return buffer.byteLength === document.binaryChunk.byteLength
+                ? document.binaryChunk
+                : document.binaryChunk.slice(0, buffer.byteLength);
+        }
+        throw new Error(`glTF buffer ${index} is missing a uri and no GLB BIN chunk is available`);
+    }
+    if (buffer.uri.startsWith("data:")) {
+        return validateLoadedBufferLength(index, buffer, decodeBufferDataUri(index, buffer.uri));
+    }
+    if (typeof fetch !== "function") {
+        throw new Error("GLTFLoader requires fetch for external buffers");
+    }
+    const url = new URL(buffer.uri, document.url).toString();
+    const response = await fetch(url, { signal: request.signal });
+    if (!response.ok) {
+        throw new Error(`glTF buffer request failed with ${response.status}`);
+    }
+    return validateLoadedBufferLength(index, buffer, await readResponseBytes(response, url, "buffer", request));
+}
+function validateBufferDescriptor(index, buffer) {
+    if (!Number.isInteger(buffer.byteLength) || buffer.byteLength < 0) {
+        throw new Error(`glTF buffer ${index} byteLength must be a non-negative integer`);
+    }
+}
+function decodeBufferDataUri(index, uri) {
+    const separator = uri.indexOf(",");
+    if (separator < 0) {
+        throw new Error(`glTF buffer ${index} data uri must include a comma separator`);
+    }
+    const header = uri.slice(5, separator).toLowerCase();
+    const mediaType = header.split(";")[0] ?? "";
+    if (mediaType && mediaType !== "application/octet-stream" && mediaType !== "application/gltf-buffer") {
+        throw new Error(`glTF buffer ${index} data uri media type must be application/octet-stream or application/gltf-buffer`);
+    }
+    const payload = uri.slice(separator + 1);
+    if (header.endsWith(";base64")) {
+        return decodeBufferBase64DataUri(index, payload);
+    }
+    try {
+        return new TextEncoder().encode(decodeURIComponent(payload)).buffer;
+    }
+    catch (error) {
+        throw new Error(`glTF buffer ${index} data uri payload must be valid URI encoding: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function decodeBufferBase64DataUri(index, payload) {
+    let decodedPayload;
+    try {
+        decodedPayload = decodeURIComponent(payload);
+    }
+    catch (error) {
+        throw new Error(`glTF buffer ${index} data uri base64 payload must be valid URI encoding: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const compactPayload = decodedPayload.replace(/\s+/g, "");
+    const paddingIndex = compactPayload.indexOf("=");
+    const paddingIsTerminal = paddingIndex < 0 || /^={1,2}$/.test(compactPayload.slice(paddingIndex));
+    if (compactPayload.length % 4 === 1 ||
+        !paddingIsTerminal ||
+        !/^[A-Za-z0-9+/]*={0,2}$/.test(compactPayload)) {
+        throw new Error(`glTF buffer ${index} data uri base64 payload is malformed`);
+    }
+    let binary;
+    try {
+        binary = atob(compactPayload);
+    }
+    catch (error) {
+        throw new Error(`glTF buffer ${index} data uri base64 payload is malformed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+}
+function validateLoadedBufferLength(index, buffer, data) {
+    if (data.byteLength !== buffer.byteLength) {
+        throw new Error(`glTF buffer ${index} declares ${buffer.byteLength} bytes but loaded ${data.byteLength}`);
+    }
+    return data;
+}
+async function prepareBufferViews(json, buffers, meshoptDecoder) {
+    const bufferViews = json.bufferViews ?? [];
+    const compressedViewEntries = bufferViews
+        .map((view, index) => ({ view, index, meshopt: resolveMeshoptCompressionExtension(view) }))
+        .filter((entry) => entry.meshopt !== undefined);
+    if (compressedViewEntries.length === 0) {
+        return { json, buffers };
+    }
+    if (!usesGLTFMeshoptExtension(json)) {
+        throw new Error("glTF uses meshopt-compressed bufferViews but meshopt extension is not declared");
+    }
+    if (!meshoptDecoder) {
+        throw new Error("glTF meshopt compression requires a meshoptDecoder");
+    }
+    const preparedBuffers = [...buffers];
+    const preparedBufferViews = [...bufferViews];
+    for (const { index, meshopt } of compressedViewEntries) {
+        const { name, extension } = meshopt;
+        validateMeshoptDescriptor(json, buffers, index, name, extension);
+        const sourceBuffer = buffers[extension.buffer];
+        const byteOffset = extension.byteOffset ?? 0;
+        const source = new Uint8Array(sourceBuffer, byteOffset, extension.byteLength);
+        const descriptor = {
+            bufferViewIndex: index,
+            byteStride: extension.byteStride,
+            count: extension.count,
+            mode: extension.mode,
+            filter: extension.filter ?? "NONE"
+        };
+        const decoded = toOwnedArrayBuffer(await meshoptDecoder(source, descriptor));
+        const expectedByteLength = extension.count * extension.byteStride;
+        if (decoded.byteLength !== expectedByteLength) {
+            throw new Error(`glTF bufferView ${index} EXT_meshopt_compression decoded ${decoded.byteLength} bytes but expected ${expectedByteLength}`);
+        }
+        const decodedBufferIndex = preparedBuffers.length;
+        preparedBuffers.push(decoded);
+        preparedBufferViews[index] = {
+            buffer: decodedBufferIndex,
+            byteOffset: 0,
+            byteLength: decoded.byteLength,
+            ...(extension.mode === "ATTRIBUTES" ? { byteStride: extension.byteStride } : {})
+        };
+    }
+    return {
+        json: { ...json, bufferViews: preparedBufferViews },
+        buffers: preparedBuffers
+    };
+}
+function resolveMeshoptCompressionExtension(view) {
+    for (const name of GLTF_MESHOPT_EXTENSION_NAMES) {
+        const extension = view.extensions?.[name];
+        if (extension)
+            return { name, extension };
+    }
+    return undefined;
+}
+function validateMeshoptDescriptor(json, buffers, bufferViewIndex, extensionName, extension) {
+    if (!Number.isInteger(extension.buffer) || extension.buffer < 0 || !json.buffers?.[extension.buffer] || !buffers[extension.buffer]) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} ${extensionName} buffer must reference an existing buffer`);
+    }
+    if (extension.byteOffset !== undefined && (!Number.isInteger(extension.byteOffset) || extension.byteOffset < 0)) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} ${extensionName} byteOffset must be a non-negative integer`);
+    }
+    if (!Number.isInteger(extension.byteLength) || extension.byteLength < 0) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} ${extensionName} byteLength must be a non-negative integer`);
+    }
+    if (!Number.isInteger(extension.byteStride) || extension.byteStride <= 0) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} ${extensionName} byteStride must be a positive integer`);
+    }
+    if (!Number.isInteger(extension.count) || extension.count < 0) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} ${extensionName} count must be a non-negative integer`);
+    }
+    if (extension.mode !== "ATTRIBUTES" && extension.mode !== "TRIANGLES" && extension.mode !== "INDICES") {
+        throw new Error(`glTF bufferView ${bufferViewIndex} ${extensionName} mode ${String(extension.mode)} is unsupported`);
+    }
+    if (extension.filter !== undefined &&
+        extension.filter !== "NONE" &&
+        extension.filter !== "OCTAHEDRAL" &&
+        extension.filter !== "QUATERNION" &&
+        extension.filter !== "EXPONENTIAL" &&
+        extension.filter !== "COLOR") {
+        throw new Error(`glTF bufferView ${bufferViewIndex} ${extensionName} filter ${String(extension.filter)} is unsupported`);
+    }
+    const sourceBuffer = buffers[extension.buffer];
+    const sourceStart = extension.byteOffset ?? 0;
+    const sourceEnd = sourceStart + extension.byteLength;
+    if (sourceEnd > sourceBuffer.byteLength) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} ${extensionName} source range exceeds buffer ${extension.buffer}`);
+    }
+}
+function toOwnedArrayBuffer(value) {
+    if (value instanceof ArrayBuffer) {
+        return value.slice(0);
+    }
+    const copy = new Uint8Array(value.byteLength);
+    copy.set(value);
+    return copy.buffer;
+}
+async function readResponseBytes(response, url, phase, request) {
+    const totalBytes = parseContentLength(response.headers?.get("content-length"));
+    const reader = response.body?.getReader();
+    if (!reader) {
+        const buffer = await response.arrayBuffer();
+        request.onProgress?.({ url, phase: "complete", loadedBytes: buffer.byteLength, ...(totalBytes === undefined ? {} : { totalBytes }) });
+        return buffer;
+    }
+    const chunks = [];
+    let loadedBytes = 0;
+    while (true) {
+        if (request.signal?.aborted) {
+            throw request.signal.reason instanceof Error ? request.signal.reason : new Error(`glTF request aborted for ${url}`);
+        }
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+        loadedBytes += value.byteLength;
+        request.onProgress?.({ url, phase, loadedBytes, ...(totalBytes === undefined ? {} : { totalBytes }) });
+    }
+    const buffer = new Uint8Array(loadedBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    request.onProgress?.({ url, phase: "complete", loadedBytes, ...(totalBytes === undefined ? {} : { totalBytes }) });
+    return buffer.buffer;
+}
+function parseContentLength(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function decodeDataUri(uri) {
+    const [header = "", payload = ""] = uri.split(",", 2);
+    if (header.endsWith(";base64")) {
+        let binary;
+        try {
+            binary = atob(payload);
+        }
+        catch (error) {
+            throw new Error(`Invalid base64 data URI payload: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i += 1) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    return new TextEncoder().encode(decodeURIComponent(payload)).buffer;
+}
+const GLB_MAGIC = 0x46546c67;
+const GLB_VERSION = 2;
+const GLB_CHUNK_JSON = 0x4e4f534a;
+const GLB_CHUNK_BIN = 0x004e4942;
+function parseGLB(data, url) {
+    const view = new DataView(data);
+    if (data.byteLength < 20) {
+        throw new Error("GLB file is too small");
+    }
+    const magic = view.getUint32(0, true);
+    const version = view.getUint32(4, true);
+    const declaredLength = view.getUint32(8, true);
+    if (magic !== GLB_MAGIC) {
+        throw new Error("Invalid GLB magic");
+    }
+    if (version !== GLB_VERSION) {
+        throw new Error(`Unsupported GLB version: ${version}`);
+    }
+    if (declaredLength !== data.byteLength) {
+        throw new Error(`GLB length mismatch: header ${declaredLength}, actual ${data.byteLength}`);
+    }
+    let offset = 12;
+    let json;
+    let binaryChunk;
+    while (offset < data.byteLength) {
+        if (offset + 8 > data.byteLength) {
+            throw new Error("Malformed GLB chunk header");
+        }
+        const chunkLength = view.getUint32(offset, true);
+        const chunkType = view.getUint32(offset + 4, true);
+        const chunkStart = offset + 8;
+        const chunkEnd = chunkStart + chunkLength;
+        if (chunkEnd > data.byteLength) {
+            throw new Error("Malformed GLB chunk length");
+        }
+        const chunk = data.slice(chunkStart, chunkEnd);
+        if (chunkType === GLB_CHUNK_JSON) {
+            const text = new TextDecoder().decode(chunk).replace(/[\u0000\s]+$/u, "");
+            json = JSON.parse(text);
+        }
+        else if (chunkType === GLB_CHUNK_BIN) {
+            binaryChunk = chunk;
+        }
+        offset = chunkEnd;
+    }
+    if (!json) {
+        throw new Error("GLB is missing a JSON chunk");
+    }
+    return { json, binaryChunk, url, byteLength: data.byteLength };
+}
+function readAccessor(json, buffers, accessorIndex, accessorCache) {
+    if (accessorCache)
+        accessorCache.profile.accessorReadCount += 1;
+    const cached = accessorCache?.rowsByAccessor.get(accessorIndex);
+    if (cached && accessorCache) {
+        accessorCache.profile.accessorCacheHitCount++;
+        return cached;
+    }
+    const startedAt = nowMs();
+    const accessor = json.accessors?.[accessorIndex];
+    if (!accessor) {
+        throw new Error(`Missing glTF accessor ${accessorIndex}`);
+    }
+    validateAccessorShape(accessorIndex, accessor);
+    const componentCount = componentCountForType(accessor.type);
+    const componentBytes = componentByteSize(accessor.componentType);
+    const rowByteLength = componentCount * componentBytes;
+    validateAccessorDescriptor(accessorIndex, accessor, rowByteLength);
+    const output = Array.from({ length: accessor.count }, () => new Array(componentCount).fill(0));
+    if (accessor.bufferView !== undefined) {
+        const { view, buffer } = getBufferView(json, buffers, accessor.bufferView);
+        const dataView = dataViewForBuffer(buffer, accessorCache);
+        const stride = view.byteStride ?? rowByteLength;
+        if (stride < rowByteLength) {
+            throw new Error(`glTF accessor ${accessorIndex} byteStride ${stride} is smaller than element size ${rowByteLength}`);
+        }
+        const offset = (view.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+        validateAccessorBounds(accessorIndex, buffer, view, offset, accessor.count, stride, rowByteLength);
+        for (let item = 0; item < accessor.count; item += 1) {
+            const baseOffset = offset + item * stride;
+            for (let component = 0; component < componentCount; component += 1) {
+                output[item][component] = readComponent(dataView, baseOffset + component * componentBytes, accessor.componentType, accessor.normalized ?? false);
+            }
+        }
+    }
+    if (accessor.sparse) {
+        applySparseAccessor(json, buffers, accessorIndex, accessor, output, componentCount, componentBytes, accessorCache);
+    }
+    if (accessorCache) {
+        recordAccessorRead(accessorCache, accessorIndex, accessor, componentCount, output.length, nowMs() - startedAt);
+        accessorCache.rowsByAccessor.set(accessorIndex, output);
+    }
+    return output;
+}
+function dataViewForBuffer(buffer, accessorCache) {
+    if (!accessorCache)
+        return new DataView(buffer);
+    const existing = accessorCache.dataViews.get(buffer);
+    if (existing)
+        return existing;
+    const view = new DataView(buffer);
+    accessorCache.dataViews.set(buffer, view);
+    accessorCache.profile.dataViewCacheEntries = accessorCache.dataViews.size;
+    return view;
+}
+function recordAccessorRead(accessorCache, accessorIndex, accessor, componentCount, rowCount, elapsedMs) {
+    const profile = accessorCache.profile;
+    const byteLength = rowCount * componentCount * componentByteSize(accessor.componentType);
+    profile.uniqueAccessorReadCount++;
+    profile.accessorRowsRead += rowCount;
+    profile.accessorValuesRead += rowCount * componentCount;
+    profile.accessorReadMs += elapsedMs;
+    profile.largestAccessors.push({
+        accessorIndex,
+        count: accessor.count,
+        type: accessor.type,
+        componentType: accessor.componentType,
+        componentCount,
+        byteLength,
+        ...(accessor.bufferView !== undefined ? { bufferView: accessor.bufferView } : {})
+    });
+    profile.largestAccessors.sort((left, right) => right.byteLength - left.byteLength);
+    if (profile.largestAccessors.length > 8) {
+        profile.largestAccessors.length = 8;
+    }
+}
+function validateAccessorShape(accessorIndex, accessor) {
+    if (!isAccessorType(accessor.type)) {
+        throw new Error(`glTF accessor ${accessorIndex} type ${String(accessor.type)} is unsupported`);
+    }
+    if (!isAccessorComponentType(accessor.componentType)) {
+        throw new Error(`glTF accessor ${accessorIndex} componentType ${String(accessor.componentType)} is unsupported`);
+    }
+    if (accessor.bufferView !== undefined && (!Number.isInteger(accessor.bufferView) || accessor.bufferView < 0)) {
+        throw new Error(`glTF accessor ${accessorIndex} bufferView must be a non-negative integer`);
+    }
+    if (accessor.sparse) {
+        validateSparseAccessorShape(accessorIndex, accessor.sparse);
+    }
+}
+function validateAccessorDescriptor(accessorIndex, accessor, rowByteLength) {
+    if (!Number.isInteger(accessor.count) || accessor.count < 0) {
+        throw new Error(`glTF accessor ${accessorIndex} count must be a non-negative integer`);
+    }
+    if (accessor.byteOffset !== undefined && (!Number.isInteger(accessor.byteOffset) || accessor.byteOffset < 0)) {
+        throw new Error(`glTF accessor ${accessorIndex} byteOffset must be a non-negative integer`);
+    }
+    if (accessor.sparse) {
+        if (!Number.isInteger(accessor.sparse.count) || accessor.sparse.count < 0) {
+            throw new Error(`glTF accessor ${accessorIndex} sparse count must be a non-negative integer`);
+        }
+        if (accessor.sparse.count > accessor.count) {
+            throw new Error(`glTF accessor ${accessorIndex} sparse count exceeds accessor count`);
+        }
+        if (accessor.sparse.indices.byteOffset !== undefined && (!Number.isInteger(accessor.sparse.indices.byteOffset) || accessor.sparse.indices.byteOffset < 0)) {
+            throw new Error(`glTF accessor ${accessorIndex} sparse indices byteOffset must be a non-negative integer`);
+        }
+        if (accessor.sparse.values.byteOffset !== undefined && (!Number.isInteger(accessor.sparse.values.byteOffset) || accessor.sparse.values.byteOffset < 0)) {
+            throw new Error(`glTF accessor ${accessorIndex} sparse values byteOffset must be a non-negative integer`);
+        }
+    }
+    if (rowByteLength <= 0) {
+        throw new Error(`glTF accessor ${accessorIndex} has invalid element size`);
+    }
+}
+function validateSparseAccessorShape(accessorIndex, sparse) {
+    const record = sparse;
+    if (!isObjectRecord(record.indices)) {
+        throw new Error(`glTF accessor ${accessorIndex} sparse indices must be an object`);
+    }
+    if (!isObjectRecord(record.values)) {
+        throw new Error(`glTF accessor ${accessorIndex} sparse values must be an object`);
+    }
+    if (!isSparseIndexComponentType(sparse.indices.componentType)) {
+        throw new Error(`glTF accessor ${accessorIndex} sparse indices componentType ${String(sparse.indices.componentType)} is unsupported`);
+    }
+    if (!Number.isInteger(sparse.indices.bufferView) || sparse.indices.bufferView < 0) {
+        throw new Error(`glTF accessor ${accessorIndex} sparse indices bufferView must be a non-negative integer`);
+    }
+    if (!Number.isInteger(sparse.values.bufferView) || sparse.values.bufferView < 0) {
+        throw new Error(`glTF accessor ${accessorIndex} sparse values bufferView must be a non-negative integer`);
+    }
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function applySparseAccessor(json, buffers, accessorIndex, accessor, output, componentCount, componentBytes, accessorCache) {
+    const sparse = accessor.sparse;
+    if (!sparse || sparse.count === 0) {
+        return;
+    }
+    const { view: indexView, buffer: indexBuffer } = getBufferView(json, buffers, sparse.indices.bufferView);
+    const indexDataView = dataViewForBuffer(indexBuffer, accessorCache);
+    const indexComponentBytes = componentByteSize(sparse.indices.componentType);
+    const indexStart = (indexView.byteOffset ?? 0) + (sparse.indices.byteOffset ?? 0);
+    validateRawRange(`glTF accessor ${accessorIndex} sparse indices`, indexBuffer, indexView, indexStart, sparse.count * indexComponentBytes);
+    const { view: valueView, buffer: valueBuffer } = getBufferView(json, buffers, sparse.values.bufferView);
+    const valueDataView = dataViewForBuffer(valueBuffer, accessorCache);
+    const valueStart = (valueView.byteOffset ?? 0) + (sparse.values.byteOffset ?? 0);
+    const rowByteLength = componentCount * componentBytes;
+    validateRawRange(`glTF accessor ${accessorIndex} sparse values`, valueBuffer, valueView, valueStart, sparse.count * rowByteLength);
+    for (let item = 0; item < sparse.count; item += 1) {
+        const targetIndex = readComponent(indexDataView, indexStart + item * indexComponentBytes, sparse.indices.componentType, false);
+        if (!Number.isInteger(targetIndex) || targetIndex < 0 || targetIndex >= accessor.count) {
+            throw new Error(`glTF accessor ${accessorIndex} sparse index ${targetIndex} is out of range`);
+        }
+        const valueOffset = valueStart + item * rowByteLength;
+        for (let component = 0; component < componentCount; component += 1) {
+            output[targetIndex][component] = readComponent(valueDataView, valueOffset + component * componentBytes, accessor.componentType, accessor.normalized ?? false);
+        }
+    }
+}
+function getBufferView(json, buffers, bufferViewIndex) {
+    if (!Number.isInteger(bufferViewIndex) || bufferViewIndex < 0) {
+        throw new Error(`glTF bufferView ${String(bufferViewIndex)} must be a non-negative integer`);
+    }
+    const view = json.bufferViews?.[bufferViewIndex];
+    if (!view) {
+        throw new Error(`Missing glTF bufferView ${bufferViewIndex}`);
+    }
+    validateBufferViewDescriptor(bufferViewIndex, view);
+    const buffer = buffers[view.buffer];
+    if (!buffer) {
+        throw new Error(`Missing glTF buffer ${view.buffer}`);
+    }
+    const start = view.byteOffset ?? 0;
+    const end = start + view.byteLength;
+    if (end > buffer.byteLength) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} exceeds buffer ${view.buffer}`);
+    }
+    return { view, buffer };
+}
+function validateBufferViewDescriptor(bufferViewIndex, view) {
+    if (!Number.isInteger(view.buffer) || view.buffer < 0) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} buffer must be a non-negative integer`);
+    }
+    if (view.byteOffset !== undefined && (!Number.isInteger(view.byteOffset) || view.byteOffset < 0)) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} byteOffset must be a non-negative integer`);
+    }
+    if (!Number.isInteger(view.byteLength) || view.byteLength < 0) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} byteLength must be a non-negative integer`);
+    }
+    if (view.byteStride !== undefined &&
+        (!Number.isInteger(view.byteStride) || view.byteStride < 4 || view.byteStride > 252 || view.byteStride % 4 !== 0)) {
+        throw new Error(`glTF bufferView ${bufferViewIndex} byteStride must be a 4-byte aligned integer between 4 and 252`);
+    }
+}
+function validateAccessorBounds(accessorIndex, buffer, view, start, count, stride, rowByteLength) {
+    const byteLength = count === 0 ? 0 : (count - 1) * stride + rowByteLength;
+    validateRawRange(`glTF accessor ${accessorIndex}`, buffer, view, start, byteLength);
+}
+function validateRawRange(label, buffer, view, start, byteLength) {
+    if (!Number.isInteger(start) || start < 0 || !Number.isInteger(byteLength) || byteLength < 0) {
+        throw new Error(`${label} byte range must be non-negative integers`);
+    }
+    const viewStart = view.byteOffset ?? 0;
+    const viewEnd = viewStart + view.byteLength;
+    const end = start + byteLength;
+    if (end > viewEnd || end > buffer.byteLength) {
+        throw new Error(`${label} exceeds its glTF bufferView`);
+    }
+}
+function readOptionalAccessor(json, buffers, accessorIndex, accessorCache) {
+    return accessorIndex === undefined ? [] : readAccessor(json, buffers, accessorIndex, accessorCache);
+}
+function readBufferViewBytes(json, buffers, bufferViewIndex) {
+    const { view, buffer } = getBufferView(json, buffers, bufferViewIndex);
+    const start = view.byteOffset ?? 0;
+    const end = start + view.byteLength;
+    return buffer.slice(start, end);
+}
+function isAccessorType(type) {
+    return type === "SCALAR" || type === "VEC2" || type === "VEC3" || type === "VEC4" || type === "MAT4";
+}
+function isAccessorComponentType(type) {
+    return type === 5120 || type === 5121 || type === 5122 || type === 5123 || type === 5125 || type === 5126;
+}
+function isSparseIndexComponentType(type) {
+    return type === 5121 || type === 5123 || type === 5125;
+}
+function componentCountForType(type) {
+    return type === "SCALAR" ? 1 : type === "VEC2" ? 2 : type === "VEC3" ? 3 : type === "VEC4" ? 4 : 16;
+}
+function componentByteSize(type) {
+    if (type === 5120 || type === 5121)
+        return 1;
+    if (type === 5122 || type === 5123)
+        return 2;
+    return 4;
+}
+function readComponent(view, byteOffset, type, normalized) {
+    if (type === 5120) {
+        const value = view.getInt8(byteOffset);
+        return normalized ? Math.max(value / 127, -1) : value;
+    }
+    if (type === 5121) {
+        const value = view.getUint8(byteOffset);
+        return normalized ? value / 255 : value;
+    }
+    if (type === 5122) {
+        const value = view.getInt16(byteOffset, true);
+        return normalized ? Math.max(value / 32767, -1) : value;
+    }
+    if (type === 5126)
+        return view.getFloat32(byteOffset, true);
+    if (type === 5125)
+        return view.getUint32(byteOffset, true);
+    const value = view.getUint16(byteOffset, true);
+    return normalized ? value / 65535 : value;
+}
+function resolvePrimitiveMaterialIndex(primitive, materials, meshIndex, primitiveIndex) {
+    if (primitive.material === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(primitive.material) || primitive.material < 0) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} material must be a non-negative integer`);
+    }
+    if (!materials[primitive.material]) {
+        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} references missing material ${primitive.material}`);
+    }
+    return primitive.material;
+}
+function materialName(material, index) {
+    return index === undefined ? DEFAULT_GLTF_MATERIAL_NAME : material?.name ?? `material-${index}`;
+}
+function meshPrimitiveName(mesh, meshIndex, primitiveIndex) {
+    const base = mesh.name ?? `mesh-${meshIndex}`;
+    return mesh.primitives.length === 1 ? base : `${base}-primitive-${primitiveIndex}`;
+}
+function resolveNodeTransform(node, nodeIndex) {
+    if (node.matrix !== undefined) {
+        if (node.translation !== undefined || node.rotation !== undefined || node.scale !== undefined) {
+            throw new Error(`glTF node ${nodeIndex} cannot combine matrix with translation, rotation, or scale`);
+        }
+        const decomposed = decomposeMat4(resolveNodeMatrix(node.matrix, nodeIndex));
+        return {
+            translation: decomposed.position,
+            rotation: decomposed.rotation,
+            scale: decomposed.scale
+        };
+    }
+    return {
+        translation: resolveVec3(node.translation, [0, 0, 0], `node ${nodeIndex} translation`),
+        rotation: resolveQuat(node.rotation, [0, 0, 0, 1], `node ${nodeIndex} rotation`),
+        scale: resolveVec3(node.scale, [1, 1, 1], `node ${nodeIndex} scale`)
+    };
+}
+function resolveNodeMatrix(matrix, nodeIndex) {
+    if (matrix.length !== 16 || matrix.some((value) => !Number.isFinite(value))) {
+        throw new RangeError(`glTF node ${nodeIndex} matrix must contain 16 finite values`);
+    }
+    return [
+        matrix[0], matrix[1], matrix[2], matrix[3],
+        matrix[4], matrix[5], matrix[6], matrix[7],
+        matrix[8], matrix[9], matrix[10], matrix[11],
+        matrix[12], matrix[13], matrix[14], matrix[15]
+    ];
+}
+function resolveVec3(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (resolved.length !== 3 || resolved.some((component) => !Number.isFinite(component))) {
+        throw new RangeError(`glTF ${label} must contain three finite values`);
+    }
+    return [resolved[0], resolved[1], resolved[2]];
+}
+function resolveQuat(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (resolved.length !== 4 || resolved.some((component) => !Number.isFinite(component))) {
+        throw new RangeError(`glTF ${label} must contain four finite values`);
+    }
+    return [resolved[0], resolved[1], resolved[2], resolved[3]];
+}
+function createScene(json, meshes, cameras, lights, skins, nodeInstanceTransforms, materialVariants, options = {}) {
+    const sceneIndex = resolveSelectedSceneIndex(json, options);
+    validateSceneGraph(json, sceneIndex);
+    validateSceneMaterialVariant(materialVariants, options.materialVariant);
+    const materialKeyForRenderable = createRuntimeMaterialKeyResolver(json, sceneIndex, meshes, skins, nodeInstanceTransforms, options.materialVariant);
+    const nodeWorldMatrices = computeGLTFNodeWorldMatrices(json);
+    const nodeNameForIndex = createGLTFNodeNameResolver(json);
+    const scene = new Scene();
+    const nodes = new Map();
+    const createNode = (index) => {
+        const source = json.nodes?.[index];
+        if (!source) {
+            throw new Error(`Missing glTF node ${index}`);
+        }
+        const existing = nodes.get(index);
+        if (existing) {
+            return existing;
+        }
+        const node = createSceneNodeForGLTFNode(scene, source, index, nodeNameForIndex(index), cameras, lights);
+        const transform = resolveNodeTransform(source, index);
+        node.transform.setPosition(transform.translation[0], transform.translation[1], transform.translation[2]);
+        node.transform.setRotation(transform.rotation[0], transform.rotation[1], transform.rotation[2], transform.rotation[3]);
+        node.transform.setScale(transform.scale[0], transform.scale[1], transform.scale[2]);
+        if (source.mesh !== undefined) {
+            attachMeshPrimitives(scene, node, source.mesh, index, meshes, skins, source.skin, nodeWorldMatrices.get(index), nodeInstanceTransforms.get(index), materialKeyForRenderable);
+        }
+        nodes.set(index, node);
+        for (const childIndex of source.children ?? []) {
+            node.addChild(createNode(childIndex));
+        }
+        return node;
+    };
+    const sceneDefinition = json.scenes?.[sceneIndex];
+    for (const nodeIndex of sceneDefinition?.nodes ?? []) {
+        scene.root.addChild(createNode(nodeIndex));
+    }
+    return scene;
+}
+function resolveSelectedSceneIndex(json, options) {
+    if (options.sceneIndex !== undefined && options.sceneName !== undefined) {
+        throw new Error("glTF scene selection cannot specify both sceneIndex and sceneName");
+    }
+    if (options.sceneName !== undefined) {
+        const sceneIndex = (json.scenes ?? []).findIndex((scene, index) => (scene.name ?? `scene-${index}`) === options.sceneName);
+        if (sceneIndex < 0) {
+            throw new Error(`glTF scene named ${options.sceneName} is not defined`);
+        }
+        return sceneIndex;
+    }
+    if (options.sceneIndex !== undefined) {
+        if (!Number.isInteger(options.sceneIndex) || options.sceneIndex < 0 || !json.scenes?.[options.sceneIndex]) {
+            throw new Error(`glTF scene ${options.sceneIndex} is missing`);
+        }
+        return options.sceneIndex;
+    }
+    return resolveDefaultSceneIndex(json);
+}
+function validateSceneMaterialVariant(materialVariants, selectedVariant) {
+    if (selectedVariant === undefined)
+        return;
+    if (!materialVariants.some((variant) => variant.name === selectedVariant)) {
+        throw new Error(`glTF material variant ${selectedVariant} is not defined`);
+    }
+}
+function validateSceneGraph(json, sceneIndex = resolveDefaultSceneIndex(json)) {
+    const nodeDefinitions = json.nodes ?? [];
+    if (json.scenes && (!Number.isInteger(sceneIndex) || sceneIndex < 0 || !json.scenes[sceneIndex]))
+        throw new Error(`glTF scene ${sceneIndex} is missing`);
+    const parentByNode = new Map();
+    for (const [nodeIndex, node] of nodeDefinitions.entries()) {
+        for (const childIndex of node.children ?? []) {
+            if (!Number.isInteger(childIndex) || childIndex < 0 || !nodeDefinitions[childIndex]) {
+                throw new Error(`glTF node ${nodeIndex} references missing child node ${childIndex}`);
+            }
+            const existingParent = parentByNode.get(childIndex);
+            if (existingParent !== undefined) {
+                throw new Error(`glTF node ${childIndex} has multiple parents: ${existingParent} and ${nodeIndex}`);
+            }
+            parentByNode.set(childIndex, nodeIndex);
+        }
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (nodeIndex) => {
+        if (visiting.has(nodeIndex)) {
+            throw new Error(`glTF node graph contains a cycle at node ${nodeIndex}`);
+        }
+        if (visited.has(nodeIndex)) {
+            return;
+        }
+        visiting.add(nodeIndex);
+        for (const childIndex of nodeDefinitions[nodeIndex]?.children ?? []) {
+            visit(childIndex);
+        }
+        visiting.delete(nodeIndex);
+        visited.add(nodeIndex);
+    };
+    for (let nodeIndex = 0; nodeIndex < nodeDefinitions.length; nodeIndex += 1) {
+        visit(nodeIndex);
+    }
+    for (const [rootListIndex, rootNodeIndex] of (json.scenes?.[sceneIndex]?.nodes ?? []).entries()) {
+        if (!Number.isInteger(rootNodeIndex) || rootNodeIndex < 0 || !nodeDefinitions[rootNodeIndex]) {
+            throw new Error(`glTF scene ${sceneIndex} root ${rootListIndex} references missing node ${rootNodeIndex}`);
+        }
+        if (parentByNode.has(rootNodeIndex)) {
+            throw new Error(`glTF scene ${sceneIndex} root ${rootNodeIndex} is also a child node`);
+        }
+    }
+}
+function attachMeshPrimitives(scene, node, meshIndex, nodeIndex, meshes, skins, nodeSkinIndex, nodeWorldMatrix, instanceTransforms, materialKeyForRenderable) {
+    if (!Number.isInteger(meshIndex) || meshIndex < 0) {
+        throw new RangeError(`glTF node ${nodeIndex} mesh must be a non-negative integer`);
+    }
+    const primitives = meshes.filter((mesh) => mesh.sourceMeshIndex === meshIndex);
+    if (primitives.length === 0) {
+        throw new Error(`glTF node ${nodeIndex} references missing mesh ${meshIndex}`);
+    }
+    if (primitives.length === 1) {
+        const mesh = primitives[0];
+        const skinning = skinningForMesh(mesh, skins, nodeSkinIndex, nodeWorldMatrix);
+        scene.addRenderable(node, new Renderable({
+            geometry: mesh.name,
+            material: materialKeyForRenderable?.(mesh, runtimeMaterialContract(skinning, instanceTransforms)) ?? mesh.material,
+            ...(skinning ? { skinning } : {}),
+            morphWeights: mesh.morphWeights,
+            ...(instanceTransforms ? { instanceTransforms } : {})
+        }));
+        return;
+    }
+    for (const mesh of primitives) {
+        const skinning = skinningForMesh(mesh, skins, nodeSkinIndex, nodeWorldMatrix);
+        const primitiveNode = scene.createNode(mesh.name);
+        primitiveNode.transform.setPosition(0, 0, 0);
+        primitiveNode.transform.setRotation(0, 0, 0, 1);
+        primitiveNode.transform.setScale(1, 1, 1);
+        scene.addRenderable(primitiveNode, new Renderable({
+            geometry: mesh.name,
+            material: materialKeyForRenderable?.(mesh, runtimeMaterialContract(skinning, instanceTransforms)) ?? mesh.material,
+            ...(skinning ? { skinning } : {}),
+            morphWeights: mesh.morphWeights,
+            ...(instanceTransforms ? { instanceTransforms } : {})
+        }));
+        node.addChild(primitiveNode);
+    }
+}
+function skinningForMesh(mesh, skins, nodeSkinIndex, nodeWorldMatrix) {
+    const skinIndex = nodeSkinIndex;
+    if (skinIndex === undefined)
+        return undefined;
+    if (mesh.joints.length === 0 || mesh.weights.length === 0) {
+        throw new Error(`glTF mesh ${mesh.name} references skin ${skinIndex} but is missing JOINTS_0 or WEIGHTS_0 attributes`);
+    }
+    const skin = skins[skinIndex];
+    if (!skin) {
+        throw new Error(`glTF mesh ${mesh.name} references missing skin ${skinIndex}`);
+    }
+    if (skin.joints.length > MAX_RENDERABLE_SKIN_JOINTS) {
+        return undefined;
+    }
+    if (!nodeWorldMatrix)
+        return skin.skinningPalette;
+    const inverseMeshWorld = invertLoaderMat4(nodeWorldMatrix);
+    const matrices = new Float32Array(skin.jointBindMatrices.length * 16);
+    for (let index = 0; index < skin.jointBindMatrices.length; index += 1) {
+        matrices.set(multiplyLoaderMat4(inverseMeshWorld, skin.jointBindMatrices[index]), index * 16);
+    }
+    return { jointCount: skin.jointBindMatrices.length, matrices };
+}
+function composeLoaderMat4(translation, rotation, scale) {
+    return composeMat4([...translation], [...rotation], [...scale]);
+}
+function multiplyLoaderMat4(left, right) {
+    return multiplyMat4([...left], [...right]);
+}
+function invertLoaderMat4(matrix) {
+    return invertMat4([...matrix]);
+}
+export function gltfRuntimeMaterialKey(material, contract) {
+    const signature = runtimeMaterialSignature(contract);
+    return signature === "base" ? material : `${material}${RUNTIME_MATERIAL_KEY_MARKER}${signature}`;
+}
+export function parseGLTFRuntimeMaterialKey(key) {
+    const markerIndex = key.lastIndexOf(RUNTIME_MATERIAL_KEY_MARKER);
+    if (markerIndex < 0)
+        return { material: key, contract: {} };
+    const signature = key.slice(markerIndex + RUNTIME_MATERIAL_KEY_MARKER.length);
+    const contract = runtimeMaterialContractFromSignature(signature);
+    if (!contract)
+        return { material: key, contract: {} };
+    return {
+        material: key.slice(0, markerIndex),
+        contract
+    };
+}
+function createRuntimeMaterialKeyResolver(json, sceneIndex, meshes, skins, nodeInstanceTransforms, materialVariant) {
+    const signaturesByMaterial = new Map();
+    const register = (material, contract) => {
+        const signatures = signaturesByMaterial.get(material) ?? new Set();
+        signatures.add(runtimeMaterialSignature(contract));
+        signaturesByMaterial.set(material, signatures);
+    };
+    const visit = (nodeIndex) => {
+        const node = json.nodes?.[nodeIndex];
+        if (!node)
+            return;
+        if (node.mesh !== undefined) {
+            const instanceTransforms = nodeInstanceTransforms.get(nodeIndex);
+            for (const mesh of meshes.filter((entry) => entry.sourceMeshIndex === node.mesh)) {
+                const skinning = skinningForMesh(mesh, skins, node.skin);
+                register(materialForVariant(mesh, materialVariant), runtimeMaterialContract(skinning, instanceTransforms));
+            }
+        }
+        for (const childIndex of node.children ?? [])
+            visit(childIndex);
+    };
+    for (const nodeIndex of json.scenes?.[sceneIndex]?.nodes ?? [])
+        visit(nodeIndex);
+    return (mesh, contract) => {
+        const material = materialForVariant(mesh, materialVariant);
+        const signatures = signaturesByMaterial.get(material);
+        return signatures && signatures.size > 1 ? gltfRuntimeMaterialKey(material, contract) : material;
+    };
+}
+function runtimeMaterialContract(skinning, instanceTransforms) {
+    return {
+        ...(skinning ? { skinned: true } : {}),
+        ...(instanceTransforms ? { instanced: true } : {})
+    };
+}
+function runtimeMaterialSignature(contract) {
+    if (contract.skinned && contract.instanced)
+        return "skinned+instanced";
+    if (contract.skinned)
+        return "skinned";
+    if (contract.instanced)
+        return "instanced";
+    return "base";
+}
+function runtimeMaterialContractFromSignature(signature) {
+    if (signature === "skinned+instanced")
+        return { skinned: true, instanced: true };
+    if (signature === "skinned")
+        return { skinned: true };
+    if (signature === "instanced")
+        return { instanced: true };
+    if (signature === "base")
+        return {};
+    return undefined;
+}
+function materialForVariant(mesh, materialVariant) {
+    if (materialVariant === undefined)
+        return mesh.material;
+    return mesh.materialVariants.find((mapping) => mapping.variant === materialVariant)?.material ?? mesh.material;
+}
+function createSceneNodeForGLTFNode(scene, source, nodeIndex, nodeName, cameras, lights) {
+    if (source.camera !== undefined && source.extensions?.KHR_lights_punctual?.light !== undefined) {
+        throw new Error(`glTF node ${nodeIndex} cannot combine camera and KHR_lights_punctual light`);
+    }
+    let node;
+    if (source.camera !== undefined) {
+        node = createCameraNodeForGLTFNode(scene, source, nodeIndex, nodeName, cameras);
+        applyGLTFNodeMetadata(node, source, nodeIndex);
+        return node;
+    }
+    const lightIndex = source.extensions?.KHR_lights_punctual?.light;
+    if (lightIndex === undefined) {
+        node = scene.createNode(nodeName);
+        applyGLTFNodeMetadata(node, source, nodeIndex);
+        return node;
+    }
+    if (!Number.isInteger(lightIndex) || lightIndex < 0) {
+        throw new RangeError(`glTF node ${nodeIndex} KHR_lights_punctual.light must be a non-negative integer`);
+    }
+    const light = lights[lightIndex];
+    if (!light) {
+        throw new Error(`glTF node ${nodeIndex} references missing punctual light ${lightIndex}`);
+    }
+    const lightNode = scene.createLight(light.type, nodeName);
+    lightNode.color = [...light.color];
+    lightNode.intensity = light.intensity;
+    if (lightNode instanceof PointLight) {
+        lightNode.range = light.range ?? 10;
+    }
+    else if (lightNode instanceof SpotLight) {
+        lightNode.range = light.range ?? 10;
+        lightNode.angle = light.spot?.outerConeAngle ?? Math.PI / 4;
+        lightNode.penumbra = spotPenumbra(light.spot?.innerConeAngle ?? 0, lightNode.angle);
+    }
+    applyGLTFNodeMetadata(lightNode, source, nodeIndex);
+    return lightNode;
+}
+function applyGLTFNodeMetadata(node, source, nodeIndex) {
+    node.userData.gltfNodeIndex = nodeIndex;
+    if (!source.extras)
+        return;
+    node.userData.gltfExtras = { ...source.extras };
+    for (const [key, value] of Object.entries(source.extras)) {
+        if (key.startsWith("a3d_"))
+            node.userData[key] = value;
+    }
+}
+function createCameraNodeForGLTFNode(scene, source, nodeIndex, nodeName, cameras) {
+    const cameraIndex = source.camera;
+    if (!Number.isInteger(cameraIndex) || cameraIndex === undefined || cameraIndex < 0) {
+        throw new RangeError(`glTF node ${nodeIndex} camera must be a non-negative integer`);
+    }
+    const camera = cameras[cameraIndex];
+    if (!camera) {
+        throw new Error(`glTF node ${nodeIndex} references missing camera ${cameraIndex}`);
+    }
+    if (camera.type === "perspective") {
+        const perspective = camera.perspective;
+        return scene.createPerspectiveCamera({
+            name: nodeName,
+            fovYRadians: perspective.yfov,
+            aspect: perspective.aspectRatio,
+            near: perspective.znear,
+            far: perspective.zfar
+        });
+    }
+    const orthographic = camera.orthographic;
+    return scene.createOrthographicCamera({
+        name: nodeName,
+        left: -orthographic.xmag / 2,
+        right: orthographic.xmag / 2,
+        bottom: -orthographic.ymag / 2,
+        top: orthographic.ymag / 2,
+        near: orthographic.znear,
+        far: orthographic.zfar
+    });
+}
+function spotPenumbra(innerConeAngle, outerConeAngle) {
+    if (outerConeAngle <= 0)
+        return 0;
+    return Math.max(0, Math.min(1, 1 - innerConeAngle / outerConeAngle));
+}
+function createGLTFNodeNameResolver(json) {
+    const bases = (json.nodes ?? []).map((node, index) => typeof node.name === "string" && node.name.trim().length > 0 ? node.name : `node-${index}`);
+    const totals = new Map();
+    for (const base of bases) {
+        totals.set(base, (totals.get(base) ?? 0) + 1);
+    }
+    const seen = new Map();
+    const names = bases.map((base) => {
+        const count = seen.get(base) ?? 0;
+        seen.set(base, count + 1);
+        return (totals.get(base) ?? 0) > 1 && count > 0 ? `${base}_${count}` : base;
+    });
+    return (nodeIndex) => {
+        const name = names[nodeIndex];
+        if (name === undefined) {
+            throw new Error(`glTF node ${nodeIndex} is missing`);
+        }
+        return name;
+    };
+}
+function findSkinForMesh(json, meshIndex) {
+    const nodeIndex = (json.nodes ?? []).findIndex((node) => node.mesh === meshIndex && node.skin !== undefined);
+    if (nodeIndex < 0)
+        return undefined;
+    return json.nodes?.[nodeIndex]?.skin;
+}
+function parentIndexByNode(json) {
+    const parents = new Map();
+    for (const [parentIndex, node] of (json.nodes ?? []).entries()) {
+        for (const childIndex of node.children ?? []) {
+            parents.set(childIndex, parentIndex);
+        }
+    }
+    return parents;
+}
+function orderSkinJoints(json, joints) {
+    const jointSet = new Set(joints);
+    const ordered = [];
+    const visited = new Set();
+    const parents = parentIndexByNode(json);
+    const visit = (joint) => {
+        if (visited.has(joint))
+            return;
+        const parent = parents.get(joint);
+        if (parent !== undefined && jointSet.has(parent))
+            visit(parent);
+        if (!json.nodes?.[joint]) {
+            throw new Error(`glTF skin references missing joint node ${joint}`);
+        }
+        visited.add(joint);
+        ordered.push(joint);
+    };
+    for (const joint of joints)
+        visit(joint);
+    return ordered;
+}
+function valueTypeForAnimationPath(path) {
+    if (path === "rotation")
+        return "quaternion";
+    if (path === "translation" || path === "scale")
+        return "vector3";
+    return "number-array";
+}
+function animationValueForPath(path, row) {
+    if (path === "rotation")
+        return toQuat(row);
+    if (path === "translation" || path === "scale")
+        return toVec3(row);
+    return [...row];
+}
+function toVec3(row) {
+    return [row[0] ?? 0, row[1] ?? 0, row[2] ?? 0];
+}
+function toQuat(row) {
+    return [row[0] ?? 0, row[1] ?? 0, row[2] ?? 0, row[3] ?? 1];
+}
+function toMat4(row) {
+    if (row.length !== 16) {
+        throw new Error(`glTF MAT4 accessor row has ${row.length} components`);
+    }
+    return [
+        row[0], row[1], row[2], row[3],
+        row[4], row[5], row[6], row[7],
+        row[8], row[9], row[10], row[11],
+        row[12], row[13], row[14], row[15]
+    ];
+}
+function identityMat4() {
+    return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function serializeGLTFAsset(url, loaderDiagnostics, images, textures, materials, materialVariants, scenes, defaultScene, meshes, cameras, lights, skins, animations) {
+    return {
+        url,
+        loaderDiagnostics,
+        images: images.map((image) => ({
+            name: image.name,
+            ...(image.uri ? { uri: image.uri } : {}),
+            ...(image.mimeType ? { mimeType: image.mimeType } : {}),
+            ...(image.data ? { byteLength: image.data.byteLength } : {})
+        })),
+        textures: textures.map((texture) => ({ ...texture })),
+        materials: materials.map((material) => ({ ...material })),
+        materialVariants: materialVariants.map((variant) => ({ ...variant })),
+        scenes: scenes.map((scene) => ({ name: scene.name, nodeIndices: [...scene.nodeIndices] })),
+        defaultScene,
+        meshes: meshes.map((mesh) => ({
+            ...mesh,
+            positions: mesh.positions.map((position) => [...position]),
+            normals: mesh.normals.map((normal) => [...normal]),
+            texcoords: mesh.texcoords.map((texcoord) => [...texcoord]),
+            texcoordSets: mesh.texcoordSets.map((set) => set.map((texcoord) => [...texcoord])),
+            tangents: mesh.tangents.map((tangent) => [...tangent]),
+            colors: mesh.colors.map((color) => [...color]),
+            joints: mesh.joints.map((joint) => [...joint]),
+            weights: mesh.weights.map((weight) => [...weight]),
+            morphTargets: mesh.morphTargets.map((target) => ({
+                positions: target.positions.map((position) => [...position]),
+                normals: target.normals.map((normal) => [...normal]),
+                tangents: target.tangents.map((tangent) => [...tangent])
+            })),
+            morphWeights: [...mesh.morphWeights],
+            indices: mesh.indices ? [...mesh.indices] : undefined
+        })),
+        cameras: cameras.map((camera) => ({
+            ...camera,
+            ...(camera.perspective ? { perspective: { ...camera.perspective } } : {}),
+            ...(camera.orthographic ? { orthographic: { ...camera.orthographic } } : {})
+        })),
+        lights: lights.map((light) => ({
+            ...light,
+            color: [...light.color],
+            ...(light.spot ? { spot: { ...light.spot } } : {})
+        })),
+        skins: skins.map((skin) => ({
+            name: skin.name,
+            joints: [...skin.joints],
+            jointNames: [...skin.jointNames],
+            inverseBindMatrices: skin.inverseBindMatrices.map((matrix) => [...matrix]),
+            ...(skin.skeletonRoot !== undefined ? { skeletonRoot: skin.skeletonRoot } : {}),
+            bones: skin.skeleton.bones.map((bone) => ({
+                name: bone.name,
+                parentIndex: bone.parentIndex,
+                translation: [...bone.translation],
+                rotation: [...bone.rotation],
+                scale: [...bone.scale],
+                inverseBindMatrix: [...bone.inverseBindMatrix]
+            }))
+        })),
+        animations: animations.map((animation) => animation.toJSON())
+    };
+}
+//# sourceMappingURL=GLTFLoader.js.map