@vgai/engine 0.5.15 → 0.5.16

package/dist/adapter/system-seam-contract.d.ts

@@ -0,0 +1,354 @@
+/** Exhaustive proof requirements for mounted SystemAdapters. A bound slot is
+ * availability, not success: each nested operation has its own required proof
+ * stage and therefore cannot hide behind `active[slot] != null`. */
+import { type SeamShape } from './seam-evidence';
+import type { SystemAdapters } from './system-adapter';
+export declare const SYSTEM_ADAPTERS_SHAPE: {
+    readonly physics: {
+        readonly optional: true;
+        readonly kind: "value";
+        readonly required: "effect";
+    };
+    readonly networking: {
+        readonly optional: true;
+        readonly kind: "value";
+        readonly required: "operation";
+    };
+    readonly navigation: {
+        readonly optional: true;
+        readonly kind: "value";
+        readonly required: "operation";
+    };
+    readonly audio: {
+        readonly optional: true;
+        readonly kind: "value";
+        readonly required: "effect";
+    };
+    readonly camera: {
+        readonly optional: true;
+        readonly kind: "value";
+        readonly required: "effect";
+    };
+    readonly debug: {
+        readonly optional: true;
+        readonly kind: "value";
+        readonly required: "operation";
+    };
+    readonly renderDebug: {
+        readonly optional: true;
+        readonly kind: "value";
+        readonly required: "effect";
+    };
+};
+export declare const PHYSICS_ADAPTER_SHAPE: {
+    readonly keyedBy: {
+        readonly optional: true;
+        readonly kind: "value";
+        readonly required: "shape";
+    };
+    readonly ownerOf: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly freeze: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly commit: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly unfreeze: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly debugDraw: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly setDebugDrawEnabled: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly contactPoints: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly colliders: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly previewCollider: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly joints: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly previewJointAnchor: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+};
+export declare const PHYSICS_2D_ADAPTER_SHAPE: {
+    readonly keyedBy: {
+        readonly optional: false;
+        readonly kind: "value";
+        readonly required: "shape";
+    };
+    readonly ownerOf: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly freeze: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly commit: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly unfreeze: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+};
+export declare const NETWORKING_ADAPTER_SHAPE: {
+    readonly peers: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly networkId: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly authority: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly editable: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly getConnectionState: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly getRoomInfo: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly getReplicationStats: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly subscribe: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly getStateSnapshot: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly messageEvents: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly getRates: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly getConditioning: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly setConditioning: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly getServerConfig: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly getPlayerIdentity: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly setPlayerIdentity: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+};
+export declare const NAVIGATION_ADAPTER_SHAPE: {
+    readonly hasNavMesh: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly findPath: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly debugMesh: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly bake: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly exportData: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly clear: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly crowdAgents: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+};
+export declare const AUDIO_ADAPTER_SHAPE: {
+    readonly resume: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly setMuted: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly isMuted: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly graphSnapshot: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly transportState: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly acquireMeters: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly acquireRecordingStream: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly audioEvents: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+};
+export declare const CAMERA_ADAPTER_SHAPE: {
+    readonly snapshot: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly subscribe: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+};
+export declare const DEBUG_ADAPTER_SHAPE: {
+    readonly providers: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly state: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly stateAll: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly commands: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+    readonly invoke: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly events: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+};
+export declare const RENDER_DEBUG_ADAPTER_SHAPE: {
+    readonly captureFrame: {
+        readonly optional: false;
+        readonly kind: "function";
+        readonly required: "effect";
+    };
+    readonly memorySnapshot: {
+        readonly optional: true;
+        readonly kind: "function";
+        readonly required: "operation";
+    };
+};
+type NonPhysicsSystemSlot = Exclude<keyof SystemAdapters, 'physics'>;
+export declare const SYSTEM_PROVIDER_SHAPES: {
+    readonly [K in NonPhysicsSystemSlot]: SeamShape<NonNullable<SystemAdapters[K]>>;
+};
+export {};
+//# sourceMappingURL=system-seam-contract.d.ts.map

