@volter/play 0.5.212 → 0.5.214

package/src/std-game.ts

@@ -1,5 +1,5 @@
 /**
- * A STD GAME, PLAYED IN THE MODEL DOCUMENT'S STAGE (volter-ai/std, design/circle-1.md, "Devices"): a project with
+ * A STD GAME, PLAYED IN THE GAME VIEW (`game-view.tsx`; volter-ai/std, design/circle-1.md, "Devices"): a project with
  * `std.json` that depends on `@volter-ai/std-dev` plays its own dev page, each player a page of its own, since std's
  * client is one a page. Play starts the game's dev server where none runs (`../serving/std-dev.ts`) and stands each
  * player's page in the stage's container as an iframe: each is one device of the dev server (std's page says its kind,
@@ -10,26 +10,30 @@
  * server sends no COEP, so a plain frame of it would be refused. Each loads the dev server at the workbench page's own
  * hostname (`editor-<key>.localhost`), so it is the same site as the page and std's receiver takes its trace (its
  * cookie is `SameSite=Strict`); Vite allows `*.localhost` by default. Every frame stays full size and drawn while
- * another is viewed (only its opacity changes), so a browser does not throttle the frames out of view.
+ * another is viewed (only its opacity changes), so a browser does not throttle the frames out of view; while the Game
+ * view is behind another tab its layer is hidden, and the browser throttles them, as it does a hidden retained
+ * webview's, until it is shown again.
  *
  * WHICH PAGE IS WHICH PLAYER. Each frame's address names a slot of this run's own (`?slot=<run>-<n>`; std's bot reads
  * the number at its end), which the page's trace says in its first line. A device is a player's when its page's trace
  * names the player's slot (`/pages`), read again as the run goes, so a page that loads again (a new page, a new
  * device) is found again, and a page of another editor's is never taken for one of these.
  *
- * THE VIEWS (the view bar, `std-view-bar.tsx`): Edit (the document's own area, live for editing, while the game runs
- * on: `DocumentPlayStage.edit`), Player N, and Grid (Edit and every player tiled; a tile clicked opens it). Keys 1 to 4
- * open Player N, Tab the next view and Escape Edit, while the editor holds the keyboard: a viewed player's page holds
- * it, and its keys are the game's; a press on the view bar gives it back to the editor. A view changes at once.
+ * THE VIEWS (the view bar, `std-view-bar.tsx`), in the Game view (`game-view.tsx`): Scene (the current level, live:
+ * its running scene on the level's own view, `GameStage.scene`), Player N, and Grid (Scene and every player tiled; a
+ * tile clicked opens it). Keys 1 to 4 open Player N and Tab the next view, while the editor holds the keyboard: a
+ * viewed player's page holds it, and its keys are the game's; a press on the view bar gives it back to the editor. A
+ * view changes at once. The level's own document stays the level as authored.
  *
  * WHO DRIVES. The viewed player is the person's ("you"): its page is told `manual`, and a press in it is the person's
  * own, which std's page hears itself. Every other player is the game's bot ("autopilot"): its page is told `autoplay`
  * with its slot and the run's goal: one of the game's goals (its `autopilot/` program's, which the session lists at
- * each run's start, `/goals`), the one its `play` script names where that is among them, else the first. Autoplay
- * turns the viewed player's bot on with one of those goals and off; the person's own press in its page takes it back.
+ * each run's start, `/goals`), the one its `play` script names where that is among them, else the first. Autoplay is
+ * std's own play of one of those goals (`setStdAutoplay`), on the viewed player's page while the Game view is on
+ * screen; the person's own press in its page takes it back, which ends the play.
  *
  * THE CLOCK. Pause, step and speed are std's `clock` control, said to every joined player's page, and to each page as
- * it joins; the viewed player's answer is the run's clock (`model-play.ts`). It holds the pages: a room the game hosts
+ * it joins; the viewed player's answer is the run's clock (`game-run.ts`). It holds the pages: a room the game hosts
  * runs on, as Colyseus has no pause for a room.
  *
  * THE AGENT'S DOORS. Each player's frame registers its driver (`@volter/sdk/framed-document-driver`): while it is the
@@ -42,13 +46,11 @@
  */
 import { createElement } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
-import type { DocumentPlayEditArea, DocumentPlayStage } from '@volter/editor-blender/api';
 import { getCurrentProject, onProjectChange } from '@volter/sdk/active-project';
 import { editorHost } from '@volter/sdk/host';
 import { registerFramedDriver } from '@volter/sdk/framed-document-driver';
-import { beginModelPlayLog, type ModelPlayRun } from './play-log';
-import { modelPlayClock, setModelPlayClock, setModelPlayFailure, setModelPlaySpeed, takeModelPlayArm } from './model-play';
-import { exportMenuOpen } from './std-export';
+import { beginPlayLog, type PlayLogRun } from './play-log';
+import { gameClock, setGameClock, setGameFailure, setGameSpeed, setGameTraceStep, takeGameArm } from './game-run';
 import { askPlay, stdAct, stdCapture, stdCaptured, stdClock, stdDrive, stdInspect, type StdClock, type StdClockAction } from './std-controls';
 import { StdGridTiles, StdViewBar } from './std-view-bar';
 
@@ -59,11 +61,57 @@ const JOIN_MS = 60_000;
 const LOOK_MS = 500;
 /** Steps a second of a std trace's clock (std's trace format 3, `s`). */
 const TRACE_STEPS_PER_SECOND = 60;
