@haiyue/extensions 0.1.0

package/dist/spine/Spine2DComponent.d.ts

@@ -0,0 +1,116 @@
+import { Component } from '@haiyue/engine';
+export interface Spine2DComponentOptions {
+    jsonUrl?: string;
+    atlasUrl?: string;
+    imageUrl?: string;
+    imageUrls?: Record<string, string>;
+    skin?: string;
+    animation?: string;
+    loop?: boolean;
+    timeScale?: number;
+    scale?: number;
+    premultipliedAlpha?: boolean;
+    debugMesh?: boolean;
+    debugBones?: boolean;
+    mixDuration?: number;
+}
+export type Spine2DStatus = 'idle' | 'loading' | 'loaded' | 'error';
+export declare class Spine2DComponent extends Component {
+    static UniqueCheckType: number;
+    static UniqueSymbol: symbol;
+    static editor: {
+        fields: {
+            jsonUrl: {
+                type: string;
+                label: string;
+            };
+            atlasUrl: {
+                type: string;
+                label: string;
+            };
+            imageUrl: {
+                type: string;
+                label: string;
+            };
+            skin: {
+                type: string;
+                label: string;
+            };
+            animation: {
+                type: string;
+                label: string;
+            };
+            loop: {
+                type: string;
+                label: string;
+            };
+            timeScale: {
+                type: string;
+                label: string;
+                step: number;
+            };
+            scale: {
+                type: string;
+                label: string;
+                min: number;
+                step: number;
+            };
+            premultipliedAlpha: {
+                type: string;
+                label: string;
+            };
+            debugMesh: {
+                type: string;
+                label: string;
+            };
+            debugBones: {
+                type: string;
+                label: string;
+            };
+            mixDuration: {
+                type: string;
+                label: string;
+                min: number;
+                step: number;
+            };
+        };
+    };
+    private _jsonUrl;
+    private _atlasUrl;
+    private _imageUrl;
+    private _imageUrls;
+    private _imageUrlsKey;
+    private _skin;
+    private _sourceKey;
+    private _sourceKeyDirty;
+    animation: string;
+    loop: boolean;
+    timeScale: number;
+    scale: number;
+    premultipliedAlpha: boolean;
+    debugMesh: boolean;
+    debugBones: boolean;
+    mixDuration: number;
+    status: Spine2DStatus;
+    error: string | null;
+    elapsed: number;
+    previousAnimation: string;
+    previousElapsed: number;
+    mixElapsed: number;
+    runtimeKey: string;
+    loadingKey: string;
+    constructor(options?: Spine2DComponentOptions);
+    get jsonUrl(): string;
+    set jsonUrl(value: string);
+    get atlasUrl(): string;
+    set atlasUrl(value: string);
+    get imageUrl(): string;
+    set imageUrl(value: string);
+    get imageUrls(): Record<string, string>;
+    set imageUrls(value: Record<string, string>);
+    get skin(): string;
+    set skin(value: string);
+    get sourceKey(): string;
+    invalidateSourceKey(refreshImageUrlsKey?: boolean): this;
+    clone(): Spine2DComponent;
+}

package/dist/spine/Spine2DGpuRenderer.d.ts

