@volter/play 0.5.212 → 0.5.214

package/contributions/game-panel.tsx

@@ -1,36 +1,27 @@
 /**
- * THE GAME PANEL — what the Blender document's bottom area shows in GAME mode (editor-blender's play mode), in place of
- * the Timeline (owner, 2026-10-06: "In game mode, the bottom panel is replaced with a game
- * version of something like that. Perhaps that's where the 'autoplay' controls and info will
- * live instead").
- *
- * ## One Play, here
- *
- * The confusion it ends was two Plays on one screen: the header's (the level's game) and the
- * Timeline's (the file's animation). A mode now chooses which one is shown. In Animation mode the
- * Timeline's transport is the one shown; in Game mode this panel's Play is, and the Timeline is
- * not mounted. A game started in Game mode keeps running in Animation mode. The 3D viewport's header carries neither (`blender-header-menus.tsx`
- * is its menus alone). Escape still stops a game, from the stage, as before.
+ * THE GAME PANEL — Play, the project's, in editor-blender's bottom area: under every document, and below a model in its
+ * Game mode, where its Animation mode shows Blender's Timeline instead (owner, 2026-10-06: "In game mode, the bottom
+ * panel is replaced with a game version of something like that. Perhaps that's where the 'autoplay' controls and info
+ * will live instead").
  *
  * ## Where it is
  *
- * The Blender document's bottom area shows it (`@volter/editor-blender`'s `blender-play-area.tsx`): play registers it
- * as the model Play's `Panel` (`play.page.tsx`, through editor-blender's API), and the area's own Game | Animation switch and size stay
- * the area's. It draws with the area's button and the Timeline's widget table.
+ * play registers it through editor-blender's API (`registerPlay`, `play.page.tsx`); the area's own Game | Animation
+ * switch below a model and its size stay the area's. It draws with the area's button and the Timeline's widget table.
+ * The game itself shows in the Game view (`../src/game-view.tsx`), which Play opens.
  *
- * ## What it drives is the Play tool's own run
+ * ## What it drives is the game's run
  *
- * Every control here is a call on the Play tool's door (`DocumentPlayExtension` and its
- * `transport`, `@volter/editor-blender/api`), each std's own control said to the game's pages
- * (`../src/std-controls.ts`): Pause holds the game's own clock, and the clock drawn here is the
- * one std answered, the game's seconds and frames. The verbs below are the same calls behind
- * command ids (`volter.model-play.<verb>`), which is how an agent drives exactly what the person
- * does: `cyclotron play pause`, or `await editor.command('volter.model-play.pause')` under `eval`.
+ * Every control here is a call on the run (`../src/game-run.ts`, `../src/game-controls.ts`), each std's own control said
+ * to the game's pages (`../src/std-controls.ts`): Pause holds the game's own clock, and the clock drawn here is the one
+ * std answered, the game's seconds and frames. The verbs below are the same calls behind command ids
+ * (`volter.play.<verb>`), which is how an agent drives exactly what the person does: `cyclotron play pause`, or
+ * `await editor.command('volter.play.pause')` under `eval`.
  *
  * ## Autoplay is the editor's switch, and the person always wins
  *
  * A std game offers its bot's goals (its `autopilot/` program's); whether the bot drives the
- * player in view, and with which goal, is this panel's toggle (or `volter.model-play.autoplay`).
+ * player in view, and with which goal, is this panel's toggle (or `volter.play.autoplay`).
  * A person's own key or click in the player's page takes it back on the spot (std's page does
  * that), so the driver line reads "You're driving". Stopped, pressing Autoplay arms it for the
  * next start. Where it cannot be switched on, the panel SAYS why, and `play state` carries the
@@ -38,8 +29,8 @@
  *
  * ## The play log, live
  *
- * The right of the panel is the run's play log as it is written (the Play tool's `log` door):
- * the newest entries of this document, newest at the bottom, filtered by kind. It follows the
+ * The right of the panel is the run's play log as it is written (`../src/play-log.ts`): its newest entries, newest at
+ * the bottom, filtered by kind. It follows the
  * newest entry until the person scrolls up to read, and follows again once they scroll back to
  * the bottom.
  *
@@ -50,12 +41,6 @@
  * playhead's blue, which is Blender's own selected-widget colour in the same theme.
  */
 import type { ViewVerb } from '@volter/sdk/commands';
-import type {
-  DocumentPlayAutoplay,
-  DocumentPlayClock,
-  DocumentPlayExtension,
-  DocumentPlayTransport,
-} from '@volter/editor-blender/api';
 import {
   type ReactNode,
   useCallback,
@@ -67,129 +52,75 @@ import {
   useState,
   useSyncExternalStore,
 } from 'react';
-import { editorBlender, registeredModelPlay, subscribeRegisteredModelPlay } from '../src/editor-blender';
+import { editorBlender } from '../src/editor-blender';
 import { CLOCK_TEXT_INTERVAL_MS, type ClockState, clockStateReader, throttledSubscription } from '../src/play-clock';
 import { getCurrentProject, onProjectChange } from '@volter/sdk/active-project';
 import { editorHost } from '@volter/sdk/host';
-import { activateWorkspaceDocument } from '@volter/sdk/workspace-document-registry';
-import { captureStdView, isStdGame, stdRun, stdRunVersion, subscribeStdGame, subscribeStdRun } from '../src/std-game';
-import { EXPORT_LABELS, EXPORT_TARGETS, isExportTarget, onStdExport, setExportMenuOpen, startStdExport, stdExport, stdTargets, type ExportTarget, type StdExport } from '../src/std-export';
+import { GAME_SPEEDS, gameClock, type GameClock, gamePlaying, subscribeGame, subscribeGameClock } from '../src/game-run';
+import {
+  armAutoplay,
+  type GameAutoplay,
+  gameAutoplay,
+  pauseGame,
+  playGame,
+  restartPlay,
+  setGameAutoplay,
+  setGameSpeedOf,
+  stepGame,
+  subscribeGameControls,
+} from '../src/game-controls';
+import { captureStdView, isStdGame, MOST_PLAYERS, setStdPlayers, STD_DEV, stdPlayersAsked, stepStdPlayers, stdRun, stdRunVersion, subscribeStdGame, subscribeStdRun } from '../src/std-game';
+import { EXPORT_LABELS, EXPORT_TARGETS, isExportTarget, onStdExport, startStdExport, stdExport, stdTargets, type ExportTarget, type StdExport } from '../src/std-export';
+import { subscribePlayLog, tailPlayLog } from '../src/play-log';
+import { showGameView } from '../src/game-view';
 
 /** Said where the project is not a std game, whose Play has nothing to run. */
 const NOT_STD = 'This project is not a std game (no std.json): `cyclotron add-play` makes it one.';
-import { subscribeModelPlayLog, tailModelPlayLog } from '../src/play-log';
-
-const STILL: DocumentPlayClock = { time: 0, tick: 0, paused: false, speed: 1, running: false };
-const NO_BOT: DocumentPlayAutoplay = { on: false, available: false, by: null };
-
-function extension(): DocumentPlayExtension | null {
-  return registeredModelPlay();
-}
 
 /** The bottom area's mode and the model document it serves: editor-blender's, through its API. */
 const playMode = () => editorBlender().playMode;
 
 // ---------------------------------------------------------------------------------------------
-// THE VERBS — `volter.model-play.<verb>`, the panel's controls behind command ids.
+// THE VERBS — `volter.play.<verb>`, the panel's controls behind command ids.
 // ---------------------------------------------------------------------------------------------
 
-/** Which document a verb acts on: the one it names, else the model document on screen. */
-function verbDocument(args: Record<string, unknown> | undefined): string {
-  const named = args?.['document'];
-  if (typeof named === 'string' && named !== '') return named;
+/** The model document a mode verb acts on: the one in front, whose bottom area is its Game or Animation. */
+function modelInFront(): string {
   const served = playMode().servedModelDocument();
-  if (served === null) throw new Error('No model document is open; open one, or name it with `document`.');
+  if (served === null) throw new Error('No model document is in front: Game | Animation is a model\'s bottom area.');
   return served;
 }
 
-/** How long a verb waits for a model document still opening on screen before it answers that it is still opening
- *  (well inside the 30 s a workbench command is given; `cyclotron play` asks again). */
-const VERB_OPEN_WAIT_MS = 20_000;
-/** The sentence a verb answers while the model document on screen is still opening; `cyclotron play` reads it. */
-const STILL_OPENING = 'is still opening';
-
-/** The verbs that start a game, which a document plays only on screen: its stage draws the game. */
-const BRINGS_FORWARD = new Set(['play', 'restart']);
-
-/**
- * A NAMED DOCUMENT IS BROUGHT FORWARD BEFORE IT PLAYS: a game runs in its document's stage, which only the document on
- * screen draws, so a Play asked of one behind another would wait for a first frame that never comes. An open document
- * is activated and waited for; one not open is refused, by name.
- */
-async function broughtForward(documentId: string): Promise<void> {
-  if (playMode().servedModelDocument() === documentId) return;
-  if (!activateWorkspaceDocument(documentId))
-    throw new Error(`${documentId} is not open, so Play cannot bring it forward to play it: open it (\`editor.open('${documentId.replace(/^document:/, '')}')\`), then ask again.`);
-  const bound = Date.now() + VERB_OPEN_WAIT_MS;
-  while (playMode().servedModelDocument() !== documentId) {
-    if (Date.now() > bound)
-      throw new Error(`${documentId} ${STILL_OPENING}: it was brought forward, and Blender is still reading or presenting its file. Ask again.`);
-    await new Promise((done) => setTimeout(done, 100));
-  }
-}
-
-/**
- * A VERB ACTS ON THE MODEL DOCUMENT ON SCREEN ONCE IT IS ON SCREEN: one still opening (Blender reading or presenting
- * its file) is waited for, rather than answered "No model document is open" (editor-blender's `noteModelOpening`); `cyclotron play` asks again while it says so.
- * A verb that starts a game on a named document brings that document forward first ({@link broughtForward}).
- */
-function waitingForTheDocument(verbs: readonly ViewVerb[]): ViewVerb[] {
-  return verbs.map((verb) => ({
-    ...verb,
-    run: async (args) => {
-      const named = args?.['document'];
-      if (typeof named !== 'string' || named === '') {
-        const found = await playMode().documentOnScreen(VERB_OPEN_WAIT_MS);
-        if (found !== null && 'opening' in found)
-          throw new Error(`${found.opening} ${STILL_OPENING}: Blender is reading or presenting its file, and the Game panel's controls act on it once it is on screen. Ask again.`);
-      } else if (BRINGS_FORWARD.has(verb.id)) await broughtForward(named);
-      return verb.run(args);
-    },
-  }));
-}
-
-function verbExtension(): DocumentPlayExtension & { transport: NonNullable<DocumentPlayExtension['transport']> } {
-  const found = extension();
-  if (found === null)
-    throw new Error('No Play tool is registered for model documents: @volter/play is not active.');
-  if (found.transport === undefined)
-    throw new Error('The registered Play tool has no pause, step, speed or restart.');
-  return found as DocumentPlayExtension & { transport: NonNullable<DocumentPlayExtension['transport']> };
-}
-
 /** THE ONE REPORT every verb answers with — what the panel draws, as data. A control's effect
  *  lands on the next drawn frame (a step runs there), so read `state` again to see it. */
-function gameState(documentId: string): unknown {
-  const found = extension();
-  const blend = playMode().modelDocumentSource(documentId);
+function gameState(): unknown {
+  const model = playMode().servedModelDocument();
   return {
-    document: documentId,
-    mode: playMode().modelPlayMode(documentId),
-    playing: found?.playing(documentId) ?? false,
-    script: blend === undefined || found?.scriptPath === undefined ? null : {
-      path: found.scriptPath(blend),
-      exists: found.hasScript?.(blend) ?? null,
-    },
-    clock: found?.transport?.clock(documentId) ?? STILL,
-    speeds: found?.transport?.speeds ?? [],
-    autoplay: autoplayState(documentId),
+    // (a model in front has Game or Animation; any other document, the Game panel)
+    mode: model === null ? 'game' : playMode().modelPlayMode(model),
+    playing: gamePlaying(),
+    script: { path: STD_DEV, exists: isStdGame() ?? null },
+    clock: gameClock(),
+    speeds: GAME_SPEEDS,
+    autoplay: autoplayState(),
+    // (a std game's: how many players Play starts, and how many have joined the running game)
+    ...(isStdGame() === true ? { players: { asked: stdPlayersAsked(), joined: stdRun()?.players.length ?? 0 } } : {}),
     export: stdExport(),
   };
 }
 
-/** Who drives the player in view: the bot while autoplay is on, else the person. */
-function driverOf(playing: boolean, autoplay: DocumentPlayAutoplay): 'bot' | 'person' | null {
+/** Who drives the player in view: the bot while std's play drives its page, else the person. */
+function driverOf(playing: boolean, autoplay: GameAutoplay): 'bot' | 'person' | null {
   if (!playing) return null;
-  return autoplay.on ? 'bot' : 'person';
+  return autoplay.driving === true ? 'bot' : 'person';
 }
 
 /** The bot's switch and who drives (`driverOf`), null when nothing plays; `why` says why the bot cannot be switched
  *  on, null when it can. */
-function autoplayState(documentId: string): unknown {
-  const found = extension();
-  const autoplay = found?.transport?.autoplay?.(documentId) ?? NO_BOT;
-  const playing = found?.playing(documentId) ?? false;
-  const why = autoplayWhy(playing, found?.transport?.clock(documentId) ?? STILL, autoplay);
+function autoplayState(): unknown {
+  const autoplay = gameAutoplay();
+  const playing = gamePlaying();
+  const why = autoplayWhy(playing, gameClock(), autoplay);
   return { ...autoplay, driver: driverOf(playing, autoplay), why };
 }
 
@@ -197,14 +128,14 @@ function autoplayState(documentId: string): unknown {
  * WHY THE BOT CANNOT BE SWITCHED ON: `not-running` while stopped or still starting (a player's page must have joined),
  * `game` once it runs and the run says why (`autoplay.unavailable`: no goals, no player in view), null when it can.
  */
-function autoplayUnavailable(playing: boolean, clock: Pick<DocumentPlayClock, 'failure' | 'running'>, autoplay: DocumentPlayAutoplay): 'not-running' | 'game' | null {
+function autoplayUnavailable(playing: boolean, clock: Pick<GameClock, 'failure' | 'running'>, autoplay: GameAutoplay): 'not-running' | 'game' | null {
   if (playing && clock.running && autoplay.available) return null;
   if (!playing || !clock.running) return 'not-running';
   return 'game';
 }
 
 /** {@link autoplayUnavailable} as the CLI says it. */
-function autoplayWhy(playing: boolean, clock: Pick<DocumentPlayClock, 'failure' | 'running'>, autoplay: DocumentPlayAutoplay): string | null {
+function autoplayWhy(playing: boolean, clock: Pick<GameClock, 'failure' | 'running'>, autoplay: GameAutoplay): string | null {
   switch (autoplayUnavailable(playing, clock, autoplay)) {
     case null: return null;
     case 'game': return autoplay.unavailable ?? 'No autoplay for the player in view.';
@@ -214,134 +145,124 @@ function autoplayWhy(playing: boolean, clock: Pick<DocumentPlayClock, 'failure'
   }
 }
 
-function requirePlaying(documentId: string, verb: string): void {
-  if (!verbExtension().playing(documentId))
-    throw new Error(`Nothing is playing in ${documentId}, so there is nothing to ${verb}; \`play\` starts it.`);
+function requirePlaying(verb: string): void {
+  if (!gamePlaying()) throw new Error(`Nothing is playing, so there is nothing to ${verb}; \`play\` starts it.`);
 }
 
-/** The Game panel's verbs: the Code-OSS commands `volter.model-play.<verb>`, registered by play's page half. */
-export const MODEL_PLAY_VIEW_VERBS: readonly ViewVerb[] = waitingForTheDocument([
-  { id: 'state', run: (args) => gameState(verbDocument(args)) },
+/** The Game panel's verbs: the Code-OSS commands `volter.play.<verb>`, registered by play's page half. */
+export const PLAY_VIEW_VERBS: readonly ViewVerb[] = [
+  { id: 'state', run: () => gameState() },
   {
     id: 'mode',
     run: (args) => {
-      const documentId = verbDocument(args);
       const mode = args?.['mode'] ?? args?.['to'];
       if (mode !== undefined) {
         const asked = playMode().playModeOf(mode);
         if (asked === null) throw new Error(`mode is \`game\` or \`animation\`; got ${String(mode)}.`);
-        editorBlender().switchPlayMode(documentId, asked);
+        editorBlender().switchPlayMode(modelInFront(), asked);
+      }
+      return gameState();
+    },
+  },
+  {
+    // HOW MANY PLAY: a std game's player count, the project's setting (`volter.play.players`); a running game's players
+    // join or leave to match it.
+    id: 'players',
+    run: async (args) => {
+      const raw = args?.['players'] ?? args?.['count'];
+      if (raw !== undefined) {
+        if (isStdGame() !== true) throw new Error('players is a std game\'s player count; this project is not a std game.');
+        const count = typeof raw === 'string' && raw.trim() !== '' ? Number(raw) : typeof raw === 'number' ? raw : Number.NaN;
+        if (!Number.isInteger(count) || count < 1 || count > 8) throw new Error(`players is a whole number from 1 to 8; got ${JSON.stringify(raw)}.`);
+        // (answered once the setting is in force)
+        await setStdPlayers(count);
       }
-      return gameState(documentId);
+      return gameState();
     },
   },
   {
     id: 'game-mode',
-    run: (args) => { const documentId = verbDocument(args); editorBlender().switchPlayMode(documentId, 'game'); return gameState(documentId); },
+    run: () => { editorBlender().switchPlayMode(modelInFront(), 'game'); return gameState(); },
   },
   {
     id: 'animation-mode',
-    run: (args) => { const documentId = verbDocument(args); editorBlender().switchPlayMode(documentId, 'animation'); return gameState(documentId); },
+    run: () => { editorBlender().switchPlayMode(modelInFront(), 'animation'); return gameState(); },
   },
   {
-    // PLAY IS GAME MODE'S CONTROL, so asking for it puts the document in Game mode: the person
-    // then sees the panel that owns the run an agent started.
+    // (the game played in the Game view, brought to the front where it already plays, as Play opens it)
     id: 'play',
-    run: (args) => {
-      const documentId = verbDocument(args);
-      const found = verbExtension();
-      if (playMode().modelPlayMode(documentId) !== 'game') editorBlender().switchPlayMode(documentId, 'game');
-      if (!found.playing(documentId)) found.setPlaying(documentId, true);
-      return gameState(documentId);
-    },
-  },
-  {
-    id: 'stop',
-    run: (args) => {
-      const documentId = verbDocument(args);
-      verbExtension().setPlaying(documentId, false);
-      return gameState(documentId);
+    run: () => {
+      if (!gamePlaying()) playGame(true);
+      else showGameView();
+      return gameState();
     },
   },
+  { id: 'stop', run: () => { playGame(false); return gameState(); } },
   {
     id: 'pause',
-    run: async (args) => {
-      const documentId = verbDocument(args);
-      requirePlaying(documentId, 'pause');
-      await verbExtension().transport.setPaused(documentId, true);
-      return gameState(documentId);
+    run: async () => {
+      requirePlaying('pause');
+      await pauseGame(true);
+      return gameState();
     },
   },
   {
     id: 'resume',
-    run: async (args) => {
-      const documentId = verbDocument(args);
-      requirePlaying(documentId, 'resume');
-      await verbExtension().transport.setPaused(documentId, false);
-      return gameState(documentId);
+    run: async () => {
+      requirePlaying('resume');
+      await pauseGame(false);
+      return gameState();
     },
   },
   {
     // `count` frames of 1/60 s, which std runs (pausing the game first) and answers.
     id: 'step',
     run: async (args) => {
-      const documentId = verbDocument(args);
-      requirePlaying(documentId, 'step');
-      const { transport } = verbExtension();
+      requirePlaying('step');
       const raw = args?.['count'];
       const count = raw === undefined ? 1 : typeof raw === 'string' && raw.trim() !== '' ? Number(raw) : typeof raw === 'number' ? raw : Number.NaN;
       if (!Number.isInteger(count) || count < 1 || count > 600) throw new Error(`step's \`count\` is a whole number of frames from 1 to 600; got ${JSON.stringify(raw)}.`);
-      await transport.step(documentId, count);
-      return gameState(documentId);
+      await stepGame(count);
+      return gameState();
     },
   },
   {
     id: 'speed',
     run: async (args) => {
-      const documentId = verbDocument(args);
-      const { transport } = verbExtension();
       const raw = args?.['speed'] ?? args?.['to'];
       const speed = typeof raw === 'string' ? Number(raw.replace(/x$/i, '')) : Number(raw);
-      if (!transport.speeds.includes(speed))
-        throw new Error(`speed is one of ${transport.speeds.join(', ')} (game seconds per real second); got ${JSON.stringify(raw)}.`);
-      await transport.setSpeed(documentId, speed);
-      return gameState(documentId);
+      if (!GAME_SPEEDS.includes(speed))
+        throw new Error(`speed is one of ${GAME_SPEEDS.join(', ')} (game seconds per real second); got ${JSON.stringify(raw)}.`);
+      await setGameSpeedOf(speed);
+      return gameState();
     },
   },
   {
-    // THE EDITOR'S AUTOPLAY SWITCH: on plays one of the game's goals (`goal`, the game's own when absent), off hands the
-    // player in view back to the person. Asked from here (an agent's `cli`), the goal is std's own headless play,
-    // which plays whether or not the editor is seen: it answers once the play has started, and `play state`'s
-    // `autoplay.state` and the play log say how it ends.
+    // THE EDITOR'S AUTOPLAY SWITCH: on plays one of the game's goals (`goal`, the game's own when absent), off ends
+    // that play, handing a page it drives back to the person. From here (an agent's `cli`) as from the panel, the goal is std's own play,
+    // recorded and checked, on the viewed player's page while the Game view is on screen and on std's headless device
+    // while it is not (`setStdAutoplay`): it answers once the play has started, and `play state`'s `autoplay.state`
+    // and the play log say how it ends.
     id: 'autoplay',
     run: async (args) => {
-      const documentId = verbDocument(args);
       const raw = args?.['on'];
       const on = raw === true || raw === 'on' || raw === 'true' ? true
         : raw === false || raw === 'off' || raw === 'false' ? false : undefined;
       if (on === undefined) throw new Error(`autoplay's \`on\` is true or false (\`play autoplay on [<goal>]|off\`); got ${String(raw)}.`);
       const goal = typeof args?.['goal'] === 'string' && args['goal'] !== '' ? args['goal'] : undefined;
-      const found = verbExtension();
-      const { transport } = found;
-      if (transport.setAutoplay === undefined)
-        throw new Error('The registered Play tool has no autoplay.');
       // (refused while nothing plays; the run says its own reasons, a headless play needing no player's page)
-      if (on && !found.playing(documentId)) throw new Error(autoplayWhy(false, transport.clock(documentId), NO_BOT) ?? 'Nothing is playing.');
-      await transport.setAutoplay(documentId, on, 'cli', on ? goal : undefined);
-      return gameState(documentId);
+      if (on && !gamePlaying()) throw new Error(autoplayWhy(false, gameClock(), gameAutoplay()) ?? 'Nothing is playing.');
+      await setGameAutoplay(on, 'cli', on ? goal : undefined);
+      return gameState();
     },
   },
   {
     id: 'restart',
-    run: (args) => {
-      const documentId = verbDocument(args);
-      const found = verbExtension();
-      if (playMode().modelPlayMode(documentId) !== 'game') editorBlender().switchPlayMode(documentId, 'game');
-      found.transport.restart(documentId);
-      return gameState(documentId);
+    run: () => {
+      restartPlay();
+      return gameState();
     },
   },
-]).concat([
   {
     // THE GAME EXPORTED, as the panel's Export menu does it, the project's and so no document's: `target` web, roblox or
     // unreal; an engine the game doesn't target refused unless `add` (true) makes it one first, as the menu's "Add
@@ -363,7 +284,7 @@ export const MODEL_PLAY_VIEW_VERBS: readonly ViewVerb[] = waitingForTheDocument(
       return { export: stdExport(), targets: await stdTargets() };
     },
   },
-]);
+];
 
 // ---------------------------------------------------------------------------------------------
 // THE PANEL
@@ -398,24 +319,21 @@ function clockText(seconds: number): string {
 /** The clock as std last answered it, redrawn at most every {@link CLOCK_TEXT_INTERVAL_MS} ms and always after the
  *  last change (`../src/play-clock.ts`): the game's seconds and frames where it is paused, which a step moves exactly;
  *  running, its speed, the time being the game's own between answers. */
-function PlayClockText({ documentId, transport }: { documentId: string | null; transport: DocumentPlayTransport | undefined }) {
+function PlayClockText() {
   const { TIMELINE_CHROME } = editorBlender().timelineGeometry;
-  const subscribe = useMemo(
-    () => throttledSubscription((listener: () => void) => transport?.subscribeClock(listener) ?? (() => {}), CLOCK_TEXT_INTERVAL_MS),
-    [transport],
-  );
+  const subscribe = useMemo(() => throttledSubscription(subscribeGameClock, CLOCK_TEXT_INTERVAL_MS), []);
   const text = useSyncExternalStore(
     subscribe,
     () => {
-      const clock = documentId !== null && transport ? transport.clock(documentId) : STILL;
-      const playing = documentId !== null && (registeredModelPlay()?.playing(documentId) ?? false);
+      const clock = gameClock();
+      const playing = gamePlaying();
       return !playing ? `stopped · ${speedText(clock.speed)}` : clock.paused ? `${clockText(clock.time)} · frame ${clock.tick}` : `running · ${speedText(clock.speed)}`;
     },
     () => `${clockText(0)} · frame 0`,
   );
   return (
     <span
-      data-testid="model-play-clock"
+      data-testid="play-clock"
       style={{ color: TIMELINE_CHROME.widgetText, fontVariantNumeric: 'tabular-nums', whiteSpace: 'nowrap' }}
     >
       {text}
@@ -429,58 +347,38 @@ function speedText(speed: number): string {
 
 /** A control's refusal, said in the console under its name. */
 const said = (control: string) => (error: unknown): void =>
-  editorHost().console.error(`${control}: ${error instanceof Error ? error.message : String(error)}`, 'model-play');
+  editorHost().console.error(`${control}: ${error instanceof Error ? error.message : String(error)}`, 'play');
 
 export function GamePanel() {
   const { PlayAreaButton, PlayModeSwitch, timelineGeometry: { HEADER_HEIGHT, TIMELINE_CHROME, TIMELINE_THEME } } = editorBlender();
   const { subscribePlayMode, playModeVersion } = playMode();
   useSyncExternalStore(subscribePlayMode, playModeVersion, playModeVersion);
-  const documentId = playMode().servedModelDocument();
-  const found = useSyncExternalStore(subscribeRegisteredModelPlay, extension, () => null);
-  const transport = found?.transport;
-  const playing = documentId !== null && (found?.playing(documentId) ?? false);
-  const subscribeClock = useCallback(
-    (listener: () => void) => transport?.subscribeClock(listener) ?? (() => {}),
-    [transport],
-  );
+  // (the project's run, whatever document is in front)
+  const playing = useSyncExternalStore(subscribeGame, gamePlaying, () => false);
   // THE CLOCK'S STATE, not its time (`../src/play-clock.ts`): the panel re-renders when a game is
   // paused, sped up, fails or starts running, never once a frame; its time is {@link PlayClockText}'s.
-  const readClockState = useMemo(
-    () => clockStateReader(() => (documentId !== null && transport ? transport.clock(documentId) : STILL)),
-    [documentId, transport],
-  );
-  const clock = useSyncExternalStore(subscribeClock, readClockState, () => STILL);
+  const readClockState = useMemo(() => clockStateReader(gameClock), []);
+  const clock = useSyncExternalStore(subscribeGameClock, readClockState, readClockState);
   // Whether the project is a std game, which Play plays (undefined while the session is asked).
   const std = useSyncExternalStore(subscribeStdGame, isStdGame, () => undefined);
-  // Its changes are announced with the clock's.
-  const autoplay = useSyncExternalStore(
-    subscribeClock,
-    () => (documentId !== null && transport?.autoplay ? transport.autoplay(documentId) : NO_BOT),
-    () => NO_BOT,
-  );
-  const blend = documentId === null ? undefined : playMode().modelDocumentSource(documentId);
-  const scriptPath = blend === undefined ? null : (found?.scriptPath?.(blend) ?? null);
-  const canPlay = documentId !== null && found !== null;
-  // A PREFAB IS NOT A LEVEL: Play on one plays the game, its levels as its client draws them, the prefab saved (and so
-  // exported) first, as Unity plays the open scene and a prefab is not one.
+  const autoplay = useSyncExternalStore(subscribeGameControls, gameAutoplay, gameAutoplay);
+  const scriptPath = STD_DEV;
   // THE GAME'S NEWEST ERROR, a player's page's (`std-game.ts`): said where the person looks, as the console says each.
   useSyncExternalStore(subscribeStdRun, stdRunVersion, stdRunVersion);
-  const thrown = playing && documentId !== null ? stdRun(documentId)?.lastError ?? null : null;
-  // (std's headless play of a goal, where it stands: `win: achieved`, `lose: failed — why`)
+  const asked = stdPlayersAsked();
+  const thrown = playing ? stdRun()?.lastError ?? null : null;
+  // (std's own play of a goal, where it stands: `win: achieved`, `lose: failed — why`)
   const headlessLine = playing && autoplay.state ? ` · ${autoplay.state}` : '';
-  const prefab = blend !== undefined && blend.startsWith('prefabs/') ? ' · a prefab: Play plays the game\'s levels, this prefab saved first' : '';
-  const status = documentId === null
-    ? 'No model document is open.'
-    : std === false
+  const status = std === false
       ? NOT_STD
       : playing && clock.failure
-        // The run plays but no game runs (`DocumentPlayClock.failure`): say so, not "Playing".
+        // The run plays but no game runs (`GameClock.failure`): say so, not "Playing".
         ? `Not running — ${clock.failure.replace(/\.$/, '')}. Restart (or save the game) to retry, or Stop.${headlessLine}`
         : playing && thrown !== null
         ? `Playing — the game threw: ${thrown}${headlessLine}`
         : playing
-        ? `${clock.paused ? 'Paused' : 'Playing'} ${scriptPath ?? ''}`.trim() + prefab + headlessLine
-        : (scriptPath === null ? 'Stopped.' : `Stopped · Play runs ${scriptPath}`) + prefab;
+        ? `${clock.paused ? 'Paused' : 'Playing'} ${scriptPath}` + headlessLine
+        : `Stopped · Play runs ${scriptPath}`;
   return (
     <div
       data-testid="game-panel"
@@ -516,77 +414,83 @@ export function GamePanel() {
         <div style={{ flex: 1 }} />
         <div style={{ display: 'flex' }} role="group" aria-label="Game transport">
           <PlayAreaButton
-            testId="model-play-button"
-            label={playing ? 'Stop playing (Escape)' : 'Play this level’s game'}
+            testId="play-button"
+            label={playing ? 'Stop the game' : 'Play the game'}
             pressed={playing}
             wide
-            disabled={!canPlay}
-            // The run's state NOW, not the render's: a game can stop between the two (Escape, an
-            // agent's `stop`, a failed script), and a toggle read from a stale render does nothing.
-            onClick={() => { if (documentId !== null && found) found.setPlaying(documentId, !found.playing(documentId)); }}
+            // The run's state NOW, not the render's: a game can stop between the two (an agent's `stop`, the Game view
+            // closed, a failed script), and a toggle read from a stale render does nothing.
+            onClick={() => { playGame(!gamePlaying()); }}
           >
             {mark(playing ? MARKS.stop : MARKS.play)}
             {playing ? 'Stop' : 'Play'}
           </PlayAreaButton>
-          {transport && (
-            <>
-              <PlayAreaButton
-                testId="model-play-pause"
-                label={clock.paused ? 'Resume' : 'Pause'}
-                pressed={playing && clock.paused}
-                disabled={!playing}
-                onClick={() => { if (documentId !== null) void Promise.resolve(transport.setPaused(documentId, !transport.clock(documentId).paused)).catch(said('Pause')); }}
-              >
-                {mark(clock.paused ? MARKS.play : MARKS.pause)}
-              </PlayAreaButton>
-              <PlayAreaButton
-                testId="model-play-step"
-                label="Step one frame (pauses first)"
-                disabled={!playing}
-                onClick={() => { if (documentId !== null) void Promise.resolve(transport.step(documentId)).catch(said('Step')); }}
-              >
-                {mark(MARKS.step)}
-              </PlayAreaButton>
-              <PlayAreaButton
-                testId="model-play-restart"
-                label="Restart: the level saved, every player's page loaded again"
-                disabled={!playing}
-                onClick={() => { if (documentId !== null) transport.restart(documentId); }}
-              >
-                {mark(MARKS.restart)}
-              </PlayAreaButton>
-              <PlayAreaButton
-                testId="model-play-capture"
-                label="Capture the viewed player's next frame (std's receiver writes it; the log names the file)"
-                disabled={!playing}
-                onClick={() => { void captureStdView().catch(said('Capture')); }}
-              >
-                {mark(MARKS.capture)}
-              </PlayAreaButton>
-            </>
-          )}
+          <PlayAreaButton
+            testId="play-pause"
+            label={clock.paused ? 'Resume' : 'Pause'}
+            pressed={playing && clock.paused}
+            disabled={!playing}
+            onClick={() => { void pauseGame(!gameClock().paused).catch(said('Pause')); }}
+          >
+            {mark(clock.paused ? MARKS.play : MARKS.pause)}
+          </PlayAreaButton>
+          <PlayAreaButton
+            testId="play-step"
+            label="Step one frame (pauses first)"
+            disabled={!playing}
+            onClick={() => { void stepGame().catch(said('Step')); }}
+          >
+            {mark(MARKS.step)}
+          </PlayAreaButton>
+          <PlayAreaButton
+            testId="play-restart"
+            label="Restart: the level saved, every player's page loaded again"
+            disabled={!playing}
+            onClick={() => { restartPlay(); }}
+          >
+            {mark(MARKS.restart)}
+          </PlayAreaButton>
+          <PlayAreaButton
+            testId="play-capture"
+            label="Capture the viewed player's next frame (std's receiver writes it; the log names the file)"
+            disabled={!playing}
+            onClick={() => { void captureStdView().catch(said('Capture')); }}
+          >
+            {mark(MARKS.capture)}
+          </PlayAreaButton>
         </div>
-        {transport && (
-          <div style={{ display: 'flex' }} role="group" aria-label="Game speed">
-            {transport.speeds.map((speed) => (
-              <PlayAreaButton
-                key={speed}
-                testId={`model-play-speed-${speed}`}
-                label={`Speed ${speedText(speed)}`}
-                pressed={clock.speed === speed}
-                wide
-                disabled={documentId === null}
-                onClick={() => { if (documentId !== null) void Promise.resolve(transport.setSpeed(documentId, speed)).catch(said('Speed')); }}
-              >
-                {speedText(speed)}
-              </PlayAreaButton>
-            ))}
+        {std === true && (
+          // HOW MANY PLAY, beside Play as an engine's Play settings are: set before a run, and a running game's
+          // players join or leave to match. A refused write is said on the console.
+          <div style={{ display: 'flex', alignItems: 'center' }} role="group" aria-label="Players">
+            <span style={{ padding: '0 4px' }}>Players</span>
+            <PlayAreaButton testId="std-players-remove" label="One player fewer (a running game's last player leaves)" disabled={asked <= 1} onClick={() => { stepStdPlayers(-1).catch(() => {}); }}>
+              −
+            </PlayAreaButton>
+            <span data-testid="std-players-count" style={{ minWidth: 14, textAlign: 'center' }}>{asked}</span>
+            <PlayAreaButton testId="std-players-add" label="One more player (a running game's new player joins)" disabled={asked >= MOST_PLAYERS} onClick={() => { stepStdPlayers(1).catch(() => {}); }}>
+              +
+            </PlayAreaButton>
           </div>
         )}
+        <div style={{ display: 'flex' }} role="group" aria-label="Game speed">
+          {GAME_SPEEDS.map((speed) => (
+            <PlayAreaButton
+              key={speed}
+              testId={`play-speed-${speed}`}
+              label={`Speed ${speedText(speed)}`}
+              pressed={clock.speed === speed}
+              wide
+              onClick={() => { void setGameSpeedOf(speed).catch(said('Speed')); }}
+            >
+              {speedText(speed)}
+            </PlayAreaButton>
+          ))}
+        </div>
         <div style={{ flex: 1 }} />
         {std === true && <ExportControl />}
         {/* THE CLOCK IS THE GAME'S, as std answered it: its seconds and frames, still while paused. */}
-        <PlayClockText documentId={documentId} transport={transport} />
+        <PlayClockText />
       </div>
       <div
         style={{
@@ -600,15 +504,13 @@ export function GamePanel() {
         }}
       >
         <div style={{ flex: '0 1 260px', minWidth: 0, display: 'flex', flexDirection: 'column', gap: 6 }}>
-          <span data-testid="model-play-status" title={status} style={{ whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis' }}>
+          <span data-testid="play-status" title={status} style={{ whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis' }}>
             {status}
           </span>
-          {transport?.autoplay && documentId !== null && (
-            <AutoplayControl documentId={documentId} playing={playing} clock={clock} autoplay={autoplay} transport={transport} />
-          )}
+          <AutoplayControl playing={playing} clock={clock} autoplay={autoplay} />
           {std === true && <ExportNote />}
         </div>
-        {documentId !== null && <PlayLogView documentId={documentId} />}
+        <PlayLogView />
       </div>
     </div>
   );
@@ -639,10 +541,9 @@ function ExportControl() {
   // (closed by a press outside it or Escape: its buttons keep the keyboard where it was, as the panel's do, so no blur
   // comes to close it)
   useEffect(() => {
-    setExportMenuOpen(open);
     if (!open) return undefined;
     const outside = (event: PointerEvent): void => { if (!menu.current?.contains(event.target as Node)) setOpen(false); };
-    // (Escape closes the menu alone: the panel's own Escape, which stops the game, never hears it)
+    // (Escape closes the menu alone)
     const escape = (event: KeyboardEvent): void => {
       if (event.key !== 'Escape') return;
       event.preventDefault();
@@ -652,7 +553,6 @@ function ExportControl() {
     window.addEventListener('pointerdown', outside, true);
     window.addEventListener('keydown', escape, true);
     return () => {
-      setExportMenuOpen(false);
       window.removeEventListener('pointerdown', outside, true);
       window.removeEventListener('keydown', escape, true);
     };
@@ -665,7 +565,7 @@ function ExportControl() {
   return (
     <div ref={menu} style={{ position: 'relative', display: 'inline-flex' }}>
       <PlayAreaButton
-        testId="model-play-export"
+        testId="play-export"
         label={running && current !== null ? `Exporting to ${EXPORT_LABELS[current.target]}` : 'Export the game: to the web, or to an engine'}
         pressed={open}
         wide
@@ -689,7 +589,7 @@ function ExportControl() {
               key={target}
               type="button"
               role="menuitem"
-              data-testid={`model-play-export-${target}`}
+              data-testid={`play-export-${target}`}
               onMouseDown={(event) => event.preventDefault()}
               onClick={() => choose(target)}
               style={{ background: 'none', border: 'none', color: TIMELINE_CHROME.text, font: 'inherit', textAlign: 'left', padding: '4px 8px', cursor: 'pointer' }}
@@ -712,7 +612,7 @@ function ExportNote() {
   const text = exportText(current, label);
   return (
     <span
-      data-testid="model-play-export-note"
+      data-testid="play-export-note"
       data-export={current.running ? 'running' : current.ok === true ? 'exported' : 'failed'}
       title={text}
       style={{ color: TIMELINE_CHROME.widgetText, whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis', minWidth: 0 }}
@@ -732,25 +632,24 @@ function exportText(current: StdExport, label: string): string {
 // AUTOPLAY AND THE PLAY LOG
 // ---------------------------------------------------------------------------------------------
 
-function AutoplayControl({ documentId, playing, clock, autoplay, transport }: {
-  readonly documentId: string;
+function AutoplayControl({ playing, clock, autoplay }: {
   readonly playing: boolean;
   readonly clock: ClockState;
-  readonly autoplay: DocumentPlayAutoplay;
-  readonly transport: DocumentPlayTransport;
+  readonly autoplay: GameAutoplay;
 }) {
   const { PlayAreaButton, timelineGeometry: { TIMELINE_CHROME, TIMELINE_THEME } } = editorBlender();
   const unavailable = autoplayUnavailable(playing, clock, autoplay);
   const armed = autoplay.armed === true;
   // STOPPED, the button ARMS: the next start switches the bot on once its player joins.
-  const canArm = !playing && transport.armAutoplay !== undefined;
+  const canArm = !playing;
   const label = unavailable === 'game'
     ? autoplay.unavailable ?? 'No autoplay for the player in view'
     : unavailable === 'not-running'
       ? canArm
         ? armed ? 'Autoplay is armed for the next Play; press to disarm' : 'Let the game’s bot drive your player as soon as it joins'
         : 'Autoplay is available once a player has joined'
-      : autoplay.on ? 'Stop autoplay and drive yourself' : 'Let the game’s bot drive your player (any key or click in its page takes over)';
+      : autoplay.on ? (autoplay.driving === true ? 'Stop autoplay and drive yourself' : 'Stop the bot’s play of its goal')
+        : 'Let the game’s bot drive your player (any key or click in its page takes over)';
   // SAID, NOT ONLY HOVERED: why there is nothing to switch.
   const note = unavailable === 'game'
     ? autoplay.unavailable ?? 'No autoplay for the player in view'
@@ -767,7 +666,7 @@ function AutoplayControl({ documentId, playing, clock, autoplay, transport }: {
     <div style={{ display: 'flex', alignItems: 'center', gap: TIMELINE_CHROME.headerGap, minWidth: 0 }}>
       {goals.length > 1 && (
         <select
-          data-testid="model-play-autoplay-goal"
+          data-testid="play-autoplay-goal"
           title="The goal Autoplay's bot plays"
           value={goal ?? ''}
           disabled={autoplay.on}
@@ -782,18 +681,18 @@ function AutoplayControl({ documentId, playing, clock, autoplay, transport }: {
       {/* KEEP THE KEYBOARD OFF THIS BUTTON (`PlayAreaButton`'s). Left focused, a person taking over with Space would
           also click this button and turn autoplay straight back on. */}
       <PlayAreaButton
-        testId="model-play-autoplay"
+        testId="play-autoplay"
         label={label}
         pressed={autoplay.on || armed}
         wide
-        disabled={canArm ? false : !playing || unavailable !== null || transport.setAutoplay === undefined}
+        disabled={canArm ? false : !playing || unavailable !== null}
         // The switch's state NOW, as the transport's buttons read theirs: a takeover can land between the render and
         // the click.
         onClick={() => {
-          const now = transport.autoplay?.(documentId) ?? NO_BOT;
+          const now = gameAutoplay();
           try {
-            if (!(extension()?.playing(documentId) ?? false)) transport.armAutoplay?.(documentId, !now.armed, goal ?? undefined);
-            else void Promise.resolve(transport.setAutoplay?.(documentId, !now.on, 'panel', now.on ? undefined : goal ?? undefined)).catch(said('Autoplay'));
+            if (!gamePlaying()) armAutoplay(now.armed !== true, goal ?? undefined);
+            else void setGameAutoplay(!now.on, 'panel', now.on ? undefined : goal ?? undefined).catch(said('Autoplay'));
           } catch (error) { said('Autoplay')(error); }
         }}
       >
@@ -801,18 +700,18 @@ function AutoplayControl({ documentId, playing, clock, autoplay, transport }: {
       </PlayAreaButton>
       </span>
       {note !== null ? (
-        <span data-testid="model-play-autoplay-note" data-reason={unavailable ?? undefined} style={{ color: TIMELINE_CHROME.widgetText, minWidth: 0 }}>
+        <span data-testid="play-autoplay-note" data-reason={unavailable ?? undefined} style={{ color: TIMELINE_CHROME.widgetText, minWidth: 0 }}>
           {note}
         </span>
       ) : playing && (
         // WHO DRIVES THE PLAYER IN VIEW, and the goal the bot plays: "Bot driving · collect-all".
         <span
-          data-testid="model-play-driver"
+          data-testid="play-driver"
           data-driver={driver ?? undefined}
           style={{ color: autoplay.on ? TIMELINE_THEME.playhead : TIMELINE_CHROME.widgetText, whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis', minWidth: 0 }}
         >
-          {driver === 'bot' ? `Bot driving${autoplay.behavior ? ` · ${autoplay.behavior}` : ''}` : 'You’re driving'}
-          {autoplay.state ? ` · headless ${autoplay.state}` : ''}
+          {driver === 'bot' ? `Bot driving${autoplay.behavior && !autoplay.state ? ` · ${autoplay.behavior}` : ''}` : 'You’re driving'}
+          {autoplay.state ? ` · ${autoplay.state}` : ''}
         </span>
       )}
     </div>
@@ -827,19 +726,19 @@ function factsText(facts: Record<string, unknown> | undefined): string {
   try { return JSON.stringify(facts); } catch { return ''; }
 }
 
-function PlayLogView({ documentId }: { readonly documentId: string }) {
+function PlayLogView() {
   const { TIMELINE_CHROME, TIMELINE_THEME } = editorBlender().timelineGeometry;
   const [kind, setKind] = useState('');
   // Writes land several to a frame; the view redraws at most once per drawn frame.
   const [, redraw] = useReducer((count: number) => count + 1, 0);
   useEffect(() => {
     let frame = 0;
-    const stop = subscribeModelPlayLog(() => {
+    const stop = subscribePlayLog(() => {
       if (frame === 0) frame = requestAnimationFrame(() => { frame = 0; redraw(); });
     });
     return () => { stop(); cancelAnimationFrame(frame); };
   }, []);
-  const tail = tailModelPlayLog(documentId, LOG_LINES, kind === '' ? undefined : kind);
+  const tail = tailPlayLog(LOG_LINES, kind === '' ? undefined : kind);
   const list = useRef<HTMLDivElement>(null);
   // Follows the newest entry until the person scrolls up; back at the bottom, it follows again.
   const following = useRef(true);
@@ -849,11 +748,11 @@ function PlayLogView({ documentId }: { readonly documentId: string }) {
   });
   const newest = tail.entries.at(-1)?.seq;
   return (
-    <div data-testid="model-play-log" style={{ flex: 1, minWidth: 0, display: 'flex', flexDirection: 'column', gap: 4 }}>
+    <div data-testid="play-log" style={{ flex: 1, minWidth: 0, display: 'flex', flexDirection: 'column', gap: 4 }}>
       <div style={{ display: 'flex', alignItems: 'center', gap: TIMELINE_CHROME.headerGap }}>
         <span>Play log</span>
         <select
-          data-testid="model-play-log-kind"
+          data-testid="play-log-kind"
           aria-label="Show entries of kind"
           value={kind}
           // Blurred once chosen, so the player's next arrow key moves the game, not this list.
@@ -875,7 +774,7 @@ function PlayLogView({ documentId }: { readonly documentId: string }) {
       </div>
       <div
         ref={list}
-        data-testid="model-play-log-entries"
+        data-testid="play-log-entries"
         data-newest={newest}
         onScroll={(event) => {
           const element = event.currentTarget;