@volter/blender-engine 0.1.147 → 0.1.149

package/browser/three/blender-runtime-view.ts

@@ -26,11 +26,11 @@ import {
   WorldBackground,
   worldSchema,
 } from './blender-runtime-lighting';
-import { fitModelDirectionalShadow, visibleShadowReceivers } from './blender-runtime-shadows';
-import {BlenderWorldVisibility,WORLD_VISIBILITY,bindWorldVisibility} from './blender-world-visibility';
+import { fitModelDirectionalShadow, farthestVisibleReceiver, fitPerspectiveShadowBias, VisibleReceivers, visibleShadowReceivers } from './blender-runtime-shadows';
 import { volumeMesh, volumeSchema } from './blender-runtime-volume';
 import { applyPhysicalMaterial, applyWorldExtinction, physicalMaterialSchema } from './blender-physical-material';
-import { prepareGraphGeometry, setMaterialGraph } from './blender-graph-material';
+import { photographGraphs, prepareGraphGeometry, setMaterialGraph } from './blender-graph-material';
+import { type BlenderPhotographSampling, eeveeSampling, workbenchSampling } from './blender-viewport-sampling';
 import {BlenderObjectInfoMaterials} from './blender-object-info-materials';
 import { type CompiledGraph, compileMaterialGraph, graphSeeThrough, materialGraphSchema } from './blender-node-graph';
 import {worldMedium, WorldVolumePass} from './blender-world-volume';
@@ -46,11 +46,32 @@ import {
   panCameraView,
 } from './blender-runtime-camera-view';
 import { DEFAULT_VIEWPORT_DISPLAY, workbenchMaterial } from './blender-workbench-material';
+import { WorkbenchOutline } from './blender-workbench-outline';
+import type { BlenderDisplaySettings } from './blender-display-transform';
 import { BlenderRuntimeInstances } from './blender-runtime-instances';
 import { BlenderTransparentInstances } from './blender-transparent-instances';
 import { BlenderMaterialRanges } from './blender-material-ranges';
 import { BlenderMotionGeometry } from './blender-motion-geometry';
 
+/** What the stage tells {@link BlenderRuntimeView.prepareDraw} about the draw it is about to make. */
+export interface BlenderDrawOptions {
+  readonly interactive: boolean;
+  readonly height: number;
+  readonly multiDraw?: boolean;
+  readonly renderer?: THREE.WebGLRenderer;
+  /** The stage's draw mode (`solid`, `rendered`, ...): Solid's object outline is Solid's alone. */
+  readonly drawMode?: string;
+  /** Target pixels per output pixel of this draw (Blender's `ui_scale`): the device pixel ratio
+   *  on screen, the supersampling factor in a photograph. */
+  readonly pixelScale?: number;
+  /** This draw is a photograph: it gets one chance, so nothing it shows may settle later. */
+  readonly photograph?: boolean;
+}
+
+/** The Preferences' Viewport Anti-Aliasing (`U.viewport_aa`) at its factory value: the tab holds
+ *  no Blender preferences. */
+const PREFERENCES_VIEWPORT_AA = 8;
+
 /** A saved `View3DShading.type` as the stage's draw mode: Material Preview is `preview`. */
 const SAVED_SHADING = {
   WIREFRAME: 'wireframe',
@@ -148,6 +169,32 @@ const drawnSkinSchema = z
     weight: z.instanceof(Float32Array),
   })
   .strict();
+/**
+ * ONE MESH THE PRESENTER CANNOT DRAW IS SKIPPED BY NAME; the rest of the frame presents.
+ *
+ * A throw anywhere in a frame would refuse the WHOLE frame: the Model document would keep showing
+ * the state before the call, every later present would fail the same way, and one mesh (a custom
+ * vertex attribute named as its render UV, say) would hide thousands of other objects.
+ *
+ * The skipped mesh is held as an empty geometry AT ITS SIGNATURE, so the session's record (it
+ * sent the mesh at that revision) and this presenter agree, and the next frame's reference to it
+ * is not a resync. Its objects stand in the graph with nothing to draw. It is drawn again when its
+ * revision changes, which is the edit that may have fixed it.
+ */
+export const REFUSED_GEOMETRY = 'blenderRefused';
+function drawnOrRefused(draw: () => THREE.BufferGeometry): THREE.BufferGeometry {
+  try {
+    return draw();
+  } catch (error) {
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(0), 3));
+    geometry.userData[REFUSED_GEOMETRY] = error instanceof Error ? error.message : String(error);
+    return geometry;
+  }
+}
+/** Each (mesh, revision, reason) is named once per tab, not once per present or per follower. */
+const NAMED_REFUSALS = new Set<string>();
+
 /** An exported mesh's geometry with its skin laid over its drawn vertices (`skinGeometry`). */
 function withFrameSkin(geometry: THREE.BufferGeometry, skin: FrameSkin | undefined): THREE.BufferGeometry {
   if (skin) skinGeometry(geometry, skin);
@@ -218,10 +265,8 @@ const unchangedMeshSchema = z
 /**
  * BLENDER'S OWN ARRAYS, as the columns the draw reads.
  *
- * This is the shape the export door emits -- `session.py`'s `foreach_get`
- * reader today, the C++ door later -- and `drawArraysFromColumns` is what
- * draws it, so the presenter takes the columns rather than a drawn mesh. The
- * buffers arrive transferred from the worker (`session-frame.mts` reads them
+ * The native export door emits these columns; `drawArraysFromColumns`
+ * builds their drawn geometry. Buffers arrive transferred from the worker (`session-frame.mts` reads them
  * out of the module filesystem), which is why every one is a typed array and
  * none is an array of numbers.
  */
@@ -283,50 +328,24 @@ const meshSchema = z.union([
   meshJsonSchema,
   unchangedMeshSchema,
 ]);
-/** Texture decodes still in flight. A RENDER MUST NOT START BEFORE THEY LAND:
- *  `createImageBitmap` is asynchronous, so a frame drawn in the same turn the
- *  material arrived would use an empty texture and look exactly like the
- *  untextured render this whole path exists to stop. (A RASTER needs no wait:
- *  a `DataTexture` holds its bytes the moment it is built.) */
-const pendingTextures = new Set<Promise<void>>();
-
-export async function texturesReady(): Promise<void> {
-  while (pendingTextures.size > 0) await Promise.all([...pendingTextures]);
-}
-
 /** An image file's own bytes (PNG or JPEG) as a three texture, decoded by the browser's own
  *  decoder. */
 function loadEncodedTexture(
   encoded: Uint8Array,
-  mime: 'image/png' | 'image/jpeg',
+  mime: 'image/png' | 'image/jpeg' | 'image/webp',
 ): { texture: THREE.Texture; ready: Promise<void> } {
   const blob = new Blob([encoded as BlobPart], { type: mime });
   const texture = new THREE.Texture();
+  // Decoded rows are bottom-first for Blender's v-up UVs. Keep flipY false
+  // for exporters as well; WebGL ignores that flag for ImageBitmap sources.
+  texture.flipY = false;
   let disposed = false;
   texture.addEventListener('dispose', () => {
     disposed = true;
-    texture.image?.close?.();
+    // r186's `Texture` types its image by a parameter, unknown here: an ImageBitmap once decoded.
+    (texture.image as ImageBitmap | null | undefined)?.close?.();
   });
-  // DECODED BOTTOM ROW FIRST, because that is the row Blender's v=0 is. A PNG
-  // stores its rows top-down -- this one is a FILE-backed image's own bytes,
-  // sent as they sit on disk -- while a UV's v=0 in Blender samples the
-  // image's BOTTOM row. A bitmap decoded in the PNG's own order therefore drew
-  // every textured surface upside down: measured on `20-rigged-courier`, the
-  // courier's painted face came back with the brows below the eyes and the
-  // mouth under the hat.
-  //
-  // The flip has to be asked for HERE and cannot be asked for on the texture:
-  // `Texture.flipY` (and `premultiplyAlpha`) are `UNPACK_FLIP_Y_WEBGL` state,
-  // which WebGL ignores for an ImageBitmap source -- three says so itself at
-  // `three/src/textures/Texture.js:274` (0.180.0), "this property has no
-  // effect when using `ImageBitmap`. You need to configure the flip on bitmap
-  // creation instead."
-  //
-  // Its alpha is asked for here too: the browser's `default` premultiplies (Chrome's does), and
-  // every reader of this texture takes the file's own texels, straight unless the image says it
-  // stores them premultiplied, which the reader then undoes. And its colour is the file's own: no
-  // embedded profile or gamma is applied, because Blender reads the texels as stored and applies
-  // the image's colour space setting itself, as the sampler does here.
+  // Decode image bitmaps bottom-row-first for Blender UVs, with explicit alpha and colour-conversion options. WebGL ignores Texture.flipY and premultiplyAlpha for ImageBitmap sources.
   const decoding = createImageBitmap(blob, {
     imageOrientation: 'flipY',
     premultiplyAlpha: 'none',
@@ -340,11 +359,7 @@ function loadEncodedTexture(
       texture.image = bitmap;
       texture.needsUpdate = true;
       presenterChanged();
-    })
-    .finally(() => {
-      pendingTextures.delete(decoding);
     });
-  pendingTextures.add(decoding);
   // Keep a rejection handled even if a document closes before its first
   // render. The owner's ready promise still reports that same failure.
   void decoding.catch(() => {});
@@ -425,8 +440,8 @@ function udimTextures(
  * one; a FILE's own PNG does not, because the decoder reads it off the bitmap
  * and asking Blender would have decoded the file just to answer
  * (`_image_values.frame_image`). Both carry the REVISION those bytes are. The
- * `*Base64` spellings are the same bytes on a channel with no transfer list
- * (`dispatch.mts`, `runtime_present`). */
+ * `*Base64` spellings are the same bytes on a channel with no transfer list.
+ */
 const rasterImageSchema = z
   .object({
     width: z.number().int().positive(),
@@ -447,16 +462,13 @@ const rasterImageSchema = z
     }).strict()).optional(),
   })
   .strict();
-/** An image as its FILE'S OWN BYTES, PNG or JPEG (`session.py::_encoded_image`): what the file
- *  already carries compressed, decoded by the browser into the texture, so neither side holds
- *  the picture as raw RGBA. MEASURED 2026-09-29 on the Stoneguard bridge: its 84 material images
- *  are 171 MB as their packed files and 1,343 MB as RGBA. */
+/** An encoded PNG or JPEG from session.py::_encoded_image, decoded by the browser without carrying raw RGBA through the frame. */
 const encodedImageSchema = z
   .object({
     revision: z.number().int().nonnegative(),
     encoded: z.instanceof(Uint8Array).optional(),
     encodedBase64: z.string().optional(),
-    mime: z.enum(['image/png', 'image/jpeg']),
+    mime: z.enum(['image/png', 'image/jpeg', 'image/webp']),
     colorspace: z.enum(['sRGB', 'data']).optional(),
   })
   .strict();
@@ -510,6 +522,12 @@ const materialSchema = z
       .object({ color: z.tuple([scalar, scalar, scalar, scalar]), roughness: scalar, metallic: scalar })
       .strict()
       .optional(),
+    /** `Material.use_backface_culling_shadow`: shadows from the faces turned to the light only. */
+    backface_culling_shadow: z.boolean().optional(),
+    /** `Material.use_backface_culling`: the back faces are not drawn (Rendered and Material Preview). */
+    backface_culling: z.boolean().optional(),
+    /** `Material.use_transparency_overlap`: a blended surface draws all its faces in one pass. */
+    transparency_overlap: z.boolean().optional(),
   })
   .strict();
 /** THE FRAME CONTRACT, and the reason it is exported: the C++ export door
@@ -595,8 +613,7 @@ export const frameSchema = z
     /** `scene.frame_current`. */
     frame: z.number().int().default(0),
     /**
-     * THE INSPECTION OVERLAYS (WORK.md §Blender in the tab is Blender,
-     * "Inspection parity", I4), keyed by armature OBJECT name. What Blender's
+     * Inspection overlays keyed by armature object name. What Blender's
      * own overlay engine READS, never what it draws: per bone a pose matrix, a
      * length, a parent and its flags, plus the armature's display type and
      * `show_in_front`. `blender-runtime-armature.ts` is the drawing.
@@ -639,9 +656,44 @@ export const frameSchema = z
         shading: z.enum(['WIREFRAME', 'SOLID', 'MATERIAL', 'RENDERED']).optional(),
         scene_world: z.boolean().optional(),
         scene_lights: z.boolean().optional(),
+        /** Solid's object outline (`View3DShading.show_object_outline`) and its colour. */
+        show_object_outline: z.boolean().optional(),
+        object_outline_color: z.tuple([z.number(), z.number(), z.number()]).optional(),
+        /** Solid's Specular Lighting (`View3DShading.show_specular_highlight`). */
+        show_specular_highlight: z.boolean().optional(),
+        /** What Solid and Wireframe draw behind the model (`View3DShading.background_type`), the
+         *  VIEWPORT colour (`background_color`, scene-linear) and the World's Viewport Display
+         *  colour (`World.color`, scene-linear) a WORLD background shows. */
+        background_type: z.enum(['THEME', 'WORLD', 'VIEWPORT']).optional(),
+        background_color: z.tuple([z.number(), z.number(), z.number()]).optional(),
+        world_color: z.tuple([z.number(), z.number(), z.number()]).nullable().optional(),
       })
       .nullable()
       .optional(),
