@volter/editor-blender 0.1.141 → 0.1.142

package/contributions/blender-play-skin.ts

@@ -23,7 +23,7 @@
  * baked, the armature keeps the pose it has.
  *
  * THE GAME'S CLOCK DRIVES IT: the runner advances it by each update's `dt`
- * (`@volter/editor-model-play`'s `play-script.ts`), so pause, step, speed and Restart hold for
+ * (`@volter/play`'s `play-script.ts`), so pause, step, speed and Restart hold for
  * animation exactly as they do for the script.
  */
 import type { BlenderActionClip } from '@volter/blender-engine/browser/rna';
@@ -32,7 +32,7 @@ import type { BlenderRuntimeView } from '@volter/blender-engine/browser/three/bl
 import type { ArmatureRig } from '@volter/blender-engine/browser/three/blender-runtime-skeleton';
 import type * as THREE from 'three';
 import { ArmaturePose, nlaLayers, poseClip, type ConstraintOverride, type PoseClip, type PoseLayer } from './blender-pose';
-import { editorHost } from '@volter/editor-sdk/host';
+import { editorHost } from '@volter/sdk/host';
 import { remedy } from './blender-runtime-skin';
 
 export interface PlayActionOptions {
@@ -74,10 +74,28 @@ export interface PlayAnimation {
   track(object: THREE.Object3D, name: string, options: PlayTrackOptions | null): Answer;
   constraint(object: THREE.Object3D, bone: string, name: string, options: PlayConstraintOptions): Answer;
   update(dt: number): void;
+  /** What each character is playing now, bottom layer first: the animation editors' live view. */
+  live(): readonly LiveArmature[];
+  /** The frames an action keys, per bone, for one armature (empty until it was baked). */
+  channels(armature: string, action: string): { bone: string; keys: number[] }[];
   readonly warnings: readonly string[];
   dispose(): void;
 }
 
+/** One character's animation at the game's last update. */
+export interface LiveArmature {
+  readonly armature: string;
+  /** The layers it was posed from, bottom first: each clip, its frame, influence and blend. */
+  readonly layers: readonly {
+    /** Where the layer comes from: an NLA track's name, or `null` for the active action. */
+    readonly track: string | null;
+    readonly action: string;
+    readonly frame: number;
+    readonly influence: number;
+    readonly blend: string;
+  }[];
+}
+
 /** A weight that moves toward its target at a rate (a crossfade). */
 interface Ramp { weight: number; target: number; rate: number }
 const ramp = (weight: number, target: number, fade: number): Ramp => ({ weight, target, rate: fade > 0 ? 1 / fade : 0 });
@@ -101,6 +119,8 @@ interface Armature {
   line: Playing[];
   readonly tracks: Map<string, Track>;
   readonly constraints: Map<string, ConstraintOverride>;
+  /** The layers of the last pose, for `live`. */
+  posed: LiveArmature['layers'];
 }
 
 /** The copy's animation. `bake` reads one action of one armature through the clip door. */
@@ -114,6 +134,7 @@ export function playAnimation(view: BlenderRuntimeView, bake: (armature: string,
   const armatures = new Map<string, Armature>();
   let time = 0;
   let disposed = false;
+  const lastSources = new Map<Armature, (string | null)[]>();
 
   const fail = (armature: Armature, action: string, why: string): void => {
     armature.clips.set(action, null);
@@ -138,7 +159,7 @@ export function playAnimation(view: BlenderRuntimeView, bake: (armature: string,
     const pose = new ArmaturePose(rig);
     pose.facts(entry);
     for (const thing of pose.unsupported()) warnings.push(`${rig.armature}: ${thing} plays only in Blender, not in a game.${remedy([thing])}`);
-    const armature: Armature = { rig, pose, facts: entry, clips: new Map(), failed: new Map(), line: [], tracks: new Map(), constraints: new Map() };
+    const armature: Armature = { rig, pose, facts: entry, clips: new Map(), failed: new Map(), line: [], tracks: new Map(), constraints: new Map(), posed: [] };
     // EACH ARMATURE STARTS ON ITS ASSIGNED ACTION, as Blender's viewport plays it.
     if (entry.action) armature.line = [{ action: entry.action, from: 0, loop: true, speed: 1, weight: ramp(1, 1, 0) }];
     armatures.set(rig.armature, armature);
@@ -157,12 +178,15 @@ export function playAnimation(view: BlenderRuntimeView, bake: (armature: string,
   /** Every layer of one armature now, bottom to top; null while a clip it needs is being baked. */
   const layersOf = (armature: Armature): PoseLayer[] | null => {
     const layers: PoseLayer[] = [];
+    /** Each layer's source, by index: a track's name, or null for the active action. */
+    const sources: (string | null)[] = [];
+    let source: string | null = null;
     let waiting = false;
     /** Whether an enabled track has strips (or a game's track plays): what places the active action. */
     let evaluated = false;
     const take = (layer: PoseLayer | null | undefined): void => {
       if (layer === undefined) waiting = true;
-      else if (layer) layers.push(layer);
+      else if (layer) { layers.push(layer); sources.push(source); }
     };
     const animation = armature.facts.animation;
     // THE SCENE FRAME, wrapping at the scene's end as Blender's playback wraps.
@@ -173,6 +197,7 @@ export function playAnimation(view: BlenderRuntimeView, bake: (armature: string,
       // ENABLED as Blender says: under a solo only the soloed track, muted or not.
       if (solo ? !track.solo : (set ? set.mute : track.mute)) continue;
       const influence = set ? set.influence.weight : 1;
+      source = track.name;
       if (set?.action) {
         const blend = track.strips[0]?.blendType ?? 'REPLACE';
         if (set.previous) take(playedLayer(armature, set.previous, influence, blend));
@@ -183,10 +208,11 @@ export function playAnimation(view: BlenderRuntimeView, bake: (armature: string,
       const stack = nlaLayers({ ...animation!, tracks: [{ ...track, mute: false, solo: false }] }, frame, (action) => clipOf(armature, action));
       if (stack.waiting) waiting = true;
       if (stack.evaluated) evaluated = true;
-      for (const layer of stack.layers) layers.push({ ...layer, influence: layer.influence * influence });
+      for (const layer of stack.layers) { layers.push({ ...layer, influence: layer.influence * influence }); sources.push(track.name); }
     }
-    for (const set of armature.tracks.values()) {
+    for (const [name, set] of armature.tracks) {
       if (!set.own || set.mute || !set.action) continue;
+      source = name;
       if (set.previous) take(playedLayer(armature, set.previous, set.influence.weight, 'REPLACE'));
       take(playedLayer(armature, set.action, set.influence.weight, 'REPLACE'));
       evaluated = true;
@@ -195,8 +221,10 @@ export function playAnimation(view: BlenderRuntimeView, bake: (armature: string,
     // no enabled track has strips, else at its influence and blend type over them.
     const nla = !!animation?.useNla;
     const strips = nla && evaluated;
+    source = null;
     for (const played of nla && solo ? [] : armature.line)
       take(playedLayer(armature, played, strips ? animation!.influence : 1, strips ? animation!.blendType : 'REPLACE'));
+    lastSources.set(armature, sources);
     return waiting ? null : layers;
   };
 
@@ -321,12 +349,26 @@ export function playAnimation(view: BlenderRuntimeView, bake: (armature: string,
         }
         const layers = layersOf(armature);
         if (!layers) continue;
+        const sources = lastSources.get(armature) ?? [];
+        armature.posed = layers.map((layer, i) => ({ track: sources[i] ?? null, action: layer.clip.action, frame: layer.frame, influence: layer.influence, blend: layer.blend }));
         armature.pose.apply(layers, {
           object: (name) => view.objectForBlenderName(name),
           override: (bone, name) => armature.constraints.get(`${bone}\u0000${name}`),
         });
       }
     },
+    channels(name, action) {
+      const clip = armatures.get(name)?.clips.get(action);
+      if (!clip) return [];
+      const bones = new Map<string, Set<number>>();
+      for (const channel of clip.channels) {
+        let frames = bones.get(channel.bone);
+        if (!frames) bones.set(channel.bone, frames = new Set());
+        for (const curve of channel.curves) if (curve) for (let i = 0; i < curve.keys.length; i += 6) frames.add(Math.round(curve.keys[i]! * 1000) / 1000);
+      }
+      return [...bones].map(([bone, frames]) => ({ bone, keys: [...frames].sort((a, b) => a - b) }));
+    },
+    live: () => [...armatures.values()].map((armature) => ({ armature: armature.rig.armature, layers: armature.posed })),
     dispose() {
       disposed = true;
       armatures.clear();

package/contributions/blender-pose.ts

@@ -20,6 +20,13 @@
  * A clip holds an action's F-Curves whole (`session.py`'s `rna_action_clip`): keys, handles,
  * interpolation, extrapolation and Cycles modifiers, evaluated as `fcurve_eval_keyframes` and
  * `fcm_cycles_time` evaluate them, so a pose is Blender's at any frame, whole or fractional.
+ *
+ * LICENCE. This file follows Blender's source (the functions named above), so it is a derivative
+ * work of Blender and is GPL-3.0-or-later, not the AGPL the package's own code carries
+ * (`../LICENSE`). Blender, Copyright (C) Blender Authors, GPL-2.0-or-later. It must not be
+ * copied into an Apache-2.0 or MIT package.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
  */
 import type { BlenderActionClip, BlenderClipCurve } from '@volter/blender-engine/browser/rna';
 import type {

package/contributions/blender-properties-context.ts

@@ -1,6 +1,6 @@
 /** Blender's Properties context remains inspectable without a selection.
  * Reuse the same RNA sections and Properties projection as selected objects. */
-import { registerNullSubjectProvider } from '@volter/editor-sdk/kit/inspection/null-subject';
+import { registerNullSubjectProvider } from '@volter/sdk/kit/inspection/null-subject';
 import { blenderOutlinerState } from './blender-outliner-model';
 import { blenderOutlinerKind } from './blender-outliner-authoring';
 import {

package/contributions/blender-properties-model.ts

@@ -34,7 +34,7 @@
  */
 
 import type { BlenderRnaContext, BlenderRnaView } from '@volter/blender-engine/browser/rna';
-import { editorHost } from '@volter/editor-sdk/host';
+import { editorHost } from '@volter/sdk/host';
 import type * as THREE from 'three';
 import {
   blenderPresentationDocumentId,
@@ -192,7 +192,7 @@ function publish(next: Partial<BlenderPropertiesState>, tabsMayHaveChanged = fal
   for (const listener of [...listeners]) listener();
   // THE TAB RAIL IS THE SECTION LIST, and section matching is the host's
   // composition — which no store of ours can move. This is the one door that
-  // re-derives it (`@volter/editor-sdk/host`, `documents.contextChanged`).
+  // re-derives it (`@volter/sdk/host`, `documents.contextChanged`).
   if (tabsMayHaveChanged) editorHost().documents.contextChanged(blenderPresentationDocumentId());
 }
 

package/contributions/blender-properties-tab.tsx

@@ -5,7 +5,7 @@
  *
  * WHY A TAB IS A SECTION, and not a rail of our own: under the `properties`
  * presentation the inspector's sections ARE the vertical icon rail, 1:1
- * (`packages/editor-sdk/src/kit/components/InspectionProjection.tsx`,
+ * (`packages/sdk/src/kit/components/InspectionProjection.tsx`,
  * `PropertiesColumn`). So the way to make Blender's tab rail appear is to
  * contribute Blender's tabs as sections — which is also exactly the shape I2
  * needs, because each of these modules then grows a CURATED body over the same
@@ -38,7 +38,7 @@
 import type {
   ToolContributionNode,
   ToolInspectorContributionProps,
-} from '@volter/editor-sdk/contributions';
+} from '@volter/sdk/contributions';
 import {
   blenderPropertiesState,
   resolveBlenderSubject,

package/contributions/blender-properties-view.tsx

@@ -55,7 +55,7 @@ import type {
 } from '@volter/blender-engine/browser/rna';
 import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
 import { faLock, faLockOpen } from '@fortawesome/free-solid-svg-icons';
-import { ColorPicker, EditorIcon, hexToRgb, parseAlpha, toHex } from '@volter/editor-sdk/widgets';
+import { ColorPicker, EditorIcon, hexToRgb, parseAlpha, toHex } from '@volter/sdk/widgets';
 import {
   type BlenderSubject,
   blenderPropertiesState,

package/contributions/blender-runtime-skin.ts

@@ -42,7 +42,7 @@
 import type { BlenderActionClip } from '@volter/blender-engine/browser/rna';
 import type { BlenderArmature } from '@volter/blender-engine/browser/three/blender-runtime-armature';
 import type { BlenderRuntimeView } from '@volter/blender-engine/browser/three/blender-runtime-view';
-import { editorHost, type StageTransportHandle } from '@volter/editor-sdk/host';
+import { editorHost, type StageTransportHandle } from '@volter/sdk/host';
 import { blenderRnaSet } from '../host/blender-runtime-host';
 import { actionLayer, ArmaturePose, nlaLayers, poseClip, poseDivergence, type PoseClip, type PoseLayer } from './blender-pose';
 
@@ -370,6 +370,40 @@ export class BlenderSkinDirector {
     this.#pose();
   }
 
+  // ------------------------------------------------------------ what the animation editors read
+
+  /** The armature the editors describe (the active object's, else the one with an action). */
+  get subject(): string | null {
+    return this.#armature;
+  }
+
+  /** Every action in the file, by name: what the Action Editor's selector offers. */
+  actionNames(): string[] {
+    return Object.keys(this.#view?.animationFacts().actions ?? {}).sort((a, b) => a.localeCompare(b));
+  }
+
+  /** The Action Editor's channels: the subject's active action, per bone, the frames it keys. */
+  channels(): { bone: string; keys: number[] }[] {
+    const bones = new Map<string, Set<number>>();
+    for (const track of this.#clip?.tracks ?? []) {
+      const raw = atob(track.keysBase64);
+      const bytes = new Uint8Array(raw.length);
+      for (let i = 0; i < raw.length; i++) bytes[i] = raw.charCodeAt(i);
+      const keys = new Float32Array(bytes.buffer, 0, bytes.length >> 2);
+      let frames = bones.get(track.bone);
+      if (!frames) bones.set(track.bone, frames = new Set());
+      for (let i = 0; i < keys.length; i += 6) frames.add(Math.round(keys[i]! * 1000) / 1000);
+    }
+    return [...bones].map(([bone, frames]) => ({ bone, keys: [...frames].sort((a, b) => a - b) }));
+  }
+
+  /** Every armature with its NLA stack and active action, as the frame describes them. */
+  stacks(): { armature: string; action: string | null; animation: BlenderArmature['animation'] }[] {
+    const facts = this.#view?.animationFacts();
+    if (!facts) return [];
+    return Object.entries(facts.armatures).map(([armature, entry]) => ({ armature, action: entry.action ?? null, animation: entry.animation }));
+  }
+
   /** The scene's name, for the one address the Timeline writes to. */
   get scene(): string | null {
     return this.#clip?.scene ?? null;

package/contributions/blender-runtime.document.tsx

@@ -26,6 +26,7 @@
 
 // How the `model` stage this document builds behaves (its starting presentation).
 import './blender-properties-context';
+import { liveAnimation, setLiveAnimation } from '../src/play-live';
 import { blenderViewFieldOfView } from '../src/presentation';
 import {
   type BlenderRuntimeView,
@@ -33,20 +34,20 @@ import {
 } from '@volter/blender-engine/browser/three/blender-runtime-view';
 import { ownedSurfaceMaterial } from '@volter/blender-engine/browser/three/blender-physical-material';
 import { createBlenderDisplayTransform, type BlenderDisplayTransform } from '@volter/blender-engine/browser/three/blender-display-transform';
-import type { ToolContributionProps, ToolDocumentToolbar } from '@volter/editor-sdk/contributions';
-import { editorHost } from '@volter/editor-sdk/host';
+import type { ToolContributionProps, ToolDocumentToolbar } from '@volter/sdk/contributions';
+import { editorHost } from '@volter/sdk/host';
 import {
   documentViewport,
   documentViewportsVersion,
   subscribeDocumentViewports,
-} from '@volter/editor-sdk/kit/document-viewports';
+} from '@volter/sdk/kit/document-viewports';
 import {
   DOCUMENT_STUDIO_PRESET,
   setViewPresentation,
   subscribeViewportPresentation,
   viewPresentation,
   viewPresentationSnapshot,
-} from '@volter/editor-sdk/kit/viewport-presentation';
+} from '@volter/sdk/kit/viewport-presentation';
 import {
   type MouseEvent as ReactMouseEvent,
   type PointerEvent as ReactPointerEvent,
@@ -79,13 +80,13 @@ import { blenderSkin } from './blender-runtime-skin';
 import { playAnimation, type PlayAnimation } from './blender-play-skin';
 import { areaSplit, subscribeAreaSplit } from '../src/area-split';
 import { noteModelDocument } from '../src/play-mode';
-import { documentPlayExtension, subscribeDocumentPlayExtensions } from '@volter/editor-sdk/kit/document-play-extension';
-import { notifyWorkspaceDocumentSelectionChanged } from '@volter/editor-sdk/kit/workspace-document-registry';
+import { documentPlayExtension, subscribeDocumentPlayExtensions } from '@volter/sdk/kit/document-play-extension';
+import { notifyWorkspaceDocumentSelectionChanged } from '@volter/sdk/kit/workspace-document-registry';
 import {
   documentSecondAreaHeader,
   setDocumentSecondArea,
   subscribeDocumentAreas,
-} from '@volter/editor-sdk/kit/document-areas';
+} from '@volter/sdk/kit/document-areas';
 import { createPortal } from 'react-dom';
 import { onViewportStages, viewportStages } from '@volter/editor-threejs/viewport-door';
 import {
@@ -93,13 +94,13 @@ import {
   subscribeObject3DDocumentSessions,
 } from '@volter/editor-threejs/kit/authoring/object3d-document-session-registry';
 import type { ToolObject3DAuthoringProps } from '@volter/editor-threejs/object3d-contributions';
-import { stageStore, subscribeStageStores } from '@volter/editor-sdk/kit/stage-store-registry';
-import { surfaceAcceptsKey } from '@volter/editor-sdk/kit/surface-keyboard';
+import { stageStore, subscribeStageStores } from '@volter/sdk/kit/stage-store-registry';
+import { surfaceAcceptsKey } from '@volter/sdk/kit/surface-keyboard';
 import { BlenderModelOpening } from './blender-model-opening';
 import { modelOpeningErrorMessage } from '../src/model-opening-error';
-import { commandLine } from '@volter/editor-sdk/kit/product-command';
-import { fontSizeVar, spaceVar, themeVars } from '@volter/editor-sdk/widgets';
-import { clearStartupFailure, reportStartupFailure } from '@volter/editor-sdk/kit/startup-failure';
+import { commandLine } from '@volter/sdk/kit/product-command';
+import { fontSizeVar, spaceVar, themeVars } from '@volter/sdk/widgets';
+import { clearStartupFailure, reportStartupFailure } from '@volter/sdk/kit/startup-failure';
 
 /** This document's model open, as a source in the page's startup-failure registry. */
 const MODEL_OPEN_STARTUP_SOURCE = 'blender-model-open';
@@ -719,7 +720,7 @@ function BlenderModelViewport(props: ToolContributionProps) {
  * THE SECOND AREA'S OWN HEADER AND SHELF, as each of Blender's areas has them.
  *
  * The area is declared to the host as the document's second area
- * (`@volter/editor-sdk/kit/document-areas`). Its HEADER stands in the document's header row over
+ * (`@volter/sdk/kit/document-areas`). Its HEADER stands in the document's header row over
  * this area: the host reserves this area's width at the row's trailing edge, so the first area's
  * header ends where the first area does, and this renders into the region it draws there: the
  * editor menus (their View ▸ Area ▸ Close Area closes this area), then THIS area's view, shading
@@ -914,6 +915,7 @@ function BlenderViewportArea({
       void view.prepareRendered(stage.rig().drawCamera(), 'render').then(() => {
         if (stopped) return;
         animation = playAnimation(view, (armature, action) => blenderActionClip({ object: armature, action }));
+        setLiveAnimation(animation);
         stopScript = documentPlayExtension('model')?.run({
           ...(animation ? { animation } : {}),
           documentId: modelId,
@@ -973,6 +975,8 @@ function BlenderViewportArea({
       stopPrepareFrames?.();
       window.removeEventListener('keydown', onEscape, true);
       stopScript?.();
+      // Only this run's animation is cleared: a restart's new run may already hold the slot.
+      if (liveAnimation() === animation) setLiveAnimation(null);
       animation?.dispose();
       animation = null;
       layers.remove();

package/contributions/blender-screenshot.menu.ts

@@ -6,9 +6,9 @@
  * goes to the project's `screenshots/` folder and the console says which file it is. Like every
  * photograph of the document it flashes the document and shows itself in the corner.
  */
-import type { MenuContribution } from '@volter/editor-sdk/chrome';
-import { editorHost } from '@volter/editor-sdk/host';
-import { announcePhotograph } from '@volter/editor-sdk/kit/photograph-notice';
+import type { MenuContribution } from '@volter/sdk/chrome';
+import { editorHost } from '@volter/sdk/host';
+import { announcePhotograph } from '@volter/sdk/kit/photograph-notice';
 
 export const point = 'workspace.menu';
 

package/contributions/blender-timeline-geometry.ts

@@ -4,8 +4,8 @@
  * own frame (5.2.1 on this box, `scripts/blender-reference-frames.py`).
  *
  * This is the first unit of the inspection arc with a sighted read behind it.
- * I1-I5 each recorded "`/Volumes/PeakSSD` was not mounted, so this is graded
- * against Blender's SOURCE alone"; Blender is installed here, the script above
+ * I1-I5 each recorded that the reference frames were not at hand, so each was graded
+ * against Blender's SOURCE alone; Blender is installed here, the script above
  * drives its real GUI, and the numbers below carry three things each: the
  * source that defines them, the pixel that confirms them, and what we draw.
  *

package/contributions/blender-timeline.document.tsx

@@ -38,8 +38,8 @@
  * you are looking.
  */
 
-import type { StageTransportHandle } from '@volter/editor-sdk/host';
-import { registerViewVerbs } from '@volter/editor-sdk/views';
+import type { StageTransportHandle } from '@volter/sdk/host';
+import { registerViewVerbs } from '@volter/sdk/views';
 import {
   type ReactNode,
   useCallback,
@@ -65,7 +65,9 @@ import {
 } from '../src/timeline-view-state';
 import { blenderSkin, blenderSkinVersion, subscribeBlenderSkin } from './blender-runtime-skin';
 import { BlenderGamePanel, GAME_PANEL_RATIO, PlayModeSwitch } from './blender-game-panel';
-import { setWorkspaceAreaRatio } from '@volter/editor-sdk/kit/workspace-areas';
+import { AnimationEditorMenu, BlenderActionEditor, BlenderNlaEditor } from './blender-animation-editors';
+import { liveAnimation, subscribeLiveAnimation } from '../src/play-live';
+import { setWorkspaceAreaRatio } from '@volter/sdk/kit/workspace-areas';
 import { modelPlayMode, playModeVersion, servedModelDocument, subscribePlayMode } from '../src/play-mode';
 import {
   CHANNEL_HEIGHT,
@@ -114,6 +116,7 @@ const REFUSALS = {
 
 /** The scene clock is available with or without an action. Only a missing
  * scene/transport prevents timeline navigation. */
+const GAME_RUNNING = 'A game is running; the Timeline is read-only until it stops (Stop in the Game panel).';
 const NOT_PLAYABLE =
   'No scene transport is attached yet; open the model document first.';
 
@@ -216,6 +219,7 @@ function report(): unknown {
     size: view.size,
     refusal: view.refusal,
     drawn: view.drawn,
+    editor: view.editor,
   };
 }
 
@@ -237,6 +241,7 @@ function report(): unknown {
  *  are fixed by this one guard: `frame`, `jump-start`, `jump-end`,
  *  `next-keyframe`, `prev-keyframe`. */
 function scrubTo(frame: number): unknown {
+  if (liveAnimation() !== null) return refuse(GAME_RUNNING);
   if (!blenderSkin.playable) return refuse(NOT_PLAYABLE);
   const handle = transport();
   if (!handle) return refuse('No stage transport is attached yet; open the model document first.');
@@ -249,6 +254,18 @@ registerViewVerbs({
   title,
   verbs: [
     { id: 'state', run: () => report() },
+    {
+      // BLENDER'S EDITOR-TYPE MENU for this area: the Timeline, the Action Editor or the NLA.
+      id: 'editor',
+      title: 'Animation: Show Editor',
+      run: (args) => {
+        const editor = args?.['editor'] ?? args?.['to'];
+        if (editor !== 'timeline' && editor !== 'action' && editor !== 'nla')
+          return refuse('editor is `timeline`, `action` (the Action Editor) or `nla`.');
+        setTimelineViewState({ editor });
+        return report();
+      },
+    },
     {
       id: 'frame',
       title: 'Timeline: Set Frame',
@@ -263,6 +280,7 @@ registerViewVerbs({
       id: 'play',
       title: 'Timeline: Play',
       run: () => {
+        if (liveAnimation() !== null) throw new Error(GAME_RUNNING);
         if (!blenderSkin.playable) throw new Error(NOT_PLAYABLE);
         const handle = transport();
         if (!handle)
@@ -364,7 +382,8 @@ registerViewVerbs({
 const BOTTOM_AREA = 'timeline';
 
 /**
- * THE BOTTOM AREA IS THE TIMELINE IN MOVIE MODE AND THE GAME PANEL IN GAME MODE
+ * THE BOTTOM AREA IS BLENDER'S ANIMATION EDITORS IN ANIMATION MODE (the Timeline, the Action
+ * Editor or the NLA, by the editor-type menu) AND THE GAME PANEL IN GAME MODE
  * (`../src/play-mode.ts`, for the model document on screen). Same area: the
  * layout's `areas` entry names this document either way. NOT THE SAME SIZE:
  * Blender's measured Timeline strip (`model.layout.ts`) left the Game panel's
@@ -378,11 +397,19 @@ const BOTTOM_AREA = 'timeline';
  */
 export default function BlenderBottomArea() {
   useSyncExternalStore(subscribePlayMode, playModeVersion, playModeVersion);
+  useSyncExternalStore(subscribeTimelineView, timelineViewVersion, timelineViewVersion);
   const documentId = servedModelDocument();
   const game = documentId !== null && modelPlayMode(documentId) === 'game';
-  useEffect(() => setWorkspaceAreaRatio(BOTTOM_AREA, game ? GAME_PANEL_RATIO : null), [game]);
+  const { editor } = timelineViewState();
+  // The Timeline keeps Blender's strip; the Action Editor and NLA list channels, so they take the
+  // Game panel's share, as a person would drag the area up to read them.
+  const tall = game || editor !== 'timeline';
+  useEffect(() => setWorkspaceAreaRatio(BOTTOM_AREA, tall ? GAME_PANEL_RATIO : null), [tall]);
   useEffect(() => () => setWorkspaceAreaRatio(BOTTOM_AREA, null), []);
-  return game ? <BlenderGamePanel /> : <BlenderTimeline />;
+  if (game) return <BlenderGamePanel />;
+  if (editor === 'action') return <BlenderActionEditor />;
+  if (editor === 'nla') return <BlenderNlaEditor />;
+  return <BlenderTimeline />;
 }
 
 function BlenderTimeline() {
@@ -562,7 +589,7 @@ function BlenderTimeline() {
   const scrubFromPointer = useCallback(
     (clientX: number) => {
       const element = canvas.current;
-      if (!element) return;
+      if (!element || liveAnimation() !== null) return;
       const box = element.getBoundingClientRect();
       transport()?.seekFrame(Math.round(toFrame(clientX - box.left)));
     },
@@ -878,14 +905,17 @@ function TimelineHeader() {
   useSyncExternalStore(subscribeTimelineView, timelineViewVersion, timelineViewVersion);
   const play = blenderSkin.state();
   const unit = TIMELINE_CHROME.unit;
+  // WHILE A GAME RUNS the transport is held: the game owns its copy, and moving the document's
+  // frame under it would put two clocks on one picture.
+  const gameRunning = useSyncExternalStore(subscribeLiveAnimation, liveAnimation, () => null) !== null;
   // Static scenes have a timeline too. Disable only while its scene/transport
   // is unavailable, using the same condition as the command door.
-  const playable = blenderSkin.playable;
+  const playable = blenderSkin.playable && !gameRunning;
   const button = (key: string, glyph: ReactNode, onClick: () => void, label: string) => (
     <button
       key={key}
       type="button"
-      title={playable ? label : `${label} — ${NOT_PLAYABLE}`}
+      title={playable ? label : `${label} — ${gameRunning ? GAME_RUNNING : NOT_PLAYABLE}`}
       aria-label={label}
       disabled={!playable}
       onClick={onClick}
@@ -923,9 +953,10 @@ function TimelineHeader() {
         borderBottom: `1px solid ${TIMELINE_CHROME.rule}`,
       }}
     >
-      {/* GAME | MOVIE in place of the title, as in the Game panel, so the person switches back
+      {/* GAME | ANIMATION in place of the title, as in the Game panel, so the person switches back
           from either (`blender-game-panel.tsx`); without a Play tool or a model, the title. */}
       <PlayModeSwitch title="Timeline" />
+      <AnimationEditorMenu />
       <TimelineViewMenu />
       {/* TWO SPACERS, which is what CENTRES the transport. Blender's Timeline
           header is three clusters: the menus at the leading edge, the

package/contributions/blender-uv-editor.document.tsx

@@ -30,7 +30,7 @@
  */
 
 import type { BlenderUvLayout } from '@volter/blender-engine/browser/rna';
-import { registerViewVerbs } from '@volter/editor-sdk/views';
+import { registerViewVerbs } from '@volter/sdk/views';
 import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
 import {
   blenderRnaVersion,

package/contributions/blender-version.status.tsx

@@ -20,7 +20,7 @@
  * host imports (`validate-editor-closure.mjs`), the first package to reach
  * that destination, and a token NAME is the published contract while the
  * handle object is the host's own sugar. The widget kit's move to
- * `@volter/editor-sdk/widgets` is deferred (WORK.md §Skews as packages, item 5);
+ * `@volter/sdk/widgets` is deferred (WORK.md §Skews as packages, item 5);
  * until it lands, a package styling inline writes the `var()`.
  *
  * Nothing before a project is open (there is no version to tell the truth
@@ -33,7 +33,7 @@
  * only the version, and the host's counters are untouched.
  */
 
-import { editorHost } from '@volter/editor-sdk/host';
+import { editorHost } from '@volter/sdk/host';
 import { useSyncExternalStore } from 'react';
 
 export const point = 'workspace.status';

package/contributions/blender.command.ts

@@ -1,5 +1,5 @@
 /**
- * THE BLENDER VERBS of the session wire (`@volter/editor-sdk/commands`, a
+ * THE BLENDER VERBS of the session wire (`@volter/sdk/commands`, a
  * `workspace.command` contribution): `blender-start`, `blender-stop`,
  * `blender-execute`, `blender-scene-info`, `blender-object-info`,
  * `blender-screenshot-view`, `blender-read-file`, `blender-write-file`,
@@ -26,13 +26,13 @@
  * `@editor/shell-store-door` to hand to the runtime host, which needed it for
  * one call — presenting the Model document — and that call is now
  * `host.workspace.open`, an address the door routes. A handler's whole context
- * is the command it is given plus `@volter/editor-sdk/host`.
+ * is the command it is given plus `@volter/sdk/host`.
  */
 import type {
   CommandContribution,
   CommandDerivedRefresh,
   CommandSpec,
-} from '@volter/editor-sdk/commands';
+} from '@volter/sdk/commands';
 import { handleBlenderCommand } from '../host/blender-runtime-host';
 
 export const point = 'workspace.command';

package/contributions/blender.environment.ts

@@ -1,11 +1,11 @@
 /**
  * BLENDER'S WORLD STUDIO LIGHTS: the eight HDRIs Blender ships for Material Preview
  * (`datafiles/studiolights/world`, copied from Blender 5.2), registered as environment images
- * (`@volter/editor-sdk/kit/environment-images`) so a view can light by one and draw it behind
+ * (`@volter/sdk/kit/environment-images`) so a view can light by one and draw it behind
  * the scene. Material Preview opens on Forest. All CC0, by Greg Zaal (Poly Haven); the terms
  * and each original are in `studiolights/world/license.txt`.
  */
-import type { EnvironmentImageSet } from '@volter/editor-sdk/kit/environment-images';
+import type { EnvironmentImageSet } from '@volter/sdk/kit/environment-images';
 import city from './studiolights/world/city.exr?url';
 import courtyard from './studiolights/world/courtyard.exr?url';
 import forest from './studiolights/world/forest.exr?url';

package/contributions/blender.keymap.ts

@@ -1,5 +1,5 @@
 /**
- * The BLENDER keymap (`@volter/editor-sdk/looks`, a `workspace.keymap`
+ * The BLENDER keymap (`@volter/sdk/looks`, a `workspace.keymap`
  * contribution). Only the chords that differ from the editor's own are
  * declared; the host fills the rest from its default table.
  *
@@ -7,7 +7,7 @@
  * `scripts/presets/keyconfig/keymap_data/blender_default.py` at the engine's
  * pin (v5.2.0) — the file that IS the "Blender" keyconfig.
  */
-import type { KeymapContribution } from '@volter/editor-sdk/looks';
+import type { KeymapContribution } from '@volter/sdk/looks';
 
 export const point = 'workspace.keymap';
 export const keymap: KeymapContribution = {

package/contributions/blender.status.tsx

@@ -22,9 +22,9 @@
  * about THIS editor, so the labels are read from this editor's own contract,
  * never transcribed from the reference:
  *
- *   - the KEYMAP (`keymap-presets.ts`, `@volter/editor-sdk/looks`) binds no
+ *   - the KEYMAP (`keymap-presets.ts`, `@volter/sdk/looks`) binds no
  *     mouse buttons and structurally cannot: a `KeyChord` is
- *     `{ key, code?, mod?, shift?, alt? }` (`editor-sdk/src/looks.ts:76-82`)
+ *     `{ key, code?, mod?, shift?, alt? }` (`sdk/src/looks.ts:76-82`)
  *     with no button field, so no keymap — the Blender one included — can
  *     move a mouse binding. Nothing to read there.
  *   - so the source is the VIEWPORT's own mouse contract: