@haiyue/extensions 0.1.0

package/dist/chunks/gltfLoader-Dm22jLYB.js

@@ -0,0 +1,2085 @@
+import { ColorSRGB, Entity, CartesianTransform3D, Geometry3D, Mesh3D, PbrMaterial } from '@haiyue/engine';
+import { Transform3D } from '@haiyue/engine/components';
+import { monotonicNow, parseAssetWorkerFirst } from '@haiyue/engine/experimental/async';
+import { mat4 } from 'wgpu-matrix';
+import { PBR_COMPATIBILITY_CONTRACT, getPbrTextureFormat, createMaterialFromDescriptor } from '@haiyue/engine/material';
+import { t as throwIfGltfLoadAborted, g as gltfDataError, d as attachGltfSource, e as createAnimationClips, r as readAccessorFloat, f as readAccessorIndices, h as generateFlatNormals, i as readAccessorUnsigned, b as applyMorphWeights, u as updateSkinnedPrimitive, c as composeTrsMatrix, j as registerGltfConservativeBounds, k as readAccessorMat4 } from './GltfAnimationRuntime-CRHsLycN.js';
+
+/** Validates the untrusted JSON envelope before the loader follows references. */
+function isGltfAsset(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isRecord(value.asset) || typeof value.asset.version !== 'string' || !value.asset.version.startsWith('2'))
+        return false;
+    const arrayFields = [
+        'buffers', 'bufferViews', 'accessors', 'meshes', 'nodes', 'scenes', 'skins',
+        'materials', 'images', 'textures', 'samplers', 'animations',
+    ];
+    if (arrayFields.some(field => value[field] !== undefined && !Array.isArray(value[field])))
+        return false;
+    if (value.scene !== undefined && !isNonNegativeInteger(value.scene))
+        return false;
+    if (value.extensionsUsed !== undefined && (!Array.isArray(value.extensionsUsed) || !value.extensionsUsed.every(item => typeof item === 'string')))
+        return false;
+    if (value.extensionsRequired !== undefined && (!Array.isArray(value.extensionsRequired) || !value.extensionsRequired.every(item => typeof item === 'string')))
+        return false;
+    if (!(value.buffers ?? []).every(buffer => isRecord(buffer)
+        && (buffer.uri === undefined || typeof buffer.uri === 'string')
+        && (buffer.byteLength === undefined || isNonNegativeInteger(buffer.byteLength))))
+        return false;
+    if (!(value.bufferViews ?? []).every(view => isRecord(view)
+        && isNonNegativeInteger(view.buffer)
+        && isNonNegativeInteger(view.byteLength)
+        && (view.byteOffset === undefined || isNonNegativeInteger(view.byteOffset))))
+        return false;
+    if (!(value.accessors ?? []).every(accessor => isRecord(accessor)
+        && isNonNegativeInteger(accessor.count)
+        && typeof accessor.type === 'string'
+        && isNonNegativeInteger(accessor.componentType)
+        && isOptionalFiniteNumberArray(accessor.min)
+        && isOptionalFiniteNumberArray(accessor.max)
+        && (accessor.bufferView === undefined || isNonNegativeInteger(accessor.bufferView))))
+        return false;
+    if (!(value.meshes ?? []).every(mesh => isRecord(mesh)
+        && Array.isArray(mesh.primitives)
+        && mesh.primitives.every(primitive => isRecord(primitive) && isNumericRecord(primitive.attributes))))
+        return false;
+    if (!(value.nodes ?? []).every(isRecord))
+        return false;
+    if (!(value.scenes ?? []).every(scene => isRecord(scene)
+        && (scene.nodes === undefined || (Array.isArray(scene.nodes) && scene.nodes.every(isNonNegativeInteger)))))
+        return false;
+    return true;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+function isNumericRecord(value) {
+    return isRecord(value) && Object.values(value).every(isNonNegativeInteger);
+}
+function isOptionalFiniteNumberArray(value) {
+    return value === undefined || (Array.isArray(value) && value.every(item => typeof item === 'number' && Number.isFinite(item)));
+}
+
+/**
+ * Keeps the accessor evidence needed to derive conservative bounds for the
+ * current morph weights and skin matrices. Missing evidence returns null so
+ * Render3D keeps its fail-open culling behavior.
+ */
+class GltfConservativeBounds {
+    _base;
+    _positionTargets;
+    _current;
+    _skinUsageCache = null;
+    constructor(_base, _positionTargets) {
+        this._base = _base;
+        this._positionTargets = _positionTargets;
+        this._current = _base;
+    }
+    static fromPrimitive(gltf, primitive) {
+        const positionAccessorIndex = primitive.attributes.POSITION;
+        if (positionAccessorIndex === undefined)
+            return null;
+        const base = readVec3Bounds(gltf.accessors?.[positionAccessorIndex]);
+        if (!base)
+            return null;
+        const positionTargets = (primitive.targets ?? []).map(target => {
+            if (target.POSITION === undefined)
+                return ZERO_BOUNDS;
+            return readVec3Bounds(gltf.accessors?.[target.POSITION]);
+        });
+        return new GltfConservativeBounds(base, positionTargets);
+    }
+    updateMorphWeights(weights) {
+        const min = [...this._base.min];
+        const max = [...this._base.max];
+        for (let targetIndex = 0; targetIndex < this._positionTargets.length; targetIndex++) {
+            const weight = weights[targetIndex] ?? 0;
+            if (!Number.isFinite(weight)) {
+                this._current = null;
+                return null;
+            }
+            if (weight === 0)
+                continue;
+            const target = this._positionTargets[targetIndex];
+            if (!target) {
+                this._current = null;
+                return null;
+            }
+            for (let axis = 0; axis < 3; axis++) {
+                const targetMin = target.min[axis];
+                const targetMax = target.max[axis];
+                const currentMin = min[axis];
+                const currentMax = max[axis];
+                if (targetMin === undefined || targetMax === undefined || currentMin === undefined || currentMax === undefined) {
+                    this._current = null;
+                    return null;
+                }
+                const a = targetMin * weight;
+                const b = targetMax * weight;
+                min[axis] = currentMin + Math.min(a, b);
+                max[axis] = currentMax + Math.max(a, b);
+            }
+        }
+        this._current = { min, max };
+        return boundsToSphere(this._current);
+    }
+    getSourceBounds() {
+        return this._current ? boundsToSphere(this._current) : null;
+    }
+    getSkinnedBounds(jointMatrices, joints, weights) {
+        if (!this._current || jointMatrices.length === 0 || jointMatrices.length % 16 !== 0)
+            return null;
+        const min = [Infinity, Infinity, Infinity];
+        const max = [-Infinity, -Infinity, -Infinity];
+        const jointCount = jointMatrices.length / 16;
+        let usage;
+        if (this._skinUsageCache
+            && this._skinUsageCache.jointCount === jointCount
+            && this._skinUsageCache.joints === joints
+            && this._skinUsageCache.weights === weights) {
+            usage = this._skinUsageCache.usage;
+        }
+        else {
+            usage = collectJointUsage(jointCount, joints, weights);
+            this._skinUsageCache = { jointCount, joints, weights, usage };
+        }
+        if (!usage)
+            return null;
+        if (usage.includeSource)
+            includeBounds(min, max, this._current);
+        for (const jointIndex of usage.joints) {
+            if (!includeTransformedBounds(min, max, this._current, jointMatrices, jointIndex * 16))
+                return null;
+        }
+        return boundsToSphere({ min, max });
+    }
+}
+function collectJointUsage(jointCount, joints, weights) {
+    if (!joints || !weights || joints.length !== weights.length || joints.length % 4 !== 0) {
+        return { joints: new Set(Array.from({ length: jointCount }, (_, index) => index)), includeSource: true };
+    }
+    const used = new Set();
+    let includeSource = false;
+    for (let vertexOffset = 0; vertexOffset < joints.length; vertexOffset += 4) {
+        let weightSum = 0;
+        for (let influence = 0; influence < 4; influence++) {
+            const offset = vertexOffset + influence;
+            const weight = weights[offset];
+            const joint = joints[offset];
+            if (weight === undefined || joint === undefined
+                || !Number.isFinite(weight) || !Number.isInteger(joint) || joint < 0 || joint >= jointCount)
+                return null;
+            if (weight <= 0)
+                continue;
+            used.add(joint);
+            weightSum += weight;
+        }
+        if (weightSum <= 0)
+            includeSource = true;
+    }
+    if (used.size === 0)
+        includeSource = true;
+    return { joints: used, includeSource };
+}
+function readVec3Bounds(accessor) {
+    if (!accessor || accessor.type !== 'VEC3')
+        return null;
+    const min = accessor.min;
+    const max = accessor.max;
+    if (!min || !max || min.length !== 3 || max.length !== 3)
+        return null;
+    if (![...min, ...max].every(Number.isFinite))
+        return null;
+    const [minX, minY, minZ] = min;
+    const [maxX, maxY, maxZ] = max;
+    if (minX === undefined || minY === undefined || minZ === undefined
+        || maxX === undefined || maxY === undefined || maxZ === undefined)
+        return null;
+    if (minX > maxX || minY > maxY || minZ > maxZ)
+        return null;
+    return {
+        min: [minX, minY, minZ],
+        max: [maxX, maxY, maxZ],
+    };
+}
+function includeTransformedBounds(outMin, outMax, bounds, matrix, offset) {
+    if (offset < 0 || offset + 15 >= matrix.length)
+        return false;
+    for (let corner = 0; corner < 8; corner++) {
+        const x = corner & 1 ? bounds.max[0] : bounds.min[0];
+        const y = corner & 2 ? bounds.max[1] : bounds.min[1];
+        const z = corner & 4 ? bounds.max[2] : bounds.min[2];
+        const tx = (matrix[offset] ?? NaN) * x + (matrix[offset + 4] ?? NaN) * y + (matrix[offset + 8] ?? NaN) * z + (matrix[offset + 12] ?? NaN);
+        const ty = (matrix[offset + 1] ?? NaN) * x + (matrix[offset + 5] ?? NaN) * y + (matrix[offset + 9] ?? NaN) * z + (matrix[offset + 13] ?? NaN);
+        const tz = (matrix[offset + 2] ?? NaN) * x + (matrix[offset + 6] ?? NaN) * y + (matrix[offset + 10] ?? NaN) * z + (matrix[offset + 14] ?? NaN);
+        if (![tx, ty, tz].every(Number.isFinite))
+            return false;
+        outMin[0] = Math.min(outMin[0], tx);
+        outMin[1] = Math.min(outMin[1], ty);
+        outMin[2] = Math.min(outMin[2], tz);
+        outMax[0] = Math.max(outMax[0], tx);
+        outMax[1] = Math.max(outMax[1], ty);
+        outMax[2] = Math.max(outMax[2], tz);
+    }
+    return true;
+}
+function includeBounds(outMin, outMax, bounds) {
+    for (let axis = 0; axis < 3; axis++) {
+        const currentMin = outMin[axis];
+        const currentMax = outMax[axis];
+        const boundsMin = bounds.min[axis];
+        const boundsMax = bounds.max[axis];
+        if (currentMin === undefined || currentMax === undefined || boundsMin === undefined || boundsMax === undefined)
+            continue;
+        outMin[axis] = Math.min(currentMin, boundsMin);
+        outMax[axis] = Math.max(currentMax, boundsMax);
+    }
+}
+function boundsToSphere(bounds) {
+    const center = [
+        (bounds.min[0] + bounds.max[0]) * 0.5,
+        (bounds.min[1] + bounds.max[1]) * 0.5,
+        (bounds.min[2] + bounds.max[2]) * 0.5,
+    ];
+    return {
+        center,
+        radius: Math.hypot(bounds.max[0] - center[0], bounds.max[1] - center[1], bounds.max[2] - center[2]),
+    };
+}
+const ZERO_BOUNDS = Object.freeze({
+    min: Object.freeze([0, 0, 0]),
+    max: Object.freeze([0, 0, 0]),
+});
+
+function createGltfCompatibilityReport(gltf, extensions, primitives, performance) {
+    const extensionEntries = extensions.map(entry => Object.freeze({ ...entry }));
+    const textures = createTextureEntries(gltf);
+    const bounds = primitives.map(input => createBoundsEntry(gltf, input));
+    const uvSemantics = primitives.map(input => Object.freeze({
+        meshIndex: input.meshIndex,
+        primitiveIndex: input.primitiveIndex,
+        capacity: input.uvSemanticPlan.capacity,
+        availableSemantics: Object.freeze([...input.uvSemanticPlan.availableSemantics]),
+        referencedSemantics: Object.freeze([...input.uvSemanticPlan.referencedSemantics]),
+        mappings: Object.freeze(input.uvSemanticPlan.mappings.map(mapping => Object.freeze({ ...mapping }))),
+        path: input.uvSemanticPlan.path,
+    }));
+    const issues = [];
+    for (const entry of extensionEntries) {
+        if (entry.support === 'supported')
+            continue;
+        issues.push(Object.freeze({
+            category: 'extension',
+            path: `gltf.extensionsUsed[${Math.max(0, (gltf.extensionsUsed ?? []).indexOf(entry.extension))}]`,
+            code: entry.support === 'partial' ? 'GLTF_EXTENSION_PARTIAL' : 'GLTF_EXTENSION_UNSUPPORTED',
+            message: entry.note,
+        }));
+    }
+    for (const entry of textures) {
+        if (entry.mipmapSource !== 'unavailable')
+            continue;
+        issues.push(Object.freeze({
+            category: 'texture-mipmap',
+            path: entry.path,
+            code: 'GLTF_TEXTURE_MIPMAP_UNAVAILABLE',
+            message: entry.note,
+        }));
+    }
+    for (const entry of bounds) {
+        if (entry.support !== 'fail-open')
+            continue;
+        issues.push(Object.freeze({
+            category: 'bounds',
+            path: entry.path,
+            code: 'GLTF_BOUNDS_FAIL_OPEN',
+            message: entry.reason ?? 'Dynamic bounds cannot be proven; frustum culling remains disabled.',
+        }));
+    }
+    return Object.freeze({
+        status: issues.length === 0 ? 'compatible' : 'degraded',
+        extensions: Object.freeze(extensionEntries),
+        textures: Object.freeze(textures),
+        bounds: Object.freeze(bounds),
+        uvSemantics: Object.freeze(uvSemantics),
+        performance: Object.freeze({ ...performance }),
+        issues: Object.freeze(issues),
+    });
+}
+function createTextureEntries(gltf) {
+    return (gltf.textures ?? []).map((texture, textureIndex) => {
+        const basisuSource = texture.extensions?.KHR_texture_basisu?.source;
+        const imageIndex = basisuSource ?? texture.source;
+        const image = imageIndex === undefined ? undefined : gltf.images?.[imageIndex];
+        const path = `gltf.textures[${textureIndex}]`;
+        if (imageIndex === undefined || !image) {
+            return Object.freeze({
+                textureIndex,
+                imageIndex: imageIndex ?? null,
+                mipmapSource: 'unavailable',
+                path,
+                note: 'Texture has no resolvable image source, so a mipmap contract cannot be established.',
+            });
+        }
+        const compressed = basisuSource !== undefined || image.mimeType === 'image/ktx2';
+        return Object.freeze({
+            textureIndex,
+            imageIndex,
+            mipmapSource: compressed ? 'source-provided' : 'generated-full-chain',
+            path,
+            note: compressed
+                ? 'KTX2/Basis texture uses the source-provided mip chain.'
+                : 'Ordinary image receives a generated full mip chain when loaded by PBR.',
+        });
+    });
+}
+function createBoundsEntry(gltf, input) {
+    const path = `gltf.meshes[${input.meshIndex}].primitives[${input.primitiveIndex}]`;
+    const dynamic = input.skinRequested || (input.primitive.targets?.length ?? 0) > 0;
+    if (!dynamic) {
+        return Object.freeze({ meshIndex: input.meshIndex, primitiveIndex: input.primitiveIndex, support: 'static', path, reason: null });
+    }
+    const reason = getBoundsEvidenceFailure(gltf, input);
+    if (reason) {
+        return Object.freeze({ meshIndex: input.meshIndex, primitiveIndex: input.primitiveIndex, support: 'fail-open', path, reason });
+    }
+    return Object.freeze({
+        meshIndex: input.meshIndex,
+        primitiveIndex: input.primitiveIndex,
+        support: 'accessor-conservative',
+        path,
+        reason: null,
+    });
+}
+function getBoundsEvidenceFailure(gltf, input) {
+    const positionIndex = input.primitive.attributes.POSITION;
+    if (positionIndex === undefined || !hasVec3Bounds(gltf.accessors?.[positionIndex])) {
+        return 'Base POSITION accessor is missing a valid finite min/max pair.';
+    }
+    for (const [targetIndex, target] of (input.primitive.targets ?? []).entries()) {
+        if (target.POSITION === undefined)
+            continue;
+        if (!hasVec3Bounds(gltf.accessors?.[target.POSITION])) {
+            return `Morph target ${targetIndex} POSITION accessor is missing a valid finite min/max pair.`;
+        }
+    }
+    if (input.skinRequested && !input.geometry.skinning) {
+        return 'Skin was requested but a runtime skin contract could not be created for this primitive.';
+    }
+    if (!input.geometry.localBounds) {
+        return 'Dynamic local bounds are unavailable for the current morph/skin state.';
+    }
+    return null;
+}
+function hasVec3Bounds(accessor) {
+    if (!accessor || accessor.type !== 'VEC3' || accessor.min?.length !== 3 || accessor.max?.length !== 3)
+        return false;
+    const min = accessor.min;
+    const max = accessor.max;
+    return [...min, ...max].every(Number.isFinite)
+        && min.every((value, axis) => {
+            const maximum = max[axis];
+            return maximum !== undefined && value <= maximum;
+        });
+}
+
+const clearcoatAdapter = Object.freeze({
+    extension: 'KHR_materials_clearcoat',
+    capability: Object.freeze({ support: 'supported', note: 'Imported as a native layered PBR clearcoat lobe.' }),
+    extendMaterial(context) {
+        const clearcoat = context.extensionData;
+        if (!clearcoat)
+            return null;
+        const basePath = `${context.materialPath}.extensions.KHR_materials_clearcoat`;
+        const textures = [];
+        if (clearcoat.clearcoatTexture)
+            textures.push({
+                slot: 'clearcoat',
+                textureInfo: clearcoat.clearcoatTexture,
+                path: `${basePath}.clearcoatTexture`,
+            });
+        if (clearcoat.clearcoatRoughnessTexture)
+            textures.push({
+                slot: 'clearcoatRoughness',
+                textureInfo: clearcoat.clearcoatRoughnessTexture,
+                path: `${basePath}.clearcoatRoughnessTexture`,
+            });
+        if (clearcoat.clearcoatNormalTexture)
+            textures.push({
+                slot: 'clearcoatNormal',
+                textureInfo: clearcoat.clearcoatNormalTexture,
+                path: `${basePath}.clearcoatNormalTexture`,
+            });
+        return {
+            state: {
+                clearcoatFactor: clearcoat.clearcoatFactor ?? 0,
+                clearcoatRoughnessFactor: clearcoat.clearcoatRoughnessFactor ?? 0,
+                clearcoatNormalScale: clearcoat.clearcoatNormalTexture?.scale ?? 1,
+            },
+            textures: Object.freeze(textures),
+        };
+    },
+});
+const iorAdapter = Object.freeze({
+    extension: 'KHR_materials_ior',
+    capability: Object.freeze({ support: 'supported', note: 'Imported into the native dielectric Fresnel IOR parameter.' }),
+    extendMaterial(context) {
+        const ior = context.extensionData;
+        if (!ior)
+            return null;
+        return { state: { ior: ior.ior ?? 1.5 } };
+    },
+});
+const specularAdapter = Object.freeze({
+    extension: 'KHR_materials_specular',
+    capability: Object.freeze({ support: 'supported', note: 'Imported into the native dielectric specular BRDF.' }),
+    extendMaterial(context) {
+        const specular = context.extensionData;
+        if (!specular)
+            return null;
+        const basePath = `${context.materialPath}.extensions.KHR_materials_specular`;
+        const textures = [];
+        if (specular.specularTexture)
+            textures.push({
+                slot: 'specular',
+                textureInfo: specular.specularTexture,
+                path: `${basePath}.specularTexture`,
+            });
+        if (specular.specularColorTexture)
+            textures.push({
+                slot: 'specularColor',
+                textureInfo: specular.specularColorTexture,
+                path: `${basePath}.specularColorTexture`,
+            });
+        return {
+            state: {
+                specularFactor: specular.specularFactor ?? 1,
+                specularColorFactor: specular.specularColorFactor ?? [1, 1, 1],
+            },
+            textures: Object.freeze(textures),
+        };
+    },
+});
+const sheenAdapter = Object.freeze({
+    extension: 'KHR_materials_sheen',
+    capability: Object.freeze({ support: 'supported', note: 'Imported as a native Charlie sheen layer with direct-light and IBL energy compensation.' }),
+    extendMaterial(context) {
+        const sheen = context.extensionData;
+        if (!sheen)
+            return null;
+        const basePath = `${context.materialPath}.extensions.KHR_materials_sheen`;
+        const textures = [];
+        if (sheen.sheenColorTexture)
+            textures.push({
+                slot: 'sheenColor',
+                textureInfo: sheen.sheenColorTexture,
+                path: `${basePath}.sheenColorTexture`,
+            });
+        if (sheen.sheenRoughnessTexture)
+            textures.push({
+                slot: 'sheenRoughness',
+                textureInfo: sheen.sheenRoughnessTexture,
+                path: `${basePath}.sheenRoughnessTexture`,
+            });
+        return {
+            state: {
+                sheenColorFactor: sheen.sheenColorFactor ?? [0, 0, 0],
+                sheenRoughnessFactor: sheen.sheenRoughnessFactor ?? 0,
+            },
+            textures: Object.freeze(textures),
+        };
+    },
+});
+const transmissionAdapter = Object.freeze({
+    extension: 'KHR_materials_transmission',
+    capability: Object.freeze({
+        support: 'supported',
+        note: 'Imported into the native screen-space scene-color path; combined Sheen keeps factor BRDF but omits Sheen texture sampling to stay within the WebGPU minimum binding budget.',
+    }),
+    extendMaterial(context) {
+        const transmission = context.extensionData;
+        if (!transmission)
+            return null;
+        const basePath = `${context.materialPath}.extensions.KHR_materials_transmission`;
+        return {
+            state: { transmissionFactor: transmission.transmissionFactor ?? 0 },
+            textures: transmission.transmissionTexture ? Object.freeze([{
+                    slot: 'transmission',
+                    textureInfo: transmission.transmissionTexture,
+                    path: `${basePath}.transmissionTexture`,
+                }]) : Object.freeze([]),
+        };
+    },
+});
+const volumeAdapter = Object.freeze({
+    extension: 'KHR_materials_volume',
+    capability: Object.freeze({ support: 'supported', note: 'Imported with thickness and Beer-Lambert attenuation in the native transmission path.' }),
+    extendMaterial(context) {
+        const volume = context.extensionData;
+        if (!volume)
+            return null;
+        const basePath = `${context.materialPath}.extensions.KHR_materials_volume`;
+        return {
+            state: {
+                thicknessFactor: volume.thicknessFactor ?? 0,
+                attenuationDistance: volume.attenuationDistance ?? Infinity,
+                attenuationColor: volume.attenuationColor ?? [1, 1, 1],
+            },
+            textures: volume.thicknessTexture ? Object.freeze([{
+                    slot: 'thickness',
+                    textureInfo: volume.thicknessTexture,
+                    path: `${basePath}.thicknessTexture`,
+                }]) : Object.freeze([]),
+        };
+    },
+});
+const variantsAdapter = Object.freeze({
+    extension: 'KHR_materials_variants',
+    capability: Object.freeze({ support: 'supported', note: 'Imported as native PBR material variants.' }),
+    collectMaterialVariantNames(gltf, rootExtensionData) {
+        const definitions = rootExtensionData?.variants ?? [];
+        return Object.freeze(definitions.map(variant => variant.name));
+    },
+    collectMaterialVariants(context) {
+        const definitions = context.rootExtensionData?.variants ?? [];
+        const mappings = context.primitiveExtensionData?.mappings ?? [];
+        const result = [];
+        for (const mapping of mappings) {
+            for (const variantIndex of mapping.variants) {
+                const name = definitions[variantIndex]?.name;
+                if (name)
+                    result.push(Object.freeze({ name, materialIndex: mapping.material }));
+            }
+        }
+        return Object.freeze(result);
+    },
+});
+function capabilityAdapter(extension, support, note) {
+    return Object.freeze({ extension, capability: Object.freeze({ support, note }) });
+}
+const DEFAULT_GLTF_EXTENSION_ADAPTERS = Object.freeze([
+    capabilityAdapter('KHR_draco_mesh_compression', 'supported', 'Decoded through the configured Draco decoder.'),
+    variantsAdapter,
+    clearcoatAdapter,
+    iorAdapter,
+    specularAdapter,
+    sheenAdapter,
+    transmissionAdapter,
+    volumeAdapter,
+    capabilityAdapter('KHR_materials_anisotropy', 'partial', 'The base PBR material is imported, but anisotropy shading is not rendered.'),
+    capabilityAdapter('KHR_texture_basisu', 'supported', 'Imported through the KTX2/Basis texture path.'),
+    capabilityAdapter('KHR_texture_transform', 'supported', 'Applied per PBR texture slot in the shader.'),
+]);
+/** Resolves an immutable per-load adapter set; user adapters replace defaults by extension id. */
+function resolveGltfExtensionAdapters(customAdapters = []) {
+    const adapters = new Map(DEFAULT_GLTF_EXTENSION_ADAPTERS.map(adapter => [adapter.extension, adapter]));
+    for (const adapter of customAdapters) {
+        const extension = adapter.extension.trim();
+        if (!extension)
+            throw new TypeError('GltfExtensionAdapter.extension must not be empty.');
+        adapters.set(extension, Object.freeze({
+            ...adapter,
+            extension,
+            capability: Object.freeze({ ...adapter.capability }),
+        }));
+    }
+    return Object.freeze([...adapters.values()]);
+}
+function createGltfExtensionCapabilities(adapters) {
+    return Object.freeze(Object.fromEntries(adapters.map(adapter => [adapter.extension, adapter.capability])));
+}
+function collectGltfMaterialExtensionPatches(gltf, material, primitive, materialPath, adapters) {
+    if (!material)
+        return Object.freeze([]);
+    const patches = [];
+    for (const adapter of adapters) {
+        if (!adapter.extendMaterial)
+            continue;
+        const extensionData = material.extensions?.[adapter.extension];
+        if (extensionData === undefined)
+            continue;
+        const patch = adapter.extendMaterial({ gltf, material, primitive, materialPath, extensionData });
+        if (patch)
+            patches.push(patch);
+    }
+    return Object.freeze(patches);
+}
+function collectGltfMaterialVariantReferences(gltf, primitive, adapters) {
+    const result = [];
+    for (const adapter of adapters) {
+        if (!adapter.collectMaterialVariants)
+            continue;
+        const rootExtensionData = gltf.extensions?.[adapter.extension];
+        const primitiveExtensionData = primitive.extensions?.[adapter.extension];
+        if (rootExtensionData === undefined && primitiveExtensionData === undefined)
+            continue;
+        result.push(...adapter.collectMaterialVariants({ gltf, primitive, rootExtensionData, primitiveExtensionData }));
+    }
+    return Object.freeze(result);
+}
+function collectGltfMaterialVariantNames(gltf, adapters) {
+    const names = new Set();
+    for (const adapter of adapters) {
+        if (!adapter.collectMaterialVariantNames)
+            continue;
+        const rootExtensionData = gltf.extensions?.[adapter.extension];
+        if (rootExtensionData === undefined)
+            continue;
+        for (const name of adapter.collectMaterialVariantNames(gltf, rootExtensionData)) {
+            if (name)
+                names.add(name);
+        }
+    }
+    for (const mesh of gltf.meshes ?? []) {
+        for (const primitive of mesh.primitives) {
+            for (const variant of collectGltfMaterialVariantReferences(gltf, primitive, adapters))
+                names.add(variant.name);
+        }
+    }
+    return Object.freeze([...names]);
+}
+
+const textureStateKeys = Object.freeze({
+    baseColor: 'baseColorTexture',
+    metallicRoughness: 'metallicRoughnessTexture',
+    normal: 'normalTexture',
+    occlusion: 'occlusionTexture',
+    emissive: 'emissiveTexture',
+    clearcoat: 'clearcoatTexture',
+    clearcoatRoughness: 'clearcoatRoughnessTexture',
+    clearcoatNormal: 'clearcoatNormalTexture',
+    specular: 'specularTexture',
+    specularColor: 'specularColorTexture',
+    sheenColor: 'sheenColorTexture',
+    sheenRoughness: 'sheenRoughnessTexture',
+    transmission: 'transmissionTexture',
+    thickness: 'thicknessTexture',
+});
+/** Compiles glTF core material data and extension patches into one engine descriptor. */
+function createGltfMaterialDescriptor(input) {
+    const { material } = input;
+    const pbr = material?.pbrMetallicRoughness;
+    const state = {
+        baseColor: pbr?.baseColorFactor
+            ? linearBaseColorFactorToSrgb(pbr.baseColorFactor)
+            : input.defaultBaseColor ?? [1, 1, 1, 1],
+        metallic: pbr?.metallicFactor ?? 1,
+        roughness: pbr?.roughnessFactor ?? 1,
+        normalScale: material?.normalTexture?.scale ?? 1,
+        occlusionStrength: material?.occlusionTexture?.strength ?? 1,
+        emissiveFactor: material?.emissiveFactor ?? [0, 0, 0],
+        alphaMode: material?.alphaMode === 'BLEND' ? 'blend' : material?.alphaMode === 'MASK' ? 'mask' : 'opaque',
+        alphaCutoff: material?.alphaCutoff ?? 0.5,
+        doubleSided: material?.doubleSided ?? false,
+    };
+    const patches = collectGltfMaterialExtensionPatches(input.gltf, material, input.primitive, input.materialPath, input.adapters);
+    const textureMappings = {};
+    const samplers = {};
+    for (const patch of patches) {
+        Object.assign(state, patch.state);
+    }
+    for (const binding of collectGltfMaterialTextureBindings(input.gltf, material, input.primitive, input.materialPath, input.adapters)) {
+        const texture = input.resolveTexture(binding);
+        state[textureStateKeys[binding.slot]] = texture.source;
+        textureMappings[binding.slot] = texture.mapping;
+        samplers[binding.slot] = texture.sampler;
+    }
+    if (Object.keys(textureMappings).length > 0)
+        state.textureMappings = textureMappings;
+    if (Object.keys(samplers).length > 0)
+        state.samplers = samplers;
+    return Object.freeze({
+        shadingModel: 'pbr-metallic-roughness',
+        state: Object.freeze(state),
+    });
+}
+/** Shared semantic source for preload, UV planning, and descriptor compilation. */
+function collectGltfMaterialTextureBindings(gltf, material, primitive, materialPath, adapters) {
+    if (!material)
+        return Object.freeze([]);
+    const pbr = material.pbrMetallicRoughness;
+    const bindings = [];
+    addTexture(bindings, 'baseColor', pbr?.baseColorTexture, `${materialPath}.pbrMetallicRoughness.baseColorTexture`);
+    addTexture(bindings, 'metallicRoughness', pbr?.metallicRoughnessTexture, `${materialPath}.pbrMetallicRoughness.metallicRoughnessTexture`);
+    addTexture(bindings, 'normal', material.normalTexture, `${materialPath}.normalTexture`);
+    addTexture(bindings, 'occlusion', material.occlusionTexture, `${materialPath}.occlusionTexture`);
+    addTexture(bindings, 'emissive', material.emissiveTexture, `${materialPath}.emissiveTexture`);
+    for (const patch of collectGltfMaterialExtensionPatches(gltf, material, primitive, materialPath, adapters)) {
+        bindings.push(...patch.textures ?? []);
+    }
+    return Object.freeze(bindings);
+}
+function addTexture(bindings, slot, textureInfo, path) {
+    if (textureInfo)
+        bindings.push(Object.freeze({ slot, textureInfo, path }));
+}
+function linearBaseColorFactorToSrgb(value) {
+    return [
+        ColorSRGB.linearToSRGB(value[0]),
+        ColorSRGB.linearToSRGB(value[1]),
+        ColorSRGB.linearToSRGB(value[2]),
+        value[3],
+    ];
+}
+
+const GLTF_UV_CHANNEL_CAPACITY = PBR_COMPATIBILITY_CONTRACT.uvChannelCapacity;
+function planGltfUvSemantics(gltf, primitive, meshIndex, primitiveIndex, adapters = DEFAULT_GLTF_EXTENSION_ADAPTERS) {
+    const primitivePath = `gltf.meshes[${meshIndex}].primitives[${primitiveIndex}]`;
+    const availableSets = Object.keys(primitive.attributes)
+        .map(parseTextureCoordinateSemantic)
+        .filter((set) => set !== null)
+        .sort((a, b) => a - b);
+    const availableSetLookup = new Set(availableSets);
+    const references = collectTextureCoordinateReferences(gltf, primitive, adapters);
+    for (const reference of references) {
+        if (availableSetLookup.has(reference.set))
+            continue;
+        return {
+            ok: false,
+            failure: Object.freeze({
+                code: 'GLTF_UV_SEMANTIC_MISSING',
+                message: `Texture references ${reference.semantic}, but the mesh primitive does not provide that attribute.`,
+                path: reference.path,
+                context: Object.freeze({ texCoord: reference.set, semantic: reference.semantic, meshIndex, primitiveIndex }),
+            }),
+        };
+    }
+    const referencedSets = [...new Set(references.map(reference => reference.set))].sort((a, b) => a - b);
+    if (referencedSets.length > GLTF_UV_CHANNEL_CAPACITY) {
+        const referencedSemantics = referencedSets.map(toTextureCoordinateSemantic);
+        return {
+            ok: false,
+            failure: Object.freeze({
+                code: 'GLTF_UV_CHANNEL_CAPACITY_EXCEEDED',
+                message: `Primitive references ${referencedSets.length} texture-coordinate sets (${referencedSemantics.join(', ')}), exceeding the ${GLTF_UV_CHANNEL_CAPACITY}-channel PBR contract.`,
+                path: `${primitivePath}.attributes`,
+                context: Object.freeze({
+                    meshIndex,
+                    primitiveIndex,
+                    capacity: GLTF_UV_CHANNEL_CAPACITY,
+                    referencedSemantics: Object.freeze(referencedSemantics),
+                }),
+            }),
+        };
+    }
+    const mappings = referencedSets.map((set, channel) => Object.freeze({
+        semantic: toTextureCoordinateSemantic(set),
+        set,
+        channel: channel,
+    }));
+    return {
+        ok: true,
+        plan: Object.freeze({
+            meshIndex,
+            primitiveIndex,
+            path: primitivePath,
+            capacity: GLTF_UV_CHANNEL_CAPACITY,
+            availableSemantics: Object.freeze(availableSets.map(toTextureCoordinateSemantic)),
+            referencedSemantics: Object.freeze(referencedSets.map(toTextureCoordinateSemantic)),
+            mappings: Object.freeze(mappings),
+        }),
+    };
+}
+function getGltfUvChannel(plan, semanticSet) {
+    return plan.mappings.find(mapping => mapping.set === semanticSet)?.channel ?? null;
+}
+function parseTextureCoordinateSemantic(semantic) {
+    const match = /^TEXCOORD_(0|[1-9]\d*)$/.exec(semantic);
+    if (!match)
+        return null;
+    const set = Number(match[1]);
+    return Number.isSafeInteger(set) ? set : null;
+}
+function toTextureCoordinateSemantic(set) {
+    return `TEXCOORD_${set}`;
+}
+function collectTextureCoordinateReferences(gltf, primitive, adapters) {
+    const materials = new Map();
+    const baseIndex = primitive.material;
+    materials.set(baseIndex ?? null, {
+        material: baseIndex === undefined ? null : gltf.materials?.[baseIndex] ?? null,
+        path: baseIndex === undefined ? 'gltf.defaultMaterial' : `gltf.materials[${baseIndex}]`,
+    });
+    for (const variant of collectGltfMaterialVariantReferences(gltf, primitive, adapters)) {
+        if (materials.has(variant.materialIndex))
+            continue;
+        materials.set(variant.materialIndex, {
+            material: gltf.materials?.[variant.materialIndex] ?? null,
+            path: `gltf.materials[${variant.materialIndex}]`,
+        });
+    }
+    const references = [];
+    for (const { material, path } of materials.values()) {
+        for (const { textureInfo, path: texturePath } of collectGltfMaterialTextureBindings(gltf, material, primitive, path, adapters)) {
+            const transform = textureInfo.extensions?.KHR_texture_transform;
+            const set = transform?.texCoord ?? textureInfo.texCoord ?? 0;
+            references.push(Object.freeze({
+                set,
+                semantic: toTextureCoordinateSemantic(set),
+                path: transform?.texCoord === undefined
+                    ? `${texturePath}.texCoord`
+                    : `${texturePath}.extensions.KHR_texture_transform.texCoord`,
+            }));
+        }
+    }
+    return references;
+}
+
+const DEFAULT_DRACO_DECODER_SCRIPT_URL = 'draco_decoder_gltf_nodejs.js';
+const FALLBACK_DRACO_DECODER_SCRIPT_URL = '../node_modules/draco3dgltf/draco_decoder_gltf_nodejs.js';
+let sharedDecoderPromise = null;
+const sharedScriptPromises = new Map();
+/** Resolves and decodes one KHR_draco_mesh_compression primitive. */
+async function decodeDracoPrimitive(gltf, buffers, extension, options) {
+    throwIfGltfLoadAborted(options.signal);
+    const view = gltf.bufferViews?.[extension.bufferView];
+    if (!view)
+        throw gltfDataError(`Missing Draco bufferView ${extension.bufferView}.`);
+    const source = buffers[view.buffer];
+    if (!source)
+        throw gltfDataError(`Missing Draco buffer ${view.buffer}.`);
+    const module = await resolveDracoDecoder(options);
+    throwIfGltfLoadAborted(options.signal);
+    const decoder = new module.Decoder();
+    const decoderBuffer = new module.DecoderBuffer();
+    const mesh = new module.Mesh();
+    const bytes = new Uint8Array(source, view.byteOffset ?? 0, view.byteLength);
+    decoderBuffer.Init(bytes, bytes.byteLength);
+    try {
+        const status = decoder.DecodeBufferToMesh(decoderBuffer, mesh);
+        throwIfGltfLoadAborted(options.signal);
+        if (!status.ok())
+            throw gltfDataError(`Draco decode failed: ${status.error_msg()}`);
+        const positions = readFloatAttribute(module, decoder, mesh, extension, 'POSITION', 3);
+        if (!positions)
+            throw gltfDataError('Draco primitive is missing POSITION attribute.');
+        const normals = readFloatAttribute(module, decoder, mesh, extension, 'NORMAL', 3);
+        const textureCoordinates = Object.keys(extension.attributes)
+            .map(semantic => ({ semantic, set: parseTextureCoordinateSemantic(semantic) }))
+            .filter((entry) => entry.set !== null)
+            .sort((a, b) => a.set - b.set)
+            .map(entry => {
+            const data = readFloatAttribute(module, decoder, mesh, extension, entry.semantic, 2);
+            if (!data)
+                throw gltfDataError(`Draco primitive is missing ${entry.semantic}.`);
+            return { set: entry.set, data };
+        });
+        const joints = readUnsignedAttribute(module, decoder, mesh, extension, 'JOINTS_0', 4);
+        const weights = readFloatAttribute(module, decoder, mesh, extension, 'WEIGHTS_0', 4);
+        const indices = readIndices(module, decoder, mesh);
+        throwIfGltfLoadAborted(options.signal);
+        return {
+            positions,
+            ...(normals === null ? {} : { normals }),
+            textureCoordinates,
+            ...(joints === null ? {} : { joints }),
+            ...(weights === null ? {} : { weights }),
+            indices,
+        };
+    }
+    finally {
+        module.destroy(mesh);
+        module.destroy(decoderBuffer);
+        module.destroy(decoder);
+    }
+}
+async function resolveDracoDecoder(options) {
+    throwIfGltfLoadAborted(options.signal);
+    const provided = options.dracoDecoder;
+    if (provided) {
+        const module = typeof provided === 'function'
+            ? await provided(options.dracoDecoderConfig)
+            : await provided;
+        throwIfGltfLoadAborted(options.signal);
+        return module;
+    }
+    if (!sharedDecoderPromise)
+        sharedDecoderPromise = loadDefaultDecoder(options.dracoDecoderConfig);
+    const module = await sharedDecoderPromise;
+    throwIfGltfLoadAborted(options.signal);
+    return module;
+}
+async function loadDefaultDecoder(config) {
+    let factory;
+    if (config?.scriptUrl) {
+        factory = await loadDecoderFactory(config.scriptUrl);
+    }
+    else {
+        try {
+            factory = await loadDecoderFactory(DEFAULT_DRACO_DECODER_SCRIPT_URL);
+        }
+        catch {
+            factory = await loadDecoderFactory(FALLBACK_DRACO_DECODER_SCRIPT_URL);
+        }
+    }
+    return factory(config);
+}
+function loadDecoderFactory(scriptUrl) {
+    const existing = getGlobalDecoderFactory();
+    if (existing)
+        return Promise.resolve(existing);
+    const existingPromise = sharedScriptPromises.get(scriptUrl);
+    if (existingPromise)
+        return existingPromise;
+    const promise = new Promise((resolve, reject) => {
+        if (typeof document === 'undefined') {
+            const workerScope = globalThis;
+            if (typeof workerScope.postMessage !== 'function' || workerScope.location === undefined) {
+                reject(gltfDataError('Draco decoder is not available. Provide LoadGltfOptions.dracoDecoder in non-browser environments.'));
+                return;
+            }
+            void loadWorkerDecoderFactory(scriptUrl).then(resolve, reject);
+            return;
+        }
+        const script = document.createElement('script');
+        script.async = true;
+        script.src = scriptUrl;
+        script.onload = () => {
+            const factory = getGlobalDecoderFactory();
+            if (factory)
+                resolve(factory);
+            else
+                reject(gltfDataError(`Draco decoder script loaded without DracoDecoderModule: ${scriptUrl}`, { url: scriptUrl }));
+        };
+        script.onerror = () => reject(gltfDataError(`Failed to load Draco decoder script: ${scriptUrl}`, { url: scriptUrl }));
+        document.head.appendChild(script);
+    });
+    sharedScriptPromises.set(scriptUrl, promise);
+    promise.catch(() => sharedScriptPromises.delete(scriptUrl));
+    return promise;
+}
+async function loadWorkerDecoderFactory(scriptUrl) {
+    const response = await fetch(scriptUrl);
+    if (!response.ok) {
+        throw gltfDataError(`Failed to load Draco decoder script: ${scriptUrl}`, { url: scriptUrl, status: response.status });
+    }
+    const source = await response.text();
+    const factory = new Function(`${source}\nreturn typeof DracoDecoderModule === "function" ? DracoDecoderModule : null;\n//# sourceURL=${scriptUrl}`)();
+    if (typeof factory !== 'function') {
+        throw gltfDataError(`Draco decoder script loaded without DracoDecoderModule: ${scriptUrl}`, { url: scriptUrl });
+    }
+    return factory;
+}
+function getGlobalDecoderFactory() {
+    const globalScope = globalThis;
+    return typeof globalScope.DracoDecoderModule === 'function' ? globalScope.DracoDecoderModule : null;
+}
+function readUnsignedAttribute(module, decoder, mesh, extension, semantic, expectedSize) {
+    const uniqueId = extension.attributes[semantic];
+    if (uniqueId === undefined)
+        return null;
+    const attribute = decoder.GetAttributeByUniqueId(mesh, uniqueId);
+    if (!attribute)
+        throw gltfDataError(`Draco primitive is missing attribute ${semantic} with unique id ${uniqueId}.`);
+    const pointCount = mesh.num_points();
+    const decode = (ArrayType, ValuesType, read) => {
+        if (!ValuesType || !read)
+            return null;
+        const values = new ValuesType();
+        try {
+            if (!read.call(decoder, mesh, attribute, values))
+                throw gltfDataError(`Failed to decode Draco attribute ${semantic}.`);
+            if (values.size() < pointCount * expectedSize) {
+                throw gltfDataError(`Draco attribute ${semantic} returned ${values.size()} values, expected at least ${pointCount * expectedSize}.`);
+            }
+            const out = new ArrayType(pointCount * expectedSize);
+            for (let i = 0; i < out.length; i++)
+                out[i] = values.GetValue(i);
+            return out;
+        }
+        finally {
+            module.destroy(values);
+        }
+    };
+    const u16 = decode(Uint16Array, module.DracoUInt16Array, decoder.GetAttributeUInt16ForAllPoints);
+    if (u16)
+        return u16;
+    const u32 = decode(Uint32Array, module.DracoUInt32Array, decoder.GetAttributeUInt32ForAllPoints);
+    if (u32)
+        return u32;
+    const values = readFloatAttribute(module, decoder, mesh, extension, semantic, expectedSize);
+    if (!values)
+        return null;
+    const out = new Uint16Array(values.length);
+    for (let i = 0; i < values.length; i++)
+        out[i] = Math.max(0, Math.round(requiredFiniteValue(values, i, `Draco ${semantic}`)));
+    return out;
+}
+function readFloatAttribute(module, decoder, mesh, extension, semantic, expectedSize) {
+    const uniqueId = extension.attributes[semantic];
+    if (uniqueId === undefined)
+        return null;
+    const attribute = decoder.GetAttributeByUniqueId(mesh, uniqueId);
+    if (!attribute)
+        throw gltfDataError(`Draco primitive is missing attribute ${semantic} with unique id ${uniqueId}.`);
+    const values = new module.DracoFloat32Array();
+    try {
+        if (!decoder.GetAttributeFloatForAllPoints(mesh, attribute, values))
+            throw gltfDataError(`Failed to decode Draco attribute ${semantic}.`);
+        const pointCount = mesh.num_points();
+        if (values.size() < pointCount * expectedSize) {
+            throw gltfDataError(`Draco attribute ${semantic} returned ${values.size()} values, expected at least ${pointCount * expectedSize}.`);
+        }
+        const out = new Float32Array(pointCount * expectedSize);
+        for (let i = 0; i < out.length; i++)
+            out[i] = values.GetValue(i);
+        return out;
+    }
+    finally {
+        module.destroy(values);
+    }
+}
+function readIndices(module, decoder, mesh) {
+    const faceCount = mesh.num_faces();
+    const indices = mesh.num_points() > 65535 ? new Uint32Array(faceCount * 3) : new Uint16Array(faceCount * 3);
+    const face = new module.DracoInt32Array();
+    try {
+        for (let faceIndex = 0; faceIndex < faceCount; faceIndex++) {
+            if (!decoder.GetFaceFromMesh(mesh, faceIndex, face))
+                throw gltfDataError(`Failed to decode Draco face ${faceIndex}.`);
+            indices[faceIndex * 3] = face.GetValue(0);
+            indices[faceIndex * 3 + 1] = face.GetValue(1);
+            indices[faceIndex * 3 + 2] = face.GetValue(2);
+        }
+        return indices;
+    }
+    finally {
+        module.destroy(face);
+    }
+}
+function requiredFiniteValue(values, index, label) {
+    const value = values[index];
+    if (value === undefined || !Number.isFinite(value))
+        throw gltfDataError(`${label} is missing a finite value at index ${index}.`);
+    return value;
+}
+
+async function createGltfMaterial(gltf, buffers, primitive, options, context, uvPlan) {
+    throwIfGltfLoadAborted(options.signal);
+    const materialIndex = primitive.material;
+    const gltfMaterial = materialIndex === undefined ? null : gltf.materials?.[materialIndex] ?? null;
+    const createDescriptor = (material, materialPath) => createGltfMaterialDescriptor({
+        gltf,
+        material,
+        primitive,
+        materialPath,
+        ...(options.baseColorFactor === undefined ? {} : { defaultBaseColor: options.baseColorFactor }),
+        adapters: context.extensionAdapters,
+        resolveTexture: binding => ({
+            source: createTextureSource(gltf, buffers, binding.textureInfo.index, binding.slot, context),
+            mapping: resolveGltfTextureMapping(binding.textureInfo, primitive, binding.path, uvPlan),
+            sampler: createSamplerDescriptor(gltf, binding.textureInfo.index),
+        }),
+    });
+    const descriptor = createDescriptor(gltfMaterial, materialIndex === undefined ? 'gltf.defaultMaterial' : `gltf.materials[${materialIndex}]`);
+    const variants = collectGltfMaterialVariantReferences(gltf, primitive, context.extensionAdapters).map(variant => ({
+        name: variant.name,
+        state: createDescriptor(gltf.materials?.[variant.materialIndex] ?? null, `gltf.materials[${variant.materialIndex}]`).state,
+    }));
+    return createMaterialFromDescriptor({ ...descriptor, variants });
+}
+function resolveGltfTextureMapping(textureInfo, primitive, path, uvPlan) {
+    const transform = textureInfo.extensions?.KHR_texture_transform;
+    const textureCoord = transform?.texCoord ?? textureInfo.texCoord ?? 0;
+    const texCoordPath = transform?.texCoord === undefined
+        ? `${path}.texCoord`
+        : `${path}.extensions.KHR_texture_transform.texCoord`;
+    const semantic = `TEXCOORD_${textureCoord}`;
+    if (primitive.attributes[semantic] === undefined) {
+        throw gltfDataError(`Texture references ${semantic}, but the mesh primitive does not provide that attribute.`, { texCoord: textureCoord, semantic }, texCoordPath);
+    }
+    const channel = getGltfUvChannel(uvPlan, textureCoord);
+    if (channel === null) {
+        throw gltfDataError(`${semantic} was not assigned to a physical PBR UV channel.`, { texCoord: textureCoord, semantic, capacity: uvPlan.capacity }, texCoordPath);
+    }
+    return {
+        texCoord: channel,
+        offset: transform?.offset ?? [0, 0],
+        rotation: transform?.rotation ?? 0,
+        scale: transform?.scale ?? [1, 1],
+    };
+}
+function createSamplerDescriptor(gltf, textureIndex) {
+    const texture = gltf.textures?.[textureIndex];
+    const sampler = texture?.sampler === undefined ? null : gltf.samplers?.[texture.sampler] ?? null;
+    return {
+        addressModeU: mapWrapMode(sampler?.wrapS),
+        addressModeV: mapWrapMode(sampler?.wrapT),
+        magFilter: mapMagFilter(sampler?.magFilter),
+        minFilter: mapMinFilter(sampler?.minFilter),
+        mipmapFilter: mapMipmapFilter(sampler?.minFilter),
+    };
+}
+function mapWrapMode(mode) {
+    switch (mode) {
+        case 33071: return 'clamp-to-edge';
+        case 33648: return 'mirror-repeat';
+        case 10497:
+        case undefined:
+            return 'repeat';
+        default:
+            return 'repeat';
+    }
+}
+function mapMagFilter(filter) {
+    return filter === 9728 ? 'nearest' : 'linear';
+}
+function mapMinFilter(filter) {
+    switch (filter) {
+        case 9728:
+        case 9984:
+        case 9986:
+            return 'nearest';
+        default:
+            return 'linear';
+    }
+}
+function mapMipmapFilter(filter) {
+    switch (filter) {
+        case 9984:
+        case 9985:
+            return 'nearest';
+        case 9986:
+        case 9987:
+            return 'linear';
+        default:
+            return 'linear';
+    }
+}
+async function preloadGltfTextures(gltf, buffers, options, context) {
+    const assetManager = options.assetManager;
+    if (!assetManager)
+        return;
+    const requests = new Map();
+    for (const mesh of gltf.meshes ?? []) {
+        for (const primitive of mesh.primitives) {
+            const materialIndexes = new Set();
+            if (primitive.material !== undefined)
+                materialIndexes.add(primitive.material);
+            for (const variant of collectGltfMaterialVariantReferences(gltf, primitive, context.extensionAdapters)) {
+                materialIndexes.add(variant.materialIndex);
+            }
+            for (const materialIndex of materialIndexes) {
+                const material = gltf.materials?.[materialIndex] ?? null;
+                for (const binding of collectGltfMaterialTextureBindings(gltf, material, primitive, `gltf.materials[${materialIndex}]`, context.extensionAdapters)) {
+                    const reference = resolveTextureReference(gltf, buffers, binding.textureInfo.index, binding.slot, context);
+                    if (reference)
+                        requests.set(reference.requestKey, reference);
+                }
+            }
+        }
+    }
+    const results = await Promise.allSettled([...requests.values()].map(async (reference) => ({
+        reference,
+        handle: await assetManager.loadTexture(reference.source, {
+            cacheKey: reference.cacheKey,
+            format: reference.format,
+            mipmaps: 'generate',
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        }),
+    })));
+    const loaded = [];
+    let firstError = null;
+    for (const result of results) {
+        if (result.status === 'fulfilled')
+            loaded.push(result.value);
+        else if (firstError === null)
+            firstError = result.reason;
+    }
+    if (firstError !== null) {
+        for (const { handle } of loaded)
+            handle.release();
+        throw firstError;
+    }
+    for (const { reference, handle } of loaded) {
+        context.preloadedTextures.set(reference.requestKey, handle.value);
+        context.assetHandles.push(handle);
+    }
+}
+function createTextureSource(gltf, buffers, textureIndex, slot, context) {
+    const reference = resolveTextureReference(gltf, buffers, textureIndex, slot, context);
+    if (!reference)
+        return null;
+    return context.preloadedTextures.get(reference.requestKey) ?? reference.source;
+}
+function resolveTextureReference(gltf, buffers, textureIndex, slot, context) {
+    const texture = gltf.textures?.[textureIndex];
+    const basisuSource = texture?.extensions?.KHR_texture_basisu?.source;
+    const imageIndex = basisuSource ?? texture?.source;
+    if (imageIndex === undefined)
+        return null;
+    const image = gltf.images?.[imageIndex] ?? null;
+    if (!image)
+        return null;
+    const compressed = basisuSource !== undefined || image.mimeType === 'image/ktx2';
+    const src = createImageUrl(gltf, buffers, imageIndex, image, context);
+    if (!src)
+        return null;
+    const source = compressed
+        ? { kind: 'compressed-texture', type: 'texture/ktx2', src }
+        : src;
+    const cacheKey = createImageCacheKey(imageIndex, image, context);
+    const format = getPbrTextureFormat(slot);
+    return {
+        source,
+        cacheKey,
+        requestKey: compressed ? `compressed:${cacheKey}` : `${format}:${cacheKey}`,
+        format,
+    };
+}
+function createImageCacheKey(imageIndex, image, context) {
+    if (image.uri) {
+        const url = image.uri.startsWith('data:') || image.uri.startsWith('blob:')
+            ? image.uri
+            : new URL(image.uri, context.baseUrl).href;
+        return `url:${url}`;
+    }
+    return `gltf:${context.assetIdentity}:image:${imageIndex}`;
+}
+function createImageUrl(gltf, buffers, imageIndex, image, context) {
+    const cached = context.imageSources.get(imageIndex);
+    if (typeof cached === 'string')
+        return cached;
+    if (image.uri) {
+        const url = image.uri.startsWith('data:') || image.uri.startsWith('blob:')
+            ? image.uri
+            : new URL(image.uri, context.baseUrl).href;
+        context.imageSources.set(imageIndex, url);
+        return url;
+    }
+    if (image.bufferView === undefined)
+        return null;
+    const view = gltf.bufferViews?.[image.bufferView];
+    if (!view)
+        return null;
+    const buffer = buffers[view.buffer];
+    if (!buffer)
+        throw gltfDataError(`Image bufferView references missing buffer ${view.buffer}.`);
+    const bytes = new Uint8Array(buffer, view.byteOffset ?? 0, view.byteLength);
+    const blob = new Blob([bytes.slice()], { type: image.mimeType || 'application/octet-stream' });
+    const url = URL.createObjectURL(blob);
+    if (!context.sharedImageSources)
+        context.objectUrls.push(url);
+    context.imageSources.set(imageIndex, url);
+    return url;
+}
+
+const GLTF_EXTENSION_CAPABILITIES = createGltfExtensionCapabilities(DEFAULT_GLTF_EXTENSION_ADAPTERS);
+function isGltfParsedAsset(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isGltfAsset(value.gltf))
+        return false;
+    if (!(value.binaryChunk === null || value.binaryChunk instanceof ArrayBuffer))
+        return false;
+    if (!Array.isArray(value.buffers) || !value.buffers.every(buffer => buffer instanceof ArrayBuffer))
+        return false;
+    if (typeof value.baseUrl !== 'string')
+        return false;
+    if (value.geometryPayloads !== undefined && !isGeometryPayloadMatrix(value.geometryPayloads))
+        return false;
+    return value.metrics === undefined || isParsedAssetMetrics(value.metrics);
+}
+function isGeometryPayloadMatrix(value) {
+    return Array.isArray(value) && value.every(mesh => Array.isArray(mesh) && mesh.every(payload => {
+        if (payload === null)
+            return true;
+        if (!isRecord(payload) || !(payload.positions instanceof Float32Array))
+            return false;
+        if (payload.indices !== undefined && !(payload.indices instanceof Uint16Array) && !(payload.indices instanceof Uint32Array))
+            return false;
+        if (payload.normals !== undefined && !(payload.normals instanceof Float32Array))
+            return false;
+        if (!Array.isArray(payload.textureCoordinates)
+            || !payload.textureCoordinates.every(entry => isRecord(entry)
+                && typeof entry.set === 'number'
+                && Number.isInteger(entry.set)
+                && entry.set >= 0
+                && entry.data instanceof Float32Array))
+            return false;
+        if (!Array.isArray(payload.positionTargets) || !payload.positionTargets.every(target => target instanceof Float32Array))
+            return false;
+        return Array.isArray(payload.normalTargets) && payload.normalTargets.every(target => target instanceof Float32Array);
+    }));
+}
+function isParsedAssetMetrics(value) {
+    if (!isRecord(value))
+        return false;
+    return [
+        'fetchMs',
+        'parseMs',
+        'workerParseMs',
+        'dracoDecodeMs',
+        'geometryPreparationMs',
+        'sourceBytes',
+        'workerTransferBytes',
+        'workerTransferBufferCount',
+    ].every(key => typeof value[key] === 'number' && Number.isFinite(value[key]) && value[key] >= 0);
+}
+
+const sharedImageSourcesByAsset = new WeakMap();
+async function loadGltfModel(src, options = {}) {
+    const loadStartedAt = nowMilliseconds();
+    throwIfGltfLoadAborted(options.signal);
+    const extensionAdapters = resolveGltfExtensionAdapters(options.extensionAdapters);
+    const extensionCapabilities = createGltfExtensionCapabilities(extensionAdapters);
+    let parsedAssetHandle = null;
+    let parsedAsset;
+    const assetManager = options.assetManager ?? null;
+    try {
+        if (assetManager) {
+            parsedAssetHandle = await assetManager.load(`gltf:parsed:${resolveAssetIdentity(src)}`, signal => loadParsedAssetForModel(src, options, signal), asset => disposeSharedImageSources(asset, assetManager), { signal: options.signal });
+            parsedAsset = parsedAssetHandle.value;
+        }
+        else {
+            parsedAsset = await loadParsedAssetForModel(src, options, options.signal);
+        }
+    }
+    catch (error) {
+        throw attachGltfSource(error, src);
+    }
+    const { gltf, buffers, baseUrl, geometryPayloads } = parsedAsset;
+    let extensionInspection;
+    try {
+        extensionInspection = validateGltfExtensions(gltf, extensionCapabilities);
+    }
+    catch (error) {
+        parsedAssetHandle?.release();
+        throw attachGltfSource(error, src);
+    }
+    try {
+        for (const warning of extensionInspection.warnings)
+            options.onWarning?.(warning);
+        throwIfGltfLoadAborted(options.signal);
+    }
+    catch (error) {
+        parsedAssetHandle?.release();
+        throw attachGltfSource(error, src);
+    }
+    const animationTargets = new Map();
+    const context = {
+        baseUrl,
+        assetIdentity: resolveAssetIdentity(src),
+        objectUrls: [],
+        imageSources: parsedAssetHandle && assetManager
+            ? getSharedImageSources(parsedAsset, assetManager)
+            : new Map(),
+        sharedImageSources: parsedAssetHandle !== null,
+        preloadedTextures: new Map(),
+        animationTargets,
+        skinnedPrimitives: [],
+        pendingSkinnedPrimitives: [],
+        assetHandles: parsedAssetHandle ? [parsedAssetHandle] : [],
+        ...(geometryPayloads === undefined ? {} : { geometryPayloads }),
+        compatibilityPrimitives: [],
+        extensionAdapters,
+    };
+    const root = new Entity('glTF Model');
+    try {
+        let mainThreadDracoDecodeMs = 0;
+        const geometryOptions = geometryPayloads === undefined
+            ? {
+                ...options,
+                diagnostics: {
+                    onDracoDecode(durationMs, decodedBytes) {
+                        mainThreadDracoDecodeMs += durationMs;
+                        options.diagnostics?.onDracoDecode?.(durationMs, decodedBytes);
+                    },
+                },
+            }
+            : options;
+        let geometryPreparationMs = parsedAsset.metrics?.geometryPreparationMs ?? 0;
+        const geometryTask = geometryPayloads === undefined
+            ? (async () => {
+                const startedAt = nowMilliseconds();
+                try {
+                    return await prepareGltfGeometryPayloads(gltf, buffers, geometryOptions);
+                }
+                finally {
+                    geometryPreparationMs = nowMilliseconds() - startedAt;
+                }
+            })()
+            : Promise.resolve(geometryPayloads);
+        let textureDecodeTranscodeUploadMs = 0;
+        const textureTask = (async () => {
+            const startedAt = nowMilliseconds();
+            try {
+                await preloadGltfTextures(gltf, buffers, options, context);
+            }
+            finally {
+                textureDecodeTranscodeUploadMs = nowMilliseconds() - startedAt;
+            }
+        })();
+        const [geometryResult, textureResult] = await Promise.all([
+            settleTask(geometryTask),
+            settleTask(textureTask),
+        ]);
+        if (!geometryResult.ok)
+            throw geometryResult.error;
+        if (!textureResult.ok)
+            throw textureResult.error;
+        context.geometryPayloads = geometryResult.value;
+        const instantiateStartedAt = nowMilliseconds();
+        root.addComponent(new CartesianTransform3D());
+        const sceneIndex = options.scene ?? gltf.scene ?? 0;
+        const scene = gltf.scenes?.[sceneIndex] ?? gltf.scenes?.[0];
+        const rootNodes = await Promise.all((scene?.nodes ?? []).map(nodeIndex => instantiateNode(gltf, buffers, nodeIndex, options, animationTargets, context)));
+        for (const child of rootNodes) {
+            throwIfGltfLoadAborted(options.signal);
+            if (child)
+                root.addChild(child);
+        }
+        resolvePendingSkins(gltf, buffers, context);
+        const animationClips = createAnimationClips(gltf, buffers, animationTargets, context.skinnedPrimitives);
+        const instantiateMs = nowMilliseconds() - instantiateStartedAt;
+        const decodedGeometryBytes = countDecodedGeometryBytes(context.compatibilityPrimitives);
+        const parsedMetrics = parsedAsset.metrics;
+        const dracoDecodeMs = (parsedMetrics?.dracoDecodeMs ?? 0) + mainThreadDracoDecodeMs;
+        const compatibilityReport = createGltfCompatibilityReport(gltf, extensionInspection.report.entries, context.compatibilityPrimitives, {
+            loadMs: nowMilliseconds() - loadStartedAt,
+            decodedGeometryBytes,
+        });
+        return {
+            root,
+            animations: animationClips.map(clip => ({ name: clip.name, duration: clip.duration, channelCount: clip.channels.length })),
+            animationClips,
+            assetStats: collectAssetStats(gltf),
+            loadMetrics: Object.freeze({
+                timings: Object.freeze({
+                    fetchMs: parsedMetrics?.fetchMs ?? 0,
+                    workerParseMs: parsedMetrics?.workerParseMs ?? 0,
+                    dracoDecodeMs,
+                    geometryPreparationMs: geometryPayloads === undefined
+                        ? Math.max(0, geometryPreparationMs - mainThreadDracoDecodeMs)
+                        : parsedMetrics?.geometryPreparationMs ?? 0,
+                    instantiateMs,
+                    textureDecodeTranscodeUploadMs,
+                    totalMs: nowMilliseconds() - loadStartedAt,
+                }),
+                sourceBytes: parsedMetrics?.sourceBytes ?? countUniqueBufferBytes(buffers),
+                decodedGeometryBytes,
+                workerTransferBytes: parsedMetrics?.workerTransferBytes ?? 0,
+                workerTransferBufferCount: parsedMetrics?.workerTransferBufferCount ?? 0,
+            }),
+            objectUrls: context.objectUrls,
+            assetHandles: context.assetHandles,
+            materialVariants: collectGltfMaterialVariantNames(gltf, extensionAdapters),
+            warnings: extensionInspection.warnings,
+            extensionReport: extensionInspection.report,
+            compatibilityReport,
+        };
+    }
+    catch (error) {
+        disposeEntityTree(root);
+        revokeObjectUrls(context.objectUrls);
+        releaseAssetHandles(context.assetHandles);
+        throw attachGltfSource(error, src);
+    }
+}
+async function loadParsedAssetForModel(src, options, signal) {
+    const assetWorker = options.assetWorker && !isInlineOrBlobUri(src) ? options.assetWorker : null;
+    return parseAssetWorkerFirst({
+        parser: { type: 'model/gltf', parse: (_input, context) => loadParsedGltfAsset(src, context.signal) },
+        input: src,
+        context: { ...(signal === undefined ? {} : { signal }), source: src },
+        worker: assetWorker
+            ? (_input, context) => assetWorker.loadParsedAsset(src, {
+                ...(context.signal === undefined ? {} : { signal: context.signal }),
+                ...(options.dracoDecoderConfig === undefined ? {} : { dracoDecoderConfig: options.dracoDecoderConfig }),
+            })
+            : null,
+    });
+}
+function resolveAssetIdentity(src) {
+    try {
+        const fallback = typeof globalThis.location?.href === 'string' ? globalThis.location.href : undefined;
+        return fallback === undefined ? new URL(src).href : new URL(src, fallback).href;
+    }
+    catch {
+        return src;
+    }
+}
+function getSharedImageSources(asset, manager) {
+    let byManager = sharedImageSourcesByAsset.get(asset);
+    if (!byManager) {
+        byManager = new WeakMap();
+        sharedImageSourcesByAsset.set(asset, byManager);
+    }
+    let sources = byManager.get(manager);
+    if (!sources) {
+        sources = new Map();
+        byManager.set(manager, sources);
+    }
+    return sources;
+}
+function disposeSharedImageSources(asset, manager) {
+    const sources = sharedImageSourcesByAsset.get(asset)?.get(manager);
+    if (!sources)
+        return;
+    for (const url of sources.values()) {
+        if (url.startsWith('blob:'))
+            URL.revokeObjectURL(url);
+    }
+    sources.clear();
+    sharedImageSourcesByAsset.get(asset)?.delete(manager);
+}
+async function settleTask(task) {
+    try {
+        return { ok: true, value: await task };
+    }
+    catch (error) {
+        return { ok: false, error };
+    }
+}
+const nowMilliseconds = monotonicNow;
+function countDecodedGeometryBytes(primitives) {
+    const buffers = new Set();
+    const add = (value) => {
+        if (value)
+            buffers.add(value.buffer);
+    };
+    for (const { geometry } of primitives) {
+        add(geometry.positions);
+        add(geometry.normals);
+        add(geometry.indices);
+        add(geometry.morphBasePositions);
+        add(geometry.morphBaseNormals);
+        for (const value of geometry.textureCoordinates.values())
+            add(value);
+        for (const target of geometry.morphTargets) {
+            add(target.positions);
+            add(target.normals);
+        }
+        add(geometry.skinning?.joints);
+        add(geometry.skinning?.weights);
+        add(geometry.skinning?.jointMatrices);
+    }
+    let total = 0;
+    for (const buffer of buffers)
+        total += buffer.byteLength;
+    return total;
+}
+function countUniqueBufferBytes(buffers) {
+    let total = 0;
+    for (const buffer of new Set(buffers))
+        total += buffer.byteLength;
+    return total;
+}
+function isInlineOrBlobUri(src) {
+    return /^(data:|blob:)/i.test(src);
+}
+function disposeGltfModel(model) {
+    disposeEntityTree(model.root);
+    revokeObjectUrls(model.objectUrls);
+    releaseAssetHandles(model.assetHandles);
+    model.animations.length = 0;
+    model.animationClips.length = 0;
+}
+function setGltfMaterialVariant(model, name) {
+    if (name !== null && !model.materialVariants.includes(name)) {
+        throw new RangeError(`Unknown glTF material variant "${name}".`);
+    }
+    visitEntityTree(model.root, entity => {
+        const material = entity.getComponent(Mesh3D)?.material;
+        if (!(material instanceof PbrMaterial))
+            return;
+        material.setVariant(name !== null && material.variantNames.includes(name) ? name : null);
+    });
+}
+function visitEntityTree(entity, visit) {
+    visit(entity);
+    for (const child of entity.children)
+        visitEntityTree(child, visit);
+}
+function releaseAssetHandles(handles) {
+    for (const handle of handles)
+        handle.release();
+    handles.length = 0;
+}
+function revokeObjectUrls(urls) {
+    for (const url of urls)
+        URL.revokeObjectURL(url);
+    urls.length = 0;
+}
+function disposeEntityTree(entity) {
+    const children = [...entity.children];
+    for (const child of children)
+        disposeEntityTree(child);
+    entity.destroy();
+}
+function collectAssetStats(gltf) {
+    return {
+        meshCount: gltf.meshes?.length ?? 0,
+        primitiveCount: (gltf.meshes ?? []).reduce((sum, mesh) => sum + mesh.primitives.length, 0),
+        materialCount: gltf.materials?.length ?? 0,
+        textureCount: gltf.textures?.length ?? 0,
+        imageCount: gltf.images?.length ?? 0,
+        animationCount: gltf.animations?.length ?? 0,
+    };
+}
+async function loadGltfAsset(src, signal) {
+    const baseUrl = resolveBaseUrl(src);
+    const fetchStartedAt = nowMilliseconds();
+    const response = await fetch(src, signal ? { signal } : undefined);
+    if (!response.ok)
+        throw gltfDataError(`Failed to load glTF: ${response.status} ${response.statusText}`, { url: src, status: response.status }, 'gltf');
+    throwIfGltfLoadAborted(signal);
+    const bytes = await response.arrayBuffer();
+    const fetchMs = nowMilliseconds() - fetchStartedAt;
+    throwIfGltfLoadAborted(signal);
+    const parseStartedAt = nowMilliseconds();
+    if (isGlb(bytes)) {
+        const parsed = parseGlb(bytes);
+        return {
+            ...parsed,
+            baseUrl,
+            fetchMs,
+            parseMs: nowMilliseconds() - parseStartedAt,
+            sourceBytes: bytes.byteLength,
+        };
+    }
+    const text = new TextDecoder().decode(bytes);
+    const gltf = parseGltfJson(text, src, 'gltf');
+    return {
+        gltf,
+        binaryChunk: null,
+        baseUrl,
+        fetchMs,
+        parseMs: nowMilliseconds() - parseStartedAt,
+        sourceBytes: bytes.byteLength,
+    };
+}
+async function loadParsedGltfAsset(src, signal) {
+    const { gltf, binaryChunk, baseUrl, fetchMs: primaryFetchMs, parseMs, sourceBytes } = await loadGltfAsset(src, signal);
+    throwIfGltfLoadAborted(signal);
+    const buffersStartedAt = nowMilliseconds();
+    const buffers = await loadBuffers(gltf, binaryChunk, baseUrl, signal);
+    const bufferFetchMs = nowMilliseconds() - buffersStartedAt;
+    return {
+        gltf,
+        binaryChunk,
+        buffers,
+        baseUrl,
+        metrics: Object.freeze({
+            fetchMs: primaryFetchMs + bufferFetchMs,
+            parseMs,
+            workerParseMs: parseMs,
+            dracoDecodeMs: 0,
+            geometryPreparationMs: 0,
+            sourceBytes: sourceBytes + countExternalBufferBytes(gltf, buffers),
+            workerTransferBytes: 0,
+            workerTransferBufferCount: 0,
+        }),
+    };
+}
+function countExternalBufferBytes(gltf, buffers) {
+    let total = 0;
+    for (const [index, descriptor] of (gltf.buffers ?? []).entries()) {
+        if (!descriptor.uri || descriptor.uri.startsWith('data:'))
+            continue;
+        total += buffers[index]?.byteLength ?? 0;
+    }
+    return total;
+}
+function validateGltfExtensions(gltf, capabilities) {
+    const usedExtensions = new Set(gltf.extensionsUsed ?? []);
+    const requiredExtensions = new Set(gltf.extensionsRequired ?? []);
+    for (const [index, extension] of (gltf.extensionsRequired ?? []).entries()) {
+        if (!usedExtensions.has(extension)) {
+            throw gltfDataError(`Required glTF extension "${extension}" is missing from extensionsUsed.`, { extension }, `gltf.extensionsRequired[${index}]`);
+        }
+        const capability = capabilities[extension];
+        if (capability?.support === 'supported')
+            continue;
+        throw gltfDataError(`Required glTF extension "${extension}" is not supported.`, { extension, support: capability?.support ?? 'unknown' }, `gltf.extensionsRequired[${index}]`);
+    }
+    const warnings = [];
+    for (const [index, extension] of (gltf.extensionsUsed ?? []).entries()) {
+        const capability = capabilities[extension];
+        if (capability?.support === 'supported')
+            continue;
+        const partial = capability?.support === 'partial';
+        warnings.push(Object.freeze({
+            code: partial ? 'W_GLTF_PARTIAL_OPTIONAL_EXTENSION' : 'W_GLTF_UNSUPPORTED_OPTIONAL_EXTENSION',
+            message: partial
+                ? `Optional glTF extension "${extension}" is only partially supported: ${capability.note}`
+                : `Optional glTF extension "${extension}" is not supported and was ignored.`,
+            extension,
+            path: `gltf.extensionsUsed[${index}]`,
+        }));
+    }
+    const entries = [...usedExtensions].map(extension => {
+        const capability = capabilities[extension];
+        const support = capability?.support ?? 'unsupported';
+        return Object.freeze({
+            extension,
+            required: requiredExtensions.has(extension),
+            support,
+            disposition: support === 'supported' ? 'supported' : support === 'partial' ? 'partial' : 'ignored',
+            note: capability?.note ?? 'No loader capability is registered; optional extension data is ignored.',
+        });
+    });
+    const frozenWarnings = Object.freeze(warnings);
+    return Object.freeze({
+        warnings: frozenWarnings,
+        report: Object.freeze({
+            fullySupported: entries.every(entry => entry.support === 'supported'),
+            entries: Object.freeze(entries),
+        }),
+    });
+}
+function resolveBaseUrl(src) {
+    try {
+        return new URL('.', src).href;
+    }
+    catch {
+        const documentBase = globalThis.document?.baseURI;
+        const candidates = [documentBase, globalThis.location?.href, 'http://localhost/'];
+        for (const candidate of candidates) {
+            if (typeof candidate !== 'string')
+                continue;
+            try {
+                return new URL('.', candidate).href;
+            }
+            catch {
+                // about:srcdoc and other opaque origins cannot resolve relatives.
+            }
+        }
+        return 'http://localhost/';
+    }
+}
+function isGlb(buffer) {
+    const view = new DataView(buffer);
+    return view.byteLength >= 12 && view.getUint32(0, true) === 0x46546c67;
+}
+function parseGlb(buffer) {
+    if (buffer.byteLength < 12)
+        throw gltfDataError('GLB header is truncated.', {}, 'glb.header');
+    const view = new DataView(buffer);
+    const version = view.getUint32(4, true);
+    if (version !== 2)
+        throw gltfDataError(`Unsupported GLB version: ${version}`, { version }, 'glb.header.version');
+    let offset = 12;
+    let gltf = null;
+    let binaryChunk = null;
+    while (offset + 8 <= view.byteLength) {
+        const chunkLength = view.getUint32(offset, true);
+        const chunkType = view.getUint32(offset + 4, true);
+        const chunkStart = offset + 8;
+        if (chunkStart + chunkLength > view.byteLength) {
+            throw gltfDataError('GLB chunk exceeds the file length.', { chunkLength, offset }, `glb.chunks[${offset}]`);
+        }
+        const chunk = buffer.slice(chunkStart, chunkStart + chunkLength);
+        if (chunkType === 0x4e4f534a) {
+            gltf = parseGltfJson(new TextDecoder().decode(chunk), 'GLB', 'glb.json');
+        }
+        else if (chunkType === 0x004e4942) {
+            binaryChunk = chunk;
+        }
+        offset = chunkStart + chunkLength;
+    }
+    if (!gltf)
+        throw gltfDataError('GLB is missing JSON chunk.', {}, 'glb.json');
+    return { gltf, binaryChunk };
+}
+function parseGltfJson(text, source, path) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (error) {
+        throw gltfDataError('glTF JSON is not valid JSON.', { url: source }, path, error);
+    }
+    if (!isGltfAsset(value)) {
+        throw gltfDataError('glTF JSON does not match the supported glTF structure.', { url: source }, path);
+    }
+    return value;
+}
+async function loadBuffers(gltf, binaryChunk, baseUrl, signal) {
+    return Promise.all((gltf.buffers ?? []).map(async (buffer, index) => {
+        throwIfGltfLoadAborted(signal);
+        if (!buffer.uri) {
+            if (index === 0 && binaryChunk)
+                return binaryChunk;
+            throw gltfDataError(`glTF buffer ${index} has no uri and no GLB chunk.`);
+        }
+        if (buffer.uri.startsWith('data:')) {
+            return dataUriToArrayBuffer(buffer.uri);
+        }
+        const response = await fetch(resolveFetchUri(buffer.uri, baseUrl), signal ? { signal } : undefined);
+        if (!response.ok)
+            throw gltfDataError(`Failed to load glTF buffer: ${buffer.uri}`, { uri: buffer.uri }, `gltf.buffers[${index}]`);
+        throwIfGltfLoadAborted(signal);
+        const result = await response.arrayBuffer();
+        throwIfGltfLoadAborted(signal);
+        return result;
+    }));
+}
+function resolveFetchUri(uri, baseUrl) {
+    if (/^(blob:|https?:\/\/)/i.test(uri))
+        return uri;
+    return new URL(uri, baseUrl).href;
+}
+function dataUriToArrayBuffer(uri) {
+    const comma = uri.indexOf(',');
+    const meta = uri.slice(0, comma);
+    const data = uri.slice(comma + 1);
+    if (meta.endsWith(';base64')) {
+        const binary = atob(data);
+        const out = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            out[i] = binary.charCodeAt(i);
+        return out.buffer;
+    }
+    return new TextEncoder().encode(decodeURIComponent(data)).buffer;
+}
+async function instantiateNode(gltf, buffers, nodeIndex, options, animationTargets, context) {
+    throwIfGltfLoadAborted(options.signal);
+    const node = gltf.nodes?.[nodeIndex];
+    if (!node)
+        return null;
+    const entity = new Entity(node.name || `glTF Node ${nodeIndex}`);
+    const { transform, target } = createNodeTransform(node, entity);
+    entity.addComponent(transform);
+    animationTargets.set(nodeIndex, target);
+    if (node.mesh !== undefined) {
+        const mesh = gltf.meshes?.[node.mesh];
+        target.weights = mesh?.weights ? [...mesh.weights] : [];
+        const primitiveEntities = await Promise.all((mesh?.primitives ?? []).map((primitive, primitiveIndex) => createPrimitiveEntity(gltf, buffers, primitive, options, `${mesh?.name || 'Mesh'} Primitive ${primitiveIndex}`, target, context, node.skin, entity, node.mesh, primitiveIndex)));
+        for (const primitiveEntity of primitiveEntities) {
+            throwIfGltfLoadAborted(options.signal);
+            if (primitiveEntity)
+                entity.addChild(primitiveEntity);
+        }
+        applyMorphWeights(target, target.weights);
+    }
+    const children = await Promise.all((node.children ?? []).map(childIndex => instantiateNode(gltf, buffers, childIndex, options, animationTargets, context)));
+    for (const child of children) {
+        throwIfGltfLoadAborted(options.signal);
+        if (child)
+            entity.addChild(child);
+    }
+    return entity;
+}
+function createNodeTransform(node, entity) {
+    const translation = node.translation ? [...node.translation] : [0, 0, 0];
+    const rotation = node.rotation ? [...node.rotation] : [0, 0, 0, 1];
+    const scale = node.scale ? [...node.scale] : [1, 1, 1];
+    const transform = new Transform3D();
+    if (node.matrix?.length === 16) {
+        transform.localMatrix = new Float32Array(node.matrix);
+    }
+    else {
+        transform.localMatrix = composeTrsMatrix(translation, rotation, scale);
+    }
+    return { transform, target: { entity, transform, translation, rotation, scale, weights: [], morphPrimitives: [] } };
+}
+async function createPrimitiveEntity(gltf, buffers, primitive, options, name, target, context, skinIndex, meshEntity, meshIndex, primitiveIndex) {
+    throwIfGltfLoadAborted(options.signal);
+    if (primitive.mode !== undefined && primitive.mode !== 4)
+        return null;
+    const payload = context.geometryPayloads?.[meshIndex]?.[primitiveIndex]
+        ?? await createPrimitiveGeometryPayload(gltf, buffers, primitive, options);
+    throwIfGltfLoadAborted(options.signal);
+    if (!payload)
+        return null;
+    const uvPlanResult = planGltfUvSemantics(gltf, primitive, meshIndex, primitiveIndex, context.extensionAdapters);
+    if (!uvPlanResult.ok) {
+        throw gltfDataError(uvPlanResult.failure.message, uvPlanResult.failure.context, uvPlanResult.failure.path);
+    }
+    const uvPlan = uvPlanResult.plan;
+    const { positions, indices, normals, textureCoordinates, joints, weights, positionTargets, normalTargets } = payload;
+    for (const mapping of uvPlan.mappings) {
+        if (textureCoordinates.some(entry => entry.set === mapping.set))
+            continue;
+        throw gltfDataError(`Decoded geometry payload is missing ${mapping.semantic}.`, { meshIndex, primitiveIndex, semantic: mapping.semantic, texCoord: mapping.set }, `${uvPlan.path}.attributes.${mapping.semantic}`);
+    }
+    const geometry = new Geometry3D({
+        positions,
+        ...(normals === undefined ? {} : { normals }),
+        textureCoordinates,
+        textureCoordinateLayout: uvPlan.mappings.map(mapping => mapping.set),
+        ...(indices === undefined ? {} : { indices }),
+    });
+    const conservativeBounds = GltfConservativeBounds.fromPrimitive(gltf, primitive);
+    if (conservativeBounds)
+        registerGltfConservativeBounds(geometry, conservativeBounds);
+    if (positionTargets.length > 0 || normalTargets.length > 0) {
+        geometry.setMorphTargets(new Array(Math.max(positionTargets.length, normalTargets.length)).fill(null).map((_, index) => ({
+            ...(positionTargets[index] === undefined ? {} : { positions: positionTargets[index] }),
+            ...(normalTargets[index] === undefined ? {} : { normals: normalTargets[index] }),
+        })), target.weights);
+        target.morphPrimitives.push({
+            geometry,
+            basePositions: positions.slice(),
+            baseNormals: normals ? normals.slice() : null,
+            positionTargets,
+            normalTargets,
+        });
+        if (target.weights.length === 0)
+            target.weights = new Array(Math.max(positionTargets.length, normalTargets.length)).fill(0);
+    }
+    const material = await createGltfMaterial(gltf, buffers, primitive, options, context, uvPlan);
+    throwIfGltfLoadAborted(options.signal);
+    const entity = new Entity(name);
+    entity.addComponent(new CartesianTransform3D());
+    entity.addComponent(new Mesh3D(geometry, material));
+    if (skinIndex !== undefined && joints && weights) {
+        context.pendingSkinnedPrimitives.push({ skinIndex, geometry, meshEntity, joints, weights });
+    }
+    context.compatibilityPrimitives.push({
+        meshIndex,
+        primitiveIndex,
+        primitive,
+        geometry,
+        skinRequested: skinIndex !== undefined,
+        uvSemanticPlan: uvPlan,
+    });
+    return entity;
+}
+async function createPrimitiveGeometryPayload(gltf, buffers, primitive, options) {
+    throwIfGltfLoadAborted(options.signal);
+    if (primitive.mode !== undefined && primitive.mode !== 4)
+        return null;
+    const dracoExtension = primitive.extensions?.KHR_draco_mesh_compression;
+    let decoded = null;
+    if (dracoExtension) {
+        const decodeStartedAt = nowMilliseconds();
+        decoded = await decodeDracoPrimitive(gltf, buffers, dracoExtension, options);
+        options.diagnostics?.onDracoDecode?.(nowMilliseconds() - decodeStartedAt, countDracoGeometryBytes(decoded));
+    }
+    throwIfGltfLoadAborted(options.signal);
+    const positionAccessor = primitive.attributes.POSITION;
+    if (positionAccessor === undefined && !decoded?.positions)
+        return null;
+    const positions = decoded?.positions ?? readAccessorFloat(gltf, buffers, positionAccessor, 3);
+    const indices = decoded?.indices ?? (primitive.indices !== undefined ? readAccessorIndices(gltf, buffers, primitive.indices) : undefined);
+    const normals = decoded?.normals ?? (primitive.attributes.NORMAL !== undefined
+        ? readAccessorFloat(gltf, buffers, primitive.attributes.NORMAL, 3)
+        : generateFlatNormals(positions, indices ?? null));
+    const textureCoordinates = decoded?.textureCoordinates ?? Object.entries(primitive.attributes)
+        .map(([semantic, accessor]) => ({ set: parseTextureCoordinateSemantic(semantic), accessor }))
+        .filter((entry) => entry.set !== null)
+        .sort((a, b) => a.set - b.set)
+        .map(entry => ({ set: entry.set, data: readAccessorFloat(gltf, buffers, entry.accessor, 2) }));
+    const joints = decoded?.joints ?? (primitive.attributes.JOINTS_0 !== undefined
+        ? readAccessorUnsigned(gltf, buffers, primitive.attributes.JOINTS_0, 4)
+        : undefined);
+    const weights = decoded?.weights ?? (primitive.attributes.WEIGHTS_0 !== undefined
+        ? readAccessorFloat(gltf, buffers, primitive.attributes.WEIGHTS_0, 4)
+        : undefined);
+    return {
+        positions,
+        ...(indices === undefined ? {} : { indices }),
+        ...(normals === undefined ? {} : { normals }),
+        textureCoordinates,
+        ...(joints === undefined ? {} : { joints }),
+        ...(weights === undefined ? {} : { weights }),
+        positionTargets: (primitive.targets ?? []).map(item => item.POSITION !== undefined
+            ? readAccessorFloat(gltf, buffers, item.POSITION, 3)
+            : new Float32Array(positions.length)),
+        normalTargets: (primitive.targets ?? []).map(item => item.NORMAL !== undefined
+            ? readAccessorFloat(gltf, buffers, item.NORMAL, 3)
+            : new Float32Array(normals.length)),
+    };
+}
+async function prepareGltfGeometryPayloads(gltf, buffers, options = {}) {
+    return Promise.all((gltf.meshes ?? []).map(mesh => Promise.all(mesh.primitives.map(primitive => createPrimitiveGeometryPayload(gltf, buffers, primitive, options)))));
+}
+function countDracoGeometryBytes(decoded) {
+    const buffers = new Set();
+    const add = (value) => {
+        if (value)
+            buffers.add(value.buffer);
+    };
+    add(decoded.positions);
+    add(decoded.indices);
+    add(decoded.normals);
+    add(decoded.joints);
+    add(decoded.weights);
+    for (const entry of decoded.textureCoordinates)
+        add(entry.data);
+    let total = 0;
+    for (const buffer of buffers)
+        total += buffer.byteLength;
+    return total;
+}
+function resolvePendingSkins(gltf, buffers, context) {
+    for (const pending of context.pendingSkinnedPrimitives) {
+        const runtime = createSkinRuntime(gltf, buffers, pending, context);
+        if (runtime) {
+            updateSkinnedPrimitive(runtime);
+            context.skinnedPrimitives.push(runtime);
+        }
+    }
+    context.pendingSkinnedPrimitives.length = 0;
+}
+function createSkinRuntime(gltf, buffers, pending, context) {
+    const skin = gltf.skins?.[pending.skinIndex];
+    if (!skin || skin.joints.length === 0)
+        return null;
+    const jointTargets = skin.joints.map(nodeIndex => context.animationTargets.get(nodeIndex) ?? null);
+    if (!jointTargets.some(Boolean))
+        return null;
+    const inverseBindMatrices = skin.inverseBindMatrices !== undefined
+        ? readAccessorMat4(gltf, buffers, skin.inverseBindMatrices)
+        : new Array(jointTargets.length).fill(null).map(() => mat4.identity());
+    if (inverseBindMatrices.length < jointTargets.length) {
+        while (inverseBindMatrices.length < jointTargets.length)
+            inverseBindMatrices.push(mat4.identity());
+    }
+    const jointMatrices = new Float32Array(jointTargets.length * 16);
+    const gpuSkinAttributes = createGpuSkinAttributes(pending.joints, pending.weights, jointTargets.length);
+    pending.geometry.setSkinning({
+        joints: gpuSkinAttributes.joints,
+        weights: gpuSkinAttributes.weights,
+        jointMatrices,
+    });
+    return {
+        geometry: pending.geometry,
+        meshEntity: pending.meshEntity,
+        jointTargets,
+        inverseBindMatrices,
+        jointMatrices,
+        inverseMeshWorldScratch: mat4.identity(),
+        jointMatrixScratch: mat4.identity(),
+        skinMatrixScratch: mat4.identity(),
+        lastMeshWorldVersion: -1,
+        lastGeometryVersion: -1,
+        lastJointWorldVersions: new Int32Array(jointTargets.length).fill(-1),
+    };
+}
+function createGpuSkinAttributes(joints, weights, jointCount) {
+    const gpuJoints = new Float32Array(joints.length);
+    const gpuWeights = new Float32Array(joints.length);
+    for (let vertexOffset = 0; vertexOffset < joints.length; vertexOffset += 4) {
+        let weightSum = 0;
+        for (let influence = 0; influence < 4; influence++) {
+            const offset = vertexOffset + influence;
+            const jointIndex = joints[offset] ?? 0;
+            const weight = weights[offset] ?? 0;
+            if (jointIndex >= 0 && jointIndex < jointCount) {
+                gpuJoints[offset] = jointIndex;
+                gpuWeights[offset] = Number.isFinite(weight) && weight > 0 ? weight : 0;
+                weightSum += gpuWeights[offset];
+            }
+            else {
+                gpuJoints[offset] = 0;
+                gpuWeights[offset] = 0;
+            }
+        }
+        if (weightSum > 0) {
+            for (let influence = 0; influence < 4; influence++) {
+                const offset = vertexOffset + influence;
+                gpuWeights[offset] = (gpuWeights[offset] ?? 0) / weightSum;
+            }
+        }
+    }
+    return { joints: gpuJoints, weights: gpuWeights };
+}
+
+export { DEFAULT_GLTF_EXTENSION_ADAPTERS as D, GLTF_EXTENSION_CAPABILITIES as G, loadGltfModel as a, collectGltfMaterialVariantNames as b, collectGltfMaterialExtensionPatches as c, disposeGltfModel as d, collectGltfMaterialVariantReferences as e, isGltfParsedAsset as i, loadParsedGltfAsset as l, prepareGltfGeometryPayloads as p, resolveGltfExtensionAdapters as r, setGltfMaterialVariant as s };
+//# sourceMappingURL=gltfLoader-Dm22jLYB.js.map