@vgai/engine 0.4.1 → 0.5.0-canary.20260719.0

package/src/adapter/vgai-scene-game-adapter.ts

@@ -13,6 +13,7 @@
  */
 
 import RAPIER from '@dimforge/rapier3d-compat';
+import type { SparkRenderer } from '@sparkjsdev/spark';
 import type { EffectComposer } from 'postprocessing';
 import * as THREE from 'three';
 import {
@@ -22,6 +23,14 @@ import {
 } from '../core/seeded-random';
 import { createSystemRunner } from '../core/system-runner';
 import { createDebugDraw } from '../dev/debug-draw';
+import { log } from '../dev/logger';
+import {
+  createRenderDebugAdapter,
+  frameCaptureContextFor,
+  type RenderDebugWiring,
+} from '../dev/render-debug-adapter';
+import { collectRenderMemory } from '../dev/render-memory';
+import { createWebGLFrameCapture } from '../dev/webgl-frame-capture';
 import { createWebGLGpuTimer } from '../dev/webgl-gpu-timer';
 import { createComponentManager } from '../ecs/component-manager';
 import { InputManager } from '../input/input-manager';
@@ -32,6 +41,12 @@ import { createTransformWriter } from '../physics/transform-writer';
 import { createTriggerDispatch } from '../physics/trigger-dispatch';
 import { RenderBatchSystem } from '../render/render-batch-system';
 import { type RenderScope, resolveRenderSettings } from '../render/render-settings';
+import {
+  disposeSparkRendererWhenIdle,
+  SPARK_DISCOVERY_INTERVAL_MS,
+  sceneHasGaussianSplat,
+  shouldDiscoverGaussianSplat,
+} from '../render/spark-renderer-lifecycle';
 import { type ViewportShadingMode, ViewportShadingRenderer } from '../render/viewport-shading';
 import {
   createDebugRegistry,
@@ -41,7 +56,6 @@ import {
 import type { WorldFrameHooks } from '../runtime/game';
 import type { EditorPreview, GameCleanup, GameContext, GameSetupFn } from '../runtime/types';
 import type { ComponentRegistry } from '../scene/component-registry';
-import { tickCustomMaterials } from '../scene/material-registry';
 import {
   clearAssetCaches,
   loadScene,
@@ -206,8 +220,12 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     const writeTransforms = createTransformWriter(physicsRegistry, scene);
 
     // --- Input (InputManager attaches window listeners; stub it headlessly) ---
-    const input = headless ? headlessInput() : new InputManager();
-    if (!headless) await input.loadMap(inputMapPath);
+    const ownsInput = !host.game;
+    const input = host.game?.input ?? (headless ? headlessInput() : new InputManager());
+    if (!headless) {
+      if (host.game) await host.game.loadInputMap(inputMapPath);
+      else await input.loadMap(inputMapPath);
+    }
 
     // --- Collision system ---
     const collisions = createCollisionSystem(physics.rapierWorld, physics.eventQueue);
@@ -230,6 +248,22 @@ export class VgaiSceneGameAdapter implements GameAdapter {
       !headless && rendererContext && typeof rendererContext.getExtension === 'function'
         ? createWebGLGpuTimer(rendererContext)
         : null;
+    // W4b (F11 frame debugger): first-party WebGL2 frame capture, constructed
+    // under the SAME real-context guard as gpuTimer — a headless/stub mount
+    // (`frameCaptureContextFor` returns null) never builds it and never
+    // registers `renderDebug`, so the capability is honestly absent there. The
+    // capture only patches the context WHILE a `captureFrame()` is armed (see
+    // beginPass/endPass in the render system below); every non-capture frame
+    // is zero-overhead.
+    const frameCaptureContext = frameCaptureContextFor(headless, rendererContext);
+    const frameCapture = frameCaptureContext ? createWebGLFrameCapture(frameCaptureContext) : null;
+    const renderDebugWiring: RenderDebugWiring | null = frameCapture
+      ? createRenderDebugAdapter({
+          capture: frameCapture,
+          scene,
+          memory: () => collectRenderMemory(scene, renderer.info),
+        })
+      : null;
     const viewportShading = new ViewportShadingRenderer();
     let viewportShadingMode: ViewportShadingMode = 'solid';
 
@@ -246,9 +280,7 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     // key off, so `InputManager.poll()` falls back to its own internal
     // self-incrementing counter instead (unchanged pre-D15 behavior) rather
     // than being pinned to a constant `0` forever.
-    systems.add('input', () => input.poll(host.game ? debugRegistry.getGameTick() : undefined), {
-      name: 'input.poll',
-    });
+    if (ownsInput) systems.add('input', () => input.poll(), { name: 'input.poll' });
     systems.add('physics', () => physics.rapierWorld.step(physics.eventQueue), {
       name: 'physics.step',
     });
@@ -264,8 +296,28 @@ export class VgaiSceneGameAdapter implements GameAdapter {
       'preRender',
       (dt) => {
         particles.batchedRenderer.update(dt);
-        tickCustomMaterials(scene, dt);
         updateSceneLODs(scene, camera);
+        sparkDiscoveryElapsedMs += dt * 1_000;
+        const shouldDiscover = shouldDiscoverGaussianSplat(0, sparkDiscoveryElapsedMs);
+        if (!sparkRenderer && !sparkRendererLoading && !sparkRendererFailed && shouldDiscover) {
+          sparkDiscoveryElapsedMs = 0;
+          if (!sceneHasGaussianSplat(scene)) return;
+          sparkRendererLoading = true;
+          void import('@sparkjsdev/spark')
+            .then(({ SparkRenderer }) => {
+              if (disposed || sparkRenderer) return;
+              sparkRenderer = new SparkRenderer({ renderer, enableLod: false });
+              sparkRenderer.traverse((node) => setUserData(node, 'engineInternal', true));
+            })
+            .catch((error: unknown) => {
+              sparkRendererFailed = true;
+              // biome-ignore lint/suspicious/noConsole: A missing renderer chunk must fail once and loudly, not retry every frame.
+              console.error('Failed to install SparkRenderer for a live Gaussian splat.', error);
+            })
+            .finally(() => {
+              sparkRendererLoading = false;
+            });
+        }
       },
       { name: 'materials-and-particles' },
     );
@@ -274,6 +326,13 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         'render',
         (dt) => {
           if (host.game?.profiler.enabled) gpuTimer?.begin();
+          if (sparkRenderer) scene.add(sparkRenderer);
+          // W4b: arm-gated frame capture wraps the real draw calls. beginPass
+          // is a no-op unless a captureFrame() armed it; afterRender delivers
+          // the assembled capture to a pending captureFrame() and restores the
+          // patched context — in the SAME finally as gpuTimer.end(). Spark is
+          // added before this so its draws fall inside the captured frame.
+          renderDebugWiring?.beforeRender();
           try {
             viewportShading.render(
               scene,
@@ -285,6 +344,8 @@ export class VgaiSceneGameAdapter implements GameAdapter {
               (mesh) => camera.layers.test(mesh.layers),
             );
           } finally {
+            renderDebugWiring?.afterRender();
+            sparkRenderer?.removeFromParent();
             gpuTimer?.end();
           }
           if (physics.debugEnabled) updatePhysicsDebug(physics.rapierWorld, physics.debugMesh);
@@ -303,7 +364,7 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     if (!headless) window.addEventListener('keydown', onDebugToggle);
 
     const postFrame = () => {
-      input.endFrame();
+      if (ownsInput) input.endFrame();
       if (host.game?.profiler.enabled) {
         host.game.profiler.reportRender({
           gpuMs: gpuTimer?.poll() ?? null,
@@ -377,8 +438,8 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     // resolves, not here (no NavMeshManager exists yet at this point in the
     // mount). `networking` remains the one game-owned capability with no
     // first-party implementer; it simply starts absent here.
-    systemAdapters.physics = createRapierPhysicsAdapter(physicsRegistry, physics.debugMesh);
-    systemAdapters.input = createInputManagerAdapter(input);
+    systemAdapters.physics = createRapierPhysicsAdapter(physicsRegistry, physics);
+    if (ownsInput) systemAdapters.input = createInputManagerAdapter(input);
     systemAdapters.assets = createVgaiAssetAdapter();
     // D10/T7.6: the audio seam `Game.play.pause()` silences on pause. Works
     // against the headless stand-in too (`headlessAudio()`'s plain
@@ -396,6 +457,11 @@ export class VgaiSceneGameAdapter implements GameAdapter {
       (host.game ? getDebugRegistry(host.game) : null) ??
       createDebugRegistry({ getTick: () => 0, getSimT: () => 0 });
     systemAdapters.debug = debugRegistry.adapter;
+    // W4b: the render-debug capability is engine-owned and first-party, seeded
+    // here (like physics/input/assets) BEFORE the engineAdapterKinds snapshot
+    // below so a warm restart / stop never mistakes it for game content. Only
+    // present when a real WebGL2 context backed the mount (renderDebugWiring).
+    if (renderDebugWiring) systemAdapters.renderDebug = renderDebugWiring.adapter;
     ctx.debug = debugRegistry.forWorld(this.id);
     // T1.2: the InputManager is a first-party per-world handle the registry
     // has no other way to reach — wired as a lazy supplier (not a direct
@@ -449,7 +515,7 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     // to THIS world's debug registry, same seed spot/precedent as
     // `setInputActionsSource`/`setVirtualInputTarget` above (typeof-guarded:
     // a headless `InputManager` stand-in may have no `setDebugEmit`).
-    if (typeof input.setDebugEmit === 'function') {
+    if (!host.game && typeof input.setDebugEmit === 'function') {
       input.setDebugEmit((event, detail) => ctx.debug?.emit(event, detail));
     }
     // D15 (T-D15.1) — same "ONE per Game root, shared across every world"
@@ -490,11 +556,18 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     }
     let currentCleanup: GameCleanup | null = null;
     let batchSystem: RenderBatchSystem | null = null;
+    let sparkRenderer: SparkRenderer | null = null;
+    let sparkRendererLoading = false;
+    let sparkRendererFailed = false;
+    // Discovery is render-loop scheduling, so advance it from the loop's `dt`
+    // instead of introducing a second wall-clock frontier into engine code.
+    // Start at the threshold so the first rendered frame discovers eager splats.
+    let sparkDiscoveryElapsedMs = SPARK_DISCOVERY_INTERVAL_MS;
 
     // Apply scene-level render settings + transparent auto-batching after a scene
     // loads (GPU host only). Gated on the resolved `environment.rendering` cascade
     // (defaults preserve prior behavior when a scene omits `rendering`).
-    const applySceneRendering = (inst: SceneInstance): void => {
+    const applySceneRendering = async (inst: SceneInstance): Promise<void> => {
       if (headless) return;
       const scope = inst.environment?.rendering as RenderScope | undefined;
       const settings = resolveRenderSettings(scope);
@@ -509,6 +582,11 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         if (import.meta.env?.DEV)
           (window as unknown as { __vgaiBatch?: unknown }).__vgaiBatch = batchSystem;
       }
+      if (inst.splatCount > 0 && !sparkRenderer) {
+        const { SparkRenderer } = await import('@sparkjsdev/spark');
+        sparkRenderer = new SparkRenderer({ renderer, enableLod: false });
+        sparkRenderer.traverse((node) => setUserData(node, 'engineInternal', true));
+      }
     };
 
     // Wire the (first-party) navigation system adapter to whichever
@@ -536,7 +614,7 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         particleRenderer: ctx.particles.batchedRenderer,
         ...(headless ? {} : { renderer }),
       });
-      applySceneRendering(inst);
+      await applySceneRendering(inst);
       applySceneNavigation(inst);
       ctx.systems.add('postPhysics', (dt) => inst.update(dt));
       return inst;
@@ -546,8 +624,12 @@ export class VgaiSceneGameAdapter implements GameAdapter {
       if (headless) throw new Error('VgaiSceneGameAdapter: setup-based games require a GPU host');
       currentCleanup = await setup(ctx, editorPreview);
     } else if (scenePath) {
-      // #139: captured BEFORE load so adoptSceneCamera can tell whether a
-      // component (e.g. SceneCamera.init) already framed the camera.
+      // The editor viewport is only the fallback/initial play viewpoint. Apply
+      // it BEFORE capturing the load baseline so authored scene cameras and
+      // camera GameComponents can override it during/after scene load.
+      applyEditorCamera(editorPreview, camera);
+      // #139: captured immediately BEFORE load so adoptSceneCamera can tell
+      // whether a component (e.g. SceneCamera.init) framed the camera.
       const preLoadPose = captureCameraPose(camera);
       const inst = await loadScene(scenePath, {
         scene,
@@ -560,8 +642,8 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         particleRenderer: ctx.particles.batchedRenderer,
         ...(headless ? {} : { renderer }),
       });
-      applyEditorCamera(editorPreview, camera) || adoptSceneCamera(inst, camera, preLoadPose);
-      applySceneRendering(inst);
+      adoptSceneCamera(inst, camera, preLoadPose);
+      await applySceneRendering(inst);
       applySceneNavigation(inst);
       ctx.systems.add('postPhysics', (dt) => inst.update(dt));
       // A pre-baked navmesh (sibling .navmesh file — see scene-loader.ts) holds
@@ -574,9 +656,10 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         },
       };
     } else if (sceneData) {
+      applyEditorCamera(editorPreview, camera);
       const preLoadPose = captureCameraPose(camera);
       const inst = await loadFromData(sceneData);
-      applyEditorCamera(editorPreview, camera) || adoptSceneCamera(inst, camera, preLoadPose);
+      adoptSceneCamera(inst, camera, preLoadPose);
       currentCleanup = {
         dispose: () => {
           inst.navMesh?.dispose(scene);
@@ -590,6 +673,30 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     // adapter.
     let disposed = false;
 
+    // W3c: attach the read-only Audio-debugger introspection capabilities
+    // (graph/transport/meters/events) onto the SAME first-party audio adapter
+    // seeded above. Dynamically imported so `tone` stays out of the
+    // mount-critical chunk (the Colyseus dynamic-import idiom); the editor
+    // panel polls, so a few-ms-late attachment is invisible. If the game
+    // replaced `systems.audio` with its OWN adapter during setup(), the
+    // first-party augmentation is skipped — the game's adapter is the truth
+    // the editor sees.
+    let disposeAudioIntrospection: (() => void) | null = null;
+    const firstPartyAudioAdapter = systemAdapters.audio;
+    if (firstPartyAudioAdapter) {
+      void import('../audio/audio-introspection').then(
+        (m) => {
+          if (disposed || systemAdapters.audio !== firstPartyAudioAdapter) return;
+          disposeAudioIntrospection = m.attachAudioIntrospection(firstPartyAudioAdapter, audio);
+        },
+        (err) => {
+          log.audio.warn('VgaiSceneGameAdapter: audio introspection unavailable', {
+            error: String(err),
+          });
+        },
+      );
+    }
+
     // Run one teardown step in isolation: a throwing step (e.g. a
     // GameComponent's dispose() misbehaving, or a WASM free() panicking) must
     // not abort the remaining steps — otherwise a single bad component leaks
@@ -618,6 +725,12 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         currentCleanup?.dispose();
         currentCleanup = null;
       });
+      safeStep('sparkRenderer.dispose', () => {
+        if (!sparkRenderer) return;
+        sparkRenderer.removeFromParent();
+        disposeSparkRendererWhenIdle(sparkRenderer);
+        sparkRenderer = null;
+      });
       // The scene instance's NavMeshManager (if any) was just disposed above
       // (currentCleanup.dispose calls `inst.navMesh?.dispose(scene)`) — clear
       // the wrapper too, or `mounted.systems.navigation` would keep pointing
@@ -689,12 +802,20 @@ export class VgaiSceneGameAdapter implements GameAdapter {
           if (!engineAdapterKinds.has(kind)) delete systemAdapters[kind as keyof SystemAdapters];
         }
       });
-      // Defect 2 fix: a full Stop means the whole GAME is going away (every
-      // world it mounted, plus any react-door registrations from its HUDs)
-      // — unlike hotReload below (a SINGLE mount warm-restarting), so this is
-      // the one call site that legitimately wants strip()'s global, no-id
-      // form rather than scoping to `this.id`.
-      safeStep('debugRegistry.strip', () => debugRegistry.strip());
+      // A game-hosted mount owns only its world-scoped registrations; sibling
+      // roots remain alive during root replacement. A bare standalone adapter
+      // owns the registry and can clear it globally.
+      safeStep('debugRegistry.strip', () =>
+        host.game ? debugRegistry.strip(this.id) : debugRegistry.strip(),
+      );
+
+      // W3c: detach introspection BEFORE the audio teardown below — releases
+      // Tone transport listeners (the transport singleton outlives this
+      // world), the context statechange hook, and any meter taps still alive.
+      safeStep('audio introspection dispose', () => {
+        disposeAudioIntrospection?.();
+        disposeAudioIntrospection = null;
+      });
 
       if (!headless) {
         safeStep('audio teardown', () => {
@@ -704,7 +825,10 @@ export class VgaiSceneGameAdapter implements GameAdapter {
           composer.dispose();
         });
       }
-      safeStep('input.dispose', () => input.dispose());
+      if (ownsInput) safeStep('input.dispose', () => input.dispose());
+      // W4b: restore any pending capture wrappers and reject a capture in
+      // flight (a Stop mid-capture must not leave the context patched).
+      safeStep('renderDebug.dispose', () => renderDebugWiring?.dispose());
       safeStep('gpuTimer.dispose', () => gpuTimer?.dispose());
       safeStep('viewportShading.dispose', () => viewportShading.dispose());
     };

package/src/ai/navigation.ts

@@ -24,6 +24,15 @@ export interface Vector3Like {
   z: number;
 }
 
+/** One crowd agent's live state — a plain-data snapshot safe to hand across
+ *  the adapter seam (no WASM handles), for editor debug draw. */
+export interface CrowdAgentSnapshot {
+  position: Vector3Like;
+  velocity: Vector3Like;
+  radius: number;
+  height: number;
+}
+
 export interface NavMeshBuildParams {
   cellSize?: number | undefined;
   cellHeight?: number | undefined;
@@ -130,6 +139,25 @@ export class NavMeshManager {
     this.crowd?.update(dt);
   }
 
+  /**
+   * Plain-data snapshots of every active crowd agent (interpolated position,
+   * velocity, radius, height) — the introspection feed for the editor's
+   * play-mode crowd debug draw. Empty when no crowd exists.
+   */
+  getCrowdAgents(): CrowdAgentSnapshot[] {
+    if (!this.crowd) return [];
+    return this.crowd.getAgents().map((a) => {
+      const p = a.interpolatedPosition;
+      const v = a.velocity();
+      return {
+        position: { x: p.x, y: p.y, z: p.z },
+        velocity: { x: v.x, y: v.y, z: v.z },
+        radius: a.radius,
+        height: a.height,
+      };
+    });
+  }
+
   /** Get or create the wireframe debug mesh. Add to scene once, call update() after rebuilding. */
   getDebugMesh(scene: Scene): NavMeshHelper | null {
     if (!this.navMesh) return null;

package/src/animation/clip-map.ts

@@ -1,11 +1,5 @@
 import type * as THREE from 'three';
 
-/** Common aliases used by many free humanoid packs. Scene-authored aliases override these. */
-const DEFAULT_CLIP_ALIASES: Record<string, string> = {
-  walking: 'walk',
-  running: 'run',
-};
-
 /**
  * Build the clip lookup shared by runtime and editor.
  *
@@ -29,8 +23,7 @@ export function buildClipMap(
     if (!clips.has(raw.toLowerCase())) clips.set(raw.toLowerCase(), clip);
   }
 
-  const mergedAliases = { ...DEFAULT_CLIP_ALIASES, ...aliases };
-  for (const [source, alias] of Object.entries(mergedAliases)) {
+  for (const [source, alias] of Object.entries(aliases)) {
     const clip = canonical.get(source.toLowerCase());
     if (!clip) continue;
     if (!clips.has(alias)) clips.set(alias, clip);

package/src/animation/theatre-director.ts

@@ -256,6 +256,29 @@ export interface CameraOwnershipChangeEvent {
  */
 export type CameraOwnershipHook = (event: CameraOwnershipChangeEvent) => void;
 
+/**
+ * WF — one detected event-marker transition on the Director's `event` extra
+ * track (authored by the editor's Sequencer as HOLD string keyframes on the
+ * SAME Director object; see the sequencer's `EVENT_MARKER_PROP`).
+ */
+export interface EventMarkerEvent {
+  /** The marker name now active (the hold keyframe's string value). */
+  readonly name: string;
+  /** The previously active marker name, or `null` before the first marker. */
+  readonly previousName: string | null;
+}
+
+/**
+ * WF seam — fired once per DETECTED change of the Director's event-marker
+ * value, exactly the `activeCamera` detection semantics: markers are
+ * *directorial* state, so the hook reflects whatever value the clock's
+ * current time holds, however the clock got there (a seek across several
+ * markers fires only the one now active; a seek BACK re-fires the older
+ * marker as a change). Gameplay consequences that must distinguish seek from
+ * advance belong in a D5 `CueRunner` (`cinematic-cues.ts`), not here.
+ */
+export type EventMarkerHook = (event: EventMarkerEvent) => void;
+
 export interface TheatreDirectorBindingOptions {
   /**
    * Which `AnimationClock` phase to evaluate the Director in. Defaults to
@@ -273,6 +296,20 @@ export interface TheatreDirectorBindingOptions {
    * non-positive at the moment of a transition reports `mode: 'cut'`.
    */
   blendSecondsKey?: string;
+  /**
+   * WF seam — event-marker hook (see {@link EventMarkerHook}). Fired when
+   * the string value of the Director's `eventMarkerKey` extra prop changes
+   * between evaluations (markers are authored as HOLD keyframes, so each
+   * marker's name holds until the next one). Optional; omit to ignore
+   * markers entirely.
+   */
+  onEventMarker?: EventMarkerHook;
+  /**
+   * Name of the extra Director prop carrying event-marker names. Defaults to
+   * `'event'` — the track the editor's Sequencer writes. An empty string or
+   * a non-string value means "no marker active".
+   */
+  eventMarkerKey?: string;
 }
 
 export interface TheatreDirectorBinding {
@@ -301,13 +338,26 @@ export function bindDirectorToClock<Props extends UnknownShorthandCompoundProps>
 ): TheatreDirectorBinding {
   const phase = options.phase ?? 'preRender';
   const blendSecondsKey = options.blendSecondsKey ?? 'blendSeconds';
+  const eventMarkerKey = options.eventMarkerKey ?? 'event';
 
   let state: DirectorState = readDirectorState(sheetObject);
   let previousCameraKey: string | null = null;
+  let previousMarker: string | null = null;
   let hasEvaluatedOnClock = false;
 
+  function evaluateEventMarker(): void {
+    if (!options.onEventMarker) return;
+    const markerRaw = state.extras[eventMarkerKey];
+    const marker = typeof markerRaw === 'string' && markerRaw !== '' ? markerRaw : null;
+    if (marker !== null && marker !== previousMarker) {
+      options.onEventMarker({ name: marker, previousName: previousMarker });
+    }
+    previousMarker = marker ?? previousMarker;
+  }
+
   function evaluate(): void {
     state = readDirectorState(sheetObject);
+    evaluateEventMarker();
 
     const changed = !hasEvaluatedOnClock || state.activeCamera !== previousCameraKey;
     if (changed) {

package/src/animation/xstate-animation-binding.ts

@@ -44,6 +44,8 @@ export interface XStateAnimationLayerState {
   readonly layer: string;
   readonly stateId: string;
   readonly clips: readonly string[];
+  /** Live native AnimationAction weights, including an in-progress crossfade. */
+  readonly clipWeights: readonly { readonly clip: string; readonly weight: number }[];
   readonly weight: number;
   readonly blendMode: 'override' | 'additive';
   readonly boneMask?: AnimationBoneMask;
@@ -408,6 +410,10 @@ export function bindXStateAnimation(
         layer: active.layer,
         stateId: active.stateId,
         clips: active.natural.map((weighted) => weighted.clip),
+        clipWeights: active.natural.map((weighted) => ({
+          clip: weighted.clip,
+          weight: actionCache.get(weighted.actionKey)?.action.getEffectiveWeight() ?? 0,
+        })),
         weight: layerWeightOf(active.meta),
         blendMode: blendModeOf(active.meta),
         ...(active.meta.boneMask ? { boneMask: active.meta.boneMask } : {}),