@haiyue/extensions 0.1.0

package/dist/chunks/pluginUtils-CvwroRMd.js

@@ -0,0 +1,33 @@
+const EXTENSIONS_PLUGIN_VERSION = '0.1.0';
+function removeSystem(context, system) {
+    if (system)
+        context.world.removeSystem(system);
+}
+function installEditorRenderSystem(context, constructor, create) {
+    let system = context.world.getSystem(constructor);
+    const created = system === null;
+    if (!system) {
+        system = create();
+        context.world.addSystem(system);
+    }
+    system.setCameraEntity?.(context.camera2DEntity);
+    if (context.registerRenderSystem) {
+        system.autoUpdate = false;
+        context.registerRenderSystem(system);
+    }
+    else {
+        system.autoUpdate = true;
+    }
+    return ownedEditorViewportSystem(context.world, system, created);
+}
+function ownedEditorViewportSystem(world, system, owned) {
+    return {
+        dispose() {
+            if (owned && world.hasSystem(system))
+                world.removeSystem(system);
+        },
+    };
+}
+
+export { EXTENSIONS_PLUGIN_VERSION as E, installEditorRenderSystem as i, ownedEditorViewportSystem as o, removeSystem as r };
+//# sourceMappingURL=pluginUtils-CvwroRMd.js.map

package/dist/experimental-gltf-worker.d.ts

@@ -0,0 +1,4 @@
+/** Experimental worker transport and low-level parsing contracts for glTF. */
+export { GltfAssetWorkerClient, createGltfAssetWorkerClientFromUrl, createGltfAssetWorkerSource, createInlineGltfAssetWorkerClient, } from './gltf/GltfAssetWorkerClient';
+export { loadParsedGltfAsset, prepareGltfGeometryPayloads, } from './gltf/gltfLoader';
+export type { GltfAnimationChannelRuntime, GltfAnimationTarget, GltfGeometryPayloadMatrix, GltfParsedAsset, GltfPrimitiveGeometryPayload, } from './gltf/gltfLoader';

package/dist/experimental-gltf-worker.js