package/dist/adapter/system-seam-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-seam-contract.d.ts","sourceRoot":"","sources":["../../src/adapter/system-seam-contract.ts"],"names":[],"mappings":"AAAA;;oEAEoE;AAGpE,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,KAAK,EAQV,cAAc,EACf,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQhC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAahC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;CAMnC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBnC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQnC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;CAG/B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAO9B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;CAGrC,CAAC;AAEH,KAAK,oBAAoB,GAAG,OAAO,CAAC,MAAM,cAAc,EAAE,SAAS,CAAC,CAAC;AAErE,eAAO,MAAM,sBAAsB,EAAE;IACnC,QAAQ,EAAE,CAAC,IAAI,oBAAoB,GAAG,SAAS,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;CAQhF,CAAC"}

package/dist/adapter/system-seam-contract.js

@@ -0,0 +1,95 @@
+/** Exhaustive proof requirements for mounted SystemAdapters. A bound slot is
+ * availability, not success: each nested operation has its own required proof
+ * stage and therefore cannot hide behind `active[slot] != null`. */
+import { defineSeamShape } from './seam-evidence';
+export const SYSTEM_ADAPTERS_SHAPE = defineSeamShape()({
+    physics: { optional: true, kind: 'value', required: 'effect' },
+    networking: { optional: true, kind: 'value', required: 'operation' },
+    navigation: { optional: true, kind: 'value', required: 'operation' },
+    audio: { optional: true, kind: 'value', required: 'effect' },
+    camera: { optional: true, kind: 'value', required: 'effect' },
+    debug: { optional: true, kind: 'value', required: 'operation' },
+    renderDebug: { optional: true, kind: 'value', required: 'effect' },
+});
+export const PHYSICS_ADAPTER_SHAPE = defineSeamShape()({
+    keyedBy: { optional: true, kind: 'value', required: 'shape' },
+    ownerOf: { optional: false, kind: 'function', required: 'operation' },
+    freeze: { optional: false, kind: 'function', required: 'effect' },
+    commit: { optional: false, kind: 'function', required: 'effect' },
+    unfreeze: { optional: false, kind: 'function', required: 'effect' },
+    debugDraw: { optional: true, kind: 'function', required: 'operation' },
+    setDebugDrawEnabled: { optional: true, kind: 'function', required: 'effect' },
+    contactPoints: { optional: true, kind: 'function', required: 'operation' },
+    colliders: { optional: true, kind: 'function', required: 'operation' },
+    previewCollider: { optional: true, kind: 'function', required: 'effect' },
+    joints: { optional: true, kind: 'function', required: 'operation' },
+    previewJointAnchor: { optional: true, kind: 'function', required: 'effect' },
+});
+export const PHYSICS_2D_ADAPTER_SHAPE = defineSeamShape()({
+    keyedBy: { optional: false, kind: 'value', required: 'shape' },
+    ownerOf: { optional: false, kind: 'function', required: 'operation' },
+    freeze: { optional: false, kind: 'function', required: 'effect' },
+    commit: { optional: false, kind: 'function', required: 'effect' },
+    unfreeze: { optional: false, kind: 'function', required: 'effect' },
+});
+export const NETWORKING_ADAPTER_SHAPE = defineSeamShape()({
+    peers: { optional: false, kind: 'function', required: 'operation' },
+    networkId: { optional: false, kind: 'function', required: 'operation' },
+    authority: { optional: false, kind: 'function', required: 'operation' },
+    editable: { optional: false, kind: 'function', required: 'operation' },
+    getConnectionState: { optional: false, kind: 'function', required: 'operation' },
+    getRoomInfo: { optional: false, kind: 'function', required: 'operation' },
+    getReplicationStats: { optional: false, kind: 'function', required: 'operation' },
+    subscribe: { optional: false, kind: 'function', required: 'effect' },
+    getStateSnapshot: { optional: true, kind: 'function', required: 'operation' },
+    messageEvents: { optional: true, kind: 'function', required: 'operation' },
+    getRates: { optional: true, kind: 'function', required: 'operation' },
+    getConditioning: { optional: true, kind: 'function', required: 'operation' },
+    setConditioning: { optional: true, kind: 'function', required: 'effect' },
+    getServerConfig: { optional: true, kind: 'function', required: 'operation' },
+    getPlayerIdentity: { optional: true, kind: 'function', required: 'operation' },
+    setPlayerIdentity: { optional: true, kind: 'function', required: 'effect' },
+});
+export const NAVIGATION_ADAPTER_SHAPE = defineSeamShape()({
+    hasNavMesh: { optional: false, kind: 'function', required: 'operation' },
+    findPath: { optional: false, kind: 'function', required: 'effect' },
+    debugMesh: { optional: false, kind: 'function', required: 'operation' },
+    bake: { optional: true, kind: 'function', required: 'effect' },
+    exportData: { optional: true, kind: 'function', required: 'operation' },
+    clear: { optional: true, kind: 'function', required: 'effect' },
+    crowdAgents: { optional: true, kind: 'function', required: 'operation' },
+});
+export const AUDIO_ADAPTER_SHAPE = defineSeamShape()({
+    resume: { optional: true, kind: 'function', required: 'effect' },
+    setMuted: { optional: false, kind: 'function', required: 'effect' },
+    isMuted: { optional: false, kind: 'function', required: 'operation' },
+    graphSnapshot: { optional: true, kind: 'function', required: 'operation' },
+    transportState: { optional: true, kind: 'function', required: 'operation' },
+    acquireMeters: { optional: true, kind: 'function', required: 'effect' },
+    acquireRecordingStream: { optional: true, kind: 'function', required: 'effect' },
+    audioEvents: { optional: true, kind: 'function', required: 'operation' },
+});
+export const CAMERA_ADAPTER_SHAPE = defineSeamShape()({
+    snapshot: { optional: false, kind: 'function', required: 'operation' },
+    subscribe: { optional: false, kind: 'function', required: 'effect' },
+});
+export const DEBUG_ADAPTER_SHAPE = defineSeamShape()({
+    providers: { optional: false, kind: 'function', required: 'operation' },
+    state: { optional: false, kind: 'function', required: 'operation' },
+    stateAll: { optional: false, kind: 'function', required: 'operation' },
+    commands: { optional: false, kind: 'function', required: 'operation' },
+    invoke: { optional: false, kind: 'function', required: 'effect' },
+    events: { optional: false, kind: 'function', required: 'operation' },
+});
+export const RENDER_DEBUG_ADAPTER_SHAPE = defineSeamShape()({
+    captureFrame: { optional: false, kind: 'function', required: 'effect' },
+    memorySnapshot: { optional: true, kind: 'function', required: 'operation' },
+});
+export const SYSTEM_PROVIDER_SHAPES = {
+    networking: NETWORKING_ADAPTER_SHAPE,
+    navigation: NAVIGATION_ADAPTER_SHAPE,
+    audio: AUDIO_ADAPTER_SHAPE,
+    camera: CAMERA_ADAPTER_SHAPE,
+    debug: DEBUG_ADAPTER_SHAPE,
+    renderDebug: RENDER_DEBUG_ADAPTER_SHAPE,
+};

