@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/animation.d.ts

@@ -0,0 +1,119 @@
+export interface DeterministicAnimationClip {
+    readonly id: string;
+    readonly durationFrames: number;
+    readonly loop: boolean;
+    readonly events?: readonly {
+        readonly frame: number;
+        readonly id: string;
+    }[];
+    readonly tracks?: readonly DeterministicAnimationTrack[];
+    readonly rootMotionTrackId?: string;
+}
+export interface DeterministicAnimationTrack {
+    readonly id: string;
+    readonly keyframes: readonly {
+        readonly frame: number;
+        readonly value: number;
+    }[];
+}
+export interface DeterministicAnimationTransition {
+    readonly from: string;
+    readonly to: string;
+    readonly when: {
+        readonly parameter: string;
+        readonly equals: boolean | number | string;
+    };
+    readonly priority?: number;
+    readonly consumeTrigger?: string;
+    readonly exitFrame?: number;
+    readonly durationFrames?: number;
+}
+export interface DeterministicAnimationState {
+    readonly id: string;
+    readonly clipId: string;
+    readonly blendTree?: {
+        readonly parameter: string;
+        readonly clips: readonly {
+            readonly clipId: string;
+            readonly threshold: number;
+        }[];
+    };
+}
+export interface DeterministicAnimationDescriptor {
+    readonly id: string;
+    readonly initialState: string;
+    readonly clips: readonly DeterministicAnimationClip[];
+    readonly states: readonly DeterministicAnimationState[];
+    readonly transitions: readonly DeterministicAnimationTransition[];
+    readonly layers?: readonly DeterministicAnimationLayer[];
+    readonly eventReconstruction?: 'synchronized' | 'non-synchronized';
+}
+export interface DeterministicAnimationLayer {
+    readonly id: string;
+    readonly stateId: string;
+    readonly weight: number;
+    readonly additive?: boolean;
+}
+export interface DeterministicAnimationRuntimeState {
+    readonly stateId: string;
+    readonly clipFrame: number;
+    readonly parameters: Readonly<Record<string, boolean | number | string>>;
+    readonly consumedTriggers: readonly string[];
+    readonly transitionBlend?: {
+        readonly from: string;
+        readonly to: string;
+        readonly fromClipFrame: number;
+        readonly elapsedFrames: number;
+        readonly durationFrames: number;
+    };
+}
+export interface DeterministicAnimationStepResult {
+    readonly state: DeterministicAnimationRuntimeState;
+    readonly events: readonly {
+        readonly id: string;
+        readonly clipId: string;
+        readonly frame: number;
+    }[];
+    readonly transitionCount: number;
+    readonly exitFrameTransitionCount: number;
+    readonly transitionBlendActive: boolean;
+    readonly sampledPose: Readonly<Record<string, number>>;
+    readonly layerPoses: Readonly<Record<string, Readonly<Record<string, number>>>>;
+    readonly rootMotionDelta: number;
+    readonly blendWeight: number;
+    readonly checksum: string;
+}
+export interface CookedDeterministicAnimation {
+    readonly id: string;
+    readonly bytes: string;
+    readonly hash: string;
+}
+export declare function cookDeterministicAnimation(descriptor: DeterministicAnimationDescriptor): CookedDeterministicAnimation;
+export declare function createDeterministicAnimationRuntimeState(descriptor: DeterministicAnimationDescriptor, parameters?: Readonly<Record<string, boolean | number | string>>): DeterministicAnimationRuntimeState;
+export declare function stepDeterministicAnimation(descriptor: DeterministicAnimationDescriptor, state: DeterministicAnimationRuntimeState, parameterUpdates?: Readonly<Record<string, boolean | number | string>>): DeterministicAnimationStepResult;
+export declare function runDeterministicAnimationFixture(frames: number): {
+    readonly checksum: string;
+    readonly cookedAssetHash: string;
+    readonly transitions: number;
+    readonly exitFrameTransitions: number;
+    readonly transitionBlendFrames: number;
+    readonly triggerLatchCount: number;
+    readonly emittedEvents: number;
+    readonly clipTimeHash: string;
+    readonly normalizedTimeHash: string;
+    readonly poseHash: string;
+    readonly blendWeightHash: string;
+    readonly layerPoseHash: string;
+    readonly rootMotionHash: string;
+    readonly reconstructedEventHash: string;
+    readonly blendTreeFrames: number;
+    readonly layerPoseFrames: number;
+    readonly rootMotionFrames: number;
+    readonly reconstructedEvents: number;
+    readonly rollbackEquivalent: boolean;
+};
+export declare function reconstructDeterministicAnimationEvents(descriptor: DeterministicAnimationDescriptor, snapshot: DeterministicAnimationRuntimeState, startFrame: number, endFrame: number): {
+    readonly events: number;
+    readonly eventHash: string;
+    readonly checksum: string;
+};