+    /** How the viewport anti-aliases (`session.py`): the scene's engine, Workbench's
+     *  `display.viewport_aa`, EEVEE's viewport `taa_samples` and the film's `filter_size`. */
+    sampling: z
+      .object({
+        engine: z.string(),
+        viewport_aa: z.string(),
+        taa_samples: z.number().int().nonnegative(),
+        filter_size: z.number().finite().nonnegative(),
+      })
+      .strict()
+      .optional(),
+    /** The scene's colour management as this frame was presented with it (`session.py`):
+     *  `view_settings` (exposure in stops) and the display device. Rendered and Material Preview
+     *  are drawn through it ({@link BlenderRuntimeView.displaySettings}). */
+    display: z
+      .object({
+        view_transform: z.string(),
+        look: z.string(),
+        exposure: z.number().finite(),
+        gamma: z.number().finite(),
+        display_device: z.string(),
+      })
+      .strict()
+      .optional(),
     /** The viewport's subject line as Blender composes it (`draw_selected_name`), less the
      *  frame and its marker, with the scene's markers in list order. */
     subject: z
@@ -657,7 +709,8 @@ export const frameSchema = z
       .optional(),
   })
   .strict();
-type Frame = z.infer<typeof frameSchema>;
+/** One presented frame, as `applyFrame` takes it (`frameSchema`). */
+export type Frame = z.infer<typeof frameSchema>;
 
 /** `BKE_scene_find_marker_name`: the list walked from both ends at once, the front one asked
  *  first, so of several markers on one frame the answer is not simply the first. */
@@ -693,6 +746,32 @@ const LENGTH_UNITS: Readonly<Record<'METRIC' | 'IMPERIAL', readonly (readonly [n
     [1609.344, 'Miles'],
   ],
 };
+/** The factory theme's 3D Viewport background (`userdef_default_theme.c`, `high_gradient`,
+ *  single colour): 0x3d. */
+const THEME_VIEWPORT_BACK = 0x3d / 255;
+
+/**
+ * SOLID'S BACKGROUND as Blender's viewport shows it (`overlay_background.cc`), for a saved 3D
+ * View. The overlay draws it "alpha under" the render, and the OCIO display shader merges the two
+ * in display-linear: `pow(c, 2.2)`, the overlay added, `pow(c, 1/2.2)`
+ * (`gpu_shader_display_transform_frag.glsl`). So a colour the overlay holds is shown as
+ * `pow(c, 1/2.2)`:
+ * - THEME: the theme's colour taken to linear by `srgb_to_linearrgb` (`overlay_instance.cc`), so
+ *   the factory grey 0x3d (61) is shown as 63;
+ * - WORLD: the World's Viewport Display colour (`world->horr`), as it is;
+ * - VIEWPORT: the shading's `background_color`, as it is.
+ * The stage photographs Solid over this colour by the same merge (`PhotographSampling.backdropMerge`).
+ */
+function savedBackground(saved: NonNullable<Frame['view']>): string {
+  const theme = THREE.MathUtils.clamp(THEME_VIEWPORT_BACK, 0, 1);
+  const themeLinear = new THREE.Color().setRGB(theme, theme, theme, THREE.SRGBColorSpace);
+  const held = saved.background_type === 'WORLD' ? (saved.world_color ?? null)
+    : saved.background_type === 'VIEWPORT' ? (saved.background_color ?? null) : null;
+  const [r, g, b] = held ?? [themeLinear.r, themeLinear.g, themeLinear.b];
+  const shown = (c: number) => Math.round(Math.max(0, Math.min(1, c)) ** (1 / 2.2) * 255);
+  return `#${[r, g, b].map((c) => shown(c).toString(16).padStart(2, '0')).join('')}`;
+}
+
 /** One render's two poses, in Blender's own (Z-up) frame. */
 export interface PhotographRecord {
   /** `scene.camera.matrix_world`, as `session.py::_photograph` sent it. */
@@ -742,31 +821,26 @@ export class BlenderRuntimeView {
   private readonly lights = new Map<string, THREE.Light>();
   private readonly lighting = new ViewportLighting();
   private readonly world = new WorldBackground();
-  private readonly worldVisibility=new BlenderWorldVisibility();
   /**
-   * THE INSPECTION OVERLAYS (I4). They are NOT children of {@link root}, and
+   * Inspection overlays are not children of {@link root}, and
    * that is the whole design: an overlay is EDITOR FURNITURE, so its
    * visibility belongs to the viewport's Helpers menu rather than to this
    * presenter, and the door for that is the host's own — a document hands
-   * each group to its stage's `setHelper(kind, object)`
-   * (`@volter/sdk/host`, `EditorHostStage`), which marks it
+   * each group to editor-threejs's viewport `setHelper(kind, object)`, which marks it
    * `editorHelper`, keeps it out of the hierarchy and the raycast, and turns
    * it on and off with the kind's checkbox. `blender-runtime.document.tsx`
    * is where they are handed over.
    *
-   * They therefore carry the Blender → document permutation THEMSELVES
-   * ({@link overlayRoots}), because a helper is a scene-root object and does
-   * not inherit this root's matrix.
+   * Each helper root carries the Blender → document permutation because it
+   * is a scene-root object and does not inherit this root's matrix.
    */
   private readonly armatureOverlay = new ArmatureOverlay();
   private readonly weightOverlay = new WeightOverlay();
   private readonly cursorOverlay = new CursorOverlay();
   /** Blender's overlay extras: cameras, lights and empties (`blender-runtime-extras.ts`). */
   private readonly extrasOverlay = new ExtrasOverlay();
-  /** The two groups the stage is handed: the Helpers menu owns THEIR
-   *  `visible`, and the inner group is what a RENDER stands down (an overlay
-   *  is modeling chrome and never appears in a photograph — the same
-   *  distinction `applyVisibility` draws for the scene's own objects). */
+  /** The Helpers menu controls these roots' visibility. Their inner overlay
+   * groups are hidden during photographs without changing the menu state. */
   private readonly armatureRoot = new THREE.Group();
   private readonly weightRoot = new THREE.Group();
   private readonly cursorRoot = new THREE.Group();
@@ -778,6 +852,8 @@ export class BlenderRuntimeView {
   private readonly hiddenSurfaceLayers = new WeakMap<THREE.Object3D,number>();
   private shadowFit: {
     camera: THREE.Camera | undefined;
+    /** Fitted to the surfaces the camera sees (a renderer was at hand), not to the frustum. */
+    visible: boolean;
     cameraMatrix: THREE.Matrix4 | undefined;
     projection: THREE.Matrix4 | undefined;
     solarLights: THREE.DirectionalLight[];
@@ -799,7 +875,11 @@ export class BlenderRuntimeView {
    *  (`blender-workbench-material.ts`) over their viewport display. */
   private workbench = false;
   private readonly workbenchMaterials = new Map<string, THREE.Material>();
-  private readonly fallback = new THREE.MeshPhysicalMaterial({ color: 0xb9bec6, roughness: 0.72, side: THREE.DoubleSide, shadowSide: THREE.BackSide });
+  /** Solid's object outline (`blender-workbench-outline.ts`). */
+  private readonly outline = new WorkbenchOutline();
+  /** What the drawing camera sees, for a sun's shadow map (`blender-runtime-shadows.ts`). */
+  private readonly visibleReceivers = new VisibleReceivers();
+  private readonly fallback = new THREE.MeshPhysicalMaterial({ color: 0xb9bec6, roughness: 0.72, side: THREE.DoubleSide, shadowSide: THREE.DoubleSide });
   /** Base Color images, by image name -- ONE texture per image however many
    *  materials read it, and the cache OWNS it: a material points at one and
    *  never disposes it. Held with the size and revision the resident bytes
@@ -812,7 +892,7 @@ export class BlenderRuntimeView {
       width: number;
       height: number;
       revision: number;
-      encoded?: { bytes: Uint8Array; mime: 'image/png' | 'image/jpeg'; colorspace: 'sRGB' | 'data' };
+      encoded?: { bytes: Uint8Array; mime: 'image/png' | 'image/jpeg' | 'image/webp'; colorspace: 'sRGB' | 'data' };
       ready?: Promise<void>;
       /** A UDIM image's tiles as a graph samples them (`udimTextures`). */
       udim?: {tiles: THREE.DataArrayTexture; map: THREE.DataTexture; frame: NonNullable<z.infer<typeof rasterImageSchema>['tiles']>};
@@ -856,12 +936,11 @@ export class BlenderRuntimeView {
   private readonly submittedMeshes = new Map<string, unknown>();
   private submitted: Record<string, unknown> | null = null;
   private submittedSession: string | null = null;
-  /** EVERY PHOTOGRAPH THIS TAB TOOK FOR A RENDER: the pose the session sent in
-   *  Blender's frame, and the pose the photograph was actually taken from,
-   *  back in that same frame (`blender-runtime-host.ts`). Python asserts the
-   *  two are equal on every render; this is the record a HARNESS grades, and
-   *  it is written before that assertion can throw, so a conversion defect
-   *  leaves both poses behind instead of only an exception. */
+  /**
+   * Record the scene-camera pose sent by Blender and the photograph’s actual pose transformed back
+   * into Blender’s frame. Python asserts equality on every render; retain both poses before that
+   * assertion can throw.
+   */
   private readonly photographs: PhotographRecord[] = [];
   /** WHO WANTS TO KNOW THE MODEL MOVED. The Properties sections read the
    *  engine through the RNA door, and a frame is the one signal in the tab
@@ -876,14 +955,12 @@ export class BlenderRuntimeView {
   private leader: BlenderRuntimeView | null = null;
 
   /**
-   * A POSE MOVED HERE MID-GESTURE, DRAWN BY EVERY OTHER VIEW OF THE MODEL NOW. The gizmo moves a
-   * presented object in the view whose area it is dragged in (`blender-outliner-authoring.ts`,
-   * `apply`), and Blender's frame for the move comes only when the gesture ends; without this the
-   * other area — a Rendered one, as Blender's always-on render preview is — stood still until the
-   * release, where Blender redraws every area on every move. Each view holds its own object for
-   * the same Blender object (the frame's id) under the same parent, so the local matrix carries.
+   * Mirror a live gizmo move into every other view of the same model using the presented object’s
+   * local matrix. Blender confirms the pose when the gesture ends. Signal every move so drawing and
+   * temporal accumulation follow it in single-view and split-view documents.
    */
   mirrorPose(object: THREE.Object3D): void {
+    presenterChanged();
     let id: string | null = null;
     for (const [key, held] of this.objects)
       if (held === object) {
@@ -892,7 +969,6 @@ export class BlenderRuntimeView {
       }
     if (id === null) return;
     const views = this.leader ? [this.leader, ...this.leader.followers] : [...this.followers];
-    let moved = false;
     for (const view of views) {
       if (view === this) continue;
       const twin = view.objects.get(id);
@@ -900,9 +976,7 @@ export class BlenderRuntimeView {
       twin.matrix.copy(object.matrix);
       twin.matrix.decompose(twin.position, twin.quaternion, twin.scale);
       twin.updateMatrixWorld(true);
-      moved = true;
     }
-    if (moved) presenterChanged();
   }
 
   /** Subscribe to frames. Returns the unsubscribe. */
@@ -936,35 +1010,19 @@ export class BlenderRuntimeView {
     return null;
   }
 
-  /**
-   * BLENDER'S OWN SELECTION, AS THIS FRAME CARRIES IT — the per-object
-   * `selected` flag and the scene's `active`, by Blender datablock NAME.
-   *
-   * The session exports both on every present, which is what makes the FRAME
-   * the state rather than a copy of it: an agent's `select_set` through the
-   * script door, an operator that activates what it just created, and a
-   * person's click in this editor all land in one place and come back the
-   * same way. Nothing in the tab holds a selection of its own —
-   * `blender-outliner-authoring.ts` reads this on every frame and overwrites
-   * the cache its panels render from.
-   *
-   * THE ACTIVE OBJECT IS REPORTED SEPARATELY because Blender's own state
-   * allows an active object that is not selected, and the Properties editor
-   * follows the ACTIVE one while the outline follows the selected set.
-   */
+  noteSavedShading(shading: keyof typeof SAVED_SHADING): void {
+    if (this.frame?.view) this.frame.view.shading = shading;
+  }
+
   /**
    * WHERE BLENDER OPENS THIS FILE: its saved 3D View in the stage's frame — the pivot, the
    * direction from the pivot to the eye (the view's +Z, `view_rotation` turning view space into
    * the world: RNA's inverse of `viewquat`), the screen's up (the view's +Y), the distance and
-   * the projection. A view saved through the scene camera opens in perspective along the same
-   * axis: looking through a camera is not a view this stage has. With it the view's SHADING, the
+   * the projection. A saved camera view supplies a perspective orbit pose along its saved axis;
+   * `cameraView` separately provides the through-camera projection. With it the view's SHADING, the
    * draw mode Blender reopens it in (null from a file whose view carried none). Null before a
    * frame or when the file saved no 3D View.
    */
-  noteSavedShading(shading: keyof typeof SAVED_SHADING): void {
-    if (this.frame?.view) this.frame.view.shading = shading;
-  }
-
   savedView(): {
     readonly target: readonly [number, number, number];
     readonly direction: readonly [number, number, number];
@@ -975,6 +1033,8 @@ export class BlenderRuntimeView {
     readonly drawMode: 'wireframe' | 'solid' | 'preview' | 'rendered' | null;
     readonly sceneWorld: boolean;
     readonly sceneLights: boolean;
+    /** Solid's and Wireframe's resolved background as an sRGB `#rrggbb`. */
+    readonly background: string;
   } | null {
     const saved = this.frame?.view;
     if (!saved) return null;
@@ -992,9 +1052,20 @@ export class BlenderRuntimeView {
       drawMode: saved.shading ? SAVED_SHADING[saved.shading] : null,
       sceneWorld: saved.scene_world ?? false,
       sceneLights: saved.scene_lights ?? false,
+      background: savedBackground(saved),
     };
   }
 
+  #playbackCamera: string | null = null;
+  #playbackCameraData: Record<string, unknown> | null = null;
+  /** The camera the scene's playback shows at the Timeline's frame (the markers' cut), and how it
+   *  stands there (its matrix and projection as the Timeline's mixer posed it); null: the scene's
+   *  own camera, as Blender last evaluated it. */
+  setPlaybackCamera(name: string | null, data: Record<string, unknown> | null = null): void {
+    this.#playbackCamera = name;
+    this.#playbackCameraData = name === null ? null : data;
+  }
+
   /**
    * THE CAMERA A CAMERA VIEW ENTERED NOW WOULD LOOK THROUGH, as `view_camera_exec` picks it:
    * the scene's camera, else the active object when it is a camera, else the view layer's first
@@ -1004,6 +1075,11 @@ export class BlenderRuntimeView {
     const frame = this.frame;
     const view = frame?.camera_view;
     if (!frame || !view) return null;
+    // WHILE THE TIMELINE PLAYS OR SCRUBS, the camera of the marker at that frame (Blender switches
+    // `scene.camera` at bound markers as it plays; the frame here is the one it last evaluated)
+    // (described by the Timeline itself when Blender's last frame did not carry it: a present ships
+    // only what moved)
+    if (this.#playbackCamera !== null && (this.#playbackCameraData || frame.cameras[this.#playbackCamera])) return this.#playbackCamera;
     if (view.scene_camera !== null && frame.cameras[view.scene_camera]) return view.scene_camera;
     if (frame.active !== null && frame.cameras[frame.active]) return frame.active;
     return view.view_layer_cameras.find((name) => frame.cameras[name]) ?? null;
@@ -1037,14 +1113,19 @@ export class BlenderRuntimeView {
     offset: readonly [number, number],
   ): BlenderCameraView | null {
     const frame = this.frame;
-    const data = cameraDataSchema.safeParse(frame?.cameras[camera]);
+    const evaluated = frame?.cameras[camera];
+    // (while the Timeline plays, the camera as its mixer posed it at that frame)
+    const posed = camera === this.#playbackCamera && this.#playbackCameraData
+      ? { ...((evaluated ?? {}) as Record<string, unknown>), ...this.#playbackCameraData } : evaluated;
+    const data = cameraDataSchema.safeParse(posed);
     if (!frame?.camera_view || !data.success) return null;
     return blenderCameraView(data.data, this.root.matrix, region, zoom, offset, frame.camera_view.aspect);
   }
 
-  /** The viewport's subject line at `frame`, `(1) Collection | Cube`: the engine's body with
-   *  the frame before it and that frame's marker after it; `frame` null is the scene's own
-   *  `frame_current`. Null before a frame or from an engine that does not report it. */
+  /**
+   * The viewport subject line at frame, prefixed by the frame and followed by its marker. A null
+   * frame uses scene.frame_current; null output means no subject line is held.
+   */
   subjectLine(playhead: number | null): string | null {
     const subject = this.frame?.subject;
     if (subject === undefined) return null;
@@ -1071,6 +1152,22 @@ export class BlenderRuntimeView {
     return step[1];
   }
 
+  /**
+   * BLENDER'S OWN SELECTION, AS THIS FRAME CARRIES IT — the per-object
+   * `selected` flag and the scene's `active`, by Blender datablock NAME.
+   *
+   * The session exports both on every present, which is what makes the FRAME
+   * the state rather than a copy of it: an agent's `select_set` through the
+   * script door, an operator that activates what it just created, and a
+   * person's click in this editor all land in one place and come back the
+   * same way. Nothing in the tab holds a selection of its own —
+   * `blender-outliner-authoring.ts` reads this on every frame and overwrites
+   * the cache its panels render from.
+   *
+   * THE ACTIVE OBJECT IS REPORTED SEPARATELY because Blender's own state
+   * allows an active object that is not selected, and the Properties editor
+   * follows the ACTIVE one while the outline follows the selected set.
+   */
   blenderSelection(): { readonly selected: readonly string[]; readonly active: string | null } {
     const frame = this.frame;
     if (frame === null) return { selected: [], active: null };
@@ -1080,20 +1177,7 @@ export class BlenderRuntimeView {
     };
   }
 
-  /**
-   * BLENDER'S MODE, PUBLISHED ON THE DOCUMENT'S OWN CONTEXT.
-   *
-   * `volter.stage.mode` (U6's context key, `editor-host-door.ts`'s `stage()`) had
-   * no reporter at all: Edit Mesh went with the mesh kit and the Model document
-   * had no mode strip, so every `when` clause that reads it was answering
-   * `null`. The engine HAS a mode — `bpy.context.mode`, and `Object.mode` on the
-   * active object, which is what the Outliner's own pose rows key on
-   * (`tree_element_pose.cc`: the channels exist only in pose mode) — and the
-   * TREE door reports both. So the document publishes it here, on the context it
-   * already publishes (`publishContext(view)`), rather than through a second
-   * door: `blender-outliner-model.ts` sets it on every read, and the host's
-   * `stage()` asks the ACTIVE document's context for it.
-   */
+  /** Publish bpy.context.mode and active-object mode on the document context for stage conditions and the Outliner. */
   private mode: string | null = null;
 
   setStageMode(mode: string | null): void {
@@ -1106,19 +1190,13 @@ export class BlenderRuntimeView {
 
   /** PLAY IS A MODE OF THE STAGE: while the document plays, the keys are the player's, and the
    *  mode this context publishes is what the frame's key rules stand down on
-   *  (`scripts/workbench/generate-keymaps.mjs`, `whenFor`). Blender's own mode returns on stop. */
+   *  (`volter.stage.mode != 'PLAY'`). Blender's own mode returns on stop. */
   private playing = false;
 
   setPlaying(playing: boolean): void {
     this.playing = playing;
   }
 
-  /** The inverse: the presented object for a Blender datablock NAME, or null
-   *  when this tab is not showing one (a camera, an excluded collection's
-   *  member, an object type the presenter draws nothing for). The OUTLINER
-   *  needs it — its rows come from the engine by name, and every one that our
-   *  viewport can select has to find its way back to a three object through
-   *  the frame's own table, never through `object.name`. */
   /**
    * WHAT THE LAST FRAME SAYS ABOUT ANIMATION, for a reader that plays clips on `skeletons`: the
    * scene's current frame and clock, every action's revision, each armature's assigned action, the
@@ -1136,6 +1214,9 @@ export class BlenderRuntimeView {
      *  pose), its action and its NLA stack. */
     armatures: Readonly<Record<string, BlenderArmature>>;
     skinArmature(object: string): string | null;
+    /** The scene's camera, every camera's settings and placement, as one string: the movie, which
+     *  carries them, is read again when it changes (switching the scene camera, an unkeyed lens). */
+    cameras: string;
   } {
     const frame = this.frame;
     return {
@@ -1145,6 +1226,11 @@ export class BlenderRuntimeView {
       active: frame?.active ?? null,
       actions: frame?.actions ?? {},
       armatures: frame?.armatures ?? {},
+      cameras: JSON.stringify([
+        frame?.camera_view?.scene_camera ?? null,
+        frame?.cameras ?? {},
+        (frame?.objects ?? []).filter((o) => o.type === 'CAMERA').map((o) => [o.name, o.matrix]),
+      ]),
       skinArmature: (name) => {
         const object = this.objectForBlenderName(name) as THREE.Mesh | null;
         const skin = object?.geometry?.userData['blenderSkin'] as { armature: string } | undefined;
@@ -1153,6 +1239,12 @@ export class BlenderRuntimeView {
     };
   }
 
+  /** The inverse: the presented object for a Blender datablock NAME, or null
+   *  when this tab is not showing one (a camera, an excluded collection's
+   *  member, an object type the presenter draws nothing for). The OUTLINER
+   *  needs it — its rows come from the engine by name, and every one that our
+   *  viewport can select has to find its way back to a three object through
+   *  the frame's own table, never through `object.name`. */
   objectForBlenderName(name: string): THREE.Object3D | null {
     const entry = this.frame?.objects.find((o) => o.name === name);
     return entry === undefined ? null : (this.objects.get(entry.id) ?? null);
@@ -1162,16 +1254,8 @@ export class BlenderRuntimeView {
    * Put `next` where `previous` stood — same parent, same id in the object
    * table, same place among its siblings' children.
    *
-   * THE ONE CALLER IS THE SKIN (`blender-runtime-skin.ts`): a mesh that turns
-   * out to be deformed by an armature has to become a `THREE.SkinnedMesh`, and
-   * three has no way to promote a `Mesh` in place. It goes through this method
-   * rather than the map directly because the table's KEY is the frame's object
-   * id and only this class knows it — a swap that missed the table would be
-   * replaced again by the next frame's reuse check, every frame, forever.
-   *
-   * A `SkinnedMesh` still answers `isMesh`, so the next frame's check
-   * (`isMesh === (obj.mesh !== null)`) keeps it and merely re-points its
-   * geometry and materials, which is exactly right.
+   * Frame application and skeleton promotion use this door so replacements
+   * retain the frame's object identity and the next frame can reuse them.
    */
   replacePresentedObject(previous: THREE.Object3D, next: THREE.Object3D): void {
     for (const [id, object] of this.objects)
@@ -1194,14 +1278,9 @@ export class BlenderRuntimeView {
       this.instances.sync();
     };
     this.root.name = 'Model';
-    // BLENDER IS Z-UP, THREE IS Y-UP: (x, y, z) -> (x, z, -y). Written as the
-    // matrix rather than `rotation.x = -Math.PI / 2`, because that Euler is a
-    // FLOAT quarter turn -- `Math.cos(-Math.PI / 2)` is 6.12e-17, not 0 -- and
-    // this matrix is the one a render inverts to answer with the pose it
-    // photographed from (`blender-runtime-host.ts`). An exact signed axis
-    // permutation inverts exactly, so that round trip is checkable with no
-    // tolerance; the float quarter turn is not, and it also leaves every model
-    // rotated by 89.999999999999996 degrees for nothing.
+    // Map Blender Z-up into three.js Y-up with the exact signed permutation (x, y, z) → (x, z, -y).
+    // Camera poses transformed through this matrix and its inverse round-trip without a
+    // floating-point tolerance.
     this.root.matrixAutoUpdate = false;
     this.root.matrix.set(1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1);
     this.root.updateMatrixWorld(true);
@@ -1232,16 +1311,6 @@ export class BlenderRuntimeView {
     this.emptyExtrasRoot.name = 'BlenderEmptyExtras';
   }
 
-  /**
-   * THE OVERLAY GROUPS, for the document to hand to its stage.
-   *
-   * `kind` is the `HelperVisibility` member whose checkbox owns it: `skeletons`
-   * is the Helpers menu's existing Skeletons row, which is Blender's viewport
-   * overlay "Bones" checkbox (`View3DOverlay.show_bones`,
-   * `rna_space.cc:5125-5129`; `space_view3d.py:7161`) under this editor's own
-   * noun; `weights` is a member this unit added, because nothing in the set
-   * stood for a vertex-group weight display.
-   */
   /**
    * BLENDER'S SOLID-MODE STUDIO, for the document to hand to its stage as
    * `dressing.viewLocked`.
@@ -1257,6 +1326,15 @@ export class BlenderRuntimeView {
     return this.lighting.group;
   }
 
+  /**
+   * THE OVERLAY GROUPS, for the document to hand to its stage.
+   *
+   * `kind` is the `HelperVisibility` member whose checkbox owns it: `skeletons`
+   * is the Helpers menu's Skeletons row, which is Blender's viewport
+   * overlay "Bones" checkbox (`View3DOverlay.show_bones`,
+   * `rna_space.cc:5125-5129`; `space_view3d.py:7161`) under this editor's own
+   * noun; `weights` controls the vertex-group weight display.
+   */
   overlayGroups(): readonly { kind: string; object: THREE.Object3D }[] {
     return [
       { kind: 'skeletons', object: this.armatureRoot },
@@ -1287,6 +1365,7 @@ export class BlenderRuntimeView {
     return placement;
   }
 
+  private heldSceneLighting: { world: boolean; lights: boolean } | undefined;
   /**
    * BLENDER'S RENDERED SHADING: the viewport held in the lighting a render photographs with
    * ({@link setRendered}) — the scene's own lights, its World behind and around the model,
@@ -1296,7 +1375,6 @@ export class BlenderRuntimeView {
    * keeps viewport visibility independently of its shading and lighting choices.
    * A render taken meanwhile ends back in this state rather than in modeling.
    */
-  private heldSceneLighting: { world: boolean; lights: boolean } | undefined;
   holdRendered(drawCamera: (() => THREE.Camera) | null, sceneLighting?: { world: boolean; lights: boolean }, visibility: 'viewport' | 'render' = 'viewport'): void {
     if (drawCamera === this.heldRendered && sceneLighting?.world === this.heldSceneLighting?.world && sceneLighting?.lights === this.heldSceneLighting?.lights && visibility === this.heldVisibility) return;
     this.heldRendered = drawCamera;
@@ -1345,12 +1423,31 @@ export class BlenderRuntimeView {
   }
 
   private report(work: Promise<void>): void {
+    this.renderedWork = work.then(() => undefined, () => undefined);
     void work.then(presenterChanged, (error: unknown) =>
       // biome-ignore lint/suspicious/noConsole: the editor console captures console.error session-wide; this is the report channel.
       console.error(`Rendered shading could not be applied: ${error instanceof Error ? error.message : String(error)}`),
     );
   }
 
+  /** The Rendered shading the viewport was last put in, still settling (`applyRendered`). */
+  private renderedWork: Promise<void> = Promise.resolve();
+
+  /**
+   * WHAT THE FRAME ON SCREEN IS STILL WAITING ON before it draws as it will: Rendered shading's
+   * settling (area-light tables, the World's sky) and every image's decode. A photograph through
+   * {@link setRendered} waits for the same things; a view presented on the viewport waits here
+   * (the model document's preparation), so a capture right after a model opens or Rendered is
+   * entered does not catch any of them half-way. A graph program still compiling is the draw's
+   * own business (`photographGraphs`).
+   */
+  async drawReady(): Promise<void> {
+    await this.renderedWork;
+    await lightingReady();
+    await Promise.allSettled([...this.textures.values()].map((held) => held.ready));
+    await this.world.ready().catch(() => undefined);
+  }
+
   /**
    * BLENDER'S SOLID SHADING ON OR OFF: while on, every presented surface is drawn by Blender's
    * Solid function over its material's viewport display; a render photograph, Material Preview
@@ -1363,6 +1460,29 @@ export class BlenderRuntimeView {
     presenterChanged();
   }
 
+  /**
+   * THE AUTHORED MATERIALS, whatever the viewport shows: `run` sees every presented mesh dressed in the
+   * materials its object's slots name (what Material Preview and Rendered show), and each gets back what
+   * it wore after. An export writes the model's own materials in Solid shading too (`blender-export-gltf`).
+   */
+  async withAuthoredMaterials<T>(run: () => Promise<T>): Promise<T> {
+    const worn = new Map<THREE.Mesh, THREE.Material | THREE.Material[]>();
+    for (const obj of this.frame?.objects ?? []) {
+      if (obj.mesh === null || obj.volume) continue;
+      const mesh = this.objects.get(obj.id) as THREE.Mesh | undefined;
+      if (!mesh?.isMesh) continue;
+      const slots: readonly (string | null)[] = obj.materials.length ? obj.materials : [null];
+      const authored = slots.map((id) => (id === null ? this.fallback : (this.materials.get(id) ?? this.fallback)));
+      worn.set(mesh, mesh.material);
+      mesh.material = obj.materials.length ? authored : authored[0]!;
+    }
+    try {
+      return await run();
+    } finally {
+      for (const [mesh, material] of worn) mesh.material = material;
+    }
+  }
+
   /** Each surface's material for the state: authored, or Solid's, derived from the frame every
    *  time so a replaced node (the skin's) is never left wearing the other. */
   private applyWorkbench(): void {
@@ -1376,7 +1496,8 @@ export class BlenderRuntimeView {
       const slots: readonly (string | null)[] = obj.materials.length ? obj.materials : [null];
       const shown = slots.map((id) => {
         const authored = id === null ? this.fallback : (this.materials.get(id) ?? this.fallback);
-        return solid ? this.workbenchFor(id, authored.side, used) : this.objectInfoMaterials.get(authored,mesh);
+        // Solid ignores a material's Backface Culling (the 3D View's own option governs it, off by default).
+        return solid ? this.workbenchFor(id, THREE.DoubleSide, used) : this.objectInfoMaterials.get(authored,mesh);
       });
       mesh.material = obj.materials.length ? shown : shown[0]!;
       prepareGraphGeometry(mesh);
@@ -1416,7 +1537,9 @@ export class BlenderRuntimeView {
 
   /** Before the renderer uploads attributes/builds its queues, for this area's
    * actual camera. Transparent instance runs are camera-order dependent. */
-  prepareDraw(camera: THREE.Camera, options?: {interactive: boolean; height: number; multiDraw?: boolean; renderer?: THREE.WebGLRenderer}): () => void {
+  prepareDraw(camera: THREE.Camera, options?: BlenderDrawOptions): () => void {
+    const outline = this.outlineColor(options);
+    photographGraphs(options?.photograph === true);
     try {
       if (!this.workbench || this.rendered) {
         if(this.objectInfoMaterials.needsRemap()) this.applyWorkbench();
@@ -1425,19 +1548,11 @@ export class BlenderRuntimeView {
       const start = performance.now();
       this.instances.prepareDraw(camera);
       this.root.updateMatrixWorld(true);
+      this.skeletons.fitBounds();
       // The script/navigation has just posed the camera and the detached
       // objects. Fit shadows for that draw, rather than the camera's pose
       // when Rendered shading was first entered. Captures use this path too.
-      if (this.rendered) this.applyShadows(true, camera);
-      if (WORLD_VISIBILITY) {
-        this.worldVisibility.sync(this.objects.values(),this.world.lightingTexture(),this.root,this.rendered);
-        for(const material of [...this.materials.values(),this.fallback])bindWorldVisibility(material,this.worldVisibility);
-        for(const object of this.objects.values()) {
-          const mesh=object as THREE.Mesh;if(!mesh.isMesh)continue;
-          for(const material of Array.isArray(mesh.material)?mesh.material:[mesh.material])bindWorldVisibility(material,this.worldVisibility);
-        }
-        if(options?.renderer)this.worldVisibility.prepare(options.renderer);
-      }
+      if (this.rendered) this.applyShadows(true, camera, options?.renderer, true);
       const opaqueDone = performance.now();
       const motion = this.motionGeometry.prepare(camera, !this.rendered && (this.mode ?? this.frame?.mode) === 'OBJECT' &&
         options?.interactive === true, options?.height ?? 0);
@@ -1455,6 +1570,7 @@ export class BlenderRuntimeView {
       this.drawPreparation.last = timing;
       if (motion) this.drawPreparation.navigation = timing;
     } catch (error) {
+      photographGraphs(false);
       this.materialRanges.finish();
       this.motionGeometry.finish();
       this.instances.finishDraw();
@@ -1462,30 +1578,108 @@ export class BlenderRuntimeView {
       throw error;
     }
     return () => {
-      this.materialRanges.finish();
-      this.motionGeometry.finish();
-      this.instances.finishDraw();
-      this.transparentInstances.finishDraw();
+      try {
+        // Over the frame as it was just drawn: its draw geometry and batches still stand.
+        if (outline && options?.renderer) this.drawOutline(options.renderer, camera, outline, options.pixelScale ?? 1);
+      } finally {
+        photographGraphs(false);
+        this.materialRanges.finish();
+        this.motionGeometry.finish();
+        this.instances.finishDraw();
+        this.transparentInstances.finishDraw();
+      }
+    };
+  }
+
+  /** Solid's object outline colour for this draw, or null when it draws none: Blender's Solid
+   *  with the file's `show_object_outline` on, and a renderer to draw it with. */
+  private outlineColor(options?: BlenderDrawOptions): readonly [number, number, number] | null {
+    const saved = this.frame?.view;
+    if (!options?.renderer || options.drawMode !== 'solid' || !this.workbench || this.rendered) return null;
+    if (!saved?.show_object_outline) return null;
+    return saved.object_outline_color ?? [0, 0, 0];
+  }
+
+  private drawOutline(renderer: THREE.WebGLRenderer, camera: THREE.Camera, color: readonly [number, number, number], pixelScale: number): void {
+    let scene: THREE.Object3D | null = this.root;
+    while (scene && !(scene as THREE.Scene).isScene) scene = scene.parent;
+    if (!scene) return;
+    const presented = new Set(this.objects.values());
+    // The presenter's own draws (batches) stand in for some objects; the id pass draws those
+    // objects themselves, each with its own id, as Blender's id buffer holds them.
+    const internal = this.root.children.filter((child) => (child as THREE.Mesh).isMesh && !presented.has(child));
+    this.outline.draw(renderer, scene as THREE.Scene, camera, this.objects.values(),
+      (object) => !this.hiddenSurfaceLayers.has(object), internal, color, pixelScale);
+  }
+
+  /**
+   * HOW EACH SHADING TYPE IS ANTI-ALIASED, as Blender's viewport accumulates it
+   * (`blender-viewport-sampling.ts` holds both models): a photograph draws every sample at once,
+   * and the stage's live view one per redraw while nothing changes, as Blender's viewport does.
+   * - SOLID: Workbench's accumulation at the Preferences' Viewport Anti-Aliasing
+   *   (`workbench_state.cc`: `U.viewport_aa` whatever the engine), whose factory value, 8, the tab
+   *   assumes: it holds no Blender preferences. Merged over its backdrop as the display shader
+   *   merges the overlay.
+   * - RENDERED: Workbench at the scene's `display.viewport_aa` when Workbench is the engine ('OFF'
+   *   one centred sample, unfiltered: no anti-aliasing at all; 'FXAA' its one centred sample, the
+   *   SMAA Workbench lays over it not reproduced); EEVEE's film otherwise, at its viewport
+   *   `taa_samples` and `filter_size`.
+   * - WIREFRAME: none here. Blender's wires are overlay lines smoothed by their own pass, not
+   *   accumulated, so a wireframe photograph keeps the stage's own supersampling and the live
+   *   view its MSAA.
+   * - MATERIAL PREVIEW: EEVEE's film, whatever the engine.
+   * Null before a frame.
+   */
+  photographSampling(): Partial<Record<'solid' | 'wireframe' | 'preview' | 'rendered', BlenderPhotographSampling>> | null {
+    const sampling = this.frame?.sampling;
+    if (!sampling) return null;
+    // The same answer for the same settings: the stage keeps its live accumulation while the
+    // sampling it was begun by is the one it is handed (every Blender frame hands it again).
+    const key = `${sampling.engine}|${sampling.viewport_aa}|${sampling.taa_samples}|${sampling.filter_size}`;
+    if (this.#sampling?.key === key) return this.#sampling.value;
+    const film = eeveeSampling(sampling.taa_samples, sampling.filter_size);
+    const sceneAa = sampling.viewport_aa === 'OFF' ? 0 : sampling.viewport_aa === 'FXAA' ? 1 : Number.parseInt(sampling.viewport_aa, 10);
+    const rendered = sampling.engine === 'BLENDER_WORKBENCH'
+      ? workbenchSampling(Number.isFinite(sceneAa) ? sceneAa : 1, false) : film;
+    const value = { solid: workbenchSampling(PREFERENCES_VIEWPORT_AA, true), rendered, preview: film };
+    this.#sampling = { key, value };
+    return value;
+  }
+
+  #sampling: { readonly key: string; readonly value: Partial<Record<'solid' | 'wireframe' | 'preview' | 'rendered', BlenderPhotographSampling>> } | null = null;
+
+  /**
+   * THE SCENE'S COLOUR MANAGEMENT for the frame on screen (`Scene.view_settings`, exposure as a
+   * multiplier, and the display device), as `session.py` sends it with every present: Rendered and
+   * Material Preview are drawn through it. Null before a frame, or from an engine that does not
+   * send it.
+   */
+  displaySettings(): (BlenderDisplaySettings & { readonly device: string }) | null {
+    const display = this.frame?.display;
+    if (!display) return null;
+    return {
+      transform: display.view_transform,
+      look: display.look,
+      exposure: 2 ** display.exposure,
+      gamma: display.gamma,
+      device: display.display_device,
     };
   }
 
   private workbenchFor(id: string | null, side: THREE.Side, used: Set<string>): THREE.Material {
     const display = (id !== null ? this.frame?.materials[id]?.viewport : undefined) ?? DEFAULT_VIEWPORT_DISPLAY;
-    const key = `${display.color.join(',')}|${display.roughness}|${display.metallic}|${side}`;
+    // Solid's Specular Lighting, as the file's 3D View holds it (on in a factory file).
+    const specular = this.frame?.view?.show_specular_highlight ?? true;
+    const key = `${display.color.join(',')}|${display.roughness}|${display.metallic}|${side}|${specular}`;
     used.add(key);
     let material = this.workbenchMaterials.get(key);
     if (!material) {
-      material = workbenchMaterial(display, side);
+      material = workbenchMaterial(display, side, specular);
       this.workbenchMaterials.set(key, material);
     }
     return material;
   }
 
-  /** Whether the viewport is held in render lighting (Blender's Rendered shading). */
-  renderedHeld(): boolean {
-    return this.heldRendered !== null;
-  }
-
   /**
    * Light the model the way a RENDER is lit — by the scene's own lights —
    * rather than the way modeling is, by the studio key. `bpy.ops.render.render()`
@@ -1527,12 +1721,7 @@ export class BlenderRuntimeView {
     this.applyVisibility();
     this.applyWorkbench();
     this.applyShadows(rendered, camera);
-    // AFTER the applies, because they are what REGISTERS the work. Awaiting
-    // first made every one of these a no-op on the first render: `apply` had
-    // not started the sky yet, so `worldReady()` saw nothing pending and the
-    // photograph went out with an empty sky texture. Measured -- a sky the page
-    // had never derived returned a render in 0.08s, which is not fast, it is
-    // wrong. One photograph, no second chance at it.
+    // Await preparation after apply registers its sky work, so ready observes every pending texture.
     if (rendered) {
       await lightingReady();
       await Promise.all([...this.textures.values()].map((held) => held.ready));
@@ -1544,27 +1733,17 @@ export class BlenderRuntimeView {
   }
 
   /**
-   * Who is drawn, which is a different question in each state.
-   *
-   * MODELING reads the viewport's visibility and lights nothing the scene
-   * owns; a RENDER reads `hide_render` — the flag the Cycles path's own
-   * snapshot skipped objects by — and lights exactly the scene's lights.
-   */
-  /**
-   * Shadows, for a render only.
-   *
-   * The renderer's shadow map is already on (`StageHost`); what is
-   * missing is anything opting into it, because MODELING wants none — a
-   * shadow across the model is in the way while it is being built, and the
-   * viewport has never cast one. So the meshes opt in for the photograph and
-   * back out afterwards, and every shadow camera is fitted to the model,
-   * whose size no default could know.
+   * Enable mesh shadows for rendered shading and captures, and fit each
+   * light's shadow camera to the visible receivers and eligible casters.
    */
-  private applyShadows(rendered: boolean, camera?: THREE.Camera): void {
-    this.root.updateMatrixWorld(true);
+  private applyShadows(rendered: boolean, camera?: THREE.Camera, renderer?: THREE.WebGLRenderer, posed = false): void {
+    // When posed is true, prepareDraw already refreshed world matrices; reuse them.
+    if (!posed) this.root.updateMatrixWorld(true);
     this.world.updateSolarDirections(this.root);
     const fitted = this.shadowFit;
-    if (rendered && fitted && fitted.camera === camera &&
+    // A fit made without a renderer (entering Rendered) is fitted again by the first draw,
+    // which can see what the camera sees.
+    if (rendered && fitted && fitted.camera === camera && (fitted.visible || !renderer || !camera) &&
       (!camera || (fitted.cameraMatrix?.equals(camera.matrixWorld) && fitted.projection?.equals(camera.projectionMatrix))) &&
       fitted.solarLights.length === this.world.solarLights.length &&
       fitted.solarLights.every((light, index) => light === this.world.solarLights[index]) &&
@@ -1575,6 +1754,7 @@ export class BlenderRuntimeView {
       })) return;
     this.shadowFit = rendered ? {
       camera,
+      visible: renderer !== undefined && camera !== undefined,
       cameraMatrix: camera?.matrixWorld.clone(),
       projection: camera?.projectionMatrix.clone(),
       solarLights: [...this.world.solarLights],
@@ -1603,14 +1783,45 @@ export class BlenderRuntimeView {
           new THREE.Matrix4().multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse),
         )
       : null;
-    const receivers = frustum
-      ? boxes.flatMap((bounds) => visibleShadowReceivers(bounds, frustum))
-      : [];
+    const suns = [...this.lights.values(), ...this.world.solarLights]
+      .some((light) => (light as THREE.DirectionalLight).isDirectionalLight && light.castShadow);
+    // WHAT THE CAMERA SEES is what a sun's map covers, as EEVEE tags its pages from the visible
+    // surfaces (`VisibleReceivers`); the frustum's boxes only when no renderer is at hand to look.
+    const seen = suns && renderer && camera ? this.sampleVisibleReceivers(renderer, camera) : [];
+    // Every visible receiver is needed only to fit a sun without a renderer to look; a point or spot
+    // light's bias needs only the farthest one (`farthestVisibleReceiver`).
+    let clipped: THREE.Vector3[] | null = null;
+    const receivers = (): THREE.Vector3[] => seen.length
+      ? seen
+      : frustum
+        ? (clipped ??= boxes.flatMap((bounds) => visibleShadowReceivers(bounds, frustum)))
+        : [];
     for (const light of [...this.lights.values(), ...this.world.solarLights]) {
       if ((light as THREE.DirectionalLight).isDirectionalLight && camera)
-        fitModelDirectionalShadow(light as THREE.DirectionalLight, receivers, casters);
-      else fitShadow(light, sphere.center, sphere.radius);
+        fitModelDirectionalShadow(light as THREE.DirectionalLight, light.castShadow ? receivers() : [], casters);
+      else {
+        fitShadow(light, sphere.center, sphere.radius);
+        if ((light as THREE.PointLight).isPointLight || (light as THREE.SpotLight).isSpotLight)
+          fitPerspectiveShadowBias(light as THREE.PointLight | THREE.SpotLight, seen.length || !frustum ? receivers()
+            : light.castShadow ? farthestVisibleReceiver(boxes, frustum, light.getWorldPosition(new THREE.Vector3())) : []);
+      }
+    }
+  }
+
+  /** The visible surfaces through `camera`, leaving out what the drawing sees through. */
+  private sampleVisibleReceivers(renderer: THREE.WebGLRenderer, camera: THREE.Camera): THREE.Vector3[] {
+    let scene: THREE.Object3D | null = this.root;
+    while (scene && !(scene as THREE.Scene).isScene) scene = scene.parent;
+    if (!scene) return [];
+    const seeThrough: THREE.Object3D[] = [];
+    for (const object of this.objects.values()) {
+      const mesh = object as THREE.Mesh;
+      if (!mesh.isMesh) continue;
+      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+      if (materials.every((material) => material.transparent || (material as THREE.MeshPhysicalMaterial).transmission > 0))
+        seeThrough.push(mesh);
     }
+    return this.visibleReceivers.sample(renderer, scene as THREE.Scene, camera, seeThrough);
   }
 
   /**
@@ -1708,6 +1919,8 @@ export class BlenderRuntimeView {
     });
   }
 
+  /** Use render visibility for captures and views that request it. Editing
+   *  retains viewport visibility independently of its shading and lighting. */
   private applyVisibility(): void {
     // Restore canonical masks before suppressing an instancer's own surface.
     // Its geometry can be hidden while its placed children remain visible.
@@ -1765,10 +1978,9 @@ export class BlenderRuntimeView {
       const data = exportedMeshSchema.parse(part.piece);
       if (staged.meshes.has(part.mesh)) throw new Error('Duplicate Blender mesh piece');
       const signature = `revision:${data.revision}`;
-      const geometry = geometryFromDrawArrays(drawArraysFromColumns({
+      const geometry = drawnOrRefused(() => withFrameSkin(geometryFromDrawArrays(drawArraysFromColumns({
         ...data.columns, attributes: data.attributes as never, activeUv: data.activeUv, renderUv: data.renderUv,
-      }, signature));
-      if (data.skin) skinGeometry(geometry, data.skin);
+      }, signature)), data.skin));
       staged.meshes.set(part.mesh, { signature, geometry });
     } else if (part.image !== undefined) {
       if (staged.images.has(part.image)) throw new Error('Duplicate Blender image piece');
@@ -1856,7 +2068,7 @@ export class BlenderRuntimeView {
           // BufferGeometry stands. If it is not resident the worker's record
           // is ahead of this presenter — a page reloaded under a still-running
           // session — and saying so by name is what makes it re-send the frame
-          // in full (`dispatch.mts`, `runtime_present`).
+          // in full.
           // AND AT THAT REVISION: the frame names every mesh with the revision the engine holds
           // it at, so it is a whole manifest of what this presenter should hold, and a resident
           // geometry at another revision has drifted from the engine (a present the session
@@ -1890,7 +2102,7 @@ export class BlenderRuntimeView {
           continue;
         prepared.set(id, {
           signature,
-          geometry: exported
+          geometry: drawnOrRefused(() => exported
             ? withFrameSkin(geometryFromDrawArrays(
                 drawArraysFromColumns(
                   {
@@ -1904,7 +2116,7 @@ export class BlenderRuntimeView {
               ), data.skin)
             : drawn
               ? withDrawnSkin(geometryFromDrawArrays(data), data.skin)
-              : drawRuntimeGeometry(data),
+              : drawRuntimeGeometry(data)),
         });
       }
     } catch (error) {
@@ -1939,7 +2151,7 @@ export class BlenderRuntimeView {
     }
     // THE PICTURES THE FRAME BROUGHT, before any material can ask for one. An
     // entry is here only because this session has not sent these bytes at this
-    // revision yet (`runtime_session._stage_images`); everything else the
+    // revision yet (`session.py`'s image-carry record); everything else the
     // materials name is already resident, which is the whole point of the
     // revision.
     for (const [name, data] of Object.entries(next.images)) {
@@ -1999,27 +2211,22 @@ export class BlenderRuntimeView {
       });
     }
     for (const [id, data] of Object.entries(next.materials)) {
-      // Cycles intersects and shades both faces, including an arcade viewed
-      // from underneath. Three's front-face default drops those surfaces.
-      // The shadow map keeps the back faces a front-faced material draws
-      // there: a two-sided depth pass puts every lit face into its own map, and
-      // the normal offset cannot hold that off at grazing light.
+      // Render both surface faces, as Cycles does. Cast shadows from both faces unless the material
+      // enables shadow backface culling. Fit the sun map to visible receivers and scale its normal
+      // offset by the map’s texel size.
       const material = this.materials.get(id) ??
-        new THREE.MeshPhysicalMaterial({ side: THREE.DoubleSide, shadowSide: THREE.BackSide });
+        new THREE.MeshPhysicalMaterial({ side: THREE.DoubleSide, shadowSide: THREE.DoubleSide });
+      material.shadowSide = data.backface_culling_shadow ? THREE.FrontSide : THREE.DoubleSide;
+      // Match Blender’s face passes: cull back faces when declared, and draw blended surfaces in one pass with Transparency Overlap enabled.
+      const side = data.backface_culling ? THREE.FrontSide : THREE.DoubleSide;
+      const singlePass = data.transparency_overlap !== false;
+      if (material.side !== side || material.forceSinglePass !== singlePass) {
+        material.side = side;
+        material.forceSinglePass = singlePass;
+        material.needsUpdate = true;
+      }
       material.name = data.name;
-      // A LINKED BASE COLOUR REPLACES THE SOCKET'S VALUE, it does not multiply
-      // it. Python's `_reduce` fills `color` from the Base Color socket's
-      // default even when the socket is LINKED (the socket keeps its last
-      // constant, and native never draws it), while three multiplies `map` by
-      // `material.color` -- so carrying that constant alongside a map tinted
-      // every textured surface by a leftover. Measured on `20-rigged-courier`:
-      // the painted face's skin photographed (107,59,41) against native's
-      // (154,108,77) at the same pixel, from a texture whose own skin is
-      // (168,118,84) on both sides.
-      //
-      // With a map, the only legitimate multiplier is the `tint` a MULTIPLY mix
-      // carries; without one it is white. Only a material with NO map draws the
-      // constant.
+      // A linked Base Color replaces the socket constant. Textured materials multiply only by the tint carried by a MULTIPLY mix; untextured materials use the constant.
       const tint = data.texture?.tint;
       if (data.texture !== undefined) {
         material.color.setRGB(
@@ -2117,10 +2324,7 @@ export class BlenderRuntimeView {
           material.needsUpdate = true;
         }
       }
-      // THE AUTHORED TEXTURE. Without it a Base Color link rendered as the
-      // socket's default and the image never reached a pixel -- measured as a
-      // byte-identical render with and without one. Blender's Base Color is an
-      // sRGB-encoded image, so the texture says so and three linearises it.
+      // Base Color images are sRGB; declare that encoding so three linearizes their texels.
       const wanted = data.texture?.image.name ?? null;
       if (wanted === null) {
         if (this.textureNames.has(id)) {
@@ -2304,17 +2508,13 @@ export class BlenderRuntimeView {
       if (bound && rig) this.skinBinds.set(bound, { geometry: bound.geometry, rig });
     }
     this.root.updateMatrixWorld(true);
-    // Keep the frame's identity and object table, not its geometry payloads:
-    // a presented mesh is already resident as its BufferGeometry, and the
-    // nested number arrays it arrived as cost ~15x their JSON (the blower's
-    // last frame held 850 MB of main-thread heap this way, measured
-    // 2026-09-13). Reuse checks compare the per-mesh signatures kept above.
+    // Keep frame identity and object metadata after presentation; BufferGeometry owns the geometry bytes and per-mesh signatures support reuse checks.
     this.frame = { ...next, meshes: {}, volumes: {}, images: {} };
     this.worldKey = JSON.stringify(next.world ?? null);
     // THE OVERLAYS, after the graph stands: the weight drawing is laid over
     // the presented mesh's own geometry and the bones over the armature
     // OBJECT's Blender matrix, so both need this frame's objects in place.
-    const overlayWarnings = this.applyOverlays(next);
+    const overlayWarnings = [...this.applyOverlays(next), ...this.nameRefusals(next.objects)];
     if (overlayWarnings.length)
       this.frame = { ...this.frame, warnings: [...this.frame.warnings, ...overlayWarnings] };
     // Visibility is read off the frame, so it is applied once the frame stands.
@@ -2338,6 +2538,36 @@ export class BlenderRuntimeView {
     return { ...this.inspect(), held };
   }
 
+  /** The meshes this presenter holds but could not draw, by mesh id, with the reason. */
+  refusedMeshes(): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const [id, entry] of this.meshes) {
+      const reason = entry.geometry.userData[REFUSED_GEOMETRY];
+      if (typeof reason === 'string') out[id] = reason;
+    }
+    return out;
+  }
+
+  /** Every held mesh that could not be drawn, named with the objects that show it: a frame
+   *  warning each frame, and on the editor's console once per mesh, revision and reason. */
+  private nameRefusals(objects: readonly { name: string; mesh: string | null }[]): string[] {
+    const said: string[] = [];
+    for (const [id, reason] of Object.entries(this.refusedMeshes())) {
+      const users = objects.filter((obj) => obj.mesh === id).map((obj) => JSON.stringify(obj.name));
+      const shown = users.length > 8 ? `${users.slice(0, 8).join(', ')} and ${users.length - 8} more` : users.join(', ');
+      const line = `The presenter skipped mesh ${JSON.stringify(id)}` +
+        (users.length ? ` (${users.length > 1 ? 'objects' : 'object'} ${shown})` : '') +
+        `, which it cannot draw: ${reason}. The rest of the document presents; the mesh is drawn again once it changes.`;
+      said.push(line);
+      const key = `${id}\u0000${this.meshes.get(id)?.signature}\u0000${reason}`;
+      if (NAMED_REFUSALS.has(key)) continue;
+      NAMED_REFUSALS.add(key);
+      // biome-ignore lint/suspicious/noConsole: the editor console captures console.warn session-wide; this is the report channel.
+      console.warn(`[blender] @@VOLTER-WARN ${line}`);
+    }
+    return said;
+  }
+
   inspect() {
     return {
       session: this.frame?.session,
@@ -2357,31 +2587,30 @@ export class BlenderRuntimeView {
   }
 
   drawStatistics() {
-    return {enabled: this.drawBatching, preparation: {...this.drawPreparation}, worldVisibility:this.worldVisibility.diagnostics(), materialRanges: this.materialRanges.inspect(), opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect(), motion: this.motionGeometry.inspect()};
+    return {enabled: this.drawBatching, preparation: {...this.drawPreparation}, materialRanges: this.materialRanges.inspect(), opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect(), motion: this.motionGeometry.inspect()};
   }
 
   snapshot() {
     return this.frame;
   }
 
-  /**
-   * A revision-owned render presenter, never a clone of the mounted scene.
-   * Copy the resident draw arrays and image bytes synchronously, then rebuild
-   * through the same frame contract. No live objects, callbacks, textures or
-   * disposable geometry cross this boundary; delta-only frames are sufficient.
-   * The caller owns this snapshot and must dispose it on every outcome.
-   */
+  /** The frame this view holds with no objects in it: its World, render and view settings. */
+  private worldFrame(): Frame {
+    const source = this.frame;
+    if (!source) throw new Error('Blender capture requires a presented frame');
+    return structuredClone({ ...source, objects: [], meshes: {}, materials: {}, instances: [], lights: {}, volumes: {}, images: {}, armatures: {}, weights: null });
+  }
+
   /** Everything this view holds, as ONE self-contained frame another view can be built from:
    *  every mesh's resident geometry and every resident image, with no reference to what a
    *  receiver already holds. */
-  private fullFrame(options: { sourceVertices?: boolean } = {}): Frame {
+  private fullFrame(): Frame {
     const source = this.frame;
     if (!source) throw new Error('Blender capture requires a presented frame');
     // Inspection overlays are not render content. In particular weight-paint
     // overlays reference source vertices, which the evaluated draw no longer
-    // needs and a render snapshot deliberately does not copy.
-    // A copy that plays keeps the armatures its skins bind to; a render snapshot draws no bones.
-    const frame: Frame = structuredClone({ ...source, images: {}, armatures: options.sourceVertices ? source.armatures : {}, weights: null });
+    // needs and a render snapshot deliberately does not copy. A render snapshot draws no bones.
+    const frame: Frame = structuredClone({ ...source, images: {}, armatures: {}, weights: null });
     for (const [id, { signature, geometry }] of this.meshes) {
       const attribute = (name: string): Float32Array<ArrayBuffer> | null => {
         const value = geometry.getAttribute(name);
@@ -2417,20 +2646,6 @@ export class BlenderRuntimeView {
           count: group.count,
           materialIndex: group.materialIndex ?? 0,
         })),
-        // A COPY THAT PLAYS keeps the draw's vertex map: Play binds skins over it (a Blender
-        // vertex's weights expand onto its drawn vertices through it), where a render snapshot
-        // needs none.
-        ...(options.sourceVertices && geometry.getAttribute('blenderVertex')
-          ? { sourceVertex: new Uint32Array((geometry.getAttribute('blenderVertex') as THREE.BufferAttribute).array) }
-          : {}),
-        // A COPY THAT PLAYS keeps its skin too, per drawn vertex, so its own skeletons bind it.
-        ...(options.sourceVertices && geometry.userData['blenderSkin'] && geometry.getAttribute('skinIndex')
-          ? { skin: {
-              ...(geometry.userData['blenderSkin'] as { armature: string; groups: string[] }),
-              index: new Uint16Array((geometry.getAttribute('skinIndex') as THREE.BufferAttribute).array),
-              weight: new Float32Array((geometry.getAttribute('skinWeight') as THREE.BufferAttribute).array),
-            } }
-          : {}),
       };
     }
     for (const [id, { signature }] of this.volumes)
@@ -2459,7 +2674,7 @@ export class BlenderRuntimeView {
           colorspace: held.encoded.colorspace,
         };
       } else {
-        const data = held.texture.image?.data;
+        const data = (held.texture.image as { data?: unknown } | null | undefined)?.data;
         if (!(data instanceof Uint8Array))
           throw new Error(`Blender capture image ${name} has no resident raster`);
         frame.images[name] = {
@@ -2503,13 +2718,13 @@ export class BlenderRuntimeView {
   }
 
   /**
-   * A COPY OF THE MODEL THAT NO LONGER FOLLOWS IT, for Play: the graph `follow` builds, from the
-   * frame this view holds now, and handed nothing afterwards. What moves its objects is the
-   * caller's; Blender's data and this view never see it, and disposing it is the whole undo.
+   * THE WORLD OF THE MODEL, FOR PLAY: a view of the World and the scene's settings this view holds now, with none of
+   * the model's objects (a game over the standard artifact brings its own, RFC 0007), handed nothing afterwards.
+   * Blender's data and this view never see it, and disposing it is the whole undo.
    */
   detach(): { readonly view: BlenderRuntimeView; dispose(): void } {
     const detached = new BlenderRuntimeView();
-    if (this.frame) detached.applyFrame(this.fullFrame({ sourceVertices: true }));
+    if (this.frame) detached.applyFrame(this.worldFrame());
     let disposed = false;
     return {
       view: detached,
@@ -2522,6 +2737,13 @@ export class BlenderRuntimeView {
     };
   }
 
+  /**
+   * A revision-owned render presenter, never a clone of the mounted scene.
+   * Copy the resident draw arrays and image bytes synchronously, then rebuild
+   * through the same frame contract. No live objects, callbacks, textures or
+   * disposable geometry cross this boundary; delta-only frames are sufficient.
+   * The caller owns this snapshot and must dispose it on every outcome.
+   */
   captureSnapshot() {
     const frame = this.fullFrame();
     const source = this.frame!;
@@ -2556,7 +2778,7 @@ export class BlenderRuntimeView {
       },
       prepareDraw:(renderer:THREE.WebGLRenderer,camera:THREE.Camera)=>{
         if(disposed)throw new Error('Blender capture snapshot is disposed');
-        return detached.prepareDraw(camera,{interactive:false,height:renderer.domElement.height,renderer});
+        return detached.prepareDraw(camera,{interactive:false,height:renderer.domElement.height,renderer,photograph:true});
       },
       dispose,
     };
@@ -2584,7 +2806,7 @@ export class BlenderRuntimeView {
       },
       prepareDraw: (renderer, camera) => {
         if (disposed) throw new Error('Blender capture snapshot is disposed');
-        return this.prepareDraw(camera, { interactive: false, height: renderer.domElement.height, renderer });
+        return this.prepareDraw(camera, { interactive: false, height: renderer.domElement.height, renderer, photograph: true });
       },
       dispose: () => {
         if (disposed) return;
@@ -2632,9 +2854,8 @@ export class BlenderRuntimeView {
   }
 
   /** THE OBSERVATION DOOR onto both records, for whoever is grading this tab
-   *  from outside (`packages/blender-engine/bench/battery/capture_live_model.mts`
-   *  reads it through the editor's document REPL and writes the two files a
-   *  replay compares). Nothing in the product reads it. */
+   *  from outside through the editor's document REPL. Nothing in the product
+   *  reads it. */
   observations() {
     return { presentation: this.submitted, photographs: this.photographs };
   }
@@ -2642,7 +2863,6 @@ export class BlenderRuntimeView {
   private clear() {
     this.skeletons.dispose();
     this.skinBinds = new WeakMap();
-    this.worldVisibility.dispose();
     this.objectInfoMaterials.clear();
     this.materialRanges.clear();
     this.motionGeometry.clear();
@@ -2691,6 +2911,8 @@ export class BlenderRuntimeView {
     this.extrasOverlay.dispose();
     for (const material of this.workbenchMaterials.values()) material.dispose();
     this.workbenchMaterials.clear();
+    this.outline.dispose();
+    this.visibleReceivers.dispose();
     this.frame = null;
     this.retiredSessions.clear();
     this.submittedMeshes.clear();