@volter/editor-threejs 0.5.210 → 0.5.212

package/src/kit/editor-shell-store.ts

@@ -1,25 +1,19 @@
 /**
- * EditorShellStore — the shell store's THREE half: the adopted scene and its object map, the
+ * EditorShellStore — the shell store's THREE half: the scene and its object map, the
  * renderer and camera, viewport tools (transform, snapping, pivot, gizmo), helper and shading
- * state, LOD pins, capture and the periodic editor-state save. It extends `ShellStore`
- * (`shell-store.ts`), the media-neutral half the kit's other modules type against, and leaves
- * the kit for `@volter/editor-threejs` with the viewport (ARCHITECTURE.md §The plan, unit 3).
+ * state, LOD pins, capture and the periodic editor-state save. It wraps the media-neutral
+ * SDK `ShellStore` that the kit's other modules type against.
  * It knows `THREE.Object3D`s and ids, never a document model: an adapter's document is that
- * adapter's private business (`authoring-inversion-guard.test.ts` is the tripwire).
+ * adapter's private business.
  */
 
-import type { ViewportTab } from '@volter/sdk';
 import { viewportCaptureOutputPass } from '@volter/editor-threejs/capture/output-pass';
-import { isEditorOwnedObject } from '@volter/editor-threejs/viewport/editor-layers';
-import type { WorldRendererConfig } from '@volter/editor-threejs/adapter/renderer-config';
 import { getUserData, setUserData } from '@volter/editor-threejs/ecs/user-data';
 import type { ViewportShadingMode } from '@volter/editor-threejs/render/viewport-shading';
 import * as THREE from 'three';
-import type { BatchedRenderer } from 'three.quarks';
 import { findEntityLod } from './entity-lod';
-import { entityIdOf } from './entity-object';
-import { ShellStore } from '@volter/sdk/kit/shell-store';
-export type { NotifyScope, PlayEditRegime } from '@volter/sdk/kit/shell-store';
+import { ShellStore } from '@volter/sdk/shell-store';
+export type { NotifyScope } from '@volter/sdk/shell-store';
 import { withSceneFogNeutralized } from './scene-view-fog';
 
 /** The store's persistence collaborator — installed by the shell, never
@@ -30,74 +24,17 @@ export interface EditorStatePersistence {
 }
 
 /**
- * WHICH TOOL THE SHELF HAS ARMED — four that draw a transform gizmo, and one
- * that draws none.
- *
- * `'select'` is Blender's Select Box, and it is a TOOL rather than an absence:
- * its shelf opens on it (`space_toolsystem_toolbar.py`,
- * `_defs_view3d_generic.select_box` first in the Object Mode `_tools_default`;
- * photographed at the engine's pin in `gizmo-select-box.png`), so a selected
- * object shows its outline and nothing else until Move / Rotate / Scale /
- * Transform is armed. Before it there was no "no gizmo" state at all — this
- * store's default was `'combined'` and every selection drew three tools'
- * handles at once — which is why it is a member here rather than a flag beside
- * it. `editor-viewport.ts` detaches on it, through the same branch a
- * non-writable selection already took.
- *
- * Which member a STAGE is born with is its presentation's (`interaction.bootTool`,
- * `kit/viewport-presentation`); arming one is always a click in the shelf.
+ * Re-export the shell’s transform-tool choices. Select shows selection outlines without a transform
+ * gizmo; Move, Rotate, Scale and Transform arm their corresponding handles. Stage presentation
+ * supplies interaction.bootTool.
  */
-export type { GizmoAnchor, PivotMode, TransformMode, TransformSpace } from '@volter/sdk/kit/shell-store';
+export type { GizmoAnchor, PivotMode, TransformMode, TransformSpace } from '@volter/sdk/shell-store';
 
 export type ShadingMode = ViewportShadingMode;
 