package/dist/animation/xstate-animation-binding.d.ts

@@ -78,6 +78,12 @@ export interface XStateAnimationBindingOptions {
      * omitted, the caller owns ticking (useful for standalone Three tests).
      */
     systems?: Pick<ReturnType<typeof createSystemRunner>, 'add' | 'remove'>;
+    /**
+     * Publish a seekable transport for an isolated design-time mount such as a
+     * CSF story. Never enable this on the live game binding: runtime inspection
+     * stays read-only there, while the story deliberately owns this preview.
+     */
+    previewTransport?: boolean;
 }
 export interface XStateAnimationLayerState {
     readonly layer: string;

package/dist/animation/xstate-animation-binding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xstate-animation-binding.d.ts","sourceRoot":"","sources":["../../src/animation/xstate-animation-binding.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"xstate-animation-binding.d.ts","sourceRoot":"","sources":["../../src/animation/xstate-animation-binding.ts"],"names":[],"mappings":"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"}

package/dist/animation/xstate-animation-binding.js

@@ -1,7 +1,7 @@
 import * as THREE from 'three';
 import { deleteUserData, getUserData, setUserData } from '../ecs/user-data';
 import { evaluateBlendTree } from './blend-node';
-import { attachAnimationRuntimeInspection } from './runtime-inspection';
+import { attachAnimationRuntimeInspection, } from './runtime-inspection';
 import { clipNamesOf, collectMachineAnimationMeta, isBlendTreeAnimationMeta, } from './xstate-animation-meta';
 /** A binding-time problem such as a missing clip, bone, or ambiguous layer. */
 export class AnimationBindingError extends Error {
@@ -199,6 +199,83 @@ export function bindXStateAnimation(actor, mixer, clips, options = {}) {
     const activeLayers = new Map();
     let disposed = false;
     let detachRuntimeInspection = () => { };
+    let previewClip = null;
+    let previewAction = null;
+    let previewPlaying = true;
+    let previewLoop = true;
+    let previewSpeed = 1;
+    function controllerPreviewSubject() {
+        const layers = [activeLayers.get('base'), ...activeLayers.values()].filter((active, index, all) => Boolean(active) && all.indexOf(active) === index);
+        for (const active of layers) {
+            const weighted = [...active.natural].sort((left, right) => {
+                const leftWeight = actionCache.get(left.actionKey)?.action.getEffectiveWeight() ?? 0;
+                const rightWeight = actionCache.get(right.actionKey)?.action.getEffectiveWeight() ?? 0;
+                return rightWeight - leftWeight;
+            })[0];
+            if (weighted) {
+                return {
+                    clip: weighted.clip,
+                    action: actionCache.get(weighted.actionKey)?.action ?? null,
+                };
+            }
+        }
+        return { clip: clips.keys().next().value ?? '', action: null };
+    }
+    function actionIsControllerOwned(action) {
+        for (const cached of actionCache.values()) {
+            if (cached.action === action)
+                return true;
+        }
+        return false;
+    }
+    function releasePreviewAction() {
+        const action = previewAction;
+        if (!action)
+            return;
+        action.stop();
+        if (!actionIsControllerOwned(action)) {
+            mixer.uncacheAction(action.getClip(), action.getRoot());
+        }
+        previewAction = null;
+    }
+    function enterClipPreview(name) {
+        const clip = clips.get(name);
+        if (!clip)
+            return;
+        releasePreviewAction();
+        previewClip = name;
+        for (const cached of actionCache.values())
+            cached.action.setEffectiveWeight(0);
+        const action = mixer.clipAction(clip).reset().play();
+        action.setEffectiveWeight(1);
+        action.setEffectiveTimeScale(1);
+        action.setLoop(previewLoop ? THREE.LoopRepeat : THREE.LoopOnce, previewLoop ? Infinity : 1);
+        action.clampWhenFinished = !previewLoop;
+        previewAction = action;
+        mixer.update(0);
+    }
+    function restoreControllerPreview() {
+        releasePreviewAction();
+        previewClip = null;
+        const snapshot = actor.getSnapshot();
+        reconcile(snapshot);
+        const context = snapshot.context;
+        for (const cached of actionCache.values())
+            cached.action.setEffectiveWeight(0);
+        for (const active of activeLayers.values()) {
+            active.crossfadeRemaining = 0;
+            active.natural = weightsOf(active.stateId, active.meta, context);
+            const loop = isBlendTreeAnimationMeta(active.meta) ? true : active.meta.loop;
+            const speed = isBlendTreeAnimationMeta(active.meta) ? 1 : active.meta.speed;
+            const layerWeight = layerWeightOf(active.meta);
+            for (const weighted of active.natural) {
+                ensureAction(weighted.actionKey, loop, speed, layerWeight)
+                    .play()
+                    .setEffectiveWeight(weighted.weight * layerWeight);
+            }
+        }
+        mixer.update(0);
+    }
     function silence(weights, except, duration) {
         for (const weighted of weights) {
             if (weighted.actionKey === except)
@@ -296,16 +373,29 @@ export function bindXStateAnimation(actor, mixer, clips, options = {}) {
     const initialSnapshot = actor.getSnapshot();
     reconcile(initialSnapshot);
     const subscription = actor.subscribe((snapshot) => {
-        if (!disposed)
+        // Isolated clip review deliberately holds behavior output. The actor may
+        // keep receiving story args, but its latest state is reconciled only when
+        // the user returns to Controller.
+        if (!disposed && !previewClip)
             reconcile(snapshot);
     });
     function tick(dt) {
         if (disposed)
             return;
+        if (options.previewTransport && !previewPlaying)
+            return;
+        const elapsed = dt * (options.previewTransport ? previewSpeed : 1);
+        if (options.previewTransport && previewClip && previewAction) {
+            mixer.update(elapsed);
+            const clip = clips.get(previewClip);
+            if (!previewLoop && clip && previewAction.time >= clip.duration)
+                previewPlaying = false;
+            return;
+        }
         const context = actor.getSnapshot().context;
         for (const active of activeLayers.values()) {
             if (active.crossfadeRemaining > 0) {
-                active.crossfadeRemaining = Math.max(0, active.crossfadeRemaining - dt);
+                active.crossfadeRemaining = Math.max(0, active.crossfadeRemaining - elapsed);
                 if (active.crossfadeRemaining <= 0)
                     applyLiveBlendWeights(active, context);
             }
@@ -313,8 +403,54 @@ export function bindXStateAnimation(actor, mixer, clips, options = {}) {
                 applyLiveBlendWeights(active, context);
             }
         }
-        mixer.update(dt);
+        mixer.update(elapsed);
     }
+    const previewTransport = options.previewTransport
+        ? {
+            getSnapshot: () => {
+                const controller = controllerPreviewSubject();
+                return {
+                    clip: previewClip ?? controller.clip,
+                    time: previewClip ? (previewAction?.time ?? 0) : (controller.action?.time ?? 0),
+                    playing: previewPlaying,
+                    loop: previewLoop,
+                    speed: previewSpeed,
+                    mode: previewClip ? 'clip' : 'controller',
+                };
+            },
+            setPlaying(playing) {
+                previewPlaying = playing;
+            },
+            setLoop(loop) {
+                previewLoop = loop;
+                if (!previewClip)
+                    enterClipPreview(controllerPreviewSubject().clip);
+                previewAction?.setLoop(loop ? THREE.LoopRepeat : THREE.LoopOnce, loop ? Infinity : 1);
+                if (previewAction)
+                    previewAction.clampWhenFinished = !loop;
+            },
+            setSpeed(speed) {
+                previewSpeed = THREE.MathUtils.clamp(speed, 0.05, 4);
+            },
+            seek(time) {
+                if (!previewClip)
+                    enterClipPreview(controllerPreviewSubject().clip);
+                const clip = previewClip ? clips.get(previewClip) : undefined;
+                if (!clip || !previewAction)
+                    return;
+                previewAction.time = THREE.MathUtils.clamp(time, 0, Math.max(clip.duration, 0));
+                mixer.update(0);
+            },
+            setClip(name) {
+                if (name === null) {
+                    if (previewClip)
+                        restoreControllerPreview();
+                    return;
+                }
+                enterClipPreview(name);
+            },
+        }
+        : undefined;
     const binding = {
         tick,
         actor,
@@ -336,6 +472,7 @@ export function bindXStateAnimation(actor, mixer, clips, options = {}) {
                 return;
             disposed = true;
             detachRuntimeInspection();
+            releasePreviewAction();
             options.systems?.remove('animation', tick);
             subscription.unsubscribe();
             for (const { action, clip } of actionCache.values()) {
@@ -353,6 +490,7 @@ export function bindXStateAnimation(actor, mixer, clips, options = {}) {
     detachRuntimeInspection = attachAnimationRuntimeInspection(owner, {
         mixer,
         clips,
+        ...(previewTransport ? { previewTransport } : {}),
         getSnapshot: () => ({
             layers: [...activeLayers.values()].map((active) => {
                 const parameters = readParameters(actor.getSnapshot().context);

package/dist/asset-formats/collider.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const ColliderDescriptorSchema: z.ZodObject<{
     type: z.ZodEnum<{
+        capsule: "capsule";
         cuboid: "cuboid";
         ball: "ball";
-        capsule: "capsule";
         trimesh: "trimesh";
     }>;
     halfExtents: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;