@@ -0,0 +1,138 @@
+import { WorkerChannel } from '@haiyue/engine/experimental/async';
+import { i as isGltfParsedAsset } from './chunks/gltfLoader-Dm22jLYB.js';
+export { l as loadParsedGltfAsset, p as prepareGltfGeometryPayloads } from './chunks/gltfLoader-Dm22jLYB.js';
+import '@haiyue/engine';
+import '@haiyue/engine/components';
+import 'wgpu-matrix';
+import '@haiyue/engine/material';
+import './chunks/GltfAnimationRuntime-CRHsLycN.js';
+import '@haiyue/engine/core';
+
+class GltfAssetWorkerClient {
+    objectUrl;
+    channel;
+    constructor(worker, objectUrl = null) {
+        this.objectUrl = objectUrl;
+        this.channel = new WorkerChannel(worker, {
+            label: 'glTF asset worker',
+            path: 'gltf.worker',
+            context: { resourceType: 'model/gltf' },
+        });
+    }
+    loadParsedAsset(src, options = {}) {
+        return this.channel.request('loadParsedGltfAsset', {
+            src,
+            dracoDecoderConfig: toWorkerDracoDecoderConfig(options.dracoDecoderConfig),
+        }, {
+            ...(options.signal ? { signal: options.signal } : {}),
+            context: { url: src },
+            abortMessage: 'glTF load aborted.',
+            validate: isGltfParsedAsset,
+        });
+    }
+    dispose(options = {}) {
+        const alreadyDisposed = this.channel.isDisposed;
+        this.channel.dispose(options);
+        if (!alreadyDisposed && this.objectUrl)
+            URL.revokeObjectURL(this.objectUrl);
+    }
+}
+function toWorkerDracoDecoderConfig(config) {
+    if (!config)
+        return undefined;
+    return {
+        ...(config.scriptUrl === undefined ? {} : { scriptUrl: config.scriptUrl }),
+        ...(config.wasmBinary === undefined ? {} : { wasmBinary: config.wasmBinary }),
+    };
+}
+/** The worker imports the same production parser used by the main-thread fallback. */
+function createGltfAssetWorkerSource(extensionGltfModuleUrl) {
+    return `
+const parserModulePromise = import(${JSON.stringify(extensionGltfModuleUrl)});
+const requests = new Map();
+self.addEventListener('message', async event => {
+  const request = event.data;
+  if (!request || request.version !== 1 || typeof request.id !== 'number') return;
+  if (request.type === 'cancel') {
+    requests.get(request.id)?.abort('cancelled');
+    requests.delete(request.id);
+    return;
+  }
+  if (request.type !== 'loadParsedGltfAsset') return;
+  const controller = new AbortController();
+  requests.set(request.id, controller);
+  try {
+    const parser = await parserModulePromise;
+    const value = await parser.loadParsedGltfAsset(request.src, controller.signal);
+    const geometryStartedAt = performance.now();
+    let dracoDecodeMs = 0;
+    value.geometryPayloads = await parser.prepareGltfGeometryPayloads(value.gltf, value.buffers, {
+      signal: controller.signal,
+      dracoDecoderConfig: request.dracoDecoderConfig,
+      diagnostics: {
+        onDracoDecode(durationMs) { dracoDecodeMs += durationMs; },
+      },
+    });
+    const geometryPreparationMs = performance.now() - geometryStartedAt;
+    if (!requiresRuntimeSourceBuffers(value.gltf)) {
+      value.binaryChunk = null;
+      value.buffers = [];
+    }
+    const transfer = [];
+    const seen = new Set();
+    const add = buffer => { if (buffer && !seen.has(buffer)) { seen.add(buffer); transfer.push(buffer); } };
+    add(value.binaryChunk);
+    for (const buffer of value.buffers || []) add(buffer);
+    for (const mesh of value.geometryPayloads || []) for (const payload of mesh || []) if (payload) {
+      for (const array of [payload.positions, payload.indices, payload.normals, payload.joints, payload.weights]) add(array && array.buffer);
+      for (const entry of payload.textureCoordinates || []) add(entry.data && entry.data.buffer);
+      for (const array of payload.positionTargets || []) add(array.buffer);
+      for (const array of payload.normalTargets || []) add(array.buffer);
+    }
+    const workerTransferBytes = transfer.reduce((total, buffer) => total + buffer.byteLength, 0);
+    const baseMetrics = value.metrics || {};
+    value.metrics = {
+      fetchMs: baseMetrics.fetchMs || 0,
+      parseMs: baseMetrics.parseMs || 0,
+      workerParseMs: (baseMetrics.parseMs || 0) + Math.max(0, geometryPreparationMs - dracoDecodeMs),
+      dracoDecodeMs,
+      geometryPreparationMs,
+      sourceBytes: baseMetrics.sourceBytes || 0,
+      workerTransferBytes,
+      workerTransferBufferCount: transfer.length,
+    };
+    self.postMessage({ version: 1, id: request.id, ok: true, value }, transfer);
+  } catch (error) {
+    if (controller.signal.aborted) return;
+    const serialized = error && typeof error.toJSON === 'function' ? error.toJSON() : {
+      name: 'EngineError', domain: 'asset', code: 'E_ASSET_INVALID_DATA',
+      message: error instanceof Error ? error.message : String(error), recoverable: false,
+      recovery: 'release-resource', context: { url: request.src, resourceType: 'model/gltf' },
+      path: error && error.path || 'gltf.parse',
+      cause: error instanceof Error ? { name: error.name, message: error.message, stack: error.stack } : undefined,
+    };
+    self.postMessage({ version: 1, id: request.id, ok: false, error: serialized });
+  } finally {
+    requests.delete(request.id);
+  }
+});
+
+function requiresRuntimeSourceBuffers(gltf) {
+  if ((gltf.animations || []).length > 0) return true;
+  if ((gltf.images || []).some(image => image.bufferView !== undefined)) return true;
+  return (gltf.skins || []).some(skin => skin.inverseBindMatrices !== undefined);
+}
+`.trim();
+}
+function createGltfAssetWorkerClientFromUrl(url, options) {
+    return new GltfAssetWorkerClient(new Worker(url, options));
+}
+function createInlineGltfAssetWorkerClient(extensionGltfModuleUrl, options) {
+    const blob = new Blob([createGltfAssetWorkerSource(extensionGltfModuleUrl)], { type: 'text/javascript' });
+    const url = URL.createObjectURL(blob);
+    const worker = new Worker(url, { type: 'module', ...options });
+    return new GltfAssetWorkerClient(worker, url);
+}
+
+export { GltfAssetWorkerClient, createGltfAssetWorkerClientFromUrl, createGltfAssetWorkerSource, createInlineGltfAssetWorkerClient };
+//# sourceMappingURL=experimental-gltf-worker.js.map

