@volter/editor-game 0.5.65 → 0.5.67

package/src/play/play-mode.ts

@@ -1,4 +1,5 @@
-import { onAssetReload } from '@volter/editor-core/project-asset-refresh';
+import { onAssetReload } from '@volter/editor-sdk/kit/project-asset-refresh';
+import { evictDreiCaches } from '../three/drei-asset-caches';
 import { editorHost } from '@volter/editor-sdk/host';
 
 /**
@@ -14,45 +15,45 @@ import { editorHost } from '@volter/editor-sdk/host';
  */
 
 import { installAdapterRuntimeBindings } from '../host/adapter-runtime-bindings';
-import { getAuthoringOverride, setActiveAuthoring } from '@volter/editor-core/authoring/active-adapter';
+import { getAuthoringOverride, setActiveAuthoring } from '@volter/editor-sdk/kit/authoring/active-adapter';
 import {
   getActiveNetworking,
   inspectedInstanceId,
   setActiveSystems,
   setInspectedInstance,
   updateInstanceSystems,
-} from '@volter/editor-core/authoring/active-systems';
-import { BoundaryAuthoringAdapter } from '@volter/editor-core/authoring/boundary-authoring-adapter';
+} from '@volter/editor-sdk/kit/authoring/active-systems';
+import { BoundaryAuthoringAdapter } from '@volter/editor-sdk/kit/authoring/boundary-authoring-adapter';
 import {
   CompositeAuthoringAdapter,
   type CompositeChild,
-} from '@volter/editor-core/authoring/composite-authoring-adapter';
+} from '@volter/editor-sdk/kit/authoring/composite-authoring-adapter';
 import { createEphemeralPersistence } from '../host/authoring/ephemeral-persistence';
 import {
   EPHEMERAL_DESTINATION,
   resolvesLiveOnly,
   runWritePipe,
   type WriteAck,
-} from '@volter/editor-core/authoring/write-pipe';
+} from '@volter/editor-sdk/kit/write-pipe';
 import { resolveAllRootEntries } from '../host/binding-resolver';
-import type { LogEntry } from '@volter/editor-core/editor-api';
-import { endLogSession, flushLogEntries, startLogSession } from '@volter/editor-core/editor-api';
-import type { ConsoleEntry } from '@volter/editor-core/editor-console';
+import type { LogEntry } from '@volter/editor-sdk/kit/editor-api';
+import { endLogSession, flushLogEntries, startLogSession } from '@volter/editor-sdk/kit/editor-api';
+import type { ConsoleEntry } from '@volter/editor-sdk/kit/editor-console';
 import {
   editorConsole,
   formatConsoleArgs,
   resumeEditorConsoleCapture,
   suspendEditorConsoleCapture,
-} from '@volter/editor-core/editor-console';
-import { EDITOR_PARTICIPANT_ID, sendControl } from '@volter/editor-core/editor-presence';
+} from '@volter/editor-sdk/kit/editor-console';
+import { EDITOR_PARTICIPANT_ID, sendControl } from '@volter/editor-sdk/kit/editor-presence';
 import {
   isEditorPresentationActive,
   subscribeEditorPresentationActivity,
-} from '@volter/editor-core/editor-presentation-activity';
-import type { EditorShellStore } from '@volter/editor-core/editor-shell-store';
+} from '@volter/editor-sdk/kit/editor-presentation-activity';
+import type { EditorShellStore } from '@volter/editor-threejs/kit/editor-shell-store';
 import { GAME_SURFACE_CONTAINMENT_CSS } from '../host/game-realm-page';
 import { reclaimGameRealm } from '../host/game-realm-reclaim';
