@haiyue/extensions 0.1.0 → 0.2.0

package/src/gltf/GltfCompatibilityReport.ts

@@ -1,214 +0,0 @@
-import type { Geometry3D } from '@haiyue/engine';
-import type { GltfAccessor, GltfAsset, GltfPrimitive } from './GltfSchema';
-import type { GltfUvSemanticPlan } from './GltfUvSemanticPlanner';
-
-export type GltfCompatibilityStatus = 'compatible' | 'degraded';
-export type GltfTextureMipmapSource = 'generated-full-chain' | 'source-provided' | 'unavailable';
-export type GltfPrimitiveBoundsSupport = 'static' | 'accessor-conservative' | 'fail-open';
-
-export interface GltfCompatibilityExtensionEntry {
-  readonly extension: string;
-  readonly required: boolean;
-  readonly support: 'supported' | 'partial' | 'unsupported';
-  readonly disposition: 'supported' | 'partial' | 'ignored';
-  readonly note: string;
-}
-
-export interface GltfTextureCompatibilityEntry {
-  readonly textureIndex: number;
-  readonly imageIndex: number | null;
-  readonly mipmapSource: GltfTextureMipmapSource;
-  readonly path: string;
-  readonly note: string;
-}
-
-export interface GltfPrimitiveBoundsCompatibilityEntry {
-  readonly meshIndex: number;
-  readonly primitiveIndex: number;
-  readonly support: GltfPrimitiveBoundsSupport;
-  readonly path: string;
-  readonly reason: string | null;
-}
-
-export interface GltfPrimitiveUvSemanticCompatibilityEntry {
-  readonly meshIndex: number;
-  readonly primitiveIndex: number;
-  readonly capacity: number;
-  readonly availableSemantics: readonly string[];
-  readonly referencedSemantics: readonly string[];
-  readonly mappings: readonly Readonly<{ semantic: string; set: number; channel: 0 | 1 }>[];
-  readonly path: string;
-}
-
-export interface GltfCompatibilityPerformanceSummary {
-  /** Fetch, parse, decode, and entity/material instantiation on the loading thread. */
-  readonly loadMs: number;
-  /** Unique decoded geometry ArrayBuffer storage retained by the loaded model. */
-  readonly decodedGeometryBytes: number;
-}
-
-export interface GltfCompatibilityIssue {
-  readonly category: 'extension' | 'texture-mipmap' | 'bounds' | 'uv-semantic';
-  readonly path: string;
-  readonly code: string;
-  readonly message: string;
-}
-
-export interface GltfCompatibilityReport {
-  readonly status: GltfCompatibilityStatus;
-  readonly extensions: readonly GltfCompatibilityExtensionEntry[];
-  readonly textures: readonly GltfTextureCompatibilityEntry[];
-  readonly bounds: readonly GltfPrimitiveBoundsCompatibilityEntry[];
-  readonly uvSemantics: readonly GltfPrimitiveUvSemanticCompatibilityEntry[];
-  readonly performance: GltfCompatibilityPerformanceSummary;
-  readonly issues: readonly GltfCompatibilityIssue[];
-}
-
-export interface GltfPrimitiveCompatibilityInput {
-  readonly meshIndex: number;
-  readonly primitiveIndex: number;
-  readonly primitive: GltfPrimitive;
-  readonly geometry: Geometry3D;
-  readonly skinRequested: boolean;
-  readonly uvSemanticPlan: GltfUvSemanticPlan;
-}
-
-export function createGltfCompatibilityReport(
-  gltf: GltfAsset,
-  extensions: readonly GltfCompatibilityExtensionEntry[],
-  primitives: readonly GltfPrimitiveCompatibilityInput[],
-  performance: GltfCompatibilityPerformanceSummary,
-): GltfCompatibilityReport {
-  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: GltfCompatibilityIssue[] = [];
-
-  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: GltfAsset): GltfTextureCompatibilityEntry[] {
-  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' as const,
-        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' as const : 'generated-full-chain' as const,
-      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: GltfAsset,
-  input: GltfPrimitiveCompatibilityInput,
-): GltfPrimitiveBoundsCompatibilityEntry {
-  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: GltfAsset, input: GltfPrimitiveCompatibilityInput): string | null {
-  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: GltfAccessor | undefined): boolean {
-  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;
-    });
-}

package/src/gltf/GltfConservativeBounds.ts

@@ -1,219 +0,0 @@
-import type { Geometry3DLocalBounds } from '@haiyue/engine/geometry';
-import type { GltfAccessor, GltfAsset, GltfPrimitive } from './GltfSchema';
-
-interface Bounds3 {
-  readonly min: readonly [number, number, number];
-  readonly max: readonly [number, number, number];
-}
-
-interface JointUsage {
-  readonly joints: Set<number>;
-  readonly includeSource: boolean;
-}
-
-/**
- * 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.
- */
-export class GltfConservativeBounds {
-  private _current: Bounds3 | null;
-  private _skinUsageCache: {
-    jointCount: number;
-    joints: Float32Array | undefined;
-    weights: Float32Array | undefined;
-    usage: JointUsage | null;
-  } | null = null;
-
-  private constructor(
-    private readonly _base: Bounds3,
-    private readonly _positionTargets: readonly (Bounds3 | null)[],
-  ) {
-    this._current = _base;
-  }
-
-  static fromPrimitive(gltf: GltfAsset, primitive: GltfPrimitive): GltfConservativeBounds | null {
-    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: ArrayLike<number>): Geometry3DLocalBounds | null {
-    const min: [number, number, number] = [...this._base.min];
-    const max: [number, number, number] = [...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(): Geometry3DLocalBounds | null {
-    return this._current ? boundsToSphere(this._current) : null;
-  }
-
-  getSkinnedBounds(
-    jointMatrices: Float32Array,
-    joints?: Float32Array,
-    weights?: Float32Array,
-  ): Geometry3DLocalBounds | null {
-    if (!this._current || jointMatrices.length === 0 || jointMatrices.length % 16 !== 0) return null;
-    const min: [number, number, number] = [Infinity, Infinity, Infinity];
-    const max: [number, number, number] = [-Infinity, -Infinity, -Infinity];
-    const jointCount = jointMatrices.length / 16;
-    let usage: JointUsage | null;
-    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: number,
-  joints: Float32Array | undefined,
-  weights: Float32Array | undefined,
-): JointUsage | null {
-  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<number>();
-  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: GltfAccessor | undefined): Bounds3 | null {
-  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: [number, number, number],
-  outMax: [number, number, number],
-  bounds: Bounds3,
-  matrix: Float32Array,
-  offset: number,
-): boolean {
-  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: [number, number, number],
-  outMax: [number, number, number],
-  bounds: Bounds3,
-): void {
-  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: Bounds3): Geometry3DLocalBounds {
-  const center: [number, number, number] = [
-    (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: Bounds3 = Object.freeze({
-  min: Object.freeze([0, 0, 0] as [number, number, number]),
-  max: Object.freeze([0, 0, 0] as [number, number, number]),
-});

package/src/gltf/GltfDracoDecoder.ts

@@ -1,251 +0,0 @@
-import { parseTextureCoordinateSemantic } from './GltfUvSemanticPlanner';
-import type { GltfAsset, GltfDracoMeshCompression } from './GltfSchema';
-import type {
-  DracoDecoder,
-  DracoDecoderConfig,
-  DracoDecoderFactory,
-  DracoDecoderModule,
-  DracoMesh,
-  DracoPrimitiveGeometry,
-  LoadGltfOptions,
-} from './GltfLoaderContract';
-import { gltfDataError, throwIfGltfLoadAborted } from './GltfLoaderErrors';
-
-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: Promise<DracoDecoderModule> | null = null;
-const sharedScriptPromises = new Map<string, Promise<DracoDecoderFactory>>();
-
-/** Resolves and decodes one KHR_draco_mesh_compression primitive. */
-export async function decodeDracoPrimitive(
-  gltf: GltfAsset,
-  buffers: ArrayBuffer[],
-  extension: GltfDracoMeshCompression,
-  options: LoadGltfOptions,
-): Promise<DracoPrimitiveGeometry> {
-  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 is { semantic: string; set: number } => 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: LoadGltfOptions): Promise<DracoDecoderModule> {
-  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: DracoDecoderConfig | undefined): Promise<DracoDecoderModule> {
-  let factory: DracoDecoderFactory;
-  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: string): Promise<DracoDecoderFactory> {
-  const existing = getGlobalDecoderFactory();
-  if (existing) return Promise.resolve(existing);
-  const existingPromise = sharedScriptPromises.get(scriptUrl);
-  if (existingPromise) return existingPromise;
-  const promise = new Promise<DracoDecoderFactory>((resolve, reject) => {
-    if (typeof document === 'undefined') {
-      const workerScope = globalThis as typeof globalThis & { postMessage?: unknown; location?: unknown };
-      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: string): Promise<DracoDecoderFactory> {
-  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}`,
-  )() as unknown;
-  if (typeof factory !== 'function') {
-    throw gltfDataError(`Draco decoder script loaded without DracoDecoderModule: ${scriptUrl}`, { url: scriptUrl });
-  }
-  return factory as DracoDecoderFactory;
-}
-
-function getGlobalDecoderFactory(): DracoDecoderFactory | null {
-  const globalScope = globalThis as typeof globalThis & { DracoDecoderModule?: DracoDecoderFactory };
-  return typeof globalScope.DracoDecoderModule === 'function' ? globalScope.DracoDecoderModule : null;
-}
-
-function readUnsignedAttribute(
-  module: DracoDecoderModule,
-  decoder: DracoDecoder,
-  mesh: DracoMesh,
-  extension: GltfDracoMeshCompression,
-  semantic: string,
-  expectedSize: number,
-): Uint16Array | Uint32Array | null {
-  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 = <T extends Uint16Array | Uint32Array>(
-    ArrayType: { new(length: number): T },
-    ValuesType: (new () => import('./GltfLoaderContract').DracoDecoderArray) | undefined,
-    read: ((mesh: DracoMesh, attribute: import('./GltfLoaderContract').DracoPointAttribute, out: import('./GltfLoaderContract').DracoDecoderArray) => boolean) | undefined,
-  ): T | null => {
-    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: DracoDecoderModule,
-  decoder: DracoDecoder,
-  mesh: DracoMesh,
-  extension: GltfDracoMeshCompression,
-  semantic: string,
-  expectedSize: number,
-): Float32Array | null {
-  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: DracoDecoderModule, decoder: DracoDecoder, mesh: DracoMesh): Uint16Array | Uint32Array {
-  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: ArrayLike<number>, index: number, label: string): number {
-  const value = values[index];
-  if (value === undefined || !Number.isFinite(value)) throw gltfDataError(`${label} is missing a finite value at index ${index}.`);
-  return value;
-}