-/**
- * What a store notification says CHANGED.
- *
- * `'selection'` is the narrow one and it is claimed by exactly five writers
- * (`select`, `selectMultiple`, `addToSelection`, `toggleSelection`,
- * `applySelectionBeforePresentation`), each of which touches
- * `_viewportSelections` and nothing else. `'content'` is the default and means
- * "assume anything may have changed", so a mutation that forgets to classify
- * itself is safe by construction — the failure mode of a wrong claim is a
- * stale panel, so the burden of proof sits on the narrow value.
- * See {@link EditorShellStore.contentVersion}.
- */
-
-/** Exact structural delta supplied by a live Three projection mutation. */
-export interface IngestObjectMapStructureDelta {
-  readonly changedParentIds: ReadonlySet<string>;
-  readonly rootsChanged: boolean;
-  /** Exact projected membership changes; omission keeps legacy callers conservative. */
-  readonly addedIds?: ReadonlySet<string>;
-  readonly removedIds?: ReadonlySet<string>;
-}
-
-/** All projected parent rows changed after a previously observed gizmo epoch. */
-export interface IngestObjectMapChanges {
-  readonly epoch: number;
-  readonly changedParentIds: ReadonlySet<string>;
-}
-
-/** Exact object-map identities whose membership changed after an observed gizmo epoch. */
-export interface IngestObjectMapMembershipChanges {
-  readonly epoch: number;
-  readonly changedIds: ReadonlySet<string>;
-}
-
-/** Enough exact structural epochs to span deferred React consumers; older readers rebuild. */
-const OBJECT_MAP_MEMBERSHIP_HISTORY = 256;
-
+export type { HelperVisibility } from '@volter/sdk/shell-store';
 