-import { toolContributionRecording } from '@volter/editor-core/gameplay-sessions';
+import { toolContributionRecording } from '@volter/editor-sdk/kit/gameplay-sessions';
 import {
   clearGameSurface,
   currentGameRealmMountId,
@@ -60,53 +61,52 @@ import {
   setGameInputGate,
   setGameSurface,
 } from '../host/gated-globals';
-import { hierarchyProjectionFromProjectConfig } from '@volter/editor-core/hierarchy-projection';
+import { hierarchyProjectionFromProjectConfig } from '@volter/editor-sdk/kit/hierarchy-projection';
 import { type JournalSubject, playJournal } from '../host/history/json-history-resource';
-import { isEditableTarget, setActiveScope } from '@volter/editor-core/hotkeys';
-import { projectBootstrapSettled } from '@volter/editor-core/initial-project';
-import { registerGameNullSubject } from '@volter/editor-core/inspection/game-subject';
-import { fetchGameManifest } from '@volter/editor-core/manifest-project';
-import { registerPerformanceSource } from '@volter/editor-core/performance-sources';
+import { isEditableTarget, setActiveScope } from '@volter/editor-sdk/kit/hotkeys';
+import { projectBootstrapSettled } from '@volter/editor-sdk/kit/initial-project';
+import { registerGameNullSubject } from '@volter/editor-sdk/kit/inspection/game-subject';
+import { fetchGameManifest } from '@volter/editor-sdk/kit/manifest-project';
+import { registerPerformanceSource } from '@volter/editor-sdk/kit/performance-sources';
 import {
   beginPlayBoot,
   endPlayBoot,
   markPlayBootPhase,
   type PlayBootPhase,
-} from '@volter/editor-core/play-boot-phase';
-import { presentationSurface } from '@volter/editor-core/presentation-surface';
-import { getCurrentProject } from '@volter/editor-core/project-manager';
+} from '@volter/editor-sdk/kit/play-boot-phase';
+import { presentationSurface } from '@volter/editor-sdk/kit/presentation-surface';
+import { getCurrentProject } from '@volter/editor-sdk/kit/active-project';
 import {
   beginProjectModuleSplitWatch,
   clearProjectModuleSplitReports,
   endProjectModuleSplitWatch,
   formatProjectModuleSplitMessage,
-} from '@volter/editor-core/project-module-split';
-import { clearRootReadiness, recordRootReadiness } from '@volter/editor-core/readiness';
-import { onShellStore } from '@volter/editor-core/shell-store-door';
-import { mountedStoryHasPixiContent } from '@volter/editor-core/stories/pixi-story-model';
+} from '@volter/editor-sdk/kit/project-module-split';
+import { clearRootReadiness, recordRootReadiness } from '@volter/editor-sdk/kit/readiness';
+import { mountedStoryHasPixiContent } from '../host/stories/pixi-story-model';
 import { domHasRenderableContent, threeSceneHasRenderableContent } from '../host/surface-content';
-import { subscribeSurfaceKeyboard, surfaceHoldsKeyboard } from '@volter/editor-core/surface-keyboard';
-import { publishToolContributionPlay } from '@volter/editor-core/tool-contribution-play';
-import { liveWorldId } from '../host/viewport-root-presentation';
+import { surfaceHoldsKeyboard } from '@volter/editor-sdk/kit/surface-keyboard';
+import { publishToolContributionPlay } from '@volter/editor-sdk/kit/tool-contribution-play';
+import { liveWorldId, presentThreeRoots } from '../host/viewport-root-presentation';
 import {
   cancelPendingWorkspacePlayUtilities,
   revealWorkspacePlayUtilities,
-} from '@volter/editor-core/workspace-play-utilities';
+} from '@volter/editor-sdk/kit/workspace-play-utilities';
 import { markGameCssScope } from '@volter/editor-sdk/session/game-css-scope';
 import type { EntrypointSelectionOverride } from '@volter/editor-sdk/session/project-module-url';
 import { isEditorLanePath } from '@volter/editor-sdk/session/tool-contribution-convention';