-/** The players a run starts with: the person's and one bot, the least a multiplayer game is tried with. */
-const FIRST_PLAYERS = 2;
-const MOST_PLAYERS = 8;
-
-export type StdView = 'edit' | 'grid' | number;
+/** The setting that says how many players Play starts (the project's `volter.play.players`): the person's, and a bot
+ *  for each other. One where it is unset, as an engine's Play starts. */
+const PLAYERS_SETTING = 'volter.play.players';
+export const MOST_PLAYERS = 8;
+/** The project's `volter.play.players`, else one. */
+const playersSet = (): number => {
+  const set = editorHost().settings.get(PLAYERS_SETTING);
+  return Math.min(MOST_PLAYERS, Math.max(1, typeof set === 'number' && Number.isInteger(set) ? set : 1));
+};
+/** The count last read, which a change of the setting is told by: watched from its first read. */
+let playersRead: number | null = null;
+/** How many players Play starts: the project's `volter.play.players`, else one. */
+export const stdPlayersAsked = (): number => {
+  if (playersRead === null) {
+    playersRead = playersSet();
+    // (the setting changed, whoever changed it: Players [-][+], `play players`, the project's settings file)
+    editorHost().settings.subscribe(() => {
+      const now = playersSet();
+      if (now === playersRead) return;
+      playersRead = now;
+      matchPlayers();
+    });
+  }
+  return playersSet();
+};
+
+export type StdView = 'scene' | 'grid' | number;
+
+/** Where a run draws its players (the Game view's, `game-view.tsx`): its container, a layer over it for the view bar
+ *  and the grid's tiles, and where a failure is said. */
+export interface GameStage {
+  readonly container: HTMLElement;
+  readonly overlay: HTMLElement;
+  readonly report: (title: string, detail: string) => void;
+  /** Whether the Game view holds the keyboard (it is in front, and the focus is its own), whose keys the view bar's
+   *  are. */
+  readonly keys: () => boolean;
+  /** Where the live Scene stands: the whole stage, a tile of the grid, or nowhere. */
+  readonly scene: (area: StdTileBox | 'whole' | null) => void;
+  /** Whether the stage is drawn now (the Game view on screen, the editor's page seen): a player's page in it draws its
+   *  frames, which one behind another tab or in a hidden page does not. */
+  readonly shown: () => boolean;
+}
+
+/** A tile of the grid, in fractions of the stage. */
+export interface StdTileBox {
+  readonly left: number;
+  readonly top: number;
+  readonly width: number;
+  readonly height: number;
+}
 
 export interface StdPlayer {
   /** Its number in the run (Player 1, 2, …). */
@@ -74,9 +122,8 @@ export interface StdPlayer {
   /** Its page (std's page id) and that page's device, once its page has joined. */
   page: string | null;
   device: string | null;
+  /** Whether the game's bot drives it, playing the run's goal: every player but the viewed one. */
   autopilot: boolean;
-  /** The goal its bot plays while it drives: one Autoplay named, or the run's. */
-  goal: string | null;
   /** How far its page's trace has been read. */
   traced: number;
   /** Withdraws its frame's driver (`@volter/sdk/framed-document-driver`). */
@@ -84,7 +131,6 @@ export interface StdPlayer {
 }
 
 export interface StdRun {
-  readonly documentId: string;
   readonly players: readonly StdPlayer[];
   readonly view: StdView;
   /** The goal the game's bots play unless Autoplay names another (its `play` script's `--goal`, else its first goal);
@@ -96,9 +142,18 @@ export interface StdRun {
   readonly url: string | null;
   /** The newest error a player's page threw (its trace's `error` line), with its player: the Game panel says it. */
   readonly lastError: string | null;
-  /** std's headless play of a goal (`playGoalHeadless`): its goal and where it stands, `playing` until std says how it
-   *  ended (`achieved`, or `failed` with why); null before any. */
-  readonly headless: { readonly goal: string; readonly state: 'playing' | 'achieved' | 'failed'; readonly why: string | null } | null;
+  /** std's own play of a goal (`playGoal`): its goal, the device it plays on (the viewed player's page, by std's id for
+   *  it, or std's `headless` device) and where it stands, `playing` until std says how it ended (`achieved`, or
+   *  `failed` with why), how its checks went as std said it (`checks of <goal>: 2 passed (…)`, `…: 1 of 2 failed (…)`
+   *  or `…: none ran (…)`) and its report's file; null before any. */
+  readonly played: {
+    readonly goal: string;
+    readonly device: string;
+    readonly state: 'playing' | 'achieved' | 'failed';
+    readonly why: string | null;
+    readonly checks: string | null;
+    readonly report: string | null;
+  } | null;
 }
 
 /** The game's goals as the last run read them, which Autoplay offers while stopped (an arm names one). */
@@ -146,18 +201,15 @@ export function stdGameNow(): Promise<boolean> {
 
 /** A run as this module keeps it. */
 type LiveRun = StdRun & { players: StdPlayer[]; view: StdView; url: string | null; goal: string | null; goals: readonly string[];
-  lastError: string | null; readonly errorsSaid: Set<string>; headless: StdRun['headless'];
+  lastError: string | null; readonly errorsSaid: Set<string>; played: StdRun['played'];
   /** How far each headless bot page's trace has been read, by its page (std's play's slots, `server-<n>`, `p2p-<n>`). */
   readonly headlessTraced: Map<string, { readonly slot: string; traced: number }>;
-  /** How far the dev server's error output has been read (`/errors`): its server's process and the next line, from
-   *  the run's mark on (where the output stood as the run began); null before the mark. */
-  serverErrors: { server: number | null; next: number } | null;
-  readonly tag: string; readonly host: HTMLElement; readonly stage: DocumentPlayStage; readonly log: ModelPlayRun; adding: Promise<void>;
+  /** How far the dev server's output has been read (`/output`): its server's process and each stream's next line, from
+   *  the run's mark on (where each stood as the run began); null before the mark. */
+  serverOutput: { server: number | null; stdout: number; stderr: number } | null;
+  readonly tag: string; readonly host: HTMLElement; readonly stage: GameStage; readonly log: PlayLogRun; adding: Promise<void>;
   failure: string | null; stopped: boolean };
 let run: LiveRun | null = null;
-/** The players each document is asked to play with (Players [-][+]), kept across its Plays and Restarts whatever
- *  joined. */
-const playerCounts = new Map<string, number>();
 const runListeners = new Set<() => void>();
 let runVersion = 0;
 const publishRun = (): void => { runVersion += 1; for (const listener of [...runListeners]) listener(); };
@@ -166,49 +218,47 @@ export function subscribeStdRun(listener: () => void): () => void {
   return () => { runListeners.delete(listener); };
 }
 export const stdRunVersion = (): number => runVersion;
-/** The std game's run of a document, or null while none runs. */
-export function stdRun(documentId?: string): StdRun | null {
-  return run && !run.stopped && (documentId === undefined || run.documentId === documentId) ? run : null;
+/** The std game's run, or null while none runs. */
+export function stdRun(): StdRun | null {
+  return run && !run.stopped ? run : null;
 }
 
-/** The goal a player's bot plays: the one Autoplay named for it, or the run's. */
-const goalOf = (current: LiveRun, player: StdPlayer): string | null => player.goal ?? current.goal;
-
 /** Says to a player's page who drives it: its bot (`autoplay`, its slot and its goal) or the person (`manual`). */
 function tellDriver(current: LiveRun, player: StdPlayer): void {
-  const goal = goalOf(current, player);
+  const goal = current.goal;
   if (player.device === null || (player.autopilot && goal === null)) return;
   void stdDrive(player.device, player.autopilot && goal !== null ? { slot: player.slot, goal } : null)
     .catch((error: unknown) => current.log.append('play', 'script-error', { phase: 'autoplay', slot: player.slot, message: String(error) }));
 }
 
-/** The bot on or off for one player, said to its page once it has joined, the change in the log. A goal named switches
- *  a driving bot to it. */
-function drive(player: StdPlayer, autopilot: boolean, by: 'view' | 'panel' | 'cli' | 'takeover', goal?: string): void {
+/** The game's bot on or off for one player, said to its page once it has joined, the change in the log. */
+function drive(player: StdPlayer, autopilot: boolean): void {
   const current = run;
-  if (!current) return;
-  const changed = goal !== undefined && goal !== player.goal;
-  if (goal !== undefined) player.goal = goal;
-  if ((autopilot && goalOf(current, player) === null) || (player.autopilot === autopilot && !(autopilot && changed))) return;
+  if (!current || player.autopilot === autopilot || (autopilot && current.goal === null)) return;
   player.autopilot = autopilot;
-  current.log.append('play', autopilot ? 'autoplay-on' : 'autoplay-off', { slot: player.slot, by, ...(autopilot ? { goal: goalOf(current, player) } : {}) });
+  current.log.append('play', autopilot ? 'autoplay-on' : 'autoplay-off', { slot: player.slot, by: 'view', ...(autopilot ? { goal: current.goal } : {}) });
   tellDriver(current, player);
   publishRun();
 }
 
-/** Who drives each player for the view: the viewed one the person, every other the bot. */
+/** Whether std's own play of a goal holds this player's page now (`playGoal` on its device). */
+const heldByStd = (current: LiveRun, player: StdPlayer): boolean =>
+  current.played?.state === 'playing' && player.device !== null && current.played.device === player.device;
+
+/** Who drives each player for the view: the viewed one the person, every other the bot; a page std's own play holds
+ *  is std's until that play ends. */
 function driveForView(): void {
   if (!run) return;
-  run.players.forEach((player, index) => drive(player, index !== run!.view, 'view'));
+  run.players.forEach((player, index) => { if (!heldByStd(run!, player)) drive(player, index !== run!.view); });
 }
 
 /**
- * The grid's tile `tile` of `count` (Edit first, then each player), in fractions of the stage. A tile is its view
+ * The grid's tile `tile` of `count` (the Scene first, then each player), in fractions of the stage. A tile is its view
  * whole, at the stage's own proportions scaled down alike (by `width`, which `height` equals), as Unity's Multiplayer
  * Play Mode shows each player's whole window: centred in its cell, with a short last row centred, so no cell stands
  * empty.
  */
-export function stdTile(tile: number, count: number): Exclude<DocumentPlayEditArea, 'live' | 'hidden'> {
+export function stdTile(tile: number, count: number): StdTileBox {
   const columns = Math.ceil(Math.sqrt(count)), rows = Math.ceil(count / columns);
   const scale = 1 / columns;
   const row = Math.floor(tile / columns);
@@ -217,7 +267,7 @@ export function stdTile(tile: number, count: number): Exclude<DocumentPlayEditAr
   return { left, top: row / rows + (1 / rows - scale) / 2, width: scale, height: scale };
 }
 
-/** Each frame placed for the view (full size, or tiled), and the document's own area: live, its tile, or hidden. */
+/** Each frame placed for the view (full size, or tiled), and the live Scene: the whole stage, its tile, or nowhere. */
 function place(): void {
   if (!run) return;
   const { players, view } = run;
@@ -234,7 +284,7 @@ function place(): void {
       zIndex: view === index ? '1' : '0',
     });
   });
-  run.stage.edit?.(view === 'edit' ? 'live' : view === 'grid' ? stdTile(0, players.length + 1) : 'hidden');
+  run.stage.scene(view === 'scene' ? 'whole' : view === 'grid' ? stdTile(0, players.length + 1) : null);
 }
 
 /** Opens a view: the frames placed, its player the person's and the rest the bot's, the keyboard in its page. */
@@ -248,9 +298,9 @@ export function setStdView(view: StdView): void {
   publishRun();
 }
 
-/** The views in their Tab order: Edit, each player, Grid. */
+/** The views in their Tab order: Scene, each player, Grid. */
 function stdViews(): StdView[] {
-  return run ? ['edit', ...run.players.map((_, index) => index), 'grid'] : [];
+  return run ? ['scene', ...run.players.map((_, index) => index), 'grid'] : [];
 }
 
 /** Why the viewed player's bot cannot be switched on (or off) now, null when it can: a goal of the game's (switching
@@ -265,15 +315,17 @@ function autoplayUnavailable(player: StdPlayer | undefined, on = true, goal?: st
 
 /** Whether the viewed player's bot drives (Autoplay's state), the goal it plays, the game's goals, and why it cannot
  *  be switched on, null when it can. */
-export function stdAutoplay(): { readonly on: boolean; readonly goal: string | null; readonly goals: readonly string[]; readonly unavailable: string | null;
-  readonly headless: StdRun['headless'] } {
+export function stdAutoplay(): { readonly on: boolean; readonly driving: boolean; readonly goal: string | null; readonly goals: readonly string[];
+  readonly unavailable: string | null; readonly played: StdRun['played'] } {
   const player = run && typeof run.view === 'number' ? run.players[run.view] : undefined;
+  const on = run?.played?.state === 'playing';
   return {
-    on: player?.autopilot ?? false,
-    goal: run && player ? goalOf(run, player) : run?.goal ?? null,
+    on,
+    driving: run !== null && player !== undefined && heldByStd(run, player),
+    goal: on ? run!.played!.goal : run?.goal ?? null,
     goals: run?.goals ?? knownGoals,
     unavailable: autoplayUnavailable(player),
-    headless: run?.headless ?? null,
+    played: run?.played ?? null,
   };
 }
 
@@ -286,75 +338,104 @@ async function refreshGoals(current: LiveRun): Promise<void> {
 }
 
 /**
- * AUTOPLAY ON OR OFF, on with `goal` where one is named, the goals read again first; refused with the reason where it
- * cannot be. Asked by an agent (`cli`), or while the editor is not seen (a hidden page draws no frames, so its players'
- * pages run nothing), it is std's own play of the goal on its headless device (`playGoalHeadless`), whose pages play
- * whether or not the editor is seen; from the panel the person sees, it is the viewed player's bot.
+ * AUTOPLAY ON OR OFF: the viewed player's bot is std's own play of a goal (`playGoal`), recorded and checked, from the
+ * panel, an agent (`cli`) or an arm alike. It plays on the device std's play takes where one is linked: the viewed
+ * player's page while the stage is drawn (`GameStage.shown`), which the person watches and std hands back to them as the
+ * goal ends; else std's headless device, whose pages play out of view, the panel's only while a player is viewed. Off
+ * hands a page std's play holds back to the person, as their own press in it does (std ends its play there, and its
+ * end drives each player for the view again), and ends a headless one; an on still reading the goals is dropped. One
+ * plays at a time: on while one plays is refused. Every other player is the game's bot (`drive`).
  */
-export async function setStdAutoplay(on: boolean, by: 'panel' | 'cli', goal?: string): Promise<void> {
+export async function setStdAutoplay(on: boolean, by: 'panel' | 'cli' | 'arm', goal?: string): Promise<void> {
   const current = run;
-  if (on && current) await refreshGoals(current);
-  if (on && current && (by === 'cli' || document.visibilityState === 'hidden')) {
-    const chosen = goal ?? current.goal;
-    if (chosen === null) throw new Error('No autoplay: the game\'s autopilot/ program offers no goal for its bot.');
-    if (current.goals.length > 0 && !current.goals.includes(chosen))
-      throw new Error(`This game's bot has no goal "${chosen}"; its goals are ${current.goals.map((one) => `"${one}"`).join(', ')}.`);
-    playGoalHeadless(current, chosen, by);
+  if (!current) throw new Error('Nothing is playing; `play` starts it.');
+  const player = typeof current.view === 'number' ? current.players[current.view] : undefined;
+  const ask = ++autoplayAsks;
+  if (!on) {
+    const held = current.players.find((one) => heldByStd(current, one));
+    if (held !== undefined) {
+      // (the person's own hand: the page's bot stopped, which ends std's play of it, failed)
+      current.log.append('play', 'autoplay-off', { slot: held.slot, by });
+      void stdDrive(held.device!, null)
+        .catch((error: unknown) => current.log.append('play', 'script-error', { phase: 'autoplay', slot: held.slot, message: String(error) }));
+    } else endStdPlay(undefined, 'ended by `autoplay off` before std said how it ended');
     return;
   }
-  const player = run && typeof run.view === 'number' ? run.players[run.view] : undefined;
-  // (off from here ends the headless play on from here started, and the viewed player's bot where it drives)
-  if (!on && by === 'cli' && headlessPlay !== null) {
-    endHeadlessPlay(undefined, 'ended by `autoplay off` before std said how it ended');
-    if (player?.autopilot === true) drive(player, false, by);
-    return;
+  if (current.played?.state === 'playing')
+    throw new Error(`std is playing ${current.played.goal} already; \`autoplay off\` ends it.`);
+  await refreshGoals(current);
+  // (an off, a later on, or the run's end while the goals were read: this on is theirs to answer)
+  if (current.stopped || ask !== autoplayAsks) return;
+  const chosen = goal ?? current.goal;
+  const shown = current.stage.shown();
+  // (the panel's Autoplay is the viewed player's, on screen; an agent's or an arm's plays out of view where none is)
+  if (by === 'panel' && shown) {
+    const refused = autoplayUnavailable(player, true, chosen ?? undefined);
+    if (refused !== null) throw new Error(refused);
   }
-  const refused = autoplayUnavailable(player, on, goal);
-  if (refused !== null) throw new Error(refused);
-  drive(player!, on, by, on ? goal : undefined);
+  if (chosen === null) throw new Error('No autoplay: the game\'s autopilot/ program offers no goal for its bot.');
+  if (current.goals.length > 0 && !current.goals.includes(chosen))
+    throw new Error(`This game's bot has no goal "${chosen}"; its goals are ${current.goals.map((one) => `"${one}"`).join(', ')}.`);
+  playGoal(current, chosen, shown && player?.device ? player.device : 'headless', by);
 }
 
-/** The session's one headless play of a goal, and the run that started it. */
-let headlessPlay: { readonly run: LiveRun; readonly abort: AbortController } | null = null;
+/** Autoplay's asks, on and off, counted: an on that read the goals first starts its play only where no ask came since. */
+let autoplayAsks = 0;
+
+/** The session's one play of a goal by std, and the run that started it. */
+let stdPlay: { readonly run: LiveRun; readonly abort: AbortController } | null = null;
 
-/** The headless play ended where one plays (`run` given: only that run's), its socket to std closed. */
-function endHeadlessPlay(run?: LiveRun, why = 'ended by Play before std said how it ended'): void {
-  if (headlessPlay === null || (run !== undefined && headlessPlay.run !== run)) return;
-  const { run: started, abort } = headlessPlay;
-  headlessPlay = null;
+/** std's play ended where one plays (`run` given: only that run's), its socket to std closed. */
+function endStdPlay(run?: LiveRun, why = 'ended by Play before std said how it ended'): void {
+  if (stdPlay === null || (run !== undefined && stdPlay.run !== run)) return;
+  const { run: started, abort } = stdPlay;
+  stdPlay = null;
   abort.abort();
-  if (!started.stopped && started.headless?.state === 'playing') {
-    started.headless = { ...started.headless, state: 'failed', why };
-    started.log.append('play', 'autoplay-end', { goal: started.headless.goal, achieved: false, why: started.headless.why });
-    publishRun();
+  if (started.played?.state === 'playing') {
+    started.played = { ...started.played, state: 'failed', why };
+    started.log.append('play', 'autoplay-end', { goal: started.played.goal, achieved: false, why: started.played.why });
+    // (a run that ended has no player to drive again)
+    if (!started.stopped) released(started);
   }
 }
 
+/** std's play over, the page it held handed back by std to its person (`manual`, or a new page where it reloaded):
+ *  each player driven for the view again, which tells only a player whose driver changed (the one std held, where it
+ *  is not the viewed one); and the panel told. */
+function released(current: LiveRun): void {
+  if (current === run && !current.stopped) driveForView();
+  publishRun();
+}
+
 /** A bot's line as std's play says it (play.ts `said`): `<slot> (<device>, <mode>): done | failed: <why> | no outcome`,
  *  then what else it noted. */
 const BOT_LINE = /^(\S+) \(([^,]+), ([^)]+)\): (done|failed: (.*?)|no outcome)(?:; (.*))?$/;
 
 /**
- * STD'S OWN PLAY OF A GOAL, on its headless device (`../serving/std-dev.ts`'s `/play`, std's `/__std/play`): its bots
- * play the goal to its end on pages std opens, recorded in the run's folder, then the goal's checks read the
- * recording. Each line std says is the play log's (`outcome` for a bot's end, `check` for a failed check, `play-line`
+ * STD'S OWN PLAY OF A GOAL (`../serving/std-dev.ts`'s `/play`, std's `/__std/play`) on `device`: a player's page std
+ * drives as it is (std's connected device, handed back to the person as the goal ends), or std's headless device,
+ * whose pages std opens. Its bot plays the goal to its end, recorded in the run's folder, then the goal's checks read
+ * the recording. Each line std says is the play log's (`outcome` for a bot's end, `check` for a failed check, `play-line`
  * otherwise), the bots' own traces too (their intents among them: `follow`), and its end is `autoplay-end` and the
- * Game panel's line: `<goal>: achieved`, or `<goal>: failed — why`.
+ * Game panel's line: `<goal>: achieved`, or `<goal>: failed — why`, with how its checks went, as std said it.
  */
-function playGoalHeadless(current: LiveRun, goal: string, by: 'panel' | 'cli'): void {
+function playGoal(current: LiveRun, goal: string, device: string, by: 'panel' | 'cli' | 'arm'): void {
   if (current.url === null) throw new Error('The game\'s dev server is still starting: autoplay once Play is running.');
-  // (one headless play a session at a time: a new one ends the one before, whichever run started it)
-  endHeadlessPlay();
+  // (one play by std a session at a time: a new one ends the one before, whichever run started it)
+  endStdPlay();
   const abort = new AbortController();
-  headlessPlay = { run: current, abort };
-  current.headless = { goal, state: 'playing', why: null };
-  current.log.append('play', 'autoplay-on', { goal, device: 'headless', by });
+  stdPlay = { run: current, abort };
+  current.played = { goal, device, state: 'playing', why: null, checks: null, report: null };
+  current.log.append('play', 'autoplay-on', { goal, device, by });
   publishRun();
   const failures: string[] = [];
   // (what std said last: a play that failed before any bot ended, its own error among them, says why there)
   let lastLine: string | null = null;
+  // (how the goal's checks went: the count line std ends them with)
+  let checks: string | null = null;
+  let report: string | null = null;
   // (an ended run, or a play another has replaced, hears nothing more of it)
-  const live = (): boolean => !current.stopped && headlessPlay?.abort === abort;
+  const live = (): boolean => !current.stopped && stdPlay?.abort === abort;
   const said = (line: string): void => {
     if (!live()) return;
     const bot = BOT_LINE.exec(line);
@@ -366,21 +447,23 @@ function playGoalHeadless(current: LiveRun, goal: string, by: 'panel' | 'cli'):
       failures.push(line);
       current.log.append('play', 'check', { goal, ok: false, failure: line.slice('check failed: '.length) });
     } else {
+      if (line.startsWith('checks of ')) checks = line;
+      if (line.startsWith('the report: ')) report = line.slice('the report: '.length);
       lastLine = line;
       current.log.append('play', 'play-line', { goal, line });
     }
   };
   const ended = (ok: boolean): void => {
     if (!live()) return;
-    headlessPlay = null;
+    stdPlay = null;
     const why = ok ? null : failures[0] ?? lastLine ?? 'std\'s play ended failed and said nothing';
-    current.headless = { goal, state: ok ? 'achieved' : 'failed', why };
+    current.played = { goal, device, state: ok ? 'achieved' : 'failed', why, checks, report };
     current.log.append('play', 'autoplay-end', { goal, achieved: ok, ...(why === null ? {} : { why }) });
-    publishRun();
+    released(current);
   };
   void (async () => {
     // (aborted, the route closes its socket to std's play, which ends it)
-    const response = await fetch('/__editor/play/std/play', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ goal }), signal: abort.signal });
+    const response = await fetch('/__editor/play/std/play', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ goal, device }), signal: abort.signal });
     if (!response.ok || response.body === null) {
       said(((await response.json().catch(() => ({}))) as { error?: string }).error ?? `std's play answered ${response.status}`);
       ended(false);
@@ -424,41 +507,49 @@ export async function captureStdView(): Promise<string> {
 
 /**
  * THE CLOCK SAID TO EVERY JOINED PLAYER'S PAGE (std's `clock` control): the game held, released, stepped `frames` or
- * set to a speed on each, the answering player's clock kept as the run's. Refused where nothing of the document's
- * plays, or no page has joined.
+ * set to a speed on each, the answering player's clock kept as the run's. Refused where nothing plays, or no page has
+ * joined.
  */
-async function clockAll(documentId: string, asked: StdClockAction): Promise<StdClock> {
-  const current = run && !run.stopped && run.documentId === documentId ? run : null;
-  if (!current) throw new Error(`Nothing is playing in ${documentId}; \`play\` starts it.`);
+async function clockAll(asked: StdClockAction): Promise<StdClock> {
+  const current = run && !run.stopped ? run : null;
+  if (!current) throw new Error('Nothing is playing; `play` starts it.');
   const joined = current.players.filter((player) => player.device !== null);
   if (joined.length === 0) throw new Error('No player\'s page has joined the game yet.');
-  const answers = await Promise.all(joined.map((player) => stdClock(player.device!, asked).then((clock) => ({ player, clock }))));
+  // (an answer is its run's: one that comes after Stop or Restart ended that run is no reading of the game now, and a
+  // page that run's end disconnected refuses with std's own "no device" before it can answer)
+  const ended = (): Error => new Error('The run ended (Stop or Restart) before its players\' pages answered.');
+  const answers = await Promise.all(joined.map((player) => stdClock(player.device!, asked).then((clock) => ({ player, clock }))))
+    .catch((error: unknown) => { throw current.stopped ? ended() : error; });
+  if (current.stopped) throw ended();
   const said = answers.find(({ player }) => player === answering(current)) ?? answers[0]!;
   current.log.append('play', asked.action, { ...asked, ...said.clock });
-  setModelPlayClock(documentId, said.clock);
+  setGameClock(said.clock);
   return said.clock;
 }
 
 /** Pause or resume every player's page. */
-export function setStdPaused(documentId: string, paused: boolean): Promise<StdClock> {
-  return clockAll(documentId, { action: paused ? 'pause' : 'resume' });
+export function setStdPaused(paused: boolean): Promise<StdClock> {
+  return clockAll({ action: paused ? 'pause' : 'resume' });
 }
 
 /** Step every player's page `frames` frames of 1/60 s, pausing it first. */
-export function stepStd(documentId: string, frames: number): Promise<StdClock> {
-  return clockAll(documentId, { action: 'step', frames });
+export function stepStd(frames: number): Promise<StdClock> {
+  return clockAll({ action: 'step', frames });
 }
 
 /** The person's speed, kept for the page's life, and said to every player's page that has joined. */
-export async function setStdSpeed(documentId: string, speed: number): Promise<void> {
-  setModelPlaySpeed(documentId, speed);
-  if (run && !run.stopped && run.documentId === documentId && run.players.some((player) => player.device !== null))
-    await clockAll(documentId, { action: 'speed', speed });
+export async function setStdSpeed(speed: number): Promise<void> {
+  setGameSpeed(speed);
+  const current = run;
+  // (the speed is the person's and is kept whatever the run's pages answer: a run that ended while they answered says
+  // nothing against it, and the next run's pages take it as they join)
+  if (current && !current.stopped && current.players.some((player) => player.device !== null))
+    await clockAll({ action: 'speed', speed }).catch((error: unknown) => { if (!current.stopped) throw error; });
 }
 
 /** A page that has just joined runs on the run's clock: held where the run is paused, at the person's speed. */
 function keepClock(current: LiveRun, player: StdPlayer): void {
-  const { paused, speed } = modelPlayClock(current.documentId);
+  const { paused, speed } = gameClock();
   const device = player.device;
   if (device === null) return;
   const said = (asked: StdClockAction): Promise<void> => stdClock(device, asked).then(() => {},
@@ -555,18 +646,49 @@ function retire(current: LiveRun, player: StdPlayer): void {
   place();
 }
 
-/** One more player, as the person asks (Players [+]). */
-export function addStdPlayer(): void {
-  if (!run || run.players.length >= MOST_PLAYERS) return;
-  playerCounts.set(run.documentId, Math.min(MOST_PLAYERS, (playerCounts.get(run.documentId) ?? FIRST_PLAYERS) + 1));
-  join(run);
+/**
+ * HOW MANY PLAY: the project's setting (`volter.play.players`), as the person (Players [-][+]) or the agent
+ * (`play players <n>`) sets it, from one to eight, written to the project's settings as any setting is; a running game's
+ * players join or leave to match whenever the setting changes, whoever changed it. Each step of the matching reads the
+ * setting as it is then, so counts set in quick succession end at the last. Settles once the setting is written and in
+ * force, and refuses, with where to read why, when the settings did not take it.
+ */
+export const setStdPlayers = (count: number): Promise<void> => writePlayers(() => count);
+
+/** One player more or fewer than the setting: a step counts from the write before it, so two quick [+] are two more. */
+export const stepStdPlayers = (by: 1 | -1): Promise<void> => writePlayers(() => playersSet() + by);
+
+/** The setting's writes, one after another: each reads the count it writes once the write before it is in force. */
+let playersWrites: Promise<void> = Promise.resolve();
+function writePlayers(count: () => number): Promise<void> {
+  const write = playersWrites.then(async () => {
+    const asked = Math.min(MOST_PLAYERS, Math.max(1, Math.round(count())));
+    await editorHost().settings.set(PLAYERS_SETTING, asked, 'project');
+    if (playersSet() !== asked)
+      throw new Error(`The project's settings did not take ${PLAYERS_SETTING} = ${asked}; the console says why.`);
+  });
+  playersWrites = write.catch(() => {});
+  return write;
+}
+
+/** The running game's players matched to the setting, and the Game panel told. */
+function matchPlayers(): void {
+  publishRun();
+  const current = run;
+  if (!current) return;
+  current.adding = current.adding.then(() => {
+    if (current.stopped) return;
+    for (let n = current.players.length; n > stdPlayersAsked(); n--) leave(current);
+    for (let n = current.players.length; n < stdPlayersAsked(); n++) join(current);
+  });
 }
 
 /** One more player: a page of its own, a real client joining, joined before the next is added. A page that never
  *  joins, or whose join cannot be read, is taken out again, its failure kept as the run's. */
 function join(current: LiveRun): void {
   current.adding = current.adding.then(async () => {
-    if (current.stopped || current.url === null || current.players.length >= MOST_PLAYERS) return;
+    // (as many as asked when this join's turn comes: a count lowered meanwhile wants it no longer)
+    if (current.stopped || current.url === null || current.players.length >= stdPlayersAsked()) return;
     const number = Math.max(0, ...current.players.map((player) => player.number)) + 1;
     const slot = `${current.tag}-${number}`;
     const frame = document.createElement('iframe');
@@ -578,7 +700,7 @@ function join(current: LiveRun): void {
     at.hostname = location.hostname;
     at.searchParams.set('slot', slot);
     frame.src = at.href;
-    const player: StdPlayer = { number, slot, frame, page: null, device: null, autopilot: false, goal: null, traced: 0, undrive: () => {} };
+    const player: StdPlayer = { number, slot, frame, page: null, device: null, autopilot: false, traced: 0, undrive: () => {} };
     Object.assign(player, { undrive: registerFramedDriver(frame, frameDriver(player)) });
     current.players.push(player);
     current.host.appendChild(frame);
@@ -608,19 +730,14 @@ function join(current: LiveRun): void {
   });
 }
 
-/** One player fewer, as the person asks (Players [-]): the last one's page unloaded, its client leaving. */
-export function removeStdPlayer(): void {
-  const current = run;
-  if (!current) return;
-  playerCounts.set(current.documentId, Math.max(1, (playerCounts.get(current.documentId) ?? FIRST_PLAYERS) - 1));
-  current.adding = current.adding.then(() => {
-    if (current.stopped || current.players.length <= 1) return;
-    const player = current.players.at(-1)!;
-    retire(current, player);
-    current.log.append('play', 'player-left', { slot: player.slot, device: player.device });
-    driveForView();
-    publishRun();
-  });
+/** The last player gone: its page unloaded, its client leaving. */
+function leave(current: LiveRun): void {
+  const player = current.players.at(-1);
+  if (player === undefined || current.players.length <= 1) return;
+  retire(current, player);
+  current.log.append('play', 'player-left', { slot: player.slot, device: player.device });
+  driveForView();
+  publishRun();
 }
 
 /**
@@ -643,6 +760,17 @@ function pageError(current: LiveRun, player: StdPlayer, facts: Record<string, un
   editorHost().console.error(`The game threw in Player ${player.number}'s page (${player.slot}): ${said}${stack}`, 'play');
 }
 
+/** Output lines in blocks: a line and the indented lines under it, blank lines left out. */
+function blocksOf(lines: readonly string[]): string[][] {
+  const blocks: string[][] = [];
+  for (const line of lines) {
+    if (line.trim() === '') continue;
+    if (/^\s/.test(line) && blocks.length > 0) blocks.at(-1)!.push(line);
+    else blocks.push([line]);
+  }
+  return blocks;
+}
+
 /**
  * WHAT THE DEV SERVER SAID ON ITS ERROR OUTPUT, in blocks (a line and the indented lines under it: an exception and its
  * stack). The room's own exceptions are Colyseus's to log there, never in a page's trace: a block that names an
@@ -651,13 +779,7 @@ function pageError(current: LiveRun, player: StdPlayer, facts: Record<string, un
  * console from Play. Anything else there (Vite's and Node's warnings, npm's notices) is the play log's `server-output`.
  */
 function serverSaid(current: LiveRun, lines: readonly string[]): void {
-  const blocks: string[][] = [];
-  for (const line of lines) {
-    if (line.trim() === '') continue;
-    if (/^\s/.test(line) && blocks.length > 0) blocks.at(-1)!.push(line);
-    else blocks.push([line]);
-  }
-  for (const block of blocks) {
+  for (const block of blocksOf(lines)) {
     const said = block.join('\n');
     // (a block that starts indented is the rest of one a look before read: its error was said there)
     if (/^\s/.test(block[0]!) || (!/Error\b/.test(block[0]!) && !block.some((line) => /^\s+at\s/.test(line)))) {
@@ -675,14 +797,25 @@ function serverSaid(current: LiveRun, lines: readonly string[]): void {
   }
 }
 
-/** The dev server's error output read on from the run's mark (where it stood as the run began; taken now, where the
- *  run's start couldn't), into the play log. */
+/** The dev server's two streams as `/output` answers them: each stream's lines from where it was asked, and its next. */
+interface ServerOutput {
+  readonly server: number | null;
+  readonly stdout: { readonly lines: string[]; readonly next: number };
+  readonly stderr: { readonly lines: string[]; readonly next: number };
+}
+
+/** The dev server's output read on from the run's mark (where it stood as the run began; taken now, where the run's
+ *  start couldn't), into the play log: each line of its standard output (the room's own `console.log`, Vite's notices)
+ *  a `server-output` as it is, and its error output read in blocks (`serverSaid`). */
 async function followServer(current: LiveRun): Promise<void> {
-  const read = current.serverErrors;
-  const errors = await askPlay<{ lines: string[]; next: number; server: number | null }>(read === null
-    ? '/errors' : `/errors?${new URLSearchParams({ server: String(read.server ?? ''), from: String(read.next) })}`);
-  current.serverErrors = { server: errors.server, next: errors.next };
-  if (read !== null) serverSaid(current, errors.lines);
+  const read = current.serverOutput;
+  const output = await askPlay<ServerOutput>(read === null ? '/output' : `/output?${new URLSearchParams({
+    server: String(read.server ?? ''), stdout: String(read.stdout), stderr: String(read.stderr) })}`);
+  current.serverOutput = { server: output.server, stdout: output.stdout.next, stderr: output.stderr.next };
+  if (read === null) return;
+  // (a line and the indented lines under it one entry, as a logged object or a warning's trace prints)
+  for (const block of blocksOf(output.stdout.lines)) current.log.append('play', 'server-output', { message: block.join('\n') });
+  serverSaid(current, output.stderr.lines);
 }
 
 /** Each player's page bound again, and its trace read on from where it was, into the play log. */
@@ -693,10 +826,10 @@ async function follow(current: LiveRun): Promise<void> {
     const said = `server-output: ${String(error)}`;
     if (current.errorsSaid.has(said)) return;
     current.errorsSaid.add(said);
-    current.log.append('play', 'server-output', { message: `Play could not read the dev server's error output: ${String(error)}` });
+    current.log.append('play', 'server-output', { message: `Play could not read the dev server's output: ${String(error)}` });
   });
   // (std's headless bots' pages, from the run's first headless play on: their slots are std's play's own)
-  if (current.headless !== null) {
+  if (current.played?.device === 'headless' || current.headlessTraced.size > 0) {
     for (const [page, slot] of Object.entries(await askPlay<Record<string, string>>('/pages')))
       if (/^(server|p2p)-\d+$/.test(slot) && !current.headlessTraced.has(page)) current.headlessTraced.set(page, { slot, traced: 0 });
     for (const [page, read] of current.headlessTraced) {
@@ -713,27 +846,32 @@ async function follow(current: LiveRun): Promise<void> {
     if (player.page === null) continue;
     const { lines, next } = await askPlay<{ lines: string[]; next: number }>(`/trace?page=${player.page}&from=${player.traced}`);
     player.traced = next;
+    let step: number | null = null;
     for (const line of lines) {
-      // (std's trace format 3: `s` the line's step, sixty a second of its page's steady clock)
+      // (std's trace format 3: `s` the line's step, sixty a second of its page's game clock, which is its
+      // `performance.now` on a live page)
       const { k, s, ...facts } = JSON.parse(line) as { k?: unknown; s?: unknown } & Record<string, unknown>;
       current.log.append('script', typeof k === 'string' ? k : 'trace', { slot: player.slot, ...facts },
         typeof s === 'number' && Number.isFinite(s) ? { simT: s / TRACE_STEPS_PER_SECOND, tick: s } : undefined);
+      if (typeof s === 'number' && Number.isFinite(s)) step = s;
       if (k === 'error') pageError(current, player, facts);
     }
+    // (the viewed player's newest traced step: the run's clock while the game runs, and only while this run is the one
+    // running, since a read in flight when Stop or Restart ended it lands after)
+    if (step !== null && !current.stopped && player === answering(current)) setGameTraceStep(step, TRACE_STEPS_PER_SECOND);
   }
 }
 
-/** The keys of the view bar, while the editor holds the keyboard: 1 to 4 a player, Tab the next view, Escape Edit. */
+/** The keys of the view bar, while the editor holds the keyboard and the Game view is in front: 1 to 4 a player, Tab
+ *  the next view. */
 function viewKey(event: KeyboardEvent): void {
-  if (!run || event.defaultPrevented || event.ctrlKey || event.metaKey || event.altKey) return;
-  // (the Export menu's Escape is the menu's)
-  if (event.code === 'Escape' && exportMenuOpen()) return;
+  if (!run || !run.stage.keys() || event.defaultPrevented || event.ctrlKey || event.metaKey || event.altKey) return;
   const target = event.target as HTMLElement | null;
   if (target && (target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName))) return;
   const views = stdViews();
   const next: StdView | undefined = /^Digit[1-4]$/.test(event.code) ? Number(event.code.slice(5)) - 1
     : event.code === 'Tab' ? views[(views.indexOf(run.view) + (event.shiftKey ? views.length - 1 : 1)) % views.length]
-    : event.code === 'Escape' && run.view !== 'edit' ? 'edit' : undefined;
+    : undefined;
   if (next === undefined || (typeof next === 'number' && !run.players[next])) return;
   event.preventDefault();
   event.stopPropagation();
@@ -741,8 +879,7 @@ function viewKey(event: KeyboardEvent): void {
 }
 
 /** Run the std game in the stage; the answer stops it (every player's page unloaded, its client leaving). */
-export function runStdGame(stage: DocumentPlayStage, report: (title: string, failure: string) => void, before: Promise<void>): () => void {
-  const { documentId } = stage;
+export function runStdGame(stage: GameStage, report: (title: string, failure: string) => void, before: Promise<void>): () => void {
   const host = document.createElement('div');
   host.dataset['testid'] = 'std-players';
   Object.assign(host.style, { position: 'absolute', inset: '0' });
@@ -753,21 +890,15 @@ export function runStdGame(stage: DocumentPlayStage, report: (title: string, fai
   // (the bar stands above the tiles, and its row passes the presses the bar doesn't hold to the tile beneath)
   Object.assign(bar.style, { position: 'relative', zIndex: '1', pointerEvents: 'none' });
   stage.container.appendChild(host);
-  (stage.overlay ?? stage.container).append(tiles, bar);
+  stage.overlay.append(tiles, bar);
   const roots: Root[] = [createRoot(bar), createRoot(tiles)];
   roots[0]!.render(createElement(StdViewBar));
   roots[1]!.render(createElement(StdGridTiles));
-  const log = beginModelPlayLog(documentId, STD_DEV);
+  const log = beginPlayLog(STD_DEV);
   const tag = Array.from(crypto.getRandomValues(new Uint8Array(3)), (byte) => byte.toString(16).padStart(2, '0')).join('');
-  const mine: LiveRun = run = { documentId, players: [], view: 0, goal: game?.goal ?? null, goals: knownGoals, url: null, tag, host, stage,
-    log, adding: Promise.resolve(), failure: null, stopped: false, lastError: null, errorsSaid: new Set(), headless: null,
-    headlessTraced: new Map(), serverErrors: null };
-  // (a press in the viewed page is the person's: the editor's window loses the keyboard to it)
-  const tookOver = (): void => {
-    const player = typeof mine.view === 'number' ? mine.players[mine.view] : undefined;
-    if (player && document.activeElement === player.frame) drive(player, false, 'takeover');
-  };
-  window.addEventListener('blur', tookOver);
+  const mine: LiveRun = run = { players: [], view: 0, goal: game?.goal ?? null, goals: knownGoals, url: null, tag, host, stage,
+    log, adding: Promise.resolve(), failure: null, stopped: false, lastError: null, errorsSaid: new Set(), played: null,
+    headlessTraced: new Map(), serverOutput: null };
   window.addEventListener('keydown', viewKey, true);
   // (each look after the last has answered, so no two read one trace from the same byte)
   let looking: ReturnType<typeof setTimeout> | null = null;
@@ -782,8 +913,8 @@ export function runStdGame(stage: DocumentPlayStage, report: (title: string, fai
     // (the run's mark, before the dev server starts: one started now is read from its first line, one running already
     // from where its output stands)
     // (a mark not answered is taken at the run's first look, where the output stands then)
-    const mark = await askPlay<{ next: number; server: number | null }>('/errors').catch(() => null);
-    if (mark !== null) mine.serverErrors = { server: mark.server, next: mark.next };
+    const mark = await askPlay<ServerOutput>('/output').catch(() => null);
+    if (mark !== null) mine.serverOutput = { server: mark.server, stdout: mark.stdout.next, stderr: mark.stderr.next };
   }).then(() => Promise.all([
     askPlay<{ url: string }>('/start', { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' }),
     // (the game's goals, read again for each run: its autopilot/ program is the author's to change)
@@ -800,34 +931,32 @@ export function runStdGame(stage: DocumentPlayStage, report: (title: string, fai
     // (the traces read from the dev server's start, whether or not a player's page joins: std's headless play's bots
     // play while the editor is not seen, and its players' pages do not)
     lookOn();
-    for (let n = playerCounts.get(documentId) ?? FIRST_PLAYERS; n > 0; n--) join(mine);
+    for (let n = stdPlayersAsked(); n > 0; n--) join(mine);
     void mine.adding.then(() => {
       if (mine.stopped) return;
-      // (a run with a player who never joined stands with its failure, and draws nothing in front of the document)
+      // (a run with a player who never joined stands with its failure)
       const failure = mine.failure ?? (mine.players.some((player) => player.device !== null) ? null : 'No player\'s page joined the game.');
-      if (failure !== null) { setModelPlayFailure(documentId, failure); return; }
-      setModelPlayFailure(documentId, null);
-      stage.ready();
+      if (failure !== null) { setGameFailure(failure); return; }
+      setGameFailure(null);
       // (Autoplay armed while stopped drives the viewed player from the run's start, with the goal it was armed with)
-      const arm = takeModelPlayArm(documentId);
+      const arm = takeGameArm();
       if (arm !== null)
-        setStdAutoplay(true, 'panel', arm.goal ?? undefined)
+        setStdAutoplay(true, 'arm', arm.goal ?? undefined)
           .catch((error: unknown) => log.append('play', 'autoplay-refused', { message: error instanceof Error ? error.message : String(error) }));
     });
     publishRun();
   }, (error: unknown) => {
     if (mine.stopped) return;
     const failure = error instanceof Error ? error.message : String(error);
-    setModelPlayFailure(documentId, failure);
+    setGameFailure(failure);
     report('The game\'s dev server could not be started', failure);
   });
   publishRun();
   return () => {
-    // (Stop, Restart, the document's close and a project change all end here: std's headless play goes with the run)
-    endHeadlessPlay(mine);
+    // (Stop, Restart, the Game view's close and a project change all end here: std's play of a goal goes with the run)
     mine.stopped = true;
+    endStdPlay(mine);
     if (looking !== null) clearTimeout(looking);
-    window.removeEventListener('blur', tookOver);
     window.removeEventListener('keydown', viewKey, true);
     for (const root of roots) root.unmount();
     for (const player of mine.players) player.undrive();