@@ -0,0 +1,65 @@
+import { type IEngine } from '@haiyue/engine/extension-authoring';
+import { Spine2DComponent } from './Spine2DComponent';
+import { SpineFloatBuilder } from './SpineFloatBuilder';
+import { type AtlasRegion } from './SpineAtlasParser';
+import { type SpineDrawBatch } from './SpineVertexBuilder';
+export interface SpineBufferDirtyRange {
+    byteOffset: number;
+    byteLength: number;
+}
+export interface AtlasPageGpu {
+    image: HTMLImageElement;
+    texture: GPUTexture;
+    textureBindGroup: GPUBindGroup;
+    width: number;
+    height: number;
+}
+export interface SpineRuntimeGpu {
+    pages: Map<string, AtlasPageGpu>;
+    vertexBuffer: GPUBuffer;
+    vertexBufferSize: number;
+    debugVertexBuffer: GPUBuffer;
+    debugVertexBufferSize: number;
+    batches: SpineDrawBatch[];
+    mergedDirtyRanges: SpineBufferDirtyRange[];
+    mergedDirtyRangePool: SpineBufferDirtyRange[];
+    allocationStats: {
+        dirtyRangePoolMisses: number;
+    };
+}
+export interface SpineRuntimeGpuBuffers {
+    vertexBuffer: GPUBuffer;
+    vertexBufferSize: number;
+    debugVertexBuffer: GPUBuffer;
+    debugVertexBufferSize: number;
+}
+export declare class Spine2DGpuRenderer {
+    private engine;
+    private cameraGpu;
+    private textureGpu;
+    private objectLayoutGpu;
+    private shaderModule;
+    private pipelineLayout;
+    private readonly pipelines;
+    private reverseZ;
+    private sampleCount;
+    private readonly pendingBufferDestroys;
+    get cameraBuffer(): GPUBuffer;
+    get objectLayout(): GPUBindGroupLayout;
+    prepare(engine: IEngine): void;
+    destroy(): void;
+    setRenderView(reverseZ: boolean, sampleCount: 1 | 4): void;
+    createRuntimeBuffers(): SpineRuntimeGpuBuffers;
+    loadAtlasPages(component: Spine2DComponent, atlas: Map<string, AtlasRegion>): Promise<Map<string, AtlasPageGpu>>;
+    writeVertices(runtime: SpineRuntimeGpu, vertices: SpineFloatBuilder, dirtyRanges: SpineBufferDirtyRange[]): void;
+    writeDebugVertices(runtime: SpineRuntimeGpu, vertices: SpineFloatBuilder, dirtyRanges: SpineBufferDirtyRange[]): void;
+    drawRuntime(pass: GPURenderPassEncoder, runtime: SpineRuntimeGpu, objectBindGroup: GPUBindGroup, debugVertexCount: number): void;
+    destroyRuntime(runtime: SpineRuntimeGpu): void;
+    private destroyAtlasPage;
+    private getPipeline;
+    private writeDirtyRanges;
+    private deferBufferDestroy;
+    private flushPendingBufferDestroys;
+    private requireEngine;
+    private requirePrepared;
+}

package/dist/spine/Spine2DRenderSystem.d.ts

@@ -0,0 +1,27 @@
+import { type IEngine, type RenderCommandContext, type RenderPipelineEntryOptions } from '@haiyue/engine/extension-authoring';
+import { Entity, type World } from '@haiyue/engine/ecs';
+import type { SpineAssetWorker } from './SpineAssetWorkerContract';
+import { RenderSystem2DBase, type RenderSystem2DBaseOptions } from '../utils/RenderSystem2DBase';
+export interface Spine2DRenderSystemOptions extends RenderSystem2DBaseOptions {
+    assetWorker?: SpineAssetWorker | null;
+}
+export declare class Spine2DRenderSystem extends RenderSystem2DBase {
+    private gpuRenderer;
+    private runtimes;
+    private entityGpu;
+    private readonly liveComponents;
+    private readonly pendingLoads;
+    private readonly assetWorker;
+    private disposed;
+    get renderPipelineOptions(): RenderPipelineEntryOptions;
+    constructor(engine: IEngine, cameraEntity: Entity, options?: Spine2DRenderSystemOptions);
+    record(world: World, delta: number, context: RenderCommandContext): this;
+    destroy(): this;
+    protected releaseGpuResourcesForRecovery(): void;
+    protected restoreGpuResourcesAfterRecovery(): void;
+    private getEntityGpu;
+    private releaseRuntimesNotIn;
+    private destroyEntityGpu;
+    private destroyRuntime;
+    private ensureRuntime;
+}

package/dist/spine/Spine2DRuntime.d.ts