package/dist/experimental-spine-worker.d.ts

@@ -0,0 +1,4 @@
+export { SPINE_ASSET_PARSER, parseSpineAssetPayload } from './spine/SpineAssetParser';
+export type { SpineAssetParserInput, SpineParsedAsset } from './spine/SpineAssetParser';
+export { SpineAssetWorkerClient, createInlineSpineAssetWorkerClient, createSpineAssetWorkerClientFromUrl, createSpineAssetWorkerSource, } from './spine/SpineAssetWorkerClient';
+export type { SpineAssetWorker } from './spine/SpineAssetWorkerContract';

package/dist/experimental-spine-worker.js

@@ -0,0 +1,110 @@
+export { S as SPINE_ASSET_PARSER, a as parseSpineAssetPayload } from './chunks/SpineAssetParser-BSDmPge1.js';
+import { WorkerChannel } from '@haiyue/engine/experimental/async';
+import '@haiyue/engine';
+import '@haiyue/engine/core';
+
+class SpineAssetWorkerClient {
+    objectUrl;
+    channel;
+    constructor(worker, objectUrl = null) {
+        this.objectUrl = objectUrl;
+        this.channel = new WorkerChannel(worker, {
+            label: 'Spine asset worker',
+            path: 'spine.worker',
+            context: { resourceType: 'skeleton/spine' },
+        });
+    }
+    loadParsedAsset(jsonUrl, atlasUrl, options = {}) {
+        return this.channel.request('loadParsedSpineAsset', { jsonUrl, atlasUrl }, {
+            ...(options.signal ? { signal: options.signal } : {}),
+            context: { url: jsonUrl },
+            abortMessage: 'Spine load aborted.',
+            validate: isSpineParsedAsset,
+        });
+    }
+    dispose(options = {}) {
+        const alreadyDisposed = this.channel.isDisposed;
+        this.channel.dispose(options);
+        if (!alreadyDisposed && this.objectUrl)
+            URL.revokeObjectURL(this.objectUrl);
+    }
+}
+function isSpineParsedAsset(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    const data = candidate.data;
+    return !!data && typeof data === 'object'
+        && Array.isArray(data.bones)
+        && Array.isArray(candidate.regions);
+}
+function createSpineAssetWorkerSource(extensionSpineModuleUrl) {
+    return `
+const parserModulePromise = import(${JSON.stringify(extensionSpineModuleUrl)});
+const requests = new Map();
+const assetError = (message, code, path, recovery, context, cause) => Object.assign(new Error(message), {
+  domain: 'component', code, path, recovery, recoverable: recovery === 'retry', context, cause,
+});
+self.addEventListener('message', async event => {
+  const request = event.data;
+  if (!request || request.version !== 1 || typeof request.id !== 'number') return;
+  if (request.type === 'cancel') { requests.get(request.id)?.abort('cancelled'); requests.delete(request.id); return; }
+  if (request.type !== 'loadParsedSpineAsset') return;
+  const controller = new AbortController();
+  requests.set(request.id, controller);
+  try {
+    const [parser, jsonResponse, atlasResponse] = await Promise.all([
+      parserModulePromise,
+      fetch(request.jsonUrl, { signal: controller.signal }),
+      request.atlasUrl ? fetch(request.atlasUrl, { signal: controller.signal }) : Promise.resolve(null),
+    ]);
+    if (!jsonResponse.ok) throw assetError(
+      'Failed to load Spine JSON: ' + jsonResponse.status + ' ' + jsonResponse.statusText,
+      'E_ASSET_LOAD_FAILED', 'spine.json', 'retry',
+      { url: request.jsonUrl, resourceType: 'skeleton/spine-json', status: jsonResponse.status },
+    );
+    if (atlasResponse && !atlasResponse.ok) throw assetError(
+      'Failed to load Spine atlas: ' + atlasResponse.status + ' ' + atlasResponse.statusText,
+      'E_ASSET_LOAD_FAILED', 'spine.atlas', 'retry',
+      { url: request.atlasUrl, resourceType: 'skeleton/spine-atlas', status: atlasResponse.status },
+    );
+    let json;
+    try { json = await jsonResponse.json(); }
+    catch (cause) {
+      throw assetError(
+        'Spine JSON is not valid JSON.', 'E_ASSET_INVALID_DATA', 'spine.json', 'release-resource',
+        { url: request.jsonUrl, resourceType: 'skeleton/spine-json' }, cause,
+      );
+    }
+    const value = parser.parseSpineAssetPayload({
+      json,
+      atlasText: atlasResponse ? await atlasResponse.text() : '',
+    });
+    self.postMessage({ version: 1, id: request.id, ok: true, value });
+  } catch (error) {
+    if (controller.signal.aborted) return;
+    const serialized = error && typeof error.toJSON === 'function' ? error.toJSON() : {
+      name: 'EngineError', domain: error && error.domain || 'asset', code: error && error.code || 'E_ASSET_INVALID_DATA',
+      message: error instanceof Error ? error.message : String(error),
+      recovery: error && error.recovery || 'release-resource',
+      recoverable: error && typeof error.recoverable === 'boolean' ? error.recoverable : false,
+      context: Object.assign({ url: request.jsonUrl, resourceType: 'skeleton/spine' }, error && error.context || {}),
+      path: error && error.path || 'spine.parse',
+      cause: error instanceof Error ? { name: error.name, message: error.message, stack: error.stack } : undefined,
+    };
+    self.postMessage({ version: 1, id: request.id, ok: false, error: serialized });
+  } finally { requests.delete(request.id); }
+});
+`.trim();
+}
+function createInlineSpineAssetWorkerClient(extensionSpineModuleUrl, options) {
+    const blob = new Blob([createSpineAssetWorkerSource(extensionSpineModuleUrl)], { type: 'text/javascript' });
+    const url = URL.createObjectURL(blob);
+    return new SpineAssetWorkerClient(new Worker(url, { type: 'module', ...options }), url);
+}
+function createSpineAssetWorkerClientFromUrl(url, options) {
+    return new SpineAssetWorkerClient(new Worker(url, options));
+}
+
+export { SpineAssetWorkerClient, createInlineSpineAssetWorkerClient, createSpineAssetWorkerClientFromUrl, createSpineAssetWorkerSource };
+//# sourceMappingURL=experimental-spine-worker.js.map

