@volter/editor-blender 0.1.151 → 0.1.152

package/contributions/blender-runtime.document.tsx

@@ -31,13 +31,14 @@ import {
   useLayoutEffect,
   useMemo,
   useRef,
-  type RefObject,
   useState,
   useSyncExternalStore,
 } from 'react';
 import * as THREE from 'three';
 import {
   bindModelDocument,
+  blenderStarting,
+  subscribeBlenderStarting,
   blenderExecute,
   subscribeBlenderRna,
   blenderViewShading,
@@ -47,7 +48,6 @@ import {
   blenderActionClip,
   blenderSceneMovie,
   blenderRnaVersion,
-  blenderPresentDocument,
   modelDocumentDirty,
   restoreModelDocument,
   revertModelDocument,
@@ -60,9 +60,7 @@ import { blenderOutlinerAuthoringFor, createBlenderOutlinerAuthoring } from './b
 import { blenderSkin } from './blender-runtime-skin';
 
 import { areaSplit, subscribeAreaSplit } from '../src/area-split';
-import { noteModelDocument, noteModelOpening } from '../src/play-mode';
-import { type DocumentPlayEditArea, modelPlayExtension, subscribeModelPlayExtension } from '../src/model-play-extension';
-import { notifyWorkspaceDocumentSelectionChanged } from '@volter/sdk/workspace-document-registry';
+import { noteModelDocument } from '../src/play-mode';
 import {
   documentSecondAreaHeader,
   setDocumentSecondArea,
@@ -77,18 +75,15 @@ import {
 } from '@volter/editor-threejs/kit/authoring/object3d-document-session-registry';
 import type { ToolObject3DAuthoringProps } from '@volter/editor-threejs/object3d-contributions';
 import { stageStore, subscribeStageStores } from '@volter/sdk/stage-store-registry';
-import { surfaceAcceptsKey } from '@volter/sdk/surface-keyboard';
 import { BlenderModelOpening } from './blender-model-opening';
 import { modelOpeningErrorMessage } from '../src/model-opening-error';
-import { commandLine } from '@volter/sdk/product-command';
-import { Button, fontSizeVar, spaceVar, themeVars } from '@volter/sdk/widgets';
+import { Button, EditorBanner } from '@volter/sdk/widgets';
+import { useProgress } from '@volter/sdk/progress';
 import { modelDocumentSaveNotice, subscribeModelDocumentSaving } from '../src/model-document-saving';
 import { clearStartupFailure, reportStartupFailure } from '@volter/sdk/startup-failure';
 
 /** This document's model open, as a source in the page's startup-failure registry. */
 const MODEL_OPEN_STARTUP_SOURCE = 'blender-model-open';
-/** How long "Opening model…" stands before the pane also says what it is waiting on. */
-const MODEL_OPEN_NOTE_AFTER_MS = 30_000;
 import {
   clearModelDocumentPreview,
   modelDocumentPreview,
@@ -97,15 +92,6 @@ import {
   type ModelDocumentPreview,
 } from '../src/model-document-preview';
 
-/** A detached copy's identity as a React key (the play area is keyed on the copy it draws). */
-const playCopyKeys = new WeakMap<object, number>();
-let nextPlayCopyKey = 0;
-function playCopyKey(copy: object): number {
-  let key = playCopyKeys.get(copy);
-  if (key === undefined) { key = ++nextPlayCopyKey; playCopyKeys.set(copy, key); }
-  return key;
-}
-
 /** The second areas' stage stores whose overlays have been opened off (`BlenderViewportArea`). */
 const overlaysOpened = new WeakSet<object>();
 
@@ -234,9 +220,10 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
   const entryId = document?.id;
   const key = JSON.stringify([documentId, entryId, blend]);
   const [opened, setOpened] = useState<{ key: string; error: string | null } | null>(null);
-  /** What a slow open is waiting on, once it has been slow (`MODEL_OPEN_NOTE_AFTER_MS`). */
-  const [stillOpening, setStillOpening] = useState<string | null>(null);
   const [attempt, setAttempt] = useState(0);
+  /** Open the model again, as often as it is asked: an error's Retry, the open's wait's Retry, or a reopen. */
+  const retry = useCallback(() => { setOpened(null); setAttempt(value => value + 1); }, []);
+  const blenderStart = useSyncExternalStore(subscribeBlenderStarting, blenderStarting, () => false);
   const saveNotice = useSyncExternalStore(subscribeModelDocumentSaving, () => modelDocumentSaveNotice(blend), () => null);
   const project = editorHost().projectLocalState.projectRootPath();
   const preview = useSyncExternalStore(subscribeModelDocumentPreview, () => modelDocumentPreview(project), () => null);
@@ -246,10 +233,6 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
   callbacks.current = { notify, publishContext };
 
   useEffect(() => editorHost().session.onEnded(clearModelDocumentPreview), []);
-  // WHILE ITS FILE OPENS, the Game panel's verbs wait for this document rather than answer that no model is open
-  // (`../src/play-mode.ts`, `noteModelOpening`); once presented, its viewport serves the panel (`noteModelDocument`).
-  const presented = opened?.key === key;
-  useEffect(() => (active === false || !documentId || presented ? undefined : noteModelOpening(documentId)), [active, documentId, presented]);
   // Retain a bounded photograph while the stage is healthy. Teardown can
   // already have changed its scene/camera, so it is too late to re-render then.
   useEffect(() => {
@@ -274,7 +257,7 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
           const context = copy.getContext('2d');
           if (context) {
             context.drawImage(frame, 0, 0, copy.width, copy.height);
-            // Encode the PNG with toBlob off the main thread to keep Play frames responsive.
+            // Encode the PNG with toBlob off the main thread to keep frames responsive.
             const image = await pngDataUrl(copy);
             if (cancelled || !image) return;
             lastFrame.current = { project, entryId, path: blend ?? 'Model', image, capturedAt: performance.now() };
@@ -309,25 +292,22 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
     const unbind = bindModelDocument(binding);
     const publish = () => { unpublish = callbacks.current.publishContext?.(view); };
     setOpened(null);
-    setStillOpening(null);
     // Native focus can arrive after the contributed pane mounts. A declined
     // open is not an in-flight load: retry when the host activates this model,
-    // rather than leaving "Opening model…" latched forever. Utility focus
+    // rather than leaving the open's wait latched forever. Utility focus
     // after a successful open must not tear down the model's published view.
     const documents = editorHost().documents;
     let starting = false;
     let finished = false;
-    let declined = false;
     const path = blend ?? 'the model';
     const open = async () => {
       if (cancelled || starting || finished) return;
-      if (binding && !modelDocumentMayOpen(binding)) { declined = true; return; }
+      if (binding && !modelDocumentMayOpen(binding)) return;
       starting = true;
-      declined = false;
       try {
         if (binding) {
           const reload = attempt > 0 && modelDocumentSaveNotice(binding.blend) !== null;
-          if (!await openModelDocumentBlend(binding, publish, reload)) { declined = true; return; }
+          if (!await openModelDocumentBlend(binding, publish, reload)) return;
         } else {
           // The standing Model document is the explicit blender-start target.
           publish();
@@ -358,13 +338,6 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
         starting = false;
       }
     };
-    // A long open reports progress while its request runs. Retry is offered only for an actual failure, avoiding a second queued open.
-    const slow = setInterval(() => {
-      if (cancelled || finished) return;
-      setStillOpening(declined
-        ? `Still waiting: Blender is holding another model, and opens ${path} when it is free.`
-        : `Still opening ${path}: Blender is working (a large file, or a cold start). ${commandLine('status')} shows what it is busy with.`);
-    }, MODEL_OPEN_NOTE_AFTER_MS);
     // Opening publishes context to other React roots. Start outside this
     // effect (or a host activation listener's synchronous notification stack)
     // so those roots cannot synchronously commit through a pending commit here.
@@ -378,18 +351,28 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
     requestOpen();
     return () => {
       cancelled = true;
-      clearInterval(slow);
       unsubscribe();
       unpublish?.();
       unbind();
     };
   }, [active, blend, documentId, entryId, key, attempt]);
 
+  // THE OPEN'S ONE WAIT, from asking for the file until its viewport is drawn: Blender's start
+  // first when it is still under way (the first open, or one after a reload or a failure), then
+  // the file's own load, then its view. Retry opens it again, as often as it is chosen.
+  const failed = opened?.key === key && opened.error !== null;
+  const preparing = opened?.key === key && !failed && !!documentId && !documentViewport(documentId);
+  useProgress(active !== false && !!documentId && !failed && (opened?.key !== key || preparing) ? {
+    documentId,
+    title: `Opening ${blend ?? 'the model'}`,
+    message: preparing ? 'Preparing its view' : blenderStart ? 'Starting Blender' : undefined,
+    actions: [{ label: 'Retry opening', run: retry }],
+  } : null);
+
   if (active === false || !documentId) return null;
   if (opened?.key !== key || opened.error) return <BlenderModelOpening
     documentId={documentId} path={blend ?? 'Model'} error={opened?.key === key ? opened.error : null} preview={preview}
-    note={stillOpening}
-    retry={() => { setOpened(null); setAttempt(value => value + 1); }}
+    retry={retry}
     returnToPreview={() => {
       if (!preview) return;
       void editorHost().workspace.open({ kind: 'document', id: preview.entryId }).then(opened => {
@@ -399,19 +382,13 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
   />;
   return <>
     <BlenderModelViewport {...props} />
-    {saveNotice && <div role="alert" data-testid="blender-model-not-saving"
-      style={{ position: 'absolute', top: spaceVar[3], left: spaceVar[3], right: spaceVar[3], zIndex: 2,
-        background: themeVars.surface.chrome, color: themeVars.content.primary,
-        border: `1px solid ${themeVars.semantic.warning}`, padding: spaceVar[3], fontSize: fontSizeVar.sm }}>
-      <strong>Model is not being saved</strong>
-      <div style={{ marginTop: spaceVar[2], marginBottom: spaceVar[3], userSelect: 'text' }}>{saveNotice}</div>
-      <div style={{ marginBottom: spaceVar[3] }}>Reopening replaces this scene with the last saved file.</div>
-      <Button variant="secondary" onClick={() => { setOpened(null); setAttempt(value => value + 1); }}>
-        Reopen saved document
-      </Button>
-    </div>}
-    {!documentViewport(documentId) && <BlenderModelOpening documentId={documentId} path={blend ?? 'Model'} error={null}
-      preparingView preview={preview} retry={() => {}} returnToPreview={() => {}} />}
+    {saveNotice && <EditorBanner tone="warning" data-testid="blender-model-not-saving"
+      style={{ position: 'absolute', top: 0, left: 0, right: 0, zIndex: 2 }}
+      actions={<Button variant="secondary" onClick={retry}>Reopen saved document</Button>}>
+      <strong>Model is not being saved.</strong> <span style={{ userSelect: 'text' }}>{saveNotice}</span> Reopening replaces this scene with the last saved file.
+    </EditorBanner>}
+    {preparing && <BlenderModelOpening documentId={documentId} path={blend ?? 'Model'} error={null}
+      preparingView preview={preview} retry={retry} returnToPreview={() => {}} />}
   </>;
 }
 
@@ -422,26 +399,21 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
  * Blender's standard always-on render preview is set up: Rendered shading, through the scene
  * camera. Each area has its own stage, shading, navigation and camera view; the model, its
  * selection and its history are the document's.
- *
- * PLAYING (the composed Play tool), the area shows a DETACHED copy of the model's World
- * (`BlenderRuntimeView.detach`) on a stage of its own, where the level's game draws (the document Play extension).
- * The model's own stage stays mounted underneath, hidden, so Stop returns to the same view of the same model:
- * nothing a game does reaches Blender.
  */
 function BlenderModelViewport(props: ToolContributionProps) {
   const { documentId } = props;
   const blend = props.document?.source?.path;
-  // THE BOTTOM AREA SERVES THIS DOCUMENT while it is the model on screen (`../src/play-mode.ts`):
-  // the Game panel drives this id's run, and Game or Animation is chosen by whether this level has a game.
+  // THE BOTTOM AREA SERVES THIS DOCUMENT while it is the model on screen (`../src/play-mode.ts`): Game or Animation,
+  // by whether the project has a game.
   useEffect(() => (documentId ? noteModelDocument(documentId, blend) : undefined), [documentId, blend]);
-  // Rendered areas and Play use the display transform carried by the presented frame. Solid uses its studio transform. Document preparation waits for that frame’s transform before photographs.
+  // Rendered areas use the display transform carried by the presented frame. Solid uses its studio transform. Document preparation waits for that frame’s transform before photographs.
   useEffect(() => {
     if (!documentId) return;
     let cancelled = false;
     let applied: BlenderDisplayTransform | null = null;
     let wanted: string | null = null;
     let settled: Promise<void> = Promise.resolve();
-    const ids = [documentId, `${documentId}#area-2`, `${documentId}#play`];
+    const ids = [documentId, `${documentId}#area-2`];
     const attach = () => {
       for (const id of ids) object3DDocumentSession(id)?.setDisplayTransform(applied);
     };
@@ -512,209 +484,18 @@ function BlenderModelViewport(props: ToolContributionProps) {
       second.dispose();
     };
   }, [split, documentId]);
-  const playing = useSyncExternalStore(
-    subscribeModelPlayExtension,
-    () => (documentId ? modelPlayExtension()?.playing(documentId) ?? false : false),
-    () => false,
-  );
-  const [played, setPlayed] = useState<ReturnType<AreaView['detach']> | null>(null);
-  const playAspect = useSyncExternalStore(
-    subscribeModelPlayExtension,
-    () => (documentId ? modelPlayExtension()?.aspectRatio?.(documentId) ?? null : null),
-    () => null,
-  );
-  const [playedReady, setPlayedReady] = useState(false);
-  /** THE PLAY OVERLAY: a layer over the editing area and the play area alike, where the Play tool puts its view
-   *  controls (`DocumentPlayStage.overlay`), so they stand whichever area is in front. It takes no press itself;
-   *  the controls in it take their own. */
-  const playOverlay = useRef<HTMLDivElement>(null);
-  /** WHERE THE MODEL'S OWN AREA STANDS WHILE THE GAME RUNS (`DocumentPlayStage.edit`): hidden behind the game, live in
-   *  front of it, or drawing in a box of the stage (a tile), taking no press; null while the tool has placed it
-   *  nowhere, and again when the game ends. A tool that places it switches it at once; otherwise it fades as the game
-   *  draws its first frame. */
-  const [editArea, setEditArea] = useState<DocumentPlayEditArea | null>(null);
-  /**
-   * RESTART IS A NEW GENERATION OF THE SAME PLAY (`DocumentPlayTransport.generation`): the copy
-   * below is detached per generation, so a restart disposes the played copy and detaches a fresh
-   * one from the model, which never moved, while playing stays true throughout.
-   *
-   * THE OLD GAME STAYS ON SCREEN UNTIL THE NEW ONE HAS DRAWN. Between the two the new copy's
-   * stage is still preparing its rendered draw, and the model area is what lies under the play
-   * area — so a restart would flash the editing model between two games. The generation is
-   * therefore taken in two steps: a layout effect photographs the old play stage while it still
-   * stands (`capture`, the frame it draws) and only then moves `shownGeneration`, which is what
-   * detaches the new copy. The photograph covers the play area until the new runner's first
-   * frame (`onPlayReady`), and the model area stays hidden throughout.
-   */
-  const generation = useSyncExternalStore(
-    subscribeModelPlayExtension,
-    () => (documentId ? modelPlayExtension()?.transport?.generation(documentId) ?? 0 : 0),
-    () => 0,
-  );
-  const [shownGeneration, setShownGeneration] = useState(generation);
-  const [restartStill, setRestartStill] = useState<string | null>(null);
-  const restarting = useRef(false);
-  // A restarted game that has not drawn yet: its stage holds no game to photograph, so a second
-  // Restart in that window keeps the cover it has (or none) rather than photographing a blank.
-  const awaitingDraw = useRef(false);
-  useLayoutEffect(() => {
-    if (generation === shownGeneration) return;
-    if (playing && documentId) {
-      restarting.current = true;
-      if (!awaitingDraw.current) {
-        let still: string | null = null;
-        try { still = documentViewport(`${documentId}#play`)?.capture?.() ?? null; }
-        catch { /* No photograph: the new stage shows as it prepares, still never the model. */ }
-        setRestartStill(still);
-      }
-      awaitingDraw.current = true;
-    }
-    setShownGeneration(generation);
-  }, [generation, shownGeneration, playing, documentId]);
-  /**
-   * A RESTARTED GAME THAT FAILS never draws (its script did not start, or threw on its first
-   * update), so the cover would stand over it while the panel said Playing. The runner says so
-   * on the clock (`DocumentPlayClock.failure`); the cover drops and the stage shows what it has.
-   */
-  const transport = modelPlayExtension()?.transport;
-  const subscribeFailure = useCallback(
-    (listener: () => void) => transport?.subscribeClock(listener) ?? (() => {}),
-    [transport],
-  );
-  const failure = useSyncExternalStore(
-    subscribeFailure,
-    () => (documentId && transport ? transport.clock(documentId).failure ?? null : null),
-    () => null,
-  );
-  useEffect(() => {
-    if (failure === null) return;
-    awaitingDraw.current = false;
-    setRestartStill(null);
-  }, [failure]);
-  /**
-   * COPIES A RESTART RETIRED, disposed only once the play area that drew them has unmounted:
-   * the commit that renders the new copy removes the old area first, and this runs after it.
-   * Disposed earlier, the old stage could draw a disposed copy for a frame.
-   */
-  const retired = useRef<ReturnType<AreaView['detach']>[]>([]);
-  useEffect(() => {
-    if (!playing || !documentId) { restarting.current = false; return; }
-    const playId = `${documentId}#play`;
-    // A game is seen as the render is: Rendered shading, chosen before the stage binds.
-    setViewPresentation(playId, { drawMode: 'rendered' });
-    // The game brings its own objects: the copy is the World alone.
-    const copy = view.detach();
-    const restart = restarting.current;
-    restarting.current = false;
-    // A restart keeps the model area hidden: the old game's photograph stands in until ready.
-    if (!restart) setPlayedReady(false);
-    setPlayed(copy);
-    if (!restart) {
-      // The stage's mode is PLAY for as long as a copy stands, so the keys are the player's.
-      view.setPlaying(true);
-      notifyWorkspaceDocumentSelectionChanged(documentId);
-    }
-    return () => {
-      // Read at cleanup: the layout effect above has already marked a restart, whose new copy
-      // takes over in this same commit with the play mode unchanged.
-      if (restarting.current && modelPlayExtension()?.playing(documentId)) {
-        retired.current.push(copy);
-        return;
-      }
-      copy.dispose();
-      for (const old of retired.current.splice(0)) old.dispose();
-      awaitingDraw.current = false;
-      setEditArea(null);
-      setPlayed(null);
-      setRestartStill(null);
-      view.setPlaying(false);
-      notifyWorkspaceDocumentSelectionChanged(documentId);
-      // Present the document after Play ends. Preserve action revisions so the next edit does not rebake unchanged clips.
-      void blenderPresentDocument().catch(() => {});
-    };
-  }, [playing, documentId, shownGeneration]);
-  useEffect(() => {
-    for (const old of retired.current.filter(one => one !== played)) old.dispose();
-    retired.current = retired.current.filter(one => one === played);
-  }, [played]);
-  // And whatever is still retired when the document itself goes (declared after the copy's own
-  // effect, so its cleanup has already handed over anything mid-restart).
-  useEffect(() => () => { for (const old of retired.current.splice(0)) old.dispose(); }, []);
-  // The document closing or going inactive ends its game; a game never outlives its stage.
-  useEffect(() => {
-    if (!documentId) return;
-    return () => modelPlayExtension()?.setPlaying(documentId, false);
-  }, [documentId]);
-  const game = playing ? played : null;
-  const playFrame = playAspect === null ? { position: 'absolute', inset: 0 } as const : {
-    position: 'absolute', left: '50%', top: '50%', transform: 'translate(-50%, -50%)',
-    width: `min(100cqw, calc(100cqh * ${playAspect}))`,
-    height: `min(100cqh, calc(100cqw / ${playAspect}))`,
-  } as const;
-  useEffect(() => {
-    if (!game || !documentId) return;
-    const modelViewport = documentViewport(documentId);
-    if (!modelViewport) return;
-    // registerObject3DDocumentSession creates this document's own viewport object; capture may follow its visible play area.
-    const capture = modelViewport.capture;
-    const playCapture = (size: Parameters<NonNullable<typeof capture>>[0]) =>
-      documentViewport(`${documentId}#play`)?.capture?.(size) ?? null;
-    modelViewport.capture = playCapture;
-    return () => {
-      if (modelViewport.capture !== playCapture) return;
-      if (capture) modelViewport.capture = capture;
-      else delete modelViewport.capture;
-    };
-  }, [game, documentId]);
-  // (the model's keys are the player's while the game is in front, and the editor's while the area is live)
-  useEffect(() => { if (game) view.setPlaying(editArea !== 'live'); }, [game, editArea, view]);
   if (!documentId) return null;
   const second = split ? follower : null;
-  // Keep both authoring areas mounted across Play/Stop. Remounting a stage discards
-  // its pose/session and repeats the second area's initial scene-camera setup.
   const area = { position: 'relative', flex: '1 1 0', minWidth: 0, margin: 12 } as const;
-  // Make the hidden Model area inert so its subtree receives neither pointer presses nor focus. A live overlay or tile uses the box supplied by the Play tool.
-  const tile = game !== null && typeof editArea === 'object' ? editArea : null;
-  const hidden = game !== null && playedReady && (editArea === null || editArea === 'hidden');
-  const modelBox = tile === null ? { inset: 12 } : {
-    left: `calc(12px + (100% - 24px) * ${tile.left})`, top: `calc(12px + (100% - 24px) * ${tile.top})`,
-    width: `calc((100% - 24px) * ${tile.width})`, height: `calc((100% - 24px) * ${tile.height})`,
-  };
   return (
-    <div style={game || second ? { position: 'absolute', inset: -12, display: 'flex', gap: 2 } : { display: 'contents' }}>
-      <div key="model" inert={hidden || tile !== null || undefined} style={game ? { position: 'absolute', ...modelBox, zIndex: 2, opacity: hidden ? 0 : 1, pointerEvents: hidden || tile !== null ? 'none' : 'auto', transition: editArea === null ? 'opacity 160ms ease-out' : 'none' } : second ? area : { display: 'contents' }}>
+    <div style={second ? { position: 'absolute', inset: -12, display: 'flex', gap: 2 } : { display: 'contents' }}>
+      <div key="model" style={second ? area : { display: 'contents' }}>
         <BlenderViewportArea {...props} view={view} main />
       </div>
-      {game && (
-        // Keyed on the COPY, so a restart mounts a new stage and runner exactly when the new copy
-        // is the one rendered — never over the old, disposed one.
-        <div key={`play-${playCopyKey(game)}`} style={{ position: 'absolute', inset: 12, containerType: 'size' }} data-testid="blender-play-area">
-          <div data-volter-play-frame style={playFrame}>
-          <BlenderViewportArea {...props} documentId={`${documentId}#play`} view={game.view} main={false} playing
-            onPlayReady={() => { awaitingDraw.current = false; setPlayedReady(true); setRestartStill(null); }}
-            onPlayEdit={setEditArea} playOverlay={playOverlay} />
-          </div>
-        </div>
-      )}
-      {game && <div key="play-overlay" ref={playOverlay} data-testid="blender-play-overlay" style={{ position: 'absolute', inset: 12, zIndex: 5, pointerEvents: 'none' }} />}
-      {game && failure !== null && (
-        // Display a failed Play start over the area until it draws; the Game panel repeats the same refusal.
-        <div key="play-failure" role="alert" data-testid="blender-play-failure"
-          style={{ position: 'absolute', left: 24, right: 24, top: 24, zIndex: 4, padding: `${spaceVar[2]} ${spaceVar[3]}`,
-            background: themeVars.surface.chrome, border: `1px solid ${themeVars.semantic.danger}`, borderRadius: themeVars.shape.small,
-            color: themeVars.content.primary, fontSize: fontSizeVar.sm, whiteSpace: 'pre-wrap', overflowWrap: 'anywhere', userSelect: 'text' }}>
-          <strong style={{ color: themeVars.semantic.danger }}>Play is not running.</strong> {failure} Restart (or save the script) to try again, or Stop.
-        </div>
-      )}
-      {game && restartStill !== null && (
-        <div key="restart-still" style={{ position: 'absolute', inset: 12, containerType: 'size', zIndex: 3, pointerEvents: 'none' }} data-testid="blender-play-restart-still">
-          <img alt="" src={restartStill} style={{ ...playFrame, display: 'block', objectFit: 'fill' }} />
-        </div>
-      )}
       {second && (
-        <div key="second" style={{ ...area, visibility: game ? 'hidden' : undefined }} aria-hidden={game ? true : undefined} data-testid="blender-second-area">
+        <div key="second" style={area} data-testid="blender-second-area">
           <BlenderViewportArea {...props} documentId={`${documentId}#area-2`} view={second.view} main={false} />
-          {!game && <SecondAreaChrome documentId={documentId} areaId={`${documentId}#area-2`} notify={props.notify} />}
+          <SecondAreaChrome documentId={documentId} areaId={`${documentId}#area-2`} notify={props.notify} />
         </div>
       )}
     </div>
@@ -785,40 +566,28 @@ function BlenderViewportArea({
   active,
   document,
   documentId,
-  notify,
   surfaces,
   view,
   main,
-  playing = false,
-  onPlayReady,
-  onPlayEdit,
-  playOverlay,
-}: ToolContributionProps & { readonly view: AreaView; readonly main: boolean; readonly playing?: boolean; readonly onPlayReady?: () => void;
-  readonly onPlayEdit?: (area: DocumentPlayEditArea) => void; readonly playOverlay?: RefObject<HTMLDivElement | null> }) {
+}: ToolContributionProps & { readonly view: AreaView; readonly main: boolean }) {
   const reads = readsOf(view);
   const build = useCallback(
     () => ({
       root: view.root,
       prepareDraw: (camera: THREE.Camera, options?: BlenderDrawOptions) => view.prepareDraw(camera, options),
       // What the view draws changes with each frame and the work after it,
-      // and with the skin's poses when the Timeline scrubs. A PLAYING copy announces nothing, and
-      // a source that announces nothing is drawn every frame (`ToolObject3DPreviewSource.onChange`):
-      // the play stage's frames are what start the Play tool's run once the stage stands.
-      ...(playing
-        ? {}
-        : {
-            onChange(listener: () => void) {
-              const stopView = view.onChange(listener);
-              const stopSkin = blenderSkin.subscribe(listener);
-              return () => {
-                stopView();
-                stopSkin();
-              };
-            },
-          }),
+      // and with the skin's poses when the Timeline scrubs.
+      onChange(listener: () => void) {
+        const stopView = view.onChange(listener);
+        const stopSkin = blenderSkin.subscribe(listener);
+        return () => {
+          stopView();
+          stopSkin();
+        };
+      },
       dispose() {},
     }),
-    [view, playing],
+    [view],
   );
   const blend = document?.source?.path;
   // Re-read on the engine's frames, the skin's publications and every drawn frame of this stage
@@ -858,8 +627,7 @@ function BlenderViewportArea({
    * person's.
    */
   useEffect(() => {
-    // A playing copy's camera is its script's.
-    if (main || playing || !documentId) return;
+    if (main || !documentId) return;
     let entered = false;
     const enter = (): void => {
       if (entered) return;
@@ -874,98 +642,7 @@ function BlenderViewportArea({
       stopSessions();
       stopFrames();
     };
-  }, [main, playing, documentId, view]);
-  /**
-   * THE LEVEL'S GAME PLAYS IN THIS STAGE (the document Play extension), once the stage stands: the Play tool draws the
-   * game in its container, in place of the hidden copy, and Escape stops the game.
-   */
-  const notifyRef = useRef(notify);
-  const surfaceRef = useRef<HTMLDivElement>(null);
-  const [playReady, setPlayReady] = useState(false);
-  notifyRef.current = notify;
-  const playReadyRef = useRef(onPlayReady);
-  playReadyRef.current = onPlayReady;
-  const playEditRef = useRef(onPlayEdit);
-  playEditRef.current = onPlayEdit;
-  useEffect(() => {
-    if (!playing || !documentId) return;
-    if (blend === undefined) {
-      notifyRef.current?.({
-        tone: 'error',
-        title: 'This model has no game',
-        detail: 'A level\'s game is its project\'s, and this model has no file of its own in the project.',
-      });
-      return;
-    }
-    const modelId = documentId.replace(/#play$/, '');
-    const layers = window.document.createElement('div');
-    Object.assign(layers.style, { position: 'absolute', inset: '0', pointerEvents: 'none' });
-    layers.dataset['testid'] = 'model-play-roots';
-    surfaceRef.current?.appendChild(layers);
-    setPlayReady(false);
-    let stopped = false;
-    let stopScript: (() => void) | null = null;
-    let hiddenCopy: boolean | null = null;
-    const start = (): void => {
-      if (stopScript || stopped) return;
-      const stage = viewportStages().find((one) => one.documentId === documentId);
-      if (!stage || !view.root.parent) return;
-      hiddenCopy = view.root.visible;
-      view.root.visible = false;
-      stopScript = modelPlayExtension()?.run({
-        documentId: modelId,
-        container: layers,
-        ready: () => { if (!stopped) { setPlayReady(true); playReadyRef.current?.(); } },
-        edit: (area) => { if (!stopped) playEditRef.current?.(area); },
-        ...(playOverlay?.current ? { overlay: playOverlay.current } : {}),
-        sourcePath: blend,
-        report: (title, detail) => {
-          editorHost().console.error(`${title}: ${detail}`, 'blender-play');
-          notifyRef.current?.({ tone: 'error', title, detail });
-        },
-      }) ?? null;
-    };
-    start();
-    let waitingStage: ReturnType<typeof viewportStages>[number] | undefined;
-    let stopPrepareFrames: (() => void) | undefined;
-    const waitForDraw = () => {
-      const stage = viewportStages().find(one => one.documentId === documentId);
-      if (stage === waitingStage) return;
-      stopPrepareFrames?.();
-      waitingStage = stage;
-      stopPrepareFrames = stage?.onFrame(start);
-      start();
-    };
-    waitForDraw();
-    const stopStages = onViewportStages(waitForDraw);
-    const onEscape = (event: KeyboardEvent): void => {
-      if (event.key !== 'Escape' || !surfaceAcceptsKey(event)) return;
-      // Decided once the event has finished dispatching: a game that claims Escape (a
-      // game's pause, registered after this listener) prevents its default, and the Escape that
-      // frees a game's mouse look is the person taking their mouse back. Neither stops Play.
-      if (globalThis.document.pointerLockElement || performance.now() - lastPointerUnlockAt < 500) return;
-      setTimeout(() => {
-        if (event.defaultPrevented) return;
-        const extension = modelPlayExtension();
-        if (extension?.escape) extension.escape(modelId);
-        else extension?.setPlaying(modelId, false);
-      }, 0);
-    };
-    let lastPointerUnlockAt = -Infinity;
-    const onLockChange = (): void => { if (!globalThis.document.pointerLockElement) lastPointerUnlockAt = performance.now(); };
-    globalThis.document.addEventListener('pointerlockchange', onLockChange);
-    window.addEventListener('keydown', onEscape, true);
-    return () => {
-      globalThis.document.removeEventListener('pointerlockchange', onLockChange);
-      stopped = true;
-      stopStages();
-      stopPrepareFrames?.();
-      window.removeEventListener('keydown', onEscape, true);
-      stopScript?.();
-      if (hiddenCopy !== null) { view.root.visible = hiddenCopy; hiddenCopy = null; }
-      layers.remove();
-    };
-  }, [playing, documentId, blend, view]);
+  }, [main, documentId, view]);
   /**
    * A SHADING PICK IS KEPT WHERE BLENDER KEEPS IT: in the file's own 3D View, the one it reopens
    * on (`blenderViewShading`), so the next save carries it and a reopen starts from it. Noted on
@@ -1114,7 +791,7 @@ function BlenderViewportArea({
       const needsScene = lighting.source === 'scene' || (preview && lighting.preview.sceneLights);
       // Shading changes lighting, not which objects an editing viewport shows.
       // Only the detached game uses render visibility, as a clean capture does.
-      view.holdRendered(needsScene && stage ? drawCamera : null, sceneLighting, playing ? 'render' : 'viewport');
+      view.holdRendered(needsScene && stage ? drawCamera : null, sceneLighting, 'viewport');
       // BLENDER'S SOLID IS BLENDER'S OWN FUNCTION: while the stage lights by Blender's studio, the
       // presenter draws every surface by it (`blender-workbench-material.ts`).
       view.setWorkbench(lighting.source === 'studio' && lighting.studioPreset === DOCUMENT_STUDIO_PRESET.id);
@@ -1129,7 +806,7 @@ function BlenderViewportArea({
       view.holdRendered(null);
       view.setWorkbench(false);
     };
-  }, [documentId, view, playing]);
+  }, [documentId, view]);
   /**
    * SHIFT+RIGHT-CLICK PLACES THE 3D CURSOR, Blender's own chord for
    * `view3d.cursor3d` (`blender_default.py`, `params.cursor_set_event`). The
@@ -1142,7 +819,7 @@ function BlenderViewportArea({
    */
   const cursorPress = useRef<{ id: number; x: number; y: number } | null>(null);
   const cursorChord = (event: ReactPointerEvent | ReactMouseEvent): boolean =>
-    !playing && event.button === 2 && event.shiftKey && event.target instanceof HTMLCanvasElement;
+    event.button === 2 && event.shiftKey && event.target instanceof HTMLCanvasElement;
   const onPointerDownCapture = (event: ReactPointerEvent): void => {
     if (!cursorChord(event)) {
       cursorPress.current = null;
@@ -1190,9 +867,7 @@ function BlenderViewportArea({
   const Surface = surfaces.Object3DAuthoring;
   return (
     <div
-      ref={surfaceRef}
-      data-play-ready={playing ? playReady : undefined}
-      style={playing ? { position: 'absolute', inset: 0 } : { display: 'contents' }}
+      style={{ display: 'contents' }}
       onPointerDownCapture={onPointerDownCapture}
       onPointerUpCapture={onPointerUpCapture}
       onPointerCancelCapture={dropCursorPress}
@@ -1201,7 +876,6 @@ function BlenderViewportArea({
     >
     <Surface
       active={active ?? true}
-      fillContainer={playing}
       documentId={documentId}
       sourcePath={blend ?? 'blender:runtime'}
       displayName={document?.label ?? 'Model'}
@@ -1212,8 +886,8 @@ function BlenderViewportArea({
       cameraView={reads.cameraView}
       build={build}
       audit={false}
-      // The authoring hierarchy is Blender’s View Layer Outliner; the default adapter supplies presentation access. A playing copy has no authoring adapter and uses the read-only stage.
-      {...(playing ? {} : { authoring })}
+      // The authoring hierarchy is Blender’s View Layer Outliner; the default adapter supplies presentation access.
+      authoring={authoring}
       cameraDirection={[0.8187, 0.4458, 0.3617]}
       // FOR A FILE THAT SAVED NO 3D VIEW: Blender's factory Modeling direction, standing back
       // three fits.