@@ -0,0 +1,103 @@
+import { Spine2DComponent } from './Spine2DComponent';
+import { Spine2DGpuRenderer, type AtlasPageGpu, type SpineBufferDirtyRange } from './Spine2DGpuRenderer';
+import { SpineFloatBuilder } from './SpineFloatBuilder';
+import { type AtlasRegion } from './SpineAtlasParser';
+import { type SpinePathConstraintScratch } from './SpinePathConstraintSolver';
+import { type SpineDrawBatch, type SpineSlotGeometryCache } from './SpineVertexBuilder';
+import { type BonePose, type IkConstraintData, type PathConstraintData, type SliderAnimationState, type SliderConstraintData, type SlotData, type SpineData, type TransformConstraintData } from './SpineSkeletonRuntime';
+import { type SpineTimelineCompileStats, type SpineTimelineSamplerState } from './SpineTimelineRuntime';
+import type { SpineAssetWorker } from './SpineAssetWorkerContract';
+export interface SpineVertexBuild {
+    vertices: SpineFloatBuilder;
+    batches: SpineDrawBatch[];
+    debugVertices: SpineFloatBuilder;
+    vertexDirtyRanges: SpineBufferDirtyRange[];
+    debugDirtyRanges: SpineBufferDirtyRange[];
+    verticesChanged: boolean;
+    debugVerticesChanged: boolean;
+}
+export interface SpineRuntimeAllocationStats {
+    slotRegionGrowths: number;
+    batchPoolMisses: number;
+    dirtyRangePoolMisses: number;
+}
+type SpineConstraintEntry = {
+    type: 'ik';
+    order: number;
+    constraint: IkConstraintData;
+} | {
+    type: 'path';
+    order: number;
+    constraint: PathConstraintData;
+} | {
+    type: 'transform';
+    order: number;
+    constraint: TransformConstraintData;
+};
+export interface SpineRuntime extends SpinePathConstraintScratch {
+    data: SpineData;
+    atlas: Map<string, AtlasRegion>;
+    pages: Map<string, AtlasPageGpu>;
+    vertexBuffer: GPUBuffer;
+    vertexBufferSize: number;
+    debugVertexBuffer: GPUBuffer;
+    debugVertexBufferSize: number;
+    batches: SpineDrawBatch[];
+    batchPool: SpineDrawBatch[];
+    vertexBuilder: SpineFloatBuilder;
+    debugVertexBuilder: SpineFloatBuilder;
+    slotVertexBuilder: SpineFloatBuilder;
+    slotDebugVertexBuilder: SpineFloatBuilder;
+    clipBuilder: SpineFloatBuilder;
+    meshPointBuilder: SpineFloatBuilder;
+    slotGeometryCache: Map<string, SpineSlotGeometryCache>;
+    slotOrderHash: number;
+    boneChildren: Map<string, string[]>;
+    setupPoses: Map<string, BonePose>;
+    previousSetupPoses: Map<string, BonePose>;
+    slotIndexByName: Map<string, number>;
+    slotCacheKeyByName: Map<string, string>;
+    sliderConstraintsByOrder: SliderConstraintData[];
+    sortedConstraintsBySkin: Map<string, SpineConstraintEntry[]>;
+    transformConstraintBoneSets: WeakMap<TransformConstraintData, Set<string>>;
+    transformWorldSpaceBonesScratch: string[];
+    drawOrderScratch: number[];
+    unchangedSlotScratch: number[];
+    orderedSlotScratch: SlotData[];
+    liveSlotKeys: Set<string>;
+    slotEntries: SpineSlotGeometryCache[];
+    changedVertexEntries: SpineSlotGeometryCache[];
+    changedDebugEntries: SpineSlotGeometryCache[];
+    sliderStateScratch: SliderAnimationState[];
+    sliderStatePool: SliderAnimationState[];
+    vertexDirtyRanges: SpineBufferDirtyRange[];
+    debugDirtyRanges: SpineBufferDirtyRange[];
+    mergedDirtyRanges: SpineBufferDirtyRange[];
+    vertexDirtyRangePool: SpineBufferDirtyRange[];
+    debugDirtyRangePool: SpineBufferDirtyRange[];
+    mergedDirtyRangePool: SpineBufferDirtyRange[];
+    vertexBuildResult: SpineVertexBuild;
+    slotColorScratch: [number, number, number, number];
+    sliderColorScratch: [number, number, number, number];
+    vertexColorScratch: [number, number, number, number];
+    timelineCompileStats: SpineTimelineCompileStats;
+    timelineSamplerState: SpineTimelineSamplerState;
+    allocationStats: SpineRuntimeAllocationStats;
+    ikStateScratch: {
+        mix: number;
+        softness: number;
+        bendPositive: boolean;
+    };
+    transformStateScratch: Pick<TransformConstraintData, 'mixRotate' | 'mixX' | 'mixY' | 'mixScaleX' | 'mixScaleY' | 'mixShearY'>;
+}
+export declare function advanceSpineRuntime(component: Spine2DComponent, delta: number): void;
+export declare function buildSpineVertices(component: Spine2DComponent, runtime: SpineRuntime): SpineVertexBuild;
+export declare function loadSpineRuntime(gpuRenderer: Spine2DGpuRenderer, component: Spine2DComponent, options?: {
+    assetWorker?: SpineAssetWorker | null;
+    signal?: AbortSignal;
+}): Promise<SpineRuntime>;
+/** Monorepo benchmark adapter; not re-exported from the Spine package facade. */
+export declare function createSpineRuntimeForBenchmark(data: SpineData, atlas: Map<string, AtlasRegion>, pages: Map<string, AtlasPageGpu>): SpineRuntime;
+/** Monorepo benchmark adapter; samples the complete animation/constraint pose path. */
+export declare function sampleSpinePosesForBenchmark(component: Spine2DComponent, runtime: SpineRuntime): number;
+export {};