-
-/** The two viewport tabs, Edit · Play. Defined ONCE, in the SDK's shared
- *  vocabulary (`@volter/sdk`), because the control API speaks it too;
- *  re-exported here so editor modules keep one import site. */
-export type { ViewportTab };
-
-export type { HelperVisibility } from '@volter/sdk/kit/shell-store';
-
-export type { ViewportAction } from '@volter/sdk/kit/shell-store';
+export type { ViewportAction } from '@volter/sdk/shell-store';
 
 export class EditorShellStore {
   /** Made by `threeStateOf`, once per shell store. */
@@ -105,55 +42,19 @@ export class EditorShellStore {
 
   // --- Scene graph references (set via bindScene) ---
   protected _scene: THREE.Scene | null = null;
-  /** Adoption stack (see enterPlayScene): each frame is the scene state that
-   *  was active when an adoption replaced it, restored in LIFO order by
-   *  exitPlayScene. A STACK (not a single slot) because adoptions nest for
-   *  R3F projects: the design session adopts its fiber scene at design time,
-   *  and play adopts the live game scene OVER it while the play-entry
-   *  transition still needs the design scene alive — the design session then
-   *  unwinds its own frame from the middle via releaseAdoptedScene. */
-  protected _adoptionStack: Array<{
-    /** `null` when the adoption replaced no scene: a session with no Scene stage plays too. */
-    scene: THREE.Scene | null;
-    objectMap: Map<string, THREE.Object3D>;
-    /** Opaque payload from {@link _captureAdoptionExtras} — a document half's
-     *  own per-adoption snapshot. The shell never inspects it. */
-    extras: unknown;
-    selection: Set<string>;
-    /** The image config that was active BEFORE this adoption — same LIFO
-     *  discipline as `scene`, so a frame spliced out of the middle simply
-     *  stops being a restore point. See {@link _applyAdoptedImageConfig}. */
-    imageConfig: WorldRendererConfig | undefined;
-  }> = [];
   protected _objectMap = new Map<string, THREE.Object3D>();
   protected _renderer: THREE.WebGLRenderer | null = null;
   protected _camera: THREE.Camera | null = null;
-  protected _batchedRenderer: BatchedRenderer | null = null;
   protected _lastThumbnailTime = 0;
   protected _lastEditorStateSaveTime = 0;
   protected _orbitTarget: THREE.Vector3 | null = null;
 
   // --- UI state (not stored in scene graph) ---
   /**
-   * Bumped whenever gizmos must be re-applied without a structural signature
-   * change (W3a B1): a single-entity rebuild (`_rebuildEntity` →
-   * `updateEntityPreview`) disposes the old Object3D WITH all its helper
-   * children, but leaves the objectMap identity/size and every toggle
-   * untouched — the viewport's `gizmoSig` gate would otherwise skip both
-   * `applyEntityGizmos` and the per-type visibility pass until an unrelated
-   * event.
+   * Advance when object helpers must be reapplied without changing object-map identity, size or
+   * visibility toggles, including single-object rebuilds.
    */
   protected _gizmoEpoch = 0;
-  /** Last structural epoch at which each projected parent's direct children changed. */
-  protected _objectMapParentChangedAt = new Map<string, number>();
-  /** A root change (or an unclassified legacy call) requires a full hierarchy read. */
-  protected _objectMapFullChangeEpoch = 0;
-  /** Last exact add/remove epoch for each projected id, independently consumed by the viewport. */
-  protected _objectMapMembershipChangedAt = new Map<string, number>();
-  /** Missing membership detail requires the viewport to reconcile its complete helper indexes. */
-  protected _objectMapMembershipFullChangeEpoch = 0;
-  /** Epochs older than this were compacted from the bounded membership history. */
-  protected _objectMapMembershipHistoryFloor = 0;
   protected _showStats = false;
   protected _shadingMode: ShadingMode = 'solid';
   protected _statePersistence: EditorStatePersistence | null = null;
@@ -162,22 +63,16 @@ export class EditorShellStore {
    * Bumped only when post-processing-relevant state changes (environment / scene
    * structure / play-stop scene swap). The viewport rebuilds its EffectComposer
    * only when this changes — NOT on every notify — so a transform drag/scrub (which
-   * notifies per frame but never touches these) no longer recompiles shaders 60×/s.
+   * notifies per frame but never touches these) never recompiles shaders 60×/s.
    */
   protected _composerVersion = 0;
   bindScene(
     scene: THREE.Scene,
     renderer?: THREE.WebGLRenderer,
-    batchedRenderer?: BatchedRenderer | null,
     camera?: THREE.Camera,
   ): void {
-    // A stage mounting while a scene is adopted binds the edit scene UNDER the adoption, where
-    // Stop restores it; the adopted scene stays the active one.
-    const base = this._adoptionStack[0];
-    if (base) base.scene = scene;
-    else this._scene = scene;
+    this._scene = scene;
     this._renderer = renderer ?? null;
-    this._batchedRenderer = batchedRenderer ?? null;
     if (camera) this._camera = camera;
   }
 
@@ -187,18 +82,14 @@ export class EditorShellStore {
   }
 
   /** Update only the editor presentation camera (for perspective/orthographic
-   * switching) without rebinding or replacing an adopted game scene. */
+   * switching) without rebinding the scene. */
   setViewportCamera(camera: THREE.Camera): void {
     this._camera = camera;
   }
 
-
   /**
-   * Where view/tool state and the autosave thumbnail go. The shell installs
-   * its transport here (`EditorContext` binds the server SDK); the store
-   * itself names no endpoint, so a document-local store (Asset Lab) or a
-   * fixture store simply never persists. Same collaborator shape as
-   * `attachHistory`, same one-owner rule.
+   * Attach the shell’s view-state and thumbnail persistence transport. A document-local store may
+   * omit it. One collaborator owns persistence for the store.
    */
   attachStatePersistence(persistence: EditorStatePersistence): void {
     if (this._statePersistence === persistence) return;
@@ -217,12 +108,12 @@ export class EditorShellStore {
 
   /**
    * Frame the whole active scene — the first thing a reader should see when a
-   * world they did not author is adopted (an ingest mount). The viewport keeps
+   * world they did not author opens. The viewport keeps
    * asking until the world HAS content, because a game builds itself
    * asynchronously; any camera input from the reader cancels it (see
    * `the world root's stage`). A no-op for a scene the reader already has a camera on.
    *
-   * `gameCamera` is a LIVE LOOKUP, not a camera: an adopted game's own camera
+   * `gameCamera` is a LIVE LOOKUP, not a camera: a game's own camera
    * may not exist yet on the frame it is captured on, so the viewport asks
    * again while its window is open. When one turns up, its view is adopted
    * instead of any measurement — see `scene-framing.ts`.
@@ -232,10 +123,9 @@ export class EditorShellStore {
     this.shell.focusOnScene();
   }
 
-
   /**
    * Live viewport camera pose, read straight from the bound Three.js camera +
-   * orbit target (`bindScene`/`setOrbitTarget` — wired by `world-root-stage.ts`).
+   * orbit target (`bindScene`/`setOrbitTarget`).
    * Null only when nothing has bound a camera yet (e.g. a headless store in a
    * unit test that never mounted `the world root's stage`).
    */
@@ -271,40 +161,6 @@ export class EditorShellStore {
     return this._gizmoEpoch;
   }
 
-  /**
-   * Return the exact projected parents changed after `epoch`, or `null` when a
-   * root/unclassified change crossed that boundary and callers must rebuild.
-   * Parent timestamps make this safe across React batching: no consumer drains
-   * a shared queue, and several projectile commits collapse into one union.
-   */
-  ingestObjectMapChangesSince(epoch: number): IngestObjectMapChanges | null {
-    if (epoch < 0 || epoch > this._gizmoEpoch || epoch < this._objectMapFullChangeEpoch) {
-      return null;
-    }
-    const changedParentIds = new Set<string>();
-    for (const [id, changedAt] of this._objectMapParentChangedAt) {
-      if (changedAt > epoch) changedParentIds.add(id);
-    }
-    return { epoch: this._gizmoEpoch, changedParentIds };
-  }
-
-  /** Return exact added/removed identities since `epoch`, or `null` across an unclassified edit. */
-  ingestObjectMapMembershipChangesSince(epoch: number): IngestObjectMapMembershipChanges | null {
-    if (
-      epoch < 0 ||
-      epoch > this._gizmoEpoch ||
-      epoch < this._objectMapMembershipFullChangeEpoch ||
-      epoch < this._objectMapMembershipHistoryFloor
-    ) {
-      return null;
-    }
-    const changedIds = new Set<string>();
-    for (const [id, changedAt] of this._objectMapMembershipChangedAt) {
-      if (changedAt > epoch) changedIds.add(id);
-    }
-    return { epoch: this._gizmoEpoch, changedIds };
-  }
-
   isSkeletonVisible(id: string): boolean {
     return Boolean(getUserData(this._objectMap.get(id), 'skeletonVisible'));
   }
@@ -326,10 +182,6 @@ export class EditorShellStore {
   get shadingMode(): ShadingMode {
     return this._shadingMode;
   }
-  /** Notify subscribers after an ingest adapter mutated a live foreign object
-   *  (material/visibility). Runtime-only — no dirty/autosave, because the edit
-   *  lives on the live `Object3D` and nothing here owns a document. */
-
   /** Notify after a live adapter changed `objectMap` membership.
    *
    * Unlike an ordinary reflected-property edit, a membership change requires
@@ -337,191 +189,9 @@ export class EditorShellStore {
    * place, and a remove+add burst can keep its size unchanged, so neither map
    * identity nor size is a complete signal. `_gizmoEpoch` is the viewport's
    * existing explicit rebuild input; bump it only at this structural seam. */
-  notifyIngestObjectMapEdit(delta?: IngestObjectMapStructureDelta): void {
+  notifyIngestObjectMapEdit(): void {
     this._gizmoEpoch++;
-    if (delta === undefined || delta.rootsChanged) {
-      this._objectMapFullChangeEpoch = this._gizmoEpoch;
-      this._objectMapParentChangedAt.clear();
-    } else {
-      for (const id of delta.changedParentIds) {
-        this._objectMapParentChangedAt.set(id, this._gizmoEpoch);
-      }
-    }
-    if (delta?.addedIds === undefined || delta.removedIds === undefined) {
-      this._objectMapMembershipFullChangeEpoch = this._gizmoEpoch;
-      this._objectMapMembershipChangedAt.clear();
-    } else {
-      for (const id of delta.addedIds) this._objectMapMembershipChangedAt.set(id, this._gizmoEpoch);
-      for (const id of delta.removedIds) {
-        this._objectMapMembershipChangedAt.set(id, this._gizmoEpoch);
-      }
-      const historyFloor = Math.max(0, this._gizmoEpoch - OBJECT_MAP_MEMBERSHIP_HISTORY);
-      if (historyFloor > this._objectMapMembershipHistoryFloor) {
-        this._objectMapMembershipHistoryFloor = historyFloor;
-        for (const [id, changedAt] of this._objectMapMembershipChangedAt) {
-          if (changedAt <= historyFloor) this._objectMapMembershipChangedAt.delete(id);
-        }
-      }
-    }
-    const affectsShell =
-      delta === undefined ||
-      delta.rootsChanged ||
-      [...(delta.addedIds ?? []), ...(delta.removedIds ?? [])].some((id) =>
-        this.shell.selectedEntityIds.has(id),
-      );
-    this.shell.notifyChange('content', affectsShell ? 'shell' : 'object-map', false);
-  }
-
-  // --- Play mode scene swap ---
-
-  /** Callback to sync transform edits to game ECS. Set by play-mode, cleared on exit.
-   *  Receives the NODE ID as well as the live object: the `PhysicsAdapter` seam
-   *  it ultimately feeds is id-keyed since P-4, and the id is already in hand
-   *  at the one call site — so nothing downstream has to map an object back. */
-  protected _ecsSyncTransform: ((id: string, obj: THREE.Object3D) => void) | null = null;
-
-  /** Set a callback that syncs editor transform changes to the game's ECS state. */
-  setEcsSyncTransform(fn: ((id: string, obj: THREE.Object3D) => void) | null): void {
-    this._ecsSyncTransform = fn;
-  }
-
-  /**
-   * Swap the store's active scene to the game scene. Editor scene is preserved.
-   *
-   * Also snapshots whatever the active document half hands back from
-   * {@link _captureAdoptionExtras}. A half that keeps mutating its LIVE
-   * metadata during play (so its inspector fields keep working) must have
-   * those edits discarded when play stops — otherwise a play-time edit
-   * silently persists with `isDirty` false. `exitPlayScene` restores the
-   * snapshot.
-   */
-  enterPlayScene(
-    gameScene: THREE.Scene,
-    imageConfig?: WorldRendererConfig | undefined,
-    projectedObjects?: ReadonlyMap<string, THREE.Object3D>,
-  ): void {
-    this._adoptionStack.push({
-      scene: this._scene,
-      objectMap: this._objectMap,
-      extras: this._captureAdoptionExtras(),
-      selection: new Set(this.shell.selectedEntityIds),
-      imageConfig: this._adoptedImageConfig,
-    });
-    this._scene = gameScene;
-    this._applyAdoptedImageConfig(imageConfig);
-
-    // The store INDEXES an adopted scene; it no longer models it. A foreign
-    // adapter supplies its pure projection explicitly, so editor identity is
-    // never written into the game's Object3Ds. Source-backed/adopted worlds
-    // already carry native authoring stamps and retain the fallback walk.
-    const gameMap = projectedObjects
-      ? new Map(projectedObjects)
-      : (() => {
-          const stamped = new Map<string, THREE.Object3D>();
-          const visit = (obj: THREE.Object3D): void => {
-            if (isEditorOwnedObject(obj)) return;
-            const eid = entityIdOf(obj);
-            if (eid !== undefined) stamped.set(eid, obj);
-            for (const child of obj.children) visit(child);
-          };
-          for (const child of gameScene.children) visit(child);
-          return stamped;
-        })();
-    this._objectMap = gameMap;
-
-    this.shell.applySelectionBeforePresentation(
-      [...this.shell.selectedEntityIds].filter((id) => gameMap.has(id)),
-    );
-    // A viewport LOD pin must not follow the entity id into the adopted game
-    // scene — there `WebGLRenderer.projectObject` owns level visibility (it
-    // calls `lod.update(camera)` for every visible LOD whose `autoUpdate` is
-    // still true, which is what a pin turns OFF), and per-frame enforcement
-    // would fight it.
-    this._lodForcedLevels.clear();
-    this._composerVersion++; // scene swapped → composer must rebuild against the game scene
-    this.shell.notifyChange();
-  }
-
-  /** Whether the active scene is one another document adopted (`enterPlayScene`). */
-  get hasAdoptedScene(): boolean {
-    return this._adoptionStack.length > 0;
-  }
-
-  /** Restore the previously-adopted scene (LIFO — see enterPlayScene). */
-  exitPlayScene(): void {
-    const frame = this._adoptionStack.pop();
-    if (!frame) return;
-    this._scene = frame.scene;
-    this._objectMap = frame.objectMap;
-    this._applyAdoptedImageConfig(frame.imageConfig);
-    // Discard any play-time env/name/ui edits — restore the pre-play snapshot.
-    this._restoreAdoptionExtras(frame.extras);
-    this.shell.applySelectionBeforePresentation([...frame.selection]);
-    this._composerVersion++; // scene swapped back → composer must rebuild against the editor scene
-    this.shell.notifyChange();
-  }
-
-  /**
-   * Release ONE adopter's adoption, wherever it sits in the stack. When
-   * `scene` is the ACTIVE scene this is exactly `exitPlayScene`; when a later
-   * adoption (play over the R3F design session) has already replaced it, the
-   * frame that would restore `scene` is unlinked from the middle of the stack
-   * instead — nothing visible changes now, and the LATER adopter's exit
-   * restores the state underneath as if this adoption never happened. No-op
-   * when `scene` was never adopted (or was already released).
-   */
-  releaseAdoptedScene(scene: THREE.Scene): void {
-    if (this._scene === scene) {
-      this.exitPlayScene();
-      return;
-    }
-    const index = this._adoptionStack.findIndex((frame) => frame.scene === scene);
-    if (index === -1) return;
-    this._adoptionStack.splice(index, 1);
-  }
-
-  /**
-   * THE ADOPTED CONTENT'S OWN COLOUR PIPELINE — what it is, not where it is
-   * applied.
-   *
-   * A mounted world may report the pipeline it was authored for
-   * (`MountedThreeRoot.rendererConfig`), and `applyWorldRendererConfig` puts it
-   * on the renderer its own host handed it. In the editor those are two
-   * DIFFERENT renderers: the design session mounts against a non-rasterizing
-   * one (`authoring/design-time-renderer.ts`) and the viewport draws the
-   * mounted scene with its own. So the declaration landed on a surface with no
-   * pixels while the surface with pixels kept the engine's defaults — measured
-   * on the translated Godot platformer, whose roughness-0 metal reads as chrome
-   * under the editor's ACES while the game renders it under its own curve.
-   *
-   * The store only REMEMBERS the declaration and bumps `_composerVersion` when
-   * it changes; `the world root's stage.rebuildComposer` is the one place that derives
-   * the viewport renderer's whole configuration, and it applies this last. That
-   * split is why there is no restore bookkeeping here: a rebuild always resets
-   * the renderer to the engine defaults first, so "unwind" is just the next
-   * rebuild seeing a different (or absent) config.
-   */
-  protected _adoptedImageConfig: WorldRendererConfig | undefined;
-
-  /** What the active adopted content declared about the renderer that draws it,
-   *  or `undefined` when it declared nothing (leave the editor's own alone). */
-  get adoptedImageConfig(): WorldRendererConfig | undefined {
-    return this._adoptedImageConfig;
-  }
-
-  protected _applyAdoptedImageConfig(next: WorldRendererConfig | undefined): void {
-    if (next === this._adoptedImageConfig) return;
-    this._adoptedImageConfig = next;
-    this._composerVersion++;
-  }
-
-  /** True while an ADOPTED live game scene is the active scene — every
-   *  `enterPlayScene` caller: play adoption, ingest mounts, and the R3F
-   *  design session. Adopted scenes own their lighting/rendering completely;
-   *  the viewport uses this to keep editor-fabricated presentation (the
-   *  helper light rig) out of them. */
-  get isAdoptedSceneActive(): boolean {
-    return this._adoptionStack.length > 0;
+    this.shell.notifyChange('content', 'shell', false);
   }
 
   // --- Vertex snap ---
@@ -543,25 +213,10 @@ export class EditorShellStore {
    * represented honestly. Both use the same offscreen render-target technique,
    * so neither needs `preserveDrawingBuffer` on the live WebGL canvas.
    *
-   * THE COLOUR PIPELINE IS THE WHOLE REASON THERE ARE TWO TARGETS. Three
-   * applies `renderer.toneMapping` and `renderer.outputColorSpace` ONLY when
-   * the destination is the canvas: rendering into an ordinary
-   * `WebGLRenderTarget` compiles every material with `NoToneMapping` and a
-   * LINEAR output transfer (`WebGLPrograms.getParameters` and
-   * `WebGLRenderer.setProgram` both gate on `currentRenderTarget === null`).
-   * So the single-target version of this function answered "what does the
-   * viewport look like" with a raw linear frame — measurably darker and
-   * flatter than the pixels on screen, and immune to every tone-mapping
-   * change (verified live: flipping the viewport to `NoToneMapping` moved the
-   * captured PNG by 0 bytes). That made this door — the only look at the EDIT
-   * viewport, and the source of every project thumbnail — unusable as
-   * evidence about the image.
-   *
-   * The fix is three's own: render the scene into a HALF-FLOAT linear buffer
-   * (so highlights survive to be tone-mapped) and resolve it through
-   * `OutputPass`, which reads `toneMapping`/`toneMappingExposure`/
-   * `outputColorSpace` off the renderer and applies exactly what the on-screen
-   * frame gets.
+   * Render into a half-float linear target to preserve highlights, then resolve through
+   * `OutputPass` using the renderer’s toneMapping, toneMappingExposure and outputColorSpace.
+   * Three applies those settings directly only when the destination is the canvas, so the
+   * output pass gives captures the same colour transform as the on-screen viewport.
    */
   protected _renderViewportImage(
     size: number | { width: number; height: number },
@@ -711,8 +366,6 @@ export class EditorShellStore {
       shadingMode: this._shadingMode,
     };
 
-    Object.assign(state, this._editorStateExtras());
-
     if (this._camera) {
       const cam = this._camera as THREE.PerspectiveCamera;
       state['camera'] = {
@@ -727,12 +380,9 @@ export class EditorShellStore {
   // --- Mutations ---
 
   /**
-   * EDITOR-ONLY level-preview override (W2b): entity id → index into the
-   * live THREE.LOD's (ascending-by-distance) levels to pin in the viewport.
-   * Pure UI state — never written to the descriptor, so it can't leak into
-   * the saved scene or the undo history. Enforced per frame by
-   * `EditorViewport.update` (the glTF loads async and entity rebuilds replace
-   * the THREE.LOD instance, so a one-shot apply would silently un-pin).
+   * Editor-only pinned LOD-level index per entity, ordered by distance. Keep this view state out of
+   * saved descriptors and undo history. EditorViewport reapplies it each frame as asynchronous
+   * loads and entity rebuilds replace LOD instances.
    */
   protected _lodForcedLevels = new Map<string, number>();
 
@@ -772,29 +422,7 @@ export class EditorShellStore {
     this.shell.notifyChange();
   }
 
-  // --- Subclass hooks -------------------------------------------------------
-  // The ONLY way the shell reaches into a document half. Each is a no-op here,
-  // so the shell runs standalone; a subclass that owns a document overrides the
-  // ones it needs (`store-notify-scope.test.ts` exercises the deferral hooks).
-
 
-
-  /** Captured into the adoption frame by `enterPlayScene`, handed back by
-   *  `exitPlayScene`. A document half snapshots its metadata here so
-   *  play-time edits to it are discarded on exit. */
-  protected _captureAdoptionExtras(): unknown {
-    return undefined;
-  }
-
-  /** Restore counterpart of {@link _captureAdoptionExtras}. */
-  protected _restoreAdoptionExtras(_extras: unknown): void {}
-
-
-  /** Extra keys folded into the periodic editor-state save. A document half
-   *  contributes whatever it needs restored on the next boot. */
-  protected _editorStateExtras(): Record<string, unknown> {
-    return {};
-  }
 }
 
 const threeStates = new WeakMap<ShellStore, EditorShellStore>();