-import { getSeededRandom, type SeededRandom } from '@volter/game-runtime/core/seeded-random';
-import { _engineLogActive } from '@volter/game-runtime/dev/logger';
-import type { PerformanceProfiler } from '@volter/game-runtime/dev/performance-profiler';
-import type { GameSession } from '@volter/game-runtime/runtime/create-runtime';
+import { getSeededRandom, type SeededRandom } from '../runtime/core/seeded-random';
+import { _engineLogActive } from '../runtime/dev/logger';
+import type { PerformanceProfiler } from '../runtime/dev/performance-profiler';
+import type { GameSession } from '../runtime/create-runtime';
 import {
   type DebugVirtualInputTarget,
   getDebugRegistry,
   type RunTicksOptions,
-} from '@volter/game-runtime/runtime/debug-registry';
-import type { GameLoop, RootInstance } from '@volter/game-runtime/runtime/game';
-import type { PlaytestContext } from '@volter/game-runtime/runtime/playtest';
-import { runTicksWhenSettled } from '@volter/game-runtime/runtime/run-ticks-settled';
+} from '../runtime/debug-registry';
+import type { GameLoop, RootInstance } from '../runtime/game';
+import type { PlaytestContext } from '../runtime/playtest';
+import { runTicksWhenSettled } from '../runtime/run-ticks-settled';
 import {
   type AuthoringAdapter,
   type InspectorProvider,
@@ -118,6 +118,7 @@ import { declaredRoots, rootById } from '@volter/editor-project/adapter/manifest
 import { readOidSourceAnchors } from '../three/authoring/oid-source-persistence';
 import { oidThree, structuralThree } from '../three/authoring/three-authoring-adapter';
 import type * as THREE from 'three';
+import { threeRoot } from '@volter/editor-threejs/adapter/three-contract';
 import { deviceEmulatedPixelRatio } from '../game-document/device-preview';
 import { exitDeferredIngestPlay, mountDeferredIngestForPlay } from '../ingest/deferred-ingest-play';
 import { getIngestPlayControl } from '../ingest/ingest-play-control';
@@ -125,6 +126,8 @@ import { withPlayBootStallGuard } from './play-boot-stall';
 import { debugEventsToLogEntries } from './play-log-events';
 import { bindPlayRecordingStop, endPlayRecording } from './play-recording';
 import { createReactPlayAuthoringAdapter } from './react-play-live-authoring';
+import { onThreeStore } from '@volter/editor-threejs/kit/three-state';
+import { presentViewportRoots } from '@volter/editor-threejs/viewport-door';
 
 /** Context needed by the orchestrator (passed from the world root's stage). */
 export interface PlayModeContext {
@@ -250,8 +253,8 @@ let _hostMountedReadyRootIds: readonly string[] = [];
 // id) resolves to the primary, so the default — and the single-instance case —
 // is "the primary has the keyboard", exactly as before split screen existed.
 // A click on an instance's viewport routes the keyboard to it
-// (`setFocusedInstance`); the input gate + InputManager for every instance read
-// this, so exactly the focused one is live and the rest are inert.
+// (`setFocusedInstance`); every instance's input gate reads this, so exactly
+// the focused one is live and the rest are inert.
 let _focusedInstanceId: string | null = null;
 const focusListeners = new Set<() => void>();
 
@@ -292,7 +295,6 @@ export function setFocusedInstance(id: string): void {
   setInspectedInstance(id);
   if (focusedInstanceId() === id) return;
   _focusedInstanceId = id;
-  resyncInstanceInputs();
   notifyFocusedInstance();
 }
 
@@ -300,59 +302,23 @@ export function setFocusedInstance(id: string): void {
  *  Game tab is active, this instance holds keyboard focus, AND our surface
  *  holds the keyboard.
  *
- *  The fourth term is U2's, and it exists for the engine's `InputManager`
- *  specifically. `gated-globals.ts` already ANDs the same predicate into every
- *  raw `window`/`document` listener a PROJECT module registers, but
- *  `InputManager` is `@volter/game-runtime`'s — a dependency, not a project module, so
- *  the dev server's lexical shadow never covers it and it attaches to the real
- *  `window`. Under the Code-OSS frame that window also carries Monaco, so
- *  without this a keystroke meant for the source file beside the running game
- *  moves the game too. Standalone it is a constant true and nothing changes.
- *  See `@editor/surface-keyboard`. */
+ *  The fourth term is U2's: `gated-globals.ts` ANDs this predicate into every
+ *  raw `window`/`document` listener a project module registers, and under the
+ *  Code-OSS frame that window also carries Monaco, so without it a keystroke
+ *  meant for the source file beside the running game moves the game too.
+ *  Standalone it is a constant true and nothing changes. See
+ *  `@editor/surface-keyboard`. */
 function instanceInputActive(id: string): boolean {
   if (!_ctx) return false;
   const { store } = _ctx;
   return (
-    store.playState === 'playing' &&
-    store.activeViewportTab === 'play' &&
+    store.shell.playState === 'playing' &&
+    store.shell.activeViewportTab === 'play' &&
     focusedInstanceId() === id &&
     surfaceHoldsKeyboard()
   );
 }
 
-/** The first-party `InputManager` for an instance, or `undefined` — a session's
- *  game handle may lack one (an ingest mount, a partial double), so resolve it
- *  defensively. */
-function instanceInput(inst: PlayInstance): { setEnabled(on: boolean): void } | undefined {
-  try {
-    return inst.session?.game?.input;
-  } catch {
-    return undefined;
-  }
-}
-
-/** Re-apply the enabled/disabled state of every live instance's InputManager
- *  from the current play/tab/focus predicate. Called whenever any of those
- *  change (store subscription, focus switch, an instance mounting). The raw
- *  window/document gates are closures over `instanceInputActive`, so they need
- *  no re-registration — they re-read focus on every event. */
-function resyncInstanceInputs(): void {
-  if (_instance.id) instanceInput(_instance)?.setEnabled(instanceInputActive(_instance.id));
-  for (const inst of _additional) instanceInput(inst)?.setEnabled(instanceInputActive(inst.id));
-}
-
-/**
- * THE SURFACE TERM'S OWN EDGE. The store subscription re-gates on play/tab
- * changes and `setFocusedInstance` on focus changes, but the fourth term above
- * moves on neither: a person clicks into Monaco and nothing in the editor's own
- * state has changed. `InputManager` is a LATCHED `setEnabled`, so unlike the
- * raw gates (closures re-read per event) it has to be told. Module scope and
- * never unsubscribed on purpose — the notification is a no-op with no instances
- * mounted, and a lane-scoped subscription would have to be rebuilt on every
- * mount for a predicate that is process-wide.
- */
-subscribeSurfaceKeyboard(resyncInstanceInputs);
-
 let _ctx: PlayModeContext | null = null;
 const playModeBindingWaiters = new Set<() => void>();
 
@@ -512,7 +478,6 @@ export async function runWarmRestartPauseBracket(
     if (!wasPaused) session.resume();
   }
 }
-let _unsubStore: (() => void) | null = null;
 /** Browser-mode component-source watch (Phase A2); null in server mode / stopped. */
 /**
  * The authoring override that was active before THIS play session installed its
@@ -657,7 +622,7 @@ async function installPlayRootAuthoring(
       children.push({
         worldId: world.id,
         kind: world.kind,
-        adapter: new BoundaryAuthoringAdapter(store, {
+        adapter: new BoundaryAuthoringAdapter(store.shell, {
           id: world.id,
           kind: world.kind,
           adapter: declaration.adapter.identity,
@@ -671,24 +636,25 @@ async function installPlayRootAuthoring(
     }
     const mounted = world.mounted;
     if (mounted.kind === 'three') {
+      const scene = threeRoot(mounted).scene;
       // The presented subject uses OID identity so Edit→Play selection stays
       // continuous. A headless or non-Three host can omit presentation; its
       // mounted tree still gets an honest structural live projection.
       // `frameControl: 'host'` on the structural branch follows from the same
       // tick-ownership fact: play's own loop drives the root and this adapter
       // holds no handle that can stop it for a gesture.
-      const isPresentedSubject = world.id === presentedWorldId && mounted.scene === store.scene;
+      const isPresentedSubject = world.id === presentedWorldId && scene === store.scene;
       const sourceAnchor = isPresentedSubject ? await readOidSourceAnchors() : undefined;
       if (!isCurrentGeneration()) {
         abandon();
         return;
       }
       const adapter = isPresentedSubject
-        ? oidThree(store, mounted.scene, liveWorldId(world.id), playRunJournal(world.id), {
+        ? oidThree(store, scene, liveWorldId(world.id), playRunJournal(world.id), {
             explicitSourceCommit: true,
             sourceAnchor,
           })
-        : structuralThree(store, mounted.scene, {
+        : structuralThree(store, scene, {
             frameControl: 'host',
             journal: playRunJournal(world.id),
           });
@@ -733,7 +699,7 @@ async function installPlayRootAuthoring(
       }
       if (mounted.substrate.name !== 'pixi') {
         const adapter = new BoundaryAuthoringAdapter(
-          store,
+          store.shell,
           {
             id: world.id,
             kind: world.kind,
@@ -751,8 +717,8 @@ async function installPlayRootAuthoring(
       const stage = mounted.substrate.root as import('pixi.js').Container;
       const [physicsRegistry, physicsAdapters, pixiAuthoring, pixiWriteTarget, canvasRuntime] =
         await Promise.all([
-          import('@volter/game-runtime/pixi/physics-registry'),
-          import('@volter/game-runtime/pixi/system-adapters'),
+          import('../runtime/pixi/physics-registry'),
+          import('../runtime/pixi/system-adapters'),
           import('../host/authoring/pixi-authoring-adapter'),
           import('../host/authoring/pixi-live-write-target'),
           import('../host/canvas-entry-runtime'),
@@ -826,7 +792,7 @@ async function installPlayRootAuthoring(
   // the left hierarchy panel only re-checks `hasAuthoringOverride()` when the
   // store notifies (same reason `ingest/mount-ingest-root.ts` calls this right after
   // installing its own override).
-  store.notifyIngestEdit();
+  store.shell.notifyIngestEdit();
 
   // Dev/e2e diagnostic handle — the SAME pattern `ingest/mount-ingest-root.ts`'s
   // `window.__vgaiIngest`/`window.__vgaiIngest2D` use:
@@ -868,7 +834,7 @@ function exitPlayRootAuthoring(store: EditorShellStore): void {
   // Play edits are session-local by architecture: nothing this run journaled
   // may still be undoable once the run is over.
   if (_instance.journalSession) {
-    store.projectHistory?.expireSession(_instance.journalSession);
+    store.shell.projectHistory?.expireSession(_instance.journalSession);
     _instance.journalSession = '';
   }
   if (import.meta.env.DEV) {
@@ -945,7 +911,9 @@ function drainDebugEventsToPlayLog(): void {
 }
 
 // Asset bytes have changed, but a running game retains its own instances.
-const stopAssetReload = onAssetReload(() => {
+const stopAssetReload = onAssetReload((paths) => {
+  // Cleared whether or not a run is live, so the next run loads the new bytes.
+  void evictDreiCaches(paths);
   if (!_instance.session) return;
   markRestartRequired(
     'Project assets changed — restart play to load the revised models or textures.',
@@ -1036,7 +1004,7 @@ function focusGameSurface(): void {
  * workspace panel names Play to hand it the store; the authored viewport is
  * read through `viewport-door.ts` when a session presents its roots.
  */
-onShellStore((store) => bindPlayMode(store));
+onThreeStore((store) => bindPlayMode(store));
 
 export function bindPlayMode(store: EditorShellStore): void {
   _ctx = { store, gameContainer: null! }; // set dynamically from the live document's container
@@ -1044,9 +1012,9 @@ export function bindPlayMode(store: EditorShellStore): void {
   // game's, and what decides is the workbench: our stage actions carry a
   // `when` clause over `vgai.stage.focused`/`vgai.play`, so a bare key reaches
   // the game rather than a shell binding, and a ⌘-chord stays the workbench's.
-  // The engine's own `InputManager` gate tracks the same predicate
-  // independently (`gated-globals.ts` and `surface-keyboard.ts`), which is what
-  // keeps a game's raw `window.addEventListener('keydown')` gated too.
+  // The realm gate tracks the same predicate independently (`gated-globals.ts`
+  // and `surface-keyboard.ts`), which is what keeps a game's raw
+  // `window.addEventListener('keydown')` gated too.
   // The idle auto-stop needs a way to end play without `play-recording.ts`
   // importing the play lifecycle it is driven BY. Handed over here rather than
   // at module scope so the two directions of the edge stay one-way.
@@ -1060,7 +1028,7 @@ export function isPlayModeActive(): boolean {
 }
 
 /**
- * Narrow relay accessor — the live play session's `InputManager`(s)
+ * Narrow relay accessor — the live play session's virtual input targets
  * and the Game root's loop, for `command-listener.ts`'s
  * `inject-input`/`set-time-scale`/`set-seed` cases. This is exactly the
  * accessor the vgai-sdk honest-gap jsdocs prescribed
@@ -1070,13 +1038,7 @@ export function isPlayModeActive(): boolean {
  * `setActiveSystems`/`getActiveSystems` instead.
  *
  * `getInputTarget(worldId?)` (D15/T-D15.5 — review objection 2's fix)
- * REPLACES what used to be a plain `input: Game['input'] | null` field —
- * `Game.input` always resolves to the DEFAULT world's `InputManager` only,
- * while the debug bridge's `window.__vgai.input.*` reached whichever world's
- * `InputManager` last called `DebugRegistry.setVirtualInputTarget` (a
- * SEPARATE, last-writer-wins slot). In a multi-world project those two could
- * name DIFFERENT roots — the exact closed-PR review objection. Now both
- * doors call the SAME `getDebugRegistry(game).getVirtualInputTarget(worldId)`
+ * is one resolution for every input door: both the SAME `getDebugRegistry(game).getVirtualInputTarget(worldId)`
  * — one resolution function (`debug-registry.ts`'s `resolveInputRootId`),
  * so `inject-input` (this accessor) and `window.__vgai.input.*`
  * (`debug-bridge.ts`) can never disagree about which world an unqualified
@@ -1132,7 +1094,7 @@ export function getPlayRuntimeAccess(): {
 /** Get the running game's scene (for editor Scene tab rendering). */
 export function getGameScene(): THREE.Scene | null {
   const mounted = _instance.session?.game.defaultRoot.mounted;
-  return mounted?.kind === 'three' ? mounted.scene : null;
+  return mounted?.kind === 'three' ? threeRoot(mounted).scene : null;
 }
 
 export interface GameRootSurfaceFact {
@@ -1149,7 +1111,7 @@ export function gameRootSurfaceFacts(): readonly GameRootSurfaceFact[] {
     const mounted = root.mounted;
     let hasRenderableContent = false;
     if (mounted.kind === 'three') {
-      hasRenderableContent = threeSceneHasRenderableContent(mounted.scene);
+      hasRenderableContent = threeSceneHasRenderableContent(threeRoot(mounted).scene);
     } else if (mounted.kind === 'canvas') {
       try {
         hasRenderableContent =
@@ -1648,7 +1610,7 @@ async function enterPlayModeInner(
   editorHost().viewport.transition.begin();
 
   // setPlayState auto-switches to Game tab
-  store.setPlayState('playing');
+  store.shell.setPlayState('playing');
   // THE GAME TAKES THE KEYBOARD AS PLAY STARTS. Until the player clicks the
   // pane, focus stays on the transport button they pressed and the hotkey
   // scope on the workspace — so the next Enter or Space activates that
@@ -1660,7 +1622,7 @@ async function enterPlayModeInner(
   editorConsole.log('Play mode started', 'play-mode');
   // Apply the project's adapter-declared utilities after transient Play chrome settles.
   editorHost().viewport.transition.onSettled(() => {
-    if (epoch === _playEpoch && store.playState === 'playing') revealWorkspacePlayUtilities();
+    if (epoch === _playEpoch && store.shell.playState === 'playing') revealWorkspacePlayUtilities();
   });
 
   // WHAT THIS BOOT CREATED, BEFORE ANYTHING ELSE CAN REACH IT. `_instance.id`
@@ -1743,7 +1705,7 @@ async function enterPlayModeInner(
     // MEASURED at N=20000: the block that ate three command budgets started
     // here and ran for 199.5s with nothing anywhere able to name it.
     markPlayBootPhase('mounting the runtime roots');
-    const { mountManifestRoots } = await import('@volter/game-runtime/runtime/mount-manifest');
+    const { mountManifestRoots } = await import('../runtime/mount-manifest');
     session = await mountManifestRoots({
       manifest,
       container: gameContainer,
@@ -1815,13 +1777,18 @@ async function enterPlayModeInner(
     }
     notifySessionListeners();
     // D19: play edits are session-local regardless of world count.
-    store.setPlayEditRegime('ephemeral');
+    store.shell.setPlayEditRegime('ephemeral');
 
     // Swap store to game scene so hierarchy/inspector show game entities.
     // liveHierarchy: first-party play mode is the ONLY adoption path that may
     // synthesize descriptors for untagged runtime objects (anti-shim rule —
     // ingest/module mounts adopt foreign scenes and must never fabricate).
-    _instance.presentation = editorHost().viewport.presentRoots(session.game.roots);
+    // With no stage bound to present them (no Scene tab open: the Game tab and a model document
+    // are the whole layout), Play still adopts its roots, so the hierarchy door and every
+    // inspector reach the live objects exactly as they do beside a Scene tab.
+    _instance.presentation =
+      presentViewportRoots(session.game.roots) ??
+      presentThreeRoots(store, session.game.roots);
     markPlayBootPhase('installing play authoring for each root');
     await installPlayRootAuthoring(
       store,
@@ -1870,8 +1837,7 @@ async function enterPlayModeInner(
       }) ?? null;
 
     // T6.3: gate game input (raw `window`/`document` listeners in game code via
-    // gated-globals, AND the default world's first-party InputManager) to only
-    // fire while play is actually running AND the Game tab is the focused
+    // gated-globals) to only fire while play is actually running AND the Game tab is the focused
     // viewport — so keystrokes typed into the editor (Scene tab, inspector
     // fields) don't leak into the running game.
     // The gate is FOCUS-AWARE (`instanceInputActive`): input flows only while
@@ -1883,14 +1849,11 @@ async function enterPlayModeInner(
     // baked into their own urls, so the gate has to be registered under it or
     // the modules find the default realm's gate instead of their own.
     setGameInputGate(() => instanceInputActive(mountId), mountId);
-    // Sync EVERY live instance's first-party InputManager from the play/tab/
-    // focus predicate whenever the store changes (a tab switch flips the active
-    // viewport for all of them). `resyncInstanceInputs` resolves each
-    // instance's `game.input` defensively — a session whose game handle has no
-    // first-party InputManager (an ingest mount, a partial double) has only the
-    // raw window/document gate above.
-    resyncInstanceInputs();
-    _unsubStore = store.subscribe(resyncInstanceInputs);
+    // THE DEFAULT REALM follows the focused instance too. Module-lifetime code
+    // that no mount id reaches lives there — a game's own input store,
+    // attached at module load — and the stop path leaves it open, so a key
+    // aimed at a Model document while the game played still reached it.
+    setGameInputGate(() => instanceInputActive(focusedInstanceId()));
 
     // Node-id keyed only: `setEcsSyncTransform` hands this an editor node id
     // and a THREE `Transform`, which a display-keyed carrier has no values for.
@@ -2005,7 +1968,7 @@ export async function mountAdditionalInstance(
   }
   markGameCssScope(container);
   setGameSurface(container, mountId);
-  const { mountManifestRoots } = await import('@volter/game-runtime/runtime/mount-manifest');
+  const { mountManifestRoots } = await import('../runtime/mount-manifest');
   const session = await mountManifestRoots({
     manifest,
     container,
@@ -2056,15 +2019,12 @@ export async function mountAdditionalInstance(
     }) ?? null;
   // FOCUS-AWARE input, exactly like the primary: this instance takes the shared
   // keyboard only while it holds focus. It mounts UNFOCUSED (the primary keeps
-  // focus), so its gate is closed and its InputManager is disabled until a click
+  // focus), so its gate is closed until a click
   // on its viewport routes focus here (`setFocusedInstance`). This is what stops
   // the pre-focus bug where every seat took the same keystroke, AND what lets
   // you drive a chosen seat manually rather than only via autoplay.
   setGameInputGate(() => instanceInputActive(mountId), mountId);
   _additional.push(inst);
-  // Now that it is in `_additional`, sync its (and every) InputManager to the
-  // current focus — disabled here, since the primary is focused.
-  resyncInstanceInputs();
 
   // `setActiveSystems` moved editor focus (`getActiveSystems`) onto the newer
   // mount. The user is still authoring the PRIMARY, so restore its focus
@@ -2139,11 +2099,10 @@ export function unmountAdditionalInstance(id: string): void {
   inst.container = null;
   inst.session = null;
   // If the removed instance held keyboard focus, focus falls back to the primary
-  // (`focusedInstanceId` already resolves a stale id to it); re-sync so the
-  // primary's InputManager re-enables, and notify the viewport highlight.
+  // (`focusedInstanceId` already resolves a stale id to it); notify the
+  // viewport highlight.
   if (_focusedInstanceId === id) {
     _focusedInstanceId = null;
-    resyncInstanceInputs();
     notifyFocusedInstance();
   }
   notifySessionListeners();
@@ -2296,7 +2255,7 @@ export function exitPlayMode(): void {
   exitPlayRootAuthoring(store);
   restorePriorAuthoring();
   // Readout-only — clear the regime the moment play is no longer active.
-  store.setPlayEditRegime(null);
+  store.shell.setPlayEditRegime(null);
 
   // Always null _instance.session even if stop() throws — otherwise enterPlayMode's
   // `if (_instance.session) return` guard would permanently block re-entering play mode.
@@ -2325,11 +2284,9 @@ export function exitPlayMode(): void {
   _hostMountedReadyRootIds = [];
 
   // Cleanup subscriptions
-  _unsubStore?.();
-  _unsubStore = null;
 
-  // T6.3: no game running — game input (raw window/document listeners AND the
-  // InputManager sync above) should never be suppressed again until the next
+  // T6.3: no game running — game input (raw window/document listeners) should
+  // never be suppressed again until the next
   // play session re-gates it. The mount's own gate is DROPPED rather than set
   // to always-true: its id is never reused, so overwriting would retain one
   // dead closure per play run.
@@ -2378,7 +2335,7 @@ export function exitPlayMode(): void {
   // that FAILED before ever flipping the store to 'playing' never produces
   // that edge, so release directly too — `releaseGameDocument` is the one
   // idempotent teardown path either way (`game-document.ts`).
-  store.setPlayState('stopped');
+  store.shell.setPlayState('stopped');
   editorHost().workspace.liveDocument.release();
   // LAST — the run's error window closes only once teardown is done, so every
   // error this teardown itself logged still belongs to the run that caused it
@@ -2403,7 +2360,7 @@ export function pausePlayMode(): void {
   // Freeze EVERY seat, not just the primary — a paused split with the extras
   // still ticking is not paused.
   for (const inst of allLiveInstances()) inst.session?.pause();
-  _ctx.store.setPlayState('paused');
+  _ctx.store.shell.setPlayState('paused');
 
   editorConsole.log('Play mode paused', 'play-mode');
 }
@@ -2415,7 +2372,7 @@ export function resumePlayMode(): void {
   if (!_instance.session || !_ctx) return;
 
   for (const inst of allLiveInstances()) inst.session?.resume();
-  _ctx.store.setPlayState('playing');
+  _ctx.store.shell.setPlayState('playing');
 
   editorConsole.log('Play mode resumed', 'play-mode');
 }

package/src/play/play-recording.ts

@@ -37,8 +37,8 @@
  * recorder's stream never sees, so nothing about the evidence changes.
  */
 
-import { isRootCanvas } from '@volter/editor-core/composite-screenshot';
-import { editorConsole } from '@volter/editor-core/editor-console';
+import { isRootCanvas } from '@volter/editor-sdk/kit/composite-screenshot';
+import { editorConsole } from '@volter/editor-sdk/kit/editor-console';
 import {
   type GameplayRecordingCapture,
   type GameplayRecordingStarted,

package/src/play/react-play-live-authoring.ts

@@ -44,8 +44,8 @@
  * three gizmo drag during play. That is the regime, not a defect.
  */
 
-import type { EditorShellStore } from '@volter/editor-core/editor-shell-store';
-import type { SourceWriteBackend } from '@volter/editor-core/ui-source/source-write-backend';
+import type { EditorShellStore } from '@volter/editor-threejs/kit/editor-shell-store';
+import type { SourceWriteBackend } from '@volter/editor-sdk/kit/ui-source/source-write-backend';
 import {
   type OidElementLike,
   ReactRootAuthoringAdapter,
@@ -158,7 +158,7 @@ export function createReactPlayAuthoringAdapter(
   root: OidElementLike,
   store: EditorShellStore,
 ): ReactRootAuthoringAdapter {
-  return new ReactRootAuthoringAdapter(root, store, {
+  return new ReactRootAuthoringAdapter(root, store.shell, {
     writeBackend: createEphemeralDomWriteBackend(root),
     provenance: EPHEMERAL_DOM_PROVENANCE,
   });