package/dist/spine/SpineAnimationBoneTimelines.d.ts

@@ -0,0 +1,8 @@
+import type { SpineAnimationBoneTimelines, SpineAnimationData } from './SpineSkeletonRuntime';
+interface SpineAnimationBoneTimelineEntry {
+    boneName: string;
+    timelines: SpineAnimationBoneTimelines;
+}
+export declare function compileAnimationBoneTimelines(animations: Record<string, SpineAnimationData>): void;
+export declare function getAnimationBoneTimelines(animation: SpineAnimationData | undefined): SpineAnimationBoneTimelineEntry[];
+export {};

package/dist/spine/SpineAssetParser.d.ts

@@ -0,0 +1,18 @@
+import { type AtlasRegion } from './SpineAtlasParser';
+export interface SpineAssetParserInput {
+    json: unknown;
+    atlasText: string;
+}
+/** Structured-clone-safe parser boundary; the runtime validates and narrows this payload before use. */
+export interface SpineParsedAsset {
+    data: unknown;
+    regions: Array<[string, AtlasRegion]>;
+}
+export declare const SPINE_ASSET_PARSER: Readonly<{
+    type: "skeleton/spine";
+    parse(input: SpineAssetParserInput, _context?: {
+        signal?: AbortSignal;
+        source?: string;
+    }): SpineParsedAsset;
+}>;
+export declare function parseSpineAssetPayload(input: SpineAssetParserInput): SpineParsedAsset;

package/dist/spine/SpineAssetWorkerClient.d.ts