package/dist/gltf/GltfAccessorReader.d.ts

@@ -0,0 +1,7 @@
+import type { GltfAsset } from './GltfSchema';
+export declare function readAccessorFloat(gltf: GltfAsset, buffers: ArrayBuffer[], accessorIndex: number, expectedSize: number): Float32Array;
+export declare function readAccessorMat4(gltf: GltfAsset, buffers: ArrayBuffer[], accessorIndex: number): Float32Array[];
+export declare function readAccessorUnsigned(gltf: GltfAsset, buffers: ArrayBuffer[], accessorIndex: number, expectedSize: number): Uint16Array | Uint32Array;
+export declare function readAccessorIndices(gltf: GltfAsset, buffers: ArrayBuffer[], accessorIndex: number): Uint16Array | Uint32Array;
+export declare function generateFlatNormals(positions: Float32Array, indices: Uint16Array | Uint32Array | null): Float32Array;
+export declare function requiredFiniteArrayValue(values: ArrayLike<number>, index: number, label: string): number;

package/dist/gltf/GltfAnimation3DAdapter.d.ts

@@ -0,0 +1,47 @@
+import { type Entity } from '@haiyue/engine';
+import type { Animation3DClip } from '../animation3d/Animation3DClip';
+import { Animation3DMixer } from '../animation3d/Animation3DMixer';
+import type { Animation3DPose } from '../animation3d/Animation3DPose';
+import { Animation3DPoseBuffer } from '../animation3d/Animation3DPoseBuffer';
+import type { LoadedGltfModel } from './GltfLoaderContract';
+export interface GltfAnimation3DRuntimeOptions {
+    /** Cancels and destroys the adapter without taking ownership of the glTF model. */
+    readonly signal?: AbortSignal;
+    /** Stable prefix used when several glTF models share a higher-level clip registry. */
+    readonly clipIdPrefix?: string;
+}
+export type GltfAnimation3DRuntimeState = 'active' | 'destroyed';
+/**
+ * Model-scoped owner combining the existing Animation3D mixer with glTF
+ * binding and pose adapters. It does not own or dispose the LoadedGltfModel.
+ */
+export declare class GltfAnimation3DRuntime {
+    readonly mixer: Animation3DMixer;
+    readonly pose: Animation3DPoseBuffer;
+    private readonly _clips;
+    private readonly _owner;
+    private readonly _resolver;
+    private readonly _poseApplier;
+    private _root;
+    private _state;
+    private readonly _signal;
+    private readonly _abortListener;
+    constructor(model: LoadedGltfModel, options?: GltfAnimation3DRuntimeOptions);
+    get state(): GltfAnimation3DRuntimeState;
+    get root(): Entity | null;
+    get clips(): readonly Animation3DClip[];
+    /** Diagnostic count without exposing the model-specific resolver handle. */
+    get bindingCount(): number;
+    /** Diagnostic count without exposing the model-specific pose-applier handle. */
+    get targetCount(): number;
+    update(deltaSeconds: number): Animation3DPose;
+    evaluate(): Animation3DPose;
+    /** @internal Applies a pose produced by a shared multi-mixer state-machine transaction. */
+    applySynchronizedPose(pose: Animation3DPose): void;
+    setTime(timeSeconds: number): Animation3DPose;
+    destroy(): void;
+    private assertActive;
+}
+export declare function createGltfAnimation3DRuntime(model: LoadedGltfModel, options?: GltfAnimation3DRuntimeOptions): GltfAnimation3DRuntime;
+/** Converts loaded legacy glTF clips without exposing glTF sampler structures. */
+export declare function createGltfAnimation3DClips(model: LoadedGltfModel, clipIdPrefix?: string): readonly Animation3DClip[];