package/dist/animation.js

@@ -0,0 +1,488 @@
+import { canonicalStringify, cloneCanonical, defaultChecksum } from './canonical.js';
+export function cookDeterministicAnimation(descriptor) {
+    validateAnimationDescriptor(descriptor);
+    const cooked = {
+        id: descriptor.id,
+        initialState: descriptor.initialState,
+        clips: [...descriptor.clips].sort((left, right) => compareStrings(left.id, right.id)),
+        states: [...descriptor.states].sort((left, right) => compareStrings(left.id, right.id)),
+        transitions: [...descriptor.transitions].sort(compareTransitions),
+        layers: [...(descriptor.layers ?? [])].sort((left, right) => compareStrings(left.id, right.id)),
+        eventReconstruction: descriptor.eventReconstruction ?? 'synchronized',
+    };
+    const bytes = canonicalStringify(cooked);
+    return { id: descriptor.id, bytes, hash: defaultChecksum(bytes) };
+}
+export function createDeterministicAnimationRuntimeState(descriptor, parameters = {}) {
+    validateAnimationDescriptor(descriptor);
+    return {
+        stateId: descriptor.initialState,
+        clipFrame: 0,
+        parameters: cloneCanonical(parameters),
+        consumedTriggers: [],
+        transitionBlend: undefined,
+    };
+}
+export function stepDeterministicAnimation(descriptor, state, parameterUpdates = {}) {
+    const states = new Map(descriptor.states.map((animationState) => [animationState.id, animationState]));
+    const clips = new Map(descriptor.clips.map((clip) => [clip.id, clip]));
+    const parameters = { ...state.parameters, ...parameterUpdates };
+    const currentAnimationState = states.get(state.stateId);
+    if (currentAnimationState === undefined) {
+        throw new Error(`Unknown animation state ${state.stateId}`);
+    }
+    if (!clips.has(currentAnimationState.clipId)) {
+        throw new Error(`Unknown animation clip ${currentAnimationState.clipId}`);
+    }
+    const consumedTriggers = clearReleasedTriggers(descriptor, parameters, state.consumedTriggers);
+    const transition = descriptor.transitions
+        .filter((candidate) => candidate.from === state.stateId)
+        .sort(compareTransitions)
+        .find((candidate) => isAnimationTransitionEligible(candidate, parameters, state.clipFrame, consumedTriggers));
+    const nextStateId = transition?.to ?? state.stateId;
+    const animationState = states.get(nextStateId);
+    if (animationState === undefined) {
+        throw new Error(`Unknown animation state ${nextStateId}`);
+    }
+    const clip = clips.get(animationState.clipId);
+    if (clip === undefined) {
+        throw new Error(`Unknown animation clip ${animationState.clipId}`);
+    }
+    const clipFrame = transition === undefined ? advanceClipFrame(clip, state.clipFrame) : 0;
+    const nextConsumedTriggers = transition?.consumeTrigger === undefined ? consumedTriggers : [...consumedTriggers, transition.consumeTrigger].sort(compareStrings);
+    const transitionBlend = advanceAnimationBlend(state.transitionBlend, transition, state.clipFrame);
+    const previousPose = transition === undefined
+        ? sampleAnimationPose(descriptor, clips, currentAnimationState, state.clipFrame, parameters, undefined)
+        : {};
+    const sampledPose = sampleAnimationPose(descriptor, clips, animationState, clipFrame, parameters, transitionBlend);
+    const layerPoses = sampleAnimationLayers(descriptor, clips, clip, clipFrame, parameters);
+    const rootMotionDelta = rootMotionDeltaForState(descriptor, clips, animationState, previousPose, sampledPose);
+    const blendWeight = transitionBlend === undefined ? 1_000 : Math.trunc((transitionBlend.elapsedFrames * 1_000) / Math.max(1, transitionBlend.durationFrames));
+    const events = (clip.events ?? [])
+        .filter((event) => event.frame === clipFrame)
+        .sort((left, right) => compareStrings(left.id, right.id))
+        .map((event) => ({ id: event.id, clipId: clip.id, frame: clipFrame }));
+    const next = { stateId: nextStateId, clipFrame, parameters, consumedTriggers: nextConsumedTriggers, transitionBlend };
+    return {
+        state: next,
+        events,
+        transitionCount: transition === undefined ? 0 : 1,
+        exitFrameTransitionCount: transition?.exitFrame === undefined ? 0 : 1,
+        transitionBlendActive: transitionBlend !== undefined,
+        sampledPose,
+        layerPoses,
+        rootMotionDelta,
+        blendWeight,
+        checksum: defaultChecksum({ next, events, sampledPose, layerPoses, rootMotionDelta, blendWeight }),
+    };
+}
+export function runDeterministicAnimationFixture(frames) {
+    const descriptor = defaultAnimationDescriptor();
+    const cooked = cookDeterministicAnimation(descriptor);
+    let state = createDeterministicAnimationRuntimeState(descriptor, { moving: false, fire: false });
+    let snapshot = state;
+    let transitions = 0;
+    let exitFrameTransitions = 0;
+    let transitionBlendFrames = 0;
+    let triggerLatchCount = 0;
+    let emittedEvents = 0;
+    const clipFrames = [];
+    const normalizedTimes = [];
+    const poses = [];
+    const layerPoses = [];
+    const blendWeights = [];
+    const rootMotionDeltas = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === Math.floor(frames / 2)) {
+            snapshot = cloneCanonical(state);
+        }
+        const result = stepDeterministicAnimation(descriptor, state, animationFixtureParameters(frame));
+        state = result.state;
+        transitions += result.transitionCount;
+        exitFrameTransitions += result.exitFrameTransitionCount;
+        transitionBlendFrames += result.transitionBlendActive ? 1 : 0;
+        triggerLatchCount += result.state.consumedTriggers.length;
+        emittedEvents += result.events.length;
+        clipFrames.push(state.clipFrame);
+        normalizedTimes.push(normalizeClipTime(descriptor, state));
+        poses.push(result.sampledPose);
+        layerPoses.push(result.layerPoses);
+        blendWeights.push(result.blendWeight);
+        rootMotionDeltas.push(result.rootMotionDelta);
+    }
+    const checksum = defaultChecksum(state);
+    let restored = snapshot;
+    for (let frame = Math.floor(frames / 2); frame < frames; frame += 1) {
+        restored = stepDeterministicAnimation(descriptor, restored, animationFixtureParameters(frame)).state;
+    }
+    const reconstructed = reconstructDeterministicAnimationEvents(descriptor, snapshot, Math.floor(frames / 2), frames);
+    return {
+        checksum,
+        cookedAssetHash: cooked.hash,
+        transitions,
+        exitFrameTransitions,
+        transitionBlendFrames,
+        triggerLatchCount,
+        emittedEvents,
+        clipTimeHash: defaultChecksum(clipFrames),
+        normalizedTimeHash: defaultChecksum(normalizedTimes),
+        poseHash: defaultChecksum(poses),
+        blendWeightHash: defaultChecksum(blendWeights),
+        layerPoseHash: defaultChecksum(layerPoses),
+        rootMotionHash: defaultChecksum(rootMotionDeltas),
+        reconstructedEventHash: reconstructed.eventHash,
+        blendTreeFrames: poses.filter((pose) => Object.prototype.hasOwnProperty.call(pose, 'upper-aim')).length,
+        layerPoseFrames: layerPoses.filter((pose) => stableLayerIds(pose).length > 0).length,
+        rootMotionFrames: rootMotionDeltas.filter((delta) => delta !== 0).length,
+        reconstructedEvents: reconstructed.events,
+        rollbackEquivalent: checksum === defaultChecksum(restored),
+    };
+}
+export function reconstructDeterministicAnimationEvents(descriptor, snapshot, startFrame, endFrame) {
+    let state = cloneCanonical(snapshot);
+    const events = [];
+    for (let frame = startFrame; frame < endFrame; frame += 1) {
+        const result = stepDeterministicAnimation(descriptor, state, animationFixtureParameters(frame));
+        state = result.state;
+        events.push(...result.events.map((event) => ({ frame, id: event.id, clipId: event.clipId })));
+    }
+    return {
+        events: events.length,
+        eventHash: defaultChecksum(events),
+        checksum: defaultChecksum({ state, events }),
+    };
+}
+function animationFixtureParameters(frame) {
+    return {
+        moving: frame % 40 > 5,
+        fire: frame % 31 <= 1,
+        aim: (frame * 7) % 101,
+    };
+}
+function defaultAnimationDescriptor() {
+    return {
+        id: 'humanoid.headless',
+        initialState: 'idle',
+        clips: [
+            { id: 'idle', durationFrames: 60, loop: true, events: [{ frame: 0, id: 'idle-loop' }], rootMotionTrackId: 'root-x', tracks: [{ id: 'root-x', keyframes: [{ frame: 0, value: 0 }, { frame: 59, value: 0 }] }, { id: 'upper-aim', keyframes: [{ frame: 0, value: 0 }, { frame: 59, value: 0 }] }] },
+            { id: 'run', durationFrames: 30, loop: true, events: [{ frame: 15, id: 'footstep' }], rootMotionTrackId: 'root-x', tracks: [{ id: 'root-x', keyframes: [{ frame: 0, value: 0 }, { frame: 29, value: 290 }] }, { id: 'upper-aim', keyframes: [{ frame: 0, value: 50 }, { frame: 29, value: 150 }] }] },
+            { id: 'fire', durationFrames: 12, loop: false, events: [{ frame: 4, id: 'muzzle' }], rootMotionTrackId: 'root-x', tracks: [{ id: 'root-x', keyframes: [{ frame: 0, value: 100 }, { frame: 11, value: 100 }] }, { id: 'upper-aim', keyframes: [{ frame: 0, value: 900 }, { frame: 11, value: 900 }] }] },
+            { id: 'aim-low', durationFrames: 30, loop: true, tracks: [{ id: 'upper-aim', keyframes: [{ frame: 0, value: 100 }, { frame: 29, value: 100 }] }] },
+            { id: 'aim-high', durationFrames: 30, loop: true, tracks: [{ id: 'upper-aim', keyframes: [{ frame: 0, value: 700 }, { frame: 29, value: 700 }] }] },
+        ],
+        states: [
+            { id: 'idle', clipId: 'idle' },
+            {
+                id: 'run',
+                clipId: 'run',
+                blendTree: {
+                    parameter: 'aim',
+                    clips: [
+                        { clipId: 'aim-low', threshold: 0 },
+                        { clipId: 'aim-high', threshold: 100 },
+                    ],
+                },
+            },
+            { id: 'fire', clipId: 'fire' },
+        ],
+        transitions: [
+            { from: 'idle', to: 'run', when: { parameter: 'moving', equals: true }, priority: 1, durationFrames: 3 },
+            { from: 'run', to: 'idle', when: { parameter: 'moving', equals: false }, priority: 1, durationFrames: 3 },
+            { from: 'idle', to: 'fire', when: { parameter: 'fire', equals: true }, priority: 0, consumeTrigger: 'fire', durationFrames: 2 },
+            { from: 'run', to: 'fire', when: { parameter: 'fire', equals: true }, priority: 0, consumeTrigger: 'fire', durationFrames: 2 },
+            { from: 'fire', to: 'idle', when: { parameter: 'fire', equals: false }, priority: 9, exitFrame: 11, durationFrames: 1 },
+        ],
+        layers: [{ id: 'upper-body', stateId: 'run', weight: 500, additive: true }],
+        eventReconstruction: 'synchronized',
+    };
+}
+function validateAnimationDescriptor(descriptor) {
+    const clipIds = uniqueIds(descriptor.clips.map((clip) => clip.id), 'animation clip');
+    const stateIds = uniqueIds(descriptor.states.map((state) => state.id), 'animation state');
+    if (!stateIds.has(descriptor.initialState)) {
+        throw new Error(`Unknown initial animation state ${descriptor.initialState}`);
+    }
+    for (const clip of descriptor.clips) {
+        if (!Number.isInteger(clip.durationFrames) || clip.durationFrames <= 0) {
+            throw new Error(`Animation clip ${clip.id} has invalid duration`);
+        }
+        for (const event of clip.events ?? []) {
+            if (!Number.isInteger(event.frame) || event.frame < 0 || event.frame >= clip.durationFrames) {
+                throw new Error(`Animation clip ${clip.id} has event ${event.id} outside clip duration`);
+            }
+        }
+        uniqueIds((clip.events ?? []).map((event) => event.id), `animation clip ${clip.id} event`);
+        uniqueIds((clip.tracks ?? []).map((track) => track.id), `animation clip ${clip.id} track`);
+        for (const track of clip.tracks ?? []) {
+            if (track.keyframes.length === 0) {
+                throw new Error(`Animation track ${track.id} requires keyframes`);
+            }
+            uniqueIds(track.keyframes.map((keyframe) => String(keyframe.frame)), `animation track ${track.id} keyframe`);
+            for (const keyframe of track.keyframes) {
+                if (!Number.isInteger(keyframe.frame) || keyframe.frame < 0 || keyframe.frame >= clip.durationFrames) {
+                    throw new Error(`Animation track ${track.id} has keyframe outside clip duration`);
+                }
+                if (!Number.isInteger(keyframe.value)) {
+                    throw new Error(`Animation track ${track.id} has unquantized value`);
+                }
+            }
+        }
+        if (clip.rootMotionTrackId !== undefined && !(clip.tracks ?? []).some((track) => track.id === clip.rootMotionTrackId)) {
+            throw new Error(`Animation clip ${clip.id} references missing root motion track ${clip.rootMotionTrackId}`);
+        }
+    }
+    for (const state of descriptor.states) {
+        if (!clipIds.has(state.clipId)) {
+            throw new Error(`Animation state ${state.id} references missing clip ${state.clipId}`);
+        }
+        if (state.blendTree !== undefined) {
+            if (state.blendTree.clips.length < 2) {
+                throw new Error(`Animation state ${state.id} blend tree requires at least two clips`);
+            }
+            for (const entry of state.blendTree.clips) {
+                if (!clipIds.has(entry.clipId)) {
+                    throw new Error(`Animation state ${state.id} blend tree references missing clip ${entry.clipId}`);
+                }
+                if (!Number.isInteger(entry.threshold)) {
+                    throw new Error(`Animation state ${state.id} blend tree threshold must be quantized integer`);
+                }
+            }
+        }
+    }
+    for (const transition of descriptor.transitions) {
+        if (!stateIds.has(transition.from) || !stateIds.has(transition.to)) {
+            throw new Error(`Animation transition ${transition.from}->${transition.to} references missing state`);
+        }
+        if (transition.exitFrame !== undefined && !Number.isInteger(transition.exitFrame)) {
+            throw new Error(`Animation transition ${transition.from}->${transition.to} has invalid exit frame`);
+        }
+        const fromState = descriptor.states.find((state) => state.id === transition.from);
+        const fromClip = descriptor.clips.find((clip) => clip.id === fromState?.clipId);
+        if (transition.exitFrame !== undefined && (transition.exitFrame < 0 || fromClip === undefined || transition.exitFrame >= fromClip.durationFrames)) {
+            throw new Error(`Animation transition ${transition.from}->${transition.to} has invalid exit frame`);
+        }
+        if (transition.durationFrames !== undefined && (!Number.isInteger(transition.durationFrames) || transition.durationFrames < 0)) {
+            throw new Error(`Animation transition ${transition.from}->${transition.to} has invalid duration`);
+        }
+    }
+    uniqueIds((descriptor.layers ?? []).map((candidate) => candidate.id), 'animation layer');
+    for (const layer of descriptor.layers ?? []) {
+        if (!stateIds.has(layer.stateId)) {
+            throw new Error(`Animation layer ${layer.id} references missing state ${layer.stateId}`);
+        }
+        if (!Number.isInteger(layer.weight) || layer.weight < 0 || layer.weight > 1_000) {
+            throw new Error(`Animation layer ${layer.id} has invalid weight`);
+        }
+    }
+    rejectAmbiguousAnimationTransitions(descriptor.transitions);
+}
+function rejectAmbiguousAnimationTransitions(transitions) {
+    const seen = new Set();
+    for (const transition of [...transitions].sort(compareTransitions)) {
+        const key = [
+            transition.from,
+            String(transition.priority ?? 0),
+            transition.when.parameter,
+            transitionWhenValueKey(transition.when.equals),
+            String(transition.exitFrame ?? -1),
+            transition.consumeTrigger ?? '',
+        ].join('|');
+        if (seen.has(key)) {
+            throw new Error(`Ambiguous animation transition from ${transition.from} on ${transition.when.parameter}`);
+        }
+        seen.add(key);
+    }
+}
+function transitionWhenValueKey(value) {
+    return `${typeof value}:${String(value)}`;
+}
+function isAnimationTransitionEligible(transition, parameters, clipFrame, consumedTriggers) {
+    if (parameters[transition.when.parameter] !== transition.when.equals) {
+        return false;
+    }
+    if (transition.exitFrame !== undefined && clipFrame < transition.exitFrame) {
+        return false;
+    }
+    return transition.consumeTrigger === undefined || !consumedTriggers.includes(transition.consumeTrigger);
+}
+function uniqueIds(ids, label) {
+    const sorted = [...ids].sort(compareStrings);
+    const duplicate = sorted.find((id, index) => index > 0 && id === sorted[index - 1]);
+    if (duplicate !== undefined) {
+        throw new Error(`Duplicate ${label} id ${duplicate}`);
+    }
+    return new Set(sorted);
+}
+function clearReleasedTriggers(descriptor, parameters, consumedTriggers) {
+    return consumedTriggers
+        .filter((trigger) => descriptor.transitions.some((transition) => (transition.consumeTrigger === trigger && parameters[transition.when.parameter] === transition.when.equals)))
+        .sort(compareStrings);
+}
+function advanceAnimationBlend(current, transition, fromClipFrame) {
+    if (transition !== undefined) {
+        const durationFrames = transition.durationFrames ?? 0;
+        if (durationFrames <= 0) {
+            return undefined;
+        }
+        return {
+            from: transition.from,
+            to: transition.to,
+            fromClipFrame,
+            elapsedFrames: 0,
+            durationFrames,
+        };
+    }
+    if (current === undefined) {
+        return undefined;
+    }
+    const elapsedFrames = current.elapsedFrames + 1;
+    return elapsedFrames >= current.durationFrames ? undefined : { ...current, elapsedFrames };
+}
+function sampleAnimationPose(descriptor, clips, state, clipFrame, parameters, blend) {
+    const currentPose = state.blendTree === undefined
+        ? sampleClipPose(clips.get(state.clipId), clipFrame)
+        : sampleBlendTreePose(clips, state.blendTree, parameters, clipFrame);
+    if (blend === undefined) {
+        return currentPose;
+    }
+    const fromState = descriptor.states.find((candidate) => candidate.id === blend.from);
+    if (fromState === undefined) {
+        throw new Error(`Animation transition blend references missing state ${blend.from}`);
+    }
+    const fromClip = clips.get(fromState.clipId);
+    if (fromClip === undefined) {
+        throw new Error(`Animation transition blend references missing clip ${fromState.clipId}`);
+    }
+    const fromPose = sampleClipPose(fromClip, blend.fromClipFrame);
+    const weight = Math.trunc((blend.elapsedFrames * 1_000) / Math.max(1, blend.durationFrames));
+    const keys = [...new Set([...stablePoseKeys(fromPose), ...stablePoseKeys(currentPose)])].sort(compareStrings);
+    return Object.fromEntries(keys.map((key) => [
+        key,
+        Math.trunc(((fromPose[key] ?? 0) * (1_000 - weight) + (currentPose[key] ?? 0) * weight) / 1_000),
+    ]));
+}
+function sampleAnimationLayers(descriptor, clips, sourceClip, clipFrame, parameters) {
+    const states = new Map(descriptor.states.map((state) => [state.id, state]));
+    const entries = [...(descriptor.layers ?? [])]
+        .sort((left, right) => compareStrings(left.id, right.id))
+        .map((layer) => {
+        const state = states.get(layer.stateId);
+        if (state === undefined) {
+            throw new Error(`Animation layer ${layer.id} references missing state ${layer.stateId}`);
+        }
+        const layerClip = clips.get(state.clipId);
+        if (layerClip === undefined) {
+            throw new Error(`Animation layer ${layer.id} references missing clip ${state.clipId}`);
+        }
+        const layerFrame = mapClipFrameToLayer(sourceClip, layerClip, clipFrame);
+        const pose = sampleAnimationPose(descriptor, clips, state, layerFrame, parameters, undefined);
+        const weighted = Object.fromEntries(stablePoseKeys(pose).map((key) => [
+            key,
+            Math.trunc((pose[key] * layer.weight) / 1_000),
+        ]));
+        return [layer.id, weighted];
+    });
+    return Object.fromEntries(entries);
+}
+function mapClipFrameToLayer(sourceClip, layerClip, clipFrame) {
+    const sourceDuration = Math.max(1, sourceClip.durationFrames);
+    const layerDuration = Math.max(1, layerClip.durationFrames);
+    return Math.min(layerDuration - 1, Math.trunc((clipFrame * layerDuration) / sourceDuration));
+}
+function sampleBlendTreePose(clips, blendTree, parameters, clipFrame) {
+    const sorted = [...blendTree.clips].sort((left, right) => left.threshold - right.threshold || compareStrings(left.clipId, right.clipId));
+    const first = sorted[0];
+    const last = sorted.at(-1);
+    const rawParameter = parameters[blendTree.parameter];
+    if (typeof rawParameter === 'number' && !Number.isFinite(rawParameter)) {
+        throw new Error(`Animation blend parameter ${blendTree.parameter} must be finite`);
+    }
+    const parameterValue = typeof rawParameter === 'number'
+        ? Math.max(first.threshold, Math.min(last.threshold, rawParameter))
+        : first.threshold;
+    const upperIndex = sorted.findIndex((entry) => entry.threshold >= parameterValue);
+    const lower = upperIndex <= 0 ? first : sorted[upperIndex - 1];
+    const upper = sorted[upperIndex];
+    const weight = Math.trunc(((parameterValue - lower.threshold) * 1_000) / Math.max(1, upper.threshold - lower.threshold));
+    const lowerClip = clips.get(lower.clipId);
+    if (lowerClip === undefined) {
+        throw new Error(`Animation blend tree references missing clip ${lower.clipId}`);
+    }
+    const upperClip = clips.get(upper.clipId);
+    if (upperClip === undefined) {
+        throw new Error(`Animation blend tree references missing clip ${upper.clipId}`);
+    }
+    const lowerPose = sampleClipPose(lowerClip, clipFrame);
+    const upperPose = sampleClipPose(upperClip, clipFrame);
+    const keys = [...new Set([...stablePoseKeys(lowerPose), ...stablePoseKeys(upperPose)])].sort(compareStrings);
+    return Object.fromEntries(keys.map((key) => [
+        key,
+        Math.trunc(((lowerPose[key] ?? 0) * (1_000 - weight) + (upperPose[key] ?? 0) * weight) / 1_000),
+    ]));
+}
+function rootMotionDeltaForState(descriptor, clips, state, previousPose, currentPose) {
+    const clip = clips.get(state.clipId);
+    const trackId = clip?.rootMotionTrackId;
+    if (trackId === undefined) {
+        return 0;
+    }
+    const delta = (currentPose[trackId] ?? 0) - (previousPose[trackId] ?? currentPose[trackId] ?? 0);
+    return descriptor.eventReconstruction === 'non-synchronized' ? 0 : delta;
+}
+function stablePoseKeys(pose) {
+    return Reflect.ownKeys(pose)
+        .filter((key) => typeof key === 'string')
+        .sort(compareStrings);
+}
+function stableLayerIds(layers) {
+    return Reflect.ownKeys(layers)
+        .filter((key) => typeof key === 'string')
+        .sort(compareStrings);
+}
+function sampleClipPose(clip, clipFrame) {
+    const entries = [...(clip.tracks ?? [])]
+        .sort((left, right) => compareStrings(left.id, right.id))
+        .map((track) => [track.id, sampleTrack(track, clipFrame)]);
+    return Object.fromEntries(entries);
+}
+function sampleTrack(track, clipFrame) {
+    const keyframes = [...track.keyframes].sort((left, right) => left.frame - right.frame);
+    let previous = keyframes[0];
+    let next = keyframes.at(-1) ?? previous;
+    for (const keyframe of keyframes) {
+        if (keyframe.frame <= clipFrame) {
+            previous = keyframe;
+        }
+        if (keyframe.frame >= clipFrame) {
+            next = keyframe;
+            break;
+        }
+    }
+    if (previous.frame === next.frame) {
+        return previous.value;
+    }
+    const numerator = clipFrame - previous.frame;
+    const denominator = Math.max(1, next.frame - previous.frame);
+    return Math.trunc(previous.value + ((next.value - previous.value) * numerator) / denominator);
+}
+function normalizeClipTime(descriptor, state) {
+    const animationState = descriptor.states.find((candidate) => candidate.id === state.stateId);
+    const clip = descriptor.clips.find((candidate) => candidate.id === animationState?.clipId);
+    return Math.trunc((state.clipFrame * 1_000_000) / Math.max(1, clip.durationFrames));
+}
+function advanceClipFrame(clip, frame) {
+    const next = frame + 1;
+    if (next < clip.durationFrames) {
+        return next;
+    }
+    return clip.loop ? 0 : clip.durationFrames - 1;
+}
+function compareTransitions(left, right) {
+    return (left.priority ?? 0) - (right.priority ?? 0)
+        || compareStrings(left.from, right.from)
+        || compareStrings(left.to, right.to)
+        || compareStrings(left.when.parameter, right.when.parameter);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}