@@ -0,0 +1,19 @@
+import { type WorkerChannelLike } from '@haiyue/engine/experimental/async';
+import type { SpineParsedAsset } from './SpineAssetParser';
+import type { SpineAssetWorker } from './SpineAssetWorkerContract';
+type SpineWorkerLike = WorkerChannelLike;
+export declare class SpineAssetWorkerClient implements SpineAssetWorker {
+    private readonly objectUrl;
+    private readonly channel;
+    constructor(worker: SpineWorkerLike, objectUrl?: string | null);
+    loadParsedAsset(jsonUrl: string, atlasUrl: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<SpineParsedAsset>;
+    dispose(options?: {
+        terminate?: boolean;
+    }): void;
+}
+export declare function createSpineAssetWorkerSource(extensionSpineModuleUrl: string): string;
+export declare function createInlineSpineAssetWorkerClient(extensionSpineModuleUrl: string, options?: WorkerOptions): SpineAssetWorkerClient;
+export declare function createSpineAssetWorkerClientFromUrl(url: string | URL, options?: WorkerOptions): SpineAssetWorkerClient;
+export {};

package/dist/spine/SpineAssetWorkerContract.d.ts

@@ -0,0 +1,6 @@
+/** Stable structural seam for optional Spine parsing offload. */
+export interface SpineAssetWorker {
+    loadParsedAsset(jsonUrl: string, atlasUrl: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<unknown>;
+}

package/dist/spine/SpineAtlasParser.d.ts

@@ -0,0 +1,21 @@
+export interface AtlasRegion {
+    name: string;
+    page: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    originalWidth: number;
+    originalHeight: number;
+    offsetX: number;
+    offsetY: number;
+    rotate: number;
+}
+export interface ResolveAtlasPageImageOptions {
+    atlasUrl: string;
+    imageUrl: string;
+    imageUrls: Record<string, string>;
+}
+export declare function parseAtlas(text: string): Map<string, AtlasRegion>;
+export declare function resolveAtlasPageImageUrl(options: ResolveAtlasPageImageOptions, atlas: Map<string, AtlasRegion>, page: string): string;
+export declare function atlasPageCount(atlas: Map<string, AtlasRegion>): number;

package/dist/spine/SpineFloatBuilder.d.ts

@@ -0,0 +1,15 @@
+export declare class SpineFloatBuilder {
+    data: Float32Array;
+    length: number;
+    constructor(initialCapacity?: number);
+    clear(): void;
+    get byteLength(): number;
+    get(index: number): number;
+    push(...values: number[]): void;
+    push8(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
+    appendArray(values: ArrayLike<number>, length?: number): void;
+    truncate(length: number): void;
+    /** Grows storage if needed and exposes a reusable writable region without allocating a temporary array. */
+    reserveLength(length: number): void;
+    private ensureCapacity;
+}

package/dist/spine/SpinePathConstraintSolver.d.ts

@@ -0,0 +1,32 @@
+import { Spine2DComponent } from './Spine2DComponent';
+import { type BonePose, type PathConstraintData, type SpineData } from './SpineSkeletonRuntime';
+import { type SpineTimelineSamplerState } from './SpineTimelineRuntime';
+export interface SpinePathConstraintScratch {
+    pathBonesScratch: BonePose[];
+    pathConstrainedBonesScratch: Set<string>;
+    pathSpacesScratch: number[];
+    pathLengthsScratch: number[];
+    pathWorldScratch: number[];
+    pathOutScratch: number[];
+    pathCurveWorldScratch: number[];
+    pathCurvesScratch: number[];
+    pathSegmentsScratch: number[];
+    pathCurvePointScratch: number[];
+    pathStateScratch: {
+        position: number;
+        spacing: number;
+        mixRotate: number;
+        mixX: number;
+        mixY: number;
+    };
+}
+export interface SpinePathConstraintRuntime extends SpinePathConstraintScratch {
+    data: SpineData;
+    timelineSamplerState: SpineTimelineSamplerState;
+}
+export interface SpinePathConstraintDeps {
+    normalizeRadians(value: number): number;
+    updateDescendantBoneTrees(name: string, poses: Map<string, BonePose>, children: Map<string, string[]>, blockedRoots?: Set<string>): void;
+}
+export declare function createSpinePathConstraintScratch(): SpinePathConstraintScratch;
+export declare function applyPathConstraint(runtime: SpinePathConstraintRuntime, component: Spine2DComponent, constraint: PathConstraintData, time: number, duration: number, loop: boolean, poses: Map<string, BonePose>, children: Map<string, string[]>, deps: SpinePathConstraintDeps): void;

package/dist/spine/SpinePlugin.d.ts

@@ -0,0 +1,8 @@
+import type { EnginePlugin } from '@haiyue/engine/core';
+import type { RenderPipelineEntryOptions } from '@haiyue/engine/extension-authoring';
+import { type Spine2DRenderSystemOptions } from './Spine2DRenderSystem';
+export interface SpinePluginOptions {
+    system?: Spine2DRenderSystemOptions;
+    render?: RenderPipelineEntryOptions | false | null;
+}
+export declare function createSpinePlugin(options?: SpinePluginOptions): EnginePlugin;

package/dist/spine/SpineSkeletonRuntime.d.ts

@@ -0,0 +1,185 @@
+export interface BoneData {
+    name: string;
+    parent?: string;
+    inherit?: string;
+    x: number;
+    y: number;
+    rotation: number;
+    shearX: number;
+    shearY: number;
+    scaleX: number;
+    scaleY: number;
+    length: number;
+}
+export interface IkConstraintData {
+    name: string;
+    order: number;
+    skin: boolean;
+    bones: string[];
+    target: string;
+    mix: number;
+    softness: number;
+    bendPositive: boolean;
+}
+export interface TransformConstraintData {
+    name: string;
+    order: number;
+    skin: boolean;
+    bones: string[];
+    target: string;
+    rotation: number;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    shearY: number;
+    mixRotate: number;
+    mixX: number;
+    mixY: number;
+    mixScaleX: number;
+    mixScaleY: number;
+    mixShearY: number;
+    localSource: boolean;
+    localTarget: boolean;
+    additive: boolean;
+}
+export interface PathConstraintData {
+    name: string;
+    order: number;
+    skin: boolean;
+    bones: string[];
+    slot: string;
+    position: number;
+    spacing: number;
+    mixRotate: number;
+    mixX: number;
+    mixY: number;
+    positionMode: string;
+    spacingMode: string;
+    rotateMode: string;
+    offsetRotation: number;
+}
+export interface SliderConstraintData {
+    name: string;
+    order: number;
+    skin: boolean;
+    animation: string;
+    bone?: string;
+    property: string;
+    scale: number;
+    offset: number;
+    loop: boolean;
+    local: boolean;
+    mix: number;
+}
+export interface SlotData {
+    name: string;
+    bone: string;
+    attachment?: string;
+    color?: [number, number, number, number];
+    blend: 'normal' | 'additive' | string;
+}
+export interface RegionAttachment {
+    type?: string;
+    name: string;
+    path: string;
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    width: number;
+    height: number;
+    color?: [number, number, number, number];
+    uvs?: number[];
+    triangles?: number[];
+    vertices?: number[];
+    vertexCount?: number;
+    lengths?: number[];
+    sequence?: {
+        count?: number;
+        start?: number;
+        digits?: number;
+        setup?: number;
+    };
+    closed?: boolean;
+    constantSpeed?: boolean;
+    end?: string;
+    skin?: string;
+    source?: string;
+}
+export interface SpineAnimationBoneTimelines {
+    rotate?: unknown[];
+    translate?: unknown[];
+    scale?: unknown[];
+    shear?: unknown[];
+    [timeline: string]: unknown;
+}
+export interface SpineAnimationData {
+    bones?: Record<string, SpineAnimationBoneTimelines>;
+    slots?: Record<string, {
+        attachment?: Array<{
+            time?: number;
+            name?: string | null;
+        }>;
+        rgba?: unknown[];
+        [timeline: string]: unknown;
+    }>;
+    attachments?: Record<string, Record<string, Record<string, {
+        sequence?: unknown[];
+    }>>>;
+    ik?: Record<string, unknown[]>;
+    transform?: Record<string, unknown[]>;
+    path?: Record<string, unknown[]>;
+    slider?: Record<string, {
+        mix?: unknown[];
+    }>;
+    drawOrder?: Array<{
+        time?: number;
+        offsets?: Array<{
+            slot: string;
+            offset?: number;
+        }>;
+    }>;
+    [timeline: string]: unknown;
+}
+export interface SpineData {
+    bones: BoneData[];
+    ik: IkConstraintData[];
+    transform: TransformConstraintData[];
+    path: PathConstraintData[];
+    sliders: SliderConstraintData[];
+    slots: SlotData[];
+    skins: Record<string, Record<string, Record<string, RegionAttachment>>>;
+    skinConstraints: Record<string, {
+        ik: string[];
+        transform: string[];
+        path: string[];
+        slider: string[];
+    }>;
+    animations: Record<string, SpineAnimationData>;
+}
+export interface BonePose {
+    data: BoneData;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    worldX: number;
+    worldY: number;
+    rotation: number;
+    shearX: number;
+    shearY: number;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+}
+export interface SliderAnimationState {
+    animation: string;
+    time: number;
+    loop: boolean;
+    mix: number;
+}
+export declare function normalizeSpineData(input: unknown): SpineData;
+export declare function parseColor(value?: string): [number, number, number, number] | undefined;

package/dist/spine/SpineSlotAnimation.d.ts

@@ -0,0 +1,17 @@
+import type { Spine2DComponent } from './Spine2DComponent';
+import type { RegionAttachment, SliderAnimationState, SlotData, SpineData } from './SpineSkeletonRuntime';
+import { type SpineTimelineSamplerState } from './SpineTimelineRuntime';
+interface SpineSlotAnimationRuntime {
+    readonly data: SpineData;
+    readonly timelineSamplerState: SpineTimelineSamplerState;
+    readonly slotColorScratch: [number, number, number, number];
+    readonly sliderColorScratch: [number, number, number, number];
+}
+type SpineSlotAnimationComponent = Pick<Spine2DComponent, 'animation' | 'skin'>;
+/** Resolves the active slot attachment timeline without owning pose evaluation. */
+export declare function getSpineSlotAttachmentName(runtime: SpineSlotAnimationRuntime, component: SpineSlotAnimationComponent, slot: SlotData, time: number): string | null;
+/** Resolves sequence attachments across the base animation and slider overlays. */
+export declare function getSpineAttachmentRegionName(runtime: SpineSlotAnimationRuntime, component: SpineSlotAnimationComponent, slot: SlotData, attachmentName: string, attachment: RegionAttachment, time: number, sliderStates: readonly SliderAnimationState[]): string;
+/** Samples slot RGBA timelines and slider blends into runtime-owned scratch storage. */
+export declare function getSpineSlotColor(runtime: SpineSlotAnimationRuntime, component: SpineSlotAnimationComponent, slot: SlotData, time: number, sliderStates: readonly SliderAnimationState[]): [number, number, number, number];
+export {};

package/dist/spine/SpineTimelineRuntime.d.ts

@@ -0,0 +1,25 @@
+interface SpineTimelineCursor {
+    intervalCursor: number;
+    intervalTime: number;
+    discreteCursor: number;
+    discreteTime: number;
+}
+/** Runtime-local playback cursors; compiled timeline TypedArrays remain immutable and shareable. */
+export interface SpineTimelineSamplerState {
+    readonly cursors: WeakMap<object, SpineTimelineCursor>;
+    cursorMisses: number;
+}
+export interface SpineTimelineCompileStats {
+    readonly timelineCount: number;
+    readonly frameCount: number;
+    readonly numericChannelCount: number;
+}
+export declare function createSpineTimelineSamplerState(): SpineTimelineSamplerState;
+/** Eagerly compiles every frame array reachable from the animation tree. */
+export declare function compileSpineTimelines(animations: Record<string, unknown>, samplerState?: SpineTimelineSamplerState): SpineTimelineCompileStats;
+export declare function getCompiledAnimationDuration(animation: unknown): number;
+export declare function sampleCompiledTimeline(frames: unknown[], time: number, key: string, fallback: number, _duration?: number, _loop?: boolean, samplerState?: SpineTimelineSamplerState): number;
+/** Returns the last frame whose time is <= sample time, or -1 before the first frame. */
+export declare function findCompiledFrameIndex(frames: unknown[] | undefined, time: number, samplerState?: SpineTimelineSamplerState): number;
+export declare function sampleCompiledColor(frames: unknown[], time: number, fallback: ArrayLike<number>, out: [number, number, number, number], samplerState?: SpineTimelineSamplerState): [number, number, number, number];
+export {};