package/dist/gltf/GltfAnimationRuntime.d.ts

@@ -0,0 +1,10 @@
+import { Geometry3D } from '@haiyue/engine';
+import { GltfConservativeBounds } from './GltfConservativeBounds';
+import type { GltfAsset } from './GltfSchema';
+import type { GltfAnimationClip, GltfAnimationTarget, GltfSkinnedPrimitiveRuntime } from './GltfLoaderContract';
+export declare function registerGltfConservativeBounds(geometry: Geometry3D, bounds: GltfConservativeBounds): void;
+export declare function createAnimationClips(gltf: GltfAsset, buffers: ArrayBuffer[], targets: Map<number, GltfAnimationTarget>, skinnedPrimitives: GltfSkinnedPrimitiveRuntime[]): GltfAnimationClip[];
+export declare function applyGltfAnimationClip(clip: GltfAnimationClip, time: number): void;
+export declare function composeTrsMatrix(translation: ArrayLike<number>, rotation: ArrayLike<number>, scale: ArrayLike<number>, out?: Float32Array<ArrayBuffer>): Float32Array;
+export declare function applyMorphWeights(target: GltfAnimationTarget, weights: ArrayLike<number>): void;
+export declare function updateSkinnedPrimitive(runtime: GltfSkinnedPrimitiveRuntime): void;

package/dist/gltf/GltfAssetWorkerClient.d.ts

@@ -0,0 +1,20 @@
+import { type WorkerChannelLike } from '@haiyue/engine/experimental/async';
+import { type DracoDecoderConfig, type GltfAssetWorker } from './GltfLoaderContract';
+type GltfAssetWorkerLike = WorkerChannelLike;
+export declare class GltfAssetWorkerClient implements GltfAssetWorker {
+    private readonly objectUrl;
+    private readonly channel;
+    constructor(worker: GltfAssetWorkerLike, objectUrl?: string | null);
+    loadParsedAsset(src: string, options?: {
+        signal?: AbortSignal;
+        dracoDecoderConfig?: DracoDecoderConfig;
+    }): Promise<Awaited<ReturnType<GltfAssetWorker['loadParsedAsset']>>>;
+    dispose(options?: {
+        terminate?: boolean;
+    }): void;
+}
+/** The worker imports the same production parser used by the main-thread fallback. */
+export declare function createGltfAssetWorkerSource(extensionGltfModuleUrl: string): string;
+export declare function createGltfAssetWorkerClientFromUrl(url: string | URL, options?: WorkerOptions): GltfAssetWorkerClient;
+export declare function createInlineGltfAssetWorkerClient(extensionGltfModuleUrl: string, options?: WorkerOptions): GltfAssetWorkerClient;
+export {};

package/dist/gltf/GltfCompatibilityReport.d.ts

@@ -0,0 +1,70 @@
+import type { Geometry3D } from '@haiyue/engine';
+import type { 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 declare function createGltfCompatibilityReport(gltf: GltfAsset, extensions: readonly GltfCompatibilityExtensionEntry[], primitives: readonly GltfPrimitiveCompatibilityInput[], performance: GltfCompatibilityPerformanceSummary): GltfCompatibilityReport;

package/dist/gltf/GltfConservativeBounds.d.ts

@@ -0,0 +1,18 @@
+import type { Geometry3DLocalBounds } from '@haiyue/engine/geometry';
+import type { GltfAsset, GltfPrimitive } from './GltfSchema';
+/**
+ * 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 declare class GltfConservativeBounds {
+    private readonly _base;
+    private readonly _positionTargets;
+    private _current;
+    private _skinUsageCache;
+    private constructor();
+    static fromPrimitive(gltf: GltfAsset, primitive: GltfPrimitive): GltfConservativeBounds | null;
+    updateMorphWeights(weights: ArrayLike<number>): Geometry3DLocalBounds | null;
+    getSourceBounds(): Geometry3DLocalBounds | null;
+    getSkinnedBounds(jointMatrices: Float32Array, joints?: Float32Array, weights?: Float32Array): Geometry3DLocalBounds | null;
+}

package/dist/gltf/GltfDracoDecoder.d.ts

@@ -0,0 +1,4 @@
+import type { GltfAsset, GltfDracoMeshCompression } from './GltfSchema';
+import type { DracoPrimitiveGeometry, LoadGltfOptions } from './GltfLoaderContract';
+/** Resolves and decodes one KHR_draco_mesh_compression primitive. */
+export declare function decodeDracoPrimitive(gltf: GltfAsset, buffers: ArrayBuffer[], extension: GltfDracoMeshCompression, options: LoadGltfOptions): Promise<DracoPrimitiveGeometry>;

package/dist/gltf/GltfExtensionAdapter.d.ts

@@ -0,0 +1,54 @@
+import type { PbrMaterialState, PbrTextureSlot } from '@haiyue/engine/material';
+import type { GltfAsset, GltfMaterial, GltfPrimitive, GltfTextureInfo } from './GltfSchema';
+export type GltfExtensionSupport = 'supported' | 'partial' | 'unsupported';
+export interface GltfExtensionCapability {
+    readonly support: GltfExtensionSupport;
+    readonly note: string;
+}
+export interface GltfMaterialTextureBinding {
+    readonly slot: PbrTextureSlot;
+    readonly textureInfo: GltfTextureInfo;
+    readonly path: string;
+}
+export interface GltfMaterialExtensionContext {
+    readonly gltf: GltfAsset;
+    readonly material: GltfMaterial;
+    readonly primitive: GltfPrimitive;
+    readonly materialPath: string;
+    readonly extensionData: unknown;
+}
+export type GltfMaterialStatePatch = Readonly<Partial<Omit<PbrMaterialState, 'baseColorTexture' | 'metallicRoughnessTexture' | 'normalTexture' | 'occlusionTexture' | 'emissiveTexture' | 'clearcoatTexture' | 'clearcoatRoughnessTexture' | 'clearcoatNormalTexture' | 'specularTexture' | 'specularColorTexture' | 'sheenColorTexture' | 'sheenRoughnessTexture' | 'transmissionTexture' | 'thicknessTexture' | 'textureMappings' | 'samplers' | 'sampler'>>>;
+export interface GltfMaterialExtensionPatch {
+    /** Pure material parameters. Texture ownership must use `textures`. */
+    readonly state?: GltfMaterialStatePatch;
+    readonly textures?: readonly GltfMaterialTextureBinding[];
+}
+export interface GltfMaterialVariantReference {
+    readonly name: string;
+    readonly materialIndex: number;
+}
+export interface GltfPrimitiveExtensionContext {
+    readonly gltf: GltfAsset;
+    readonly primitive: GltfPrimitive;
+    readonly rootExtensionData: unknown;
+    readonly primitiveExtensionData: unknown;
+}
+/**
+ * A stateless glTF extension adapter. Hooks return declarative patches and
+ * references; resource ownership and concrete material creation stay in the
+ * loader and engine respectively.
+ */
+export interface GltfExtensionAdapter {
+    readonly extension: string;
+    readonly capability: GltfExtensionCapability;
+    readonly extendMaterial?: (context: GltfMaterialExtensionContext) => GltfMaterialExtensionPatch | null;
+    readonly collectMaterialVariantNames?: (gltf: GltfAsset, rootExtensionData: unknown) => readonly string[];
+    readonly collectMaterialVariants?: (context: GltfPrimitiveExtensionContext) => readonly GltfMaterialVariantReference[];
+}
+export declare const DEFAULT_GLTF_EXTENSION_ADAPTERS: readonly GltfExtensionAdapter[];
+/** Resolves an immutable per-load adapter set; user adapters replace defaults by extension id. */
+export declare function resolveGltfExtensionAdapters(customAdapters?: readonly GltfExtensionAdapter[]): readonly GltfExtensionAdapter[];
+export declare function createGltfExtensionCapabilities(adapters: readonly GltfExtensionAdapter[]): Readonly<Record<string, GltfExtensionCapability>>;
+export declare function collectGltfMaterialExtensionPatches(gltf: GltfAsset, material: GltfMaterial | null, primitive: GltfPrimitive, materialPath: string, adapters: readonly GltfExtensionAdapter[]): readonly GltfMaterialExtensionPatch[];
+export declare function collectGltfMaterialVariantReferences(gltf: GltfAsset, primitive: GltfPrimitive, adapters: readonly GltfExtensionAdapter[]): readonly GltfMaterialVariantReference[];
+export declare function collectGltfMaterialVariantNames(gltf: GltfAsset, adapters: readonly GltfExtensionAdapter[]): readonly string[];