@volter/editor-threejs 0.5.210 → 0.5.212

package/src/kit/editor-viewport.ts

@@ -1,14 +1,14 @@
 import type { SparkRenderer } from '@sparkjsdev/spark';
-import { invalidateStages } from '@volter/sdk/kit/stage-invalidation';
+import { invalidateStages } from '@volter/sdk/stage-invalidation';
 import { StagePresentationRig } from './components/standard-viewport-dressing';
 import {
   bindViewPresentation,
   subscribeViewportPresentation,
   type ViewportOverlays,
   viewPresentation,
-} from '@volter/sdk/kit/viewport-presentation';
+} from '@volter/sdk/viewport-presentation';
 import { themeVars, zIndex } from '@volter/sdk/widgets';
-import type { AssetDropContext, AuthoringAdapter } from '@volter/project/adapter';
+import type { AuthoringAdapter } from '@volter/project/adapter';
 import {
   EDITOR_CAMERA_FAR,
   EDITOR_CAMERA_NEAR,
@@ -33,7 +33,7 @@ import {
 import * as THREE from 'three';
 import { axisViewName, isQuarterTurnUp } from './asset-workflow/model-inspection';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
-import { TransformControls } from 'three/addons/controls/TransformControls.js';
+import { TransformControls, type TransformControlsGizmo } from 'three/addons/controls/TransformControls.js';
 import { LineMaterial } from 'three/addons/lines/LineMaterial.js';
 import { LineSegments2 } from 'three/addons/lines/LineSegments2.js';
 import { LineSegmentsGeometry } from 'three/addons/lines/LineSegmentsGeometry.js';
@@ -41,18 +41,16 @@ import { BatchedRenderer } from 'three.quarks';
 import {
   applyAuthoringTransform,
   beginAuthoringTransformEdit,
-  dropAuthoringAsset,
   endAuthoringTransformEdit,
   setAuthoringSelection,
   spatialHandlesForAdapter,
-} from '@volter/sdk/kit/authoring/consumer-actions';
-import { beginLiveGesture, endLiveGesture } from '@volter/sdk/kit/live-gesture-lock';
-import { drillIntoSelectionScope, pickAcrossScopeExit } from '@volter/sdk/kit/authoring/selection-scope';
+} from '@volter/sdk/authoring/consumer-actions';
+import { beginLiveGesture, endLiveGesture } from './live-gesture-lock';
+import { drillIntoSelectionScope, pickAcrossScopeExit } from '@volter/sdk/authoring/selection-scope';
 import { setViewportPickContext } from './authoring/viewport-pick-context';
-import { isRootHidden } from '@volter/sdk/kit/authoring/world-session-state';
-import type { CameraViewMode } from './camera-authoring';
+import { isRootHidden } from '@volter/sdk/authoring/world-session-state';
 import { type ConstraintControl, ConstraintHelper } from './constraint-helper';
-import { editorConsole } from '@volter/sdk/kit/editor-console';
+import { editorConsole } from '@volter/sdk/editor-console';
 import type { EditorShellStore } from './editor-shell-store';
 import { findEntityLod } from './entity-lod';
 import { entityIdOf, entityObject3D } from './entity-object';
@@ -69,8 +67,7 @@ import {
   nativeViewportSelectionBox,
   nativeViewportWire,
   subscribeNativeSelectionTheme,
-} from '@volter/sdk/kit/native-selection-style';
-import { presentationRegionBasis } from '@volter/sdk/kit/presentation-surface';
+} from '@volter/sdk/native-selection-style';
 import { ReflectionProbeHelper } from './reflection-probe-helper';
 import { frameableContentBounds, seededViewShowsWorld, viewFromGameCamera } from './scene-framing';
 import {
@@ -86,22 +83,21 @@ import { perspectiveDistanceToFitBox } from './three-viewport/camera-fit';
 import { SelectionBrackets } from './three-viewport/selection-brackets';
 import { collectThreeSelectionOutlineTargets } from './three-viewport/selection-outline';
 import { toneMappedSourceColor } from './three-viewport/source-color';
-import type { ThreeViewportProjection } from '@volter/sdk/kit/three-viewport-presentation';
-import { showTransientHint } from '@volter/sdk/kit/transient-hint';
-import { activeKeymapNavigation, subscribeEditorKeymap } from '@volter/sdk/kit/keymap-presets';
+import type { ThreeViewportProjection } from './three-viewport-presentation';
+import { showTransientHint } from '@volter/sdk/transient-hint';
+import { editorHost } from '@volter/sdk/host';
 import { TriggerVolumeHelper } from './trigger-volume-helper';
 import { viewportAuthoringPolicy } from './viewport-authoring-policy';
 import { ensureThreeIntegration } from './three-integration';
 
-/** A bounds box or LineSegments wireframe tagged with its source entity object. */
 /** A selected mesh's wireframe (the view's `selection.wire` overlay, Unity's Selection Wire):
  *  a stage-owned line set that copies the mesh's world matrix each frame, never a child of it. */
 interface WireHelper extends THREE.LineSegments {
   _wireOf?: THREE.Object3D;
 }
 
-interface TaggedHelper extends ContentBoundsHelper {
-  isBoxHelper: boolean;
+/** The source tag on a diagnostic wire cube; other helper kinds have no tag. */
+interface TaggedHelper {
   _entityObj?: THREE.Object3D;
 }
 
@@ -132,30 +128,11 @@ export function topmostPublishedObjects(
   return roots;
 }
 
-/** Topmost live objects among an exact add/remove delta; removed ids contribute nothing. */
-export function topmostChangedObjects(
-  objectMap: ReadonlyMap<string, THREE.Object3D>,
-  changedIds: ReadonlySet<string>,
-): THREE.Object3D[] {
-  const changed = new Set<THREE.Object3D>();
-  for (const id of changedIds) {
-    const object = objectMap.get(id);
-    if (object) changed.add(object);
-  }
-  return [...changed].filter((object) => {
-    for (let parent = object.parent; parent !== null; parent = parent.parent) {
-      if (changed.has(parent)) return false;
-    }
-    return true;
-  });
-}
-
 /**
- * Everything the viewport parks in `_boxHelpers`: the Bounds diagnostic's
- * plain full boxes (and its degenerate-entity wire cubes), plus selection
- * brackets for nodes that have no renderable silhouette. They share one map
- * because every consumer treats them identically — hide for the camera
- * preview, re-add on `setScene`, refresh each frame, dispose on rebuild.
+ * The Bounds diagnostic's boxes and degenerate-entity wire cubes, selected
+ * mesh wires, and selection brackets. They share visibility, scene transfer
+ * and disposal; each frame updates bounds and brackets, copies mesh-wire
+ * matrices, or follows a tagged cube's source position.
  */
 type BoundsHelper = ContentBoundsHelper | THREE.LineSegments | SelectionBrackets;
 
@@ -174,16 +151,10 @@ const DEGENERATE_HELPER_SIZE = 0.5;
  *  streaming itself in is reached within a second. */
 const CONTENT_BOUNDS_MAX_AGE_MS = 1000;
 
-/** The two ground-plane normals a region's declared basis selects between.
- *  Shared constants: `Plane.set` copies the normal, so nothing here is handed a
- *  reference it could mutate. */
-const UP_Y = new THREE.Vector3(0, 1, 0);
-const UP_Z = new THREE.Vector3(0, 0, 1);
-
 /** Scratch for the clip-plane fit — one per module, same reason as
  *  `content-bounds.ts`'s `nodeBox`. */
 const _clipSphere = new THREE.Sphere();
-/** Gizmo-anchor scratch — see the two pivot branches in `_syncSelection`. */
+/** Gizmo-anchor scratch — see the two pivot branches in `syncFromStore`. */
 const _medianTmp = new THREE.Vector3();
 const _pivotPos = new THREE.Vector3();
 const _pivotQuat = new THREE.Quaternion();
@@ -205,8 +176,7 @@ const VC_DIRS: THREE.Vector3[] = [
 /**
  * THE EDITOR'S OWN TRANSFORM-GIZMO AXIS COLOURS (X/Y/Z), used when the look names no
  * `color.gizmo` group. Their values are Godot's editor axis colours (`theme_modern.cpp`,
- * `axis_x_color`…). Kept as plain `[r,g,b]` triples: call sites construct their own
- * `new THREE.Color(...)`, so nothing here can be mutated in place.
+ * `axis_x_color`…). Plain sRGB triples become fresh Color values through `_gizmoAxisColor`.
  */
 const KIT_GIZMO_AXIS_RGB: readonly [number, number, number][] = [
   [0.96, 0.2, 0.32], // X
@@ -232,9 +202,8 @@ const KIT_GIZMO_AXIS_RGB: readonly [number, number, number][] = [
  * spellings, and the matrix is the authority — see
  * `blender-runtime-view.ts`'s constructor.
  *
- * Chosen by the look (`StageContribution.upAxis`), never by the
- * document: the stage draws one world at a time and the look is what states
- * which program's viewport this is.
+ * Chosen by the view presentation's world frame through `setStageFunction`.
+ * The look supplies the gizmos' paint and dimensions.
  */
 type StageAxisFrame = readonly (readonly [axis: number, sign: 1 | -1])[];
 const AXIS_FRAME_Y_UP: StageAxisFrame = [
@@ -257,46 +226,9 @@ const AXIS_FRAME_Z_UP_LEFT: StageAxisFrame = [
 /** The label a source axis index carries on the navigation gizmo. */
 const AXIS_LETTER = ['X', 'Y', 'Z'] as const;
 
-/**
- * An ONLINE asset dropped on the viewport — the asset browser's drag payload,
- * verbatim. An `url` means the file to fetch is already known; without one the
- * source has to be asked for its file list first.
- */
-export interface OnlineAssetDrop {
-  readonly source: string;
-  readonly id: string;
-  readonly name: string;
-  readonly url?: string;
-  readonly format?: string;
-  readonly includes?: { relativePath: string; url: string; size: number }[];
-}
-
-/**
- * THE VIEWPORT'S ONE DOOR TO THE ONLINE ASSET LIBRARY — a collaborator the
- * SHELL installs, never a transport the viewport imports (ARCHITECTURE-CORE
- * §Editor chrome, "the viewport stack is separable").
- *
- * The viewport contributes what only it knows: the world point under the
- * cursor, and the adapter that owns what a dropped path MEANS. Everything the
- * download needs — the asset cache, the source's file list, the project's
- * download history, and the console report when it fails — is the shell's
- * (`world-root-stage.ts` installs it over `editor-api.ts` +
- * `asset-editor-persistence.ts`, which together weigh 64 files the gizmo
- * viewport otherwise carries to place a chair).
- *
- * Returns the PROJECT-LOCAL path to hand the adapter's `assetDrop`, or `null`
- * when the asset could not be resolved — in which case the resolver has
- * already SAID SO on the console, so the viewport stays quiet. A rejection is
- * the resolver failing to report at all, and the viewport reports that itself.
- */
-export type OnlineAssetResolver = (asset: OnlineAssetDrop) => Promise<string | null>;
-
 export interface EditorViewportOptions {
   /** Native renderer for renderer-coupled Three extensions such as Spark. */
   readonly renderer?: THREE.WebGLRenderer;
-  /** How a dropped ONLINE asset becomes a project path. Omit and an online
-   *  drop is REFUSED BY NAME on the console — see {@link OnlineAssetResolver}. */
-  readonly onlineAssetResolver?: OnlineAssetResolver;
   /** Document-local adapter. Omit for the editor's active project adapter. */
   readonly authoring?: () => AuthoringAdapter;
   /** Document-local picking when this viewport is not the project viewport. */
@@ -304,48 +236,15 @@ export interface EditorViewportOptions {
   /** The camera the stage draws with, when that is not the viewport's own (a document session's
    *  orthographic or camera view): screen tests such as the box select project through it. */
   readonly drawCamera?: () => THREE.Camera;
-  /** Only the one project viewport publishes the legacy global pick context. */
+  /** Only the one project viewport publishes the global pick context. */
   readonly publishPickContext?: boolean;
   readonly onProjectionChange?: (projection: ThreeViewportProjection) => void;
-  /**
-   * How far the canvas BLEEDS past the box a person can see, in CSS px.
-   *
-   * A document stage inflates its canvas (`StageHost.tsx`, `inset: -12`) so
-   * the image fills the dock panel edge to edge, and gives the DOM furniture
-   * that bleed back (`inset: 12`) so the chrome stays inside the panel. The
-   * ORIENTATION GIZMO is drawn on the canvas, not in the DOM, so it never got
-   * that correction: measured on the Model stage, the canvas runs to page x
-   * 1437.5 where the panel ends at 1419, and the gizmo — placed 5 px from the
-   * CANVAS edge — had its −Z ball cut off by the Inspector. That is the same
-   * defect the furniture's own docblock records fixing for the navigation
-   * cluster. One value, set from the one expression that positions the DOM
-   * furniture; every other host leaves it 0.
-   */
+  /** Canvas bleed in CSS pixels. Inset the canvas-rendered compass by the same amount that positions the DOM furniture inside the visible panel. */
   readonly chromeInsetPx?: number;
-  /**
-   * The editor's own DESIGN-TIME LIGHT RIG (the ambient and the directional
-   * this class adds to every scene it is given). Default on. `false` is a
-   * host saying the content lights itself — which is the same thing a
-   * document says by turning the standard dressing's key light off, and the
-   * rig has to hear it. MEASURED: the rig's lights sit on `EDITOR_LAYER`,
-   * but three filters lights by the CAMERA's layers
-   * (`WebGLRenderer.projectObject`), and the camera that draws a document
-   * stage enables that layer so it can see the grid and the gizmo — so the
-   * layer scopes the rig away from nobody, and a document lit by its own
-   * view-locked studio was being lit by this as well.
-   */
+  /** Enable the editor light rig by default. Hosts whose content supplies its own lighting disable it explicitly. */
   readonly lightRig?: boolean;
 }
 
-/**
- * The floor grid as a shader over one plane (`extent` metres square, y = 0).
- * Lines are `fwidth`-antialiased so they keep one on-screen width at every
- * distance; the 1 m level fades out where its cells fall under a few pixels
- * (Blender's adaptive grid never lets lines merge), the 10 m level stays; the
- * whole floor fades to its edge. `uColor` is the palette's grid colour
- * (`_applyViewportLook`). Depth-tested, never written: content standing on
- * the floor occludes it, and it occludes nothing.
- */
 /**
  * THE STAGE'S FIELD OF VIEW, as the view states it (`ViewportCamera.fov`): an angle held on one
  * side of the region — vertical, horizontal, the larger or the smaller — so a panel that widens
@@ -404,23 +303,7 @@ function hsvToColor(h: number, s: number, v: number, out: THREE.Color): THREE.Co
 }
 
 
-/**
- * One ball of the navigation gizmo: filled with its letter (a positive axis),
- * or the ring Blender draws for a negative one.
- *
- * BOTH FORMS MUST REACH THE SAME EDGE, and they did not. The disc was filled
- * to `size/2 − 5` while the ring's 8 px stroke straddled that radius and
- * reached `size/2 − 1`, so a POSITIVE ball drew 0.844 of its sprite and a
- * negative one 0.969 — measured live on the Model stage, +X came out 11.8 CSS
- * beside −X's 15.5, the filled ball SMALLER than the hollow one beside it.
- * Blender's are one size (its variation is depth, which the caller applies).
- * One outer radius here, the ring's stroke laid inside it.
- *
- * THE LETTER is not black. Measured on Blender's +X ball: glyph ink
- * (88,19,29) over a (245,54,81) fill — 0.359 / 0.352 / 0.358 of the ball's
- * own colour, one ratio in all three channels, so it is the axis colour
- * darkened rather than a neutral. Cap height 7.5 CSS on a 17.5 CSS ball.
- */
+/** Draw positive-axis balls filled with dark letters and negative-axis balls as rings, with equal outer extents. */
 const COMPASS_LETTER_INK = 0.356;
 const COMPASS_LETTER_CAP_FRACTION = 7.5 / 17.5;
 
@@ -502,44 +385,7 @@ function compassGlyphTexture(text: string): THREE.CanvasTexture {
  *  three-quarter view (`ViewportCamera.opening`). */
 const STAGE_OPENING_DIRECTION = new THREE.Vector3(1, 0.72, 1).normalize();
 
-/**
- * THE COMPASS'S BOX, AND THE GIZMO'S OWN SIZES — re-measured 2026-09-19 from
- * `modeling-edit-none.png` and `modeling-object-none.png` at their native 2x,
- * and the numbers they replace were not small errors.
- *
- * THE METHOD, because a ball-centre distance read straight off the frame is
- * the wrong number: every axis is FORESHORTENED by the view, so the one thing
- * that can be measured is the projection. The main camera's own basis comes
- * out of the floor calibration (see {@link GRAZING_FADE_GLSL}); an axis `a`
- * lands at `R · (a·right, −a·up)` from the gizmo's centre, and the three
- * NEGATIVE balls (no stalk to contaminate a centroid) then give three
- * equations for `R` and the centre. Solved: R = 63.9 device px = **31.96 CSS**
- * with the centre at (2734.2, 257.3) device, cross-checked by the third ball
- * to within one device pixel and by the ink bbox (2·R·0.9155 + ball = 150
- * device against 149 measured). The previous `28` came from reading a
- * foreshortened distance as if it were the radius.
- *
- * BALL DIAMETER is not one number either: Blender scales it with DEPTH, which
- * an orthographic gizmo camera does not do for free. Six balls, against
- * `facing` = (axis·view + 1)/2 — the same quantity
- * `_syncOrientationGizmoDepth` already fades with:
- *
- *   facing   0.09   0.28   0.32   0.68   0.72   0.91
- *   d (CSS)  15.25  15.75  16.12  17.00  16.75  17.50
- *
- * — a straight line, `d = 15.0 + 2.75·facing`, residual ≤ 0.25 CSS on all six.
- *
- * PLACEMENT, measured identically in both frames: the gizmo's coloured ink
- * spans 74.5 × 73.5 CSS centred on that solved centre, its right edge 8.5 CSS
- * inside the region's right edge and its top 38 CSS below the region's top.
- * (The old `14` and `39.5` were the same reading taken against a smaller
- * drawn circle.) The navigation cluster's first glyph sits 16 CSS under the
- * ink, its glyphs 16 CSS on a 30 CSS pitch — which ours already draws
- * exactly, so only where the cluster STARTS moves.
- *
- * The box is the scissored square the gizmo draws into; the geometry reaches
- * `stalk + ball/2` = 40.2 px from the centre, so 90 still contains it.
- */
+/** Navigation-gizmo dimensions in CSS pixels, shared by sprite geometry and its canvas box. */
 export const COMPASS_BOX_PX = 90;
 /** Blender's gizmo sphere: the distance from the centre to a ball's centre. */
 const COMPASS_STALK_PX = 32;
@@ -558,59 +404,11 @@ const COMPASS_MARGIN_TOP_PX = 38 + COMPASS_INK_HEIGHT_PX / 2 - COMPASS_BOX_PX /
  *  `stage.chrome.viewName` `gizmo`). */
 export const COMPASS_CENTER_RIGHT_PX = COMPASS_MARGIN_RIGHT_PX + COMPASS_BOX_PX / 2;
 export const COMPASS_INK_BOTTOM_PX = COMPASS_MARGIN_TOP_PX + COMPASS_BOX_PX / 2 + COMPASS_INK_HEIGHT_PX / 2;
-/**
- * Where the navigation cluster starts. Blender's first GLYPH sits 16 CSS
- * under the gizmo's ink; the cluster component pads 14.5 CSS above its own
- * first glyph (measured on our frame), so the constant is that gap less the
- * padding.
- */
+/** Navigation-cluster top offset after subtracting the component’s own padding from the desired gap. */
 export const COMPASS_CLUSTER_TOP_PX =
   COMPASS_MARGIN_TOP_PX + COMPASS_BOX_PX / 2 + COMPASS_INK_HEIGHT_PX / 2 + 16 - 14.5;
 
-/**
- * THE GRAZING FADE — the floor's depth, transcribed from Blender's own frames.
- *
- * The radial band below keeps a finite grid off a hard rim; it says nothing
- * about DEPTH, and at a document camera standing 11 m from a 1 m subject the
- * band (110–200 m) never engages inside the visible floor. Measured on our
- * Model stage: the 1 m line reads 84 and the X axis `203,41,63` at EVERY
- * depth, from the front of the frame to the horizon — a flat lattice, which
- * is what a fresh viewer names first.
- *
- * WHAT BLENDER DOES, measured (not read out of its source): calibrate
- * `modeling-edit-none.png` from its own floor — fit the two axis lines, index
- * the 1 m grid crossings along each (a 1D projective map, residual <0.05 of a
- * cell), and solve the camera from the two vanishing points with the
- * principal point at the region centre. That gives f = 1976 device px
- * (Blender's viewport lens: 50 mm on its DEFAULT_SENSOR_WIDTH of 72 mm),
- * camera 17.96 m out at elevation 26.46°, azimuth −23.82° — which reproduces
- * the elevation and azimuth Blender's opening direction was independently
- * solved from (`@volter/editor-blender`'s presentation), so the calibration is
- * checked against something already in this repo. Sampling the X axis at thirteen known floor points, its ink over
- * the `#3f3f3f` floor, IN LINEAR LIGHT (the blend happens before the sRGB
- * encode — read as sRGB levels the profile fits nothing):
- *
- *   camera dist  12.3   15.6   22.2   28.6   45.9   70.5   115.2  (metres)
- *   alpha        0.943  0.963  0.872  0.766  0.572  0.426  0.258
- *   1-(1-h/r)^4  0.985  0.944  0.832  0.731  0.535  0.383  0.250
- *   ratio        0.957  1.020  1.048  1.048  1.068  1.113  1.033
- *
- * So the fade is `1 - (1 - |V·n|)^4` over the unit fragment→camera vector and
- * the floor normal — the GRAZING ANGLE, flat to ±6% across a 9x range of
- * distance. Two frames of the same scene at different view distances
- * (`modeling-near.png`, `modeling-far.png`) put the axis at the same PIXELS
- * with ink within 3–5%, which is the same statement: the profile follows the
- * angle, not the metres.
- *
- * WHERE THE EVIDENCE STOPS: Blender also carries a far-distance term, and
- * these frames cannot size it — at 115 m from an 18 m camera the residual is
- * still flat, so whatever its onset is, it is past everything photographed.
- * Not transcribed; the band below is what ends our finite floor.
- *
- * Scale-free by construction: the fade is a ratio of camera height to
- * distance, so a 1 m subject framed like Blender's 2 m one fades identically
- * at the same pixels.
- */
+/** Fade the floor by the ratio of camera height to distance, independent of subject scale. */
 export const GRAZING_FADE_GLSL = /* glsl */ `
 float volterGrazingFade(vec3 worldPosition, vec3 eye, vec3 planeNormal, float amount) {
   vec3 toEye = eye - worldPosition;
@@ -628,26 +426,7 @@ const AXIS_SEGMENT_METRES = 2;
 /** Segments per axis (both directions from the origin). */
 const AXIS_SEGMENTS_PER_AXIS = (AXIS_HALF_LENGTH * 2) / AXIS_SEGMENT_METRES;
 
-/**
- * The X and Z axis lines as a CHAIN of short segments rather than one segment
- * each, so the grazing fade below can read a per-fragment world position.
- *
- * WHY, measured: a line through the origin always runs BEHIND the camera in
- * one direction, and `LineMaterial` trims such a segment against the camera
- * plane while building its screen-space quad (`trimSegment`). A varying
- * carried from the UNTRIMMED endpoints then interpolates across a quad whose
- * clip `w` went through zero, and the reconstruction is meaningless: probed
- * on the live Model stage with the fragment's own `|Δy|/|Δ|` written out as
- * grey, a 400 m segment read 0.027–0.045 down the whole visible line where
- * the true grazing sine runs 0.20–0.70 — i.e. pinned near the far endpoint's
- * value, and the axis faded flat to a tenth of its colour everywhere. Over a
- * 2 m segment the interpolation is exact wherever the segment is in front of
- * the camera, and the one segment that straddles the camera plane is 2 m of
- * line at the edge of the frame. (three's own answer to this is the
- * `worldUnits` path, which carries BOTH endpoints as constant varyings and
- * solves for the fragment — but that path also makes `linewidth` a world
- * measure, and this line's 2 device px is measured.)
- */
+/** Build axis lines from short segments so the grazing fade interpolates positions across clipped screen-space quads. */
 function axisSegmentPositions(threeAxis: number): number[] {
   const positions: number[] = [];
   for (let i = 0; i < AXIS_SEGMENTS_PER_AXIS; i++) {
@@ -663,7 +442,7 @@ function axisSegmentPositions(threeAxis: number): number[] {
 
 /**
  * Give the floor AXES the same grazing fade the floor grid takes, through the
- * same 0..1 amount object. It starts at 0 — today's flat axis — and
+ * same 0..1 amount object. It starts at 0 (no fade), and
  * `_applyViewportLook` raises it for a look that paints the viewport.
  */
 function applyAxisGrazingFade(
@@ -698,6 +477,15 @@ const _gridQuat = new THREE.Quaternion();
 const _gridEye = new THREE.Vector3();
 const _gridUp = new THREE.Vector3(0, 1, 0);
 
+/**
+ * The floor grid as a shader over one plane (`extent` metres square, y = 0).
+ * Lines are `fwidth`-antialiased so they keep one on-screen width at every
+ * distance; the 1 m level fades out where its cells fall under a few pixels
+ * (Blender's adaptive grid never lets lines merge), the 10 m level stays; the
+ * whole floor fades to its edge. `uColor` is the palette's grid colour
+ * (`_applyViewportLook`). Depth-tested, never written: content standing on
+ * the floor occludes it, and it occludes nothing.
+ */
 function createFloorGrid(extent: number): THREE.Mesh<THREE.PlaneGeometry, THREE.ShaderMaterial> {
   const geometry = new THREE.PlaneGeometry(extent, extent);
   geometry.rotateX(-Math.PI / 2);
@@ -715,7 +503,7 @@ function createFloorGrid(extent: number): THREE.Mesh<THREE.PlaneGeometry, THREE.
       uFadeEnd: { value: extent / 2 },
       // The grazing fade's amount, 0..1 — set by `_applyViewportLook` from
       // the one predicate that already decides whether a look paints the
-      // viewport at all. See {@link GRAZING_FADE_GLSL} for the measurement.
+      // viewport at all. {@link GRAZING_FADE_GLSL} computes its angle profile.
       uGrazingFade: { value: 0 },
       // The plane the grid lies in: the floor, or an axis-aligned orthographic view's own plane
       // (`EditorViewport.alignGridToView`). A unit axis.
@@ -756,12 +544,7 @@ function createFloorGrid(extent: number): THREE.Mesh<THREE.PlaneGeometry, THREE.
       uniform float uReach;
       varying vec3 vWorld;
       ${GRAZING_FADE_GLSL}
-      // Coverage of a line WIDTH device pixels across, with a one-pixel
-      // anti-aliased edge — so its core is FULL, the way Blender's is. The
-      // earlier form (1 - distance/width) was a triangle with no plateau:
-      // whether a line reached its own colour depended on where the nearest
-      // fragment centre happened to fall, and the measured peak wandered
-      // between 0.67 and 1 of it.
+      // Device-pixel line coverage with a full-strength core and a one-pixel antialiased edge.
       float gridLine(vec2 coord, float width) {
         vec2 d = max(fwidth(coord), vec2(1e-6));
         vec2 dist = abs(fract(coord - 0.5) - 0.5) / d;
@@ -791,12 +574,7 @@ function createFloorGrid(extent: number): THREE.Mesh<THREE.PlaneGeometry, THREE.
           float pixel = max(fwidth(world).x, fwidth(world).y);
           float bottomAlpha = uMinorFade * (1.0 - smoothstep(uUnit * 0.015625, uUnit * 0.25, pixel));
           float emphasis = top > 0.5 ? 1.0 : middle > 0.5 ? uMinorFade : 0.0;
-          // The theme's grid colour carries alpha 0x80 and its emphasis colour none, and the
-          // two colours here were fitted to Blender's PERSPECTIVE frames, where four additive
-          // passes (1 + 1/2 + 1/4 + 1/8) take that alpha to about 0.94. Drawn once, as an
-          // aligned view draws it, the grid colour keeps 0.502 / 0.941 of that. (Measured: the
-          // 10 cm lines +5 over the ground at 198 px per metre, predicted +5.4; the 1 m lines
-          // 89 against 88. The 0.94 is inferred from the passes, not read off a frame.)
+          // Normalize the theme grid alpha for a single aligned pass. Emphasis uses full opacity.
           float levelAlpha = (top > 0.5 || middle > 0.5 ? 1.0 : bottom * bottomAlpha) * mix(0.533, 1.0, emphasis);
           float edge = 1.0 - smoothstep(uFadeStart * uReach, uFadeEnd * uReach, length(world - uCenter));
           float alignedAlpha = levelAlpha * edge * uOpacity;
@@ -807,37 +585,17 @@ function createFloorGrid(extent: number): THREE.Mesh<THREE.PlaneGeometry, THREE.
         }
         vec2 pixelsPerMetre = 1.0 / max(fwidth(p), vec2(1e-6));
         float minorVisible = smoothstep(4.0, 14.0, min(pixelsPerMetre.x, pixelsPerMetre.y)) * uMinorFade;
-        // Both levels reach FULL strength in their own colour, as Blender's
-        // do: the 1 m line is measured at exactly the palette's grid colour
-        // and the 10 m line brighter than it (see uMajorColor). The minor
-        // level's only attenuation is its own drop-out as cells shrink.
+        // Fade minor lines as their cells approach pixel size.
         float minor = gridLine(p, uLineWidth) * minorVisible;
-        // The 10 m level is WIDER as well as brighter, which is what lets it
-        // reach full coverage — and so its full colour. Measured across one
-        // scanline of modeling-object-none.png at device resolution: the 1 m
-        // line is 4 px at half rise and plateaus at 83, the 10 m line is 6 px
-        // and plateaus at 101. At one shared width ours drew a 10 m line that
-        // never exceeded 0.75 coverage and so measured 91, not 102.
+        // Major lines use their own width and color.
         float major = gridLine(p / uMajorEvery, uMajorWidth);
         float line = max(minor, major);
         float fade = 1.0 - smoothstep(uFadeStart * uReach, uFadeEnd * uReach, length(world - uCenter));
-        // The floor's DEPTH, beside the band that ends its finite extent:
-        // Blender's own grazing-angle profile, transcribed from its frames
-        // (see GRAZING_FADE_GLSL above). Without it this lattice reads the
-        // same ink at the front of the frame and at the horizon.
+        // Apply the floor’s grazing-angle attenuation independently of its distance fade.
         fade *= volterGrazingFade(vWorld, cameraPosition, uPlaneNormal, uGrazingFade);
         float alpha = line * fade * uOpacity;
         if (alpha <= 0.002) discard;
-        // WHICH level a fragment belongs to is the major's SHARE of the
-        // coverage being drawn, never a comparison of the two and never the
-        // major's raw coverage. Every 10 m line is also a 1 m line, so there
-        // the two are equal: a step() between them compares values equal to
-        // within rounding and flips per fragment (photographed with the major
-        // forced white: the 10 m lines came out DOTTED), and mixing by the raw
-        // coverage dilutes the colour by the line's own anti-aliasing (the
-        // same lines then measured 91 where Blender's is 102). As a share it
-        // is exactly 1 wherever the major draws — core and skirt alike, and in
-        // the far field where the minor has dropped out — and 0 on a 1 m line.
+        // Mix colors by the major line’s share of coverage, including antialiased skirts.
         float majorShare = clamp(major / max(line, 1e-6), 0.0, 1.0);
         gl_FragColor = vec4(mix(uColor, uMajorColor, majorShare), alpha);
         #include <colorspace_fragment>
@@ -890,6 +648,8 @@ export class EditorViewport {
   readonly camera: THREE.PerspectiveCamera;
   readonly orthographicCamera: THREE.OrthographicCamera;
   readonly orbitControls: OrbitControls;
+  /** Fit clip planes only for the editor-owned camera; a live project camera retains its own projection. */
+  readonly projectionOwner = { owned: false };
   readonly transformControls: TransformControls;
   /** The rotate/scale halves of the 'combined' gizmo (Unity's Transform
    *  tool). Constructed always, shown only in combined mode — three's
@@ -906,16 +666,14 @@ export class EditorViewport {
   })();
   /** The floor: a shader grid (`createFloorGrid`), not line geometry. */
   readonly grid: THREE.Mesh<THREE.PlaneGeometry, THREE.ShaderMaterial>;
-  /** Keyed `bounds:<id>` / `selection:<id>` — the Bounds diagnostic and a
-   *  non-renderable selection fallback can both be live for the same entity.
-   *  Nothing reads a key back; the map exists so a rebuild can dispose exactly
-   *  what it made. */
+  /** Keyed `bounds:<id>`, `selection:<id>` or `wire:<id>:<index>` for diagnostic boxes,
+   *  selection brackets and mesh wires. A rebuild disposes every stored helper. */
   private _boxHelpers = new Map<string, BoundsHelper>();
-  /** The view's selection marks (`kit/viewport-presentation` overlays.selection): the native
+  /** The view's selection marks (`@volter/sdk/viewport-presentation` overlays.selection): the native
    *  outline is the stage's own switch; `box` brackets every selected object, not only those
    *  without geometry (Godot); `wire` draws the selected meshes' wireframes (Unity). */
-  private _selectionMarks = { outline: true, wire: false, box: false };
-  private _unsubscribeSelectionTheme: () => void = () => {};
+  private _selectionMarks = { wire: false, box: false };
+  private _unsubscribeSelectionTheme: () => void;
   private _constraintHelpers = new Map<string, ConstraintHelper>();
   private _constraintControlRaycaster = (() => {
     const raycaster = new THREE.Raycaster();
@@ -929,7 +687,7 @@ export class EditorViewport {
   private _cameraHelpers = new Map<string, { source: THREE.Camera; helper: THREE.CameraHelper }>();
   private _lightHelpers = new Map<
     string,
-    { source: THREE.Light; helper: THREE.Object3D & { update?(): void; dispose?(): void } }
+    { source: THREE.Light; helper: THREE.Object3D & { update(): void; dispose(): void } }
   >();
   private _audioHelpers = new Map<string, { source: THREE.Object3D; helper: THREE.Group }>();
   private _spatialHandleRoots: THREE.Object3D[] = [];
@@ -944,8 +702,8 @@ export class EditorViewport {
   private _spatialHandleDragPlane = new THREE.Plane();
   private _spatialHandleDragOffset = new THREE.Vector3();
   private _spatialHandleDragPoint = new THREE.Vector3();
-  private _orbitEnabledBeforeHandleDrag = true;
-  private _transformEnabledBeforeHandleDrag = true;
+  private _orbitEnabledBeforeHandleDrag!: boolean;
+  private _transformEnabledBeforeHandleDrag!: boolean;
   private _gizmoHelper: THREE.Object3D;
   private _editorAmbient: THREE.AmbientLight;
   private _editorDirLight: THREE.DirectionalLight;
@@ -953,53 +711,50 @@ export class EditorViewport {
   private readonly _lightRig: boolean;
 
   private _scene: THREE.Scene;
-  /** World AABB of the active scene's non-editor content, cached because
-   *  measuring it walks the whole graph (2k+ nodes for an ingested game).
-   *  Empty until the first refresh; see {@link _contentBounds}. */
+  /** Cached world AABB of non-editor content; empty until the first _contentBounds refresh. */
   private readonly _contentBoundsBox = new THREE.Box3();
   /** `performance.now()` of the last content-bounds measurement; 0 invalidates
    *  it (a scene swap), so the next reader re-measures immediately. */
   private _contentBoundsAt = 0;
-  private _renderer: THREE.WebGLRenderer | undefined;
+  private readonly _renderer: THREE.WebGLRenderer | undefined;
   private _sparkRenderer: SparkRenderer | null = null;
   private _sparkRendererLoading = false;
   private _sparkRendererFailed = false;
   private _lastSparkDiscoveryAt = Number.NEGATIVE_INFINITY;
   private _disposed = false;
   /** Editor infrastructure objects that must move with the active scene. */
-  private _editorObjects: THREE.Object3D[] = [];
+  private _editorObjects: THREE.Object3D[];
   /** The view presentation this stage is lit by, when bound (`bindPresentation`). */
   private _presentation: { readonly rig: StagePresentationRig; readonly stop: () => void } | null = null;
   /** The world's axis lines: WHICH show is the view's (`overlays.axes`, {@link setAxisLines}),
    *  their colours and width the look's (`color.viewport.axisX/Y/Z`, `axisLineWidth`). */
-  private _axisLines: LineSegments2 | null = null;
+  private _axisLines: LineSegments2 | null;
   /** The world's vertical axis line, a child of {@link _axisLines} (see `_rebuildAxisLines`). */
   private _verticalAxisLine: LineSegments2 | null = null;
   /** The look's axis-line width in device pixels (null: the editor's own), which an
    *  axis-aligned view sets aside for one pixel. */
-  private _axisLineWidth: number | null = null;
+  private _axisLineWidth!: number | null;
   /** A device-pixel width as `LineMaterial` takes it: CSS pixels, three keeping its viewport in
    *  CSS units. The editor's own is 2 CSS. */
   private _axisLineCss(device: number | null): number {
     return device === null ? 2 : device / (this._renderer?.getPixelRatio() ?? 1);
   }
-  private _axesWanted = false;
+  private _axesWanted!: boolean;
   private _stageAxes: ViewportOverlays['axes'] = 'floor';
   /** The look's axis colours by WORLD axis (X, Y, Z), each `null` for the gizmo's own. */
-  private _lookAxisHexes: readonly [number | null, number | null, number | null] = [null, null, null];
+  private _lookAxisHexes!: readonly [number | null, number | null, number | null];
   /** The palette's grid hex, kept for the same reason the axis hexes are. */
-  private _lookGridHex: number | null = null;
-  /** The palette background this viewport paints (the palette's sRGB hex) and
-   *  the colour actually set for it under the renderer's tone mapping, so a
-   *  theme or pipeline change replaces OUR colour and never a host's own. */
+  private _lookGridHex!: number;
+  /** The palette's background hex, used to recognize the viewport's own background
+   *  and preserve a host-supplied background. */
   private _lookBackgroundHex: number | null = null;
   private _lookToneMapping: THREE.ToneMapping | null = null;
-  private _lookExposure: number | null = null;
+  private _lookExposure!: number;
   /** The active look's `stage.gizmoSize`, px per Blender gizmo unit
    *  — null under every look that names none. Cached off the theme token
    *  rather than read per frame; {@link _applyGizmoSize} is what turns it into
    *  three's `size`. */
-  private _lookGizmoSizePx: number | null = null;
+  private _lookGizmoSizePx!: number | null;
   /** The stage's world up axis (its presentation's `world.upAxis`, `setStageFunction`), as
    *  the table every gizmo label and colour reads (see {@link StageAxisFrame}). Defaults to
    *  three's own frame. */
@@ -1010,23 +765,8 @@ export class EditorViewport {
    *  makes a delta enough. */
   private _appliedAxisSigns: readonly (1 | -1)[] = [1, 1, 1];
   /** The look's gizmo colours and highlight ({@link nativeGizmoLook}); all-null keeps the
-   *  editor's own (the kit's axis colours, three's yellow highlight, opaque handles). */
-  private _gizmoLook: NativeGizmoLook = {
-    axes: null,
-    navigation: null,
-    hover: null,
-    drag: null,
-    opacity: null,
-    arrowLength: null,
-    arrowHead: null,
-    ringWidth: null,
-    navigationSize: null,
-    navigationForm: 'balls',
-    background: null,
-    navigationCorner: 'top-right',
-    highlightSaturation: null,
-    highlightValue: null,
-  };
+   *  editor's own axis colours, three's yellow highlight and each handle's native opacity. */
+  private _gizmoLook!: NativeGizmoLook;
   /** The stage's box-select rule (its presentation's `interaction.boxSelect`) — `'touch'` is
    *  Blender's Select Box, `'contain'` (and null) the editor's own. Read by the marquee at the
    *  moment it resolves, never cached into the rectangle. */
@@ -1048,24 +788,19 @@ export class EditorViewport {
   /** Camera input belongs to the whole viewport surface, including authoring
    * overlays rendered above the WebGL canvas. */
   private _interactionElement: HTMLElement;
-  /** The interaction-element pointerup relay (see the ctor's binding comment). */
-  private _onInteractionPointerUp: ((e: PointerEvent) => void) | undefined;
-  /** The interaction-element dblclick relay — same targeting story as the
-   *  pointerup relay above (OrbitControls' pointer capture retargets the
-   *  clicks a `dblclick` is synthesized from). */
-  private _onInteractionDblClick: ((e: MouseEvent) => void) | undefined;
+  /** Relay double-clicks from the element OrbitControls captures. */
+  private readonly _onInteractionDblClick: (e: MouseEvent) => void;
   private readonly _authoring: () => AuthoringAdapter;
   private readonly _pick: ((clientX: number, clientY: number) => string | null) | undefined;
   private readonly _drawCamera: (() => THREE.Camera) | undefined;
   /** The camera on screen: the stage's drawing camera where it states one, else the viewport's.
    *  Every screen test asks it (picks, the box select, vertex snap, handles, the ground plane);
-   *  fly mode and the grid's own alignment keep the viewport's cameras, which they move. */
+   *  fly mode moves the viewport's camera; grid alignment takes its caller's camera. */
   private get _screenCamera(): THREE.Camera {
     return this._drawCamera?.() ?? this.renderCamera;
   }
   private readonly _standaloneAuthoring: boolean;
   private readonly _publishPickContext: boolean;
-  private readonly _onlineAssetResolver: OnlineAssetResolver | undefined;
   private readonly _onProjectionChange: ((projection: ThreeViewportProjection) => void) | undefined;
   private _pointerDownPos = new THREE.Vector2();
   private _skipNextSync = false;
@@ -1075,14 +810,14 @@ export class EditorViewport {
   /** True between a canvas pointerdown and its pointerup — see `_onPointerUp`. */
   private _pointerSessionActive = false;
   private _marqueeDiv: HTMLDivElement | null = null;
-  private _pointerDownButton = -1;
+  private _pointerDownButton!: number;
   private _altDragOrbit = false;
 
   // -- Orientation gizmo --
   private _vcScene = new THREE.Scene();
   private _vcCamera: THREE.OrthographicCamera;
   private _vcClickTargets: THREE.Mesh[] = [];
-  /** The gizmo's six balls and three stalks, kept for the per-frame depth
+  /** The gizmo's six balls and six stalks, kept for the per-frame depth
    *  cue (`_syncOrientationGizmoDepth`). */
   private _vcBalls: Array<{
     readonly fill: THREE.Sprite;
@@ -1100,7 +835,7 @@ export class EditorViewport {
     readonly positive: boolean;
     readonly color: THREE.Color;
   }> = [];
-  /** The cone form's cones: drawn front to back, never dimmed (Unity's are not). */
+  /** Cone heads and triad lines, depth-sorted without dimming. */
   private _vcSolids: Array<{ readonly mesh: THREE.Mesh; readonly direction: THREE.Vector3 }> = [];
   private _vcSize = COMPASS_BOX_PX;
   /** The view's navigation gizmo (`overlays.navigation`): clicked, only drawn, or neither. */
@@ -1112,54 +847,24 @@ export class EditorViewport {
   private _vcMarginRight = COMPASS_MARGIN_RIGHT_PX;
   private _vcMarginTop = COMPASS_MARGIN_TOP_PX;
   /** See {@link EditorViewportOptions.chromeInsetPx}. */
-  private _chromeInsetPx = 0;
+  private readonly _chromeInsetPx: number;
   /** Scratch dir vector reused each frame by renderViewCube (avoids per-frame alloc). */
   private _vcDir = new THREE.Vector3();
-  /** Scratch color reused by renderCameraPreview (avoids per-frame alloc). */
-  private _previewClearColor = new THREE.Color();
-  /** Transient camera view/pilot subject. The native camera remains owned by
-   *  the active adapter; this reference changes only viewport presentation. */
-  private _cameraView: THREE.Camera | null = null;
   private _projection: ThreeViewportProjection = 'perspective';
-  private _pendingProjection: ThreeViewportProjection | null = null;
-  private _viewportAspect = 1;
+  private _viewportAspect: number;
   /** The view's field of view (`ViewportCamera.fov`), held on its side as the region reshapes. */
   private _fieldOfView: StageFieldOfView = KIT_FIELD_OF_VIEW;
-  private _orthographicHeight = 10;
-  private _cameraViewMode: CameraViewMode | null = null;
-  private _orbitEnabledBeforeCameraView = true;
-  private _orbitTargetBeforeCameraView = new THREE.Vector3();
-  /** Last objectMap + visibility signature applied by syncFromStore's gizmo/helper
-   *  passes — lets those O(scene) loops skip when their inputs are unchanged (e.g.
-   *  during a transform drag, which notifies per frame but changes none of them). */
+  private _orthographicHeight!: number;
+  /** Inputs last reconciled by syncFromStore's helper membership and visibility work. */
   private _lastGizmoObjectMap: Map<string, THREE.Object3D> | null = null;
-  private _lastGizmoSig = '';
-  private _lastGizmoEpoch = -1;
-  /** Previous world-hidden eye state — edge detection for environment suppress/restore. */
-  /**
-   * Spec 28 — recomputed from surface visibility AND selection ownership on every
-   * `syncFromStore`; read by the per-frame render hooks (`renderViewCube`,
-   * `renderCameraPreview`) and the view-cube click path, which run between
-   * notifies and must not re-walk the composite 60×/s.
-   */
+  private _lastGizmoSig!: string;
+  private _lastGizmoEpoch!: number;
+  /** Selection ownership and surface visibility cached for helper, handle, gizmo and input consumers. */
   private _threejsToolContextActive = false;
   /** A three stage is painted here (selection or not) — the floor's and the compass's gate. */
   private _threeSurfaceShowing = false;
   private _vcRaycaster = new THREE.Raycaster();
 
-  // -- Asset drop --
-  private _dropOverlay: HTMLDivElement | null = null;
-  /**
-   * The ground the viewport drops assets and probe points onto. NOT a constant:
-   * it is re-read from the ACTIVE region's declared basis
-   * (`presentation-surface.ts`'s `presentationRegionBasis`) on every raycast,
-   * because a Z-up
-   * game's ground is not `y = 0` and the editor may not guess which it is
-   * (ARCHITECTURE-CORE §The editor protocol, "Zero inference"). Mutated in
-   * place rather than reallocated — this sits on a drag path, not a frame path.
-   */
-  private _groundPlane = new THREE.Plane(new THREE.Vector3(0, 1, 0), 0);
-
   // -- Multi-drag: track primary object's transform at drag start --
   private _dragStartPos = new THREE.Vector3();
   private _dragStartQuat = new THREE.Quaternion();
@@ -1218,30 +923,28 @@ export class EditorViewport {
    *  debug mesh, … — scene-root objects toggled by the Helpers menu. */
   private _helpers = new Map<string, THREE.Object3D>();
 
-  // -- NavMesh path-probe visuals (W1a Navigation window) --
-
-  // -- Snap-to-view animation --
+  // Snap-to-view animation.
   private _snapAnimating = false;
-  private _snapStartTime = 0;
+  private _snapStartTime!: number;
   private _snapDuration = 400;
   private _snapQ1 = new THREE.Quaternion();
   private _snapQ2 = new THREE.Quaternion();
-  private _snapDist = 0;
+  private _snapDist!: number;
 
   // -- Fly camera (right-click + WASD) --
   private _flyActive = false;
   private _snapHold = false;
   private _flyKeys = new Set<string>();
   private _flySpeed = 5;
-  private _flyEuler = new THREE.Euler(0, 0, 0, 'YXZ');
+  private _flyEuler = new THREE.Euler();
   private _rightMouseDown = false;
 
   constructor(
     canvas: HTMLCanvasElement,
     scene: THREE.Scene,
     store: EditorShellStore,
-    interactionElement: HTMLElement = canvas,
-    options: EditorViewportOptions = {},
+    interactionElement: HTMLElement,
+    options: EditorViewportOptions,
   ) {
     // The integration's registrations (the authoring policy this viewport asks, its verbs, the
     // view-state persistence) exist before any viewport does; idempotent.
@@ -1258,7 +961,6 @@ export class EditorViewport {
     this._standaloneAuthoring = options.authoring !== undefined;
     this._publishPickContext = options.publishPickContext ?? true;
     this._chromeInsetPx = options.chromeInsetPx ?? 0;
-    this._onlineAssetResolver = options.onlineAssetResolver;
     this._onProjectionChange = options.onProjectionChange;
 
     // Camera — enableAll so editor sees both game content (layer 0) and editor objects (layer 31)
@@ -1283,63 +985,35 @@ export class EditorViewport {
     this.orthographicCamera.layers.enableAll();
     this._syncOrthographicFromPerspective();
 
-    // Grid — with the standard distance fade (the dressing module owns the
-    // grid treatment), so it never ends on a hard rim or degenerates into
-    // convergence-line artifacts at the horizon.
-    // The floor is a SHADER grid, Blender's way: anti-aliased lines of a
-    // constant on-screen width (a line helper's one device pixel halved into
-    // the floor on every downsample — measured), a minor 1 m level that fades
-    // out where its cells get small so distance never merges it into a slab,
-    // a major 10 m level that stays, the palette's colour, and a fade to the
-    // floor's own edge so it never ends on a rim.
+    // Draw anti-aliased screen-width floor lines, adaptively fading fine levels while retaining the major grid and radial edge fade.
     this.grid = createFloorGrid(400);
     this.grid.layers.set(EDITOR_LAYER);
     scene.add(this.grid);
-    // Axis lines — the world's, which ones the view says (`_rebuildAxisLines`) — as
-    // screen-space two-pixel lines: a one-pixel line halves into the floor
-    // when a frame is downsampled (measured), Blender's are two.
+    // Draw world axes as screen-space lines sized by the viewport look and projection.
     const axisGeometry = new LineSegmentsGeometry();
-    axisGeometry.setPositions(axisSegmentPositions(0));
-    axisGeometry.setColors(new Array(AXIS_SEGMENTS_PER_AXIS * 2 * 3).fill(1));
     this._axisLines = new LineSegments2(
       axisGeometry,
       new LineMaterial({
         vertexColors: true,
-        linewidth: 2,
-        // Blended for draw order over the floor, but at FULL strength:
-        // Blender's axis plateaus at its flat theme colour (`#cb293f`,
-        // `#69aa15`, measured across the whole width of
-        // `modeling-object-none.png`), and an opacity here would make the
-        // stage's axis colour depend on whatever it happens to cross.
+        // Keep axis colours at full strength while blending their draw order over the floor.
         transparent: true,
         opacity: 1,
         depthWrite: false,
         toneMapped: false,
       }),
     );
-    // The axes take the floor's own grazing fade, because in the reference
-    // they ARE the floor: Blender draws both out of one overlay shader and
-    // one `fade`, and its X axis measures 0.96 of its colour at the front of
-    // the frame against 0.26 near the horizon. `LineMaterial` interpolates
-    // per-segment endpoints with the clip `w` intact, so a world-position
-    // varying taken from the segment's own ends is perspective-correct along
-    // the line — which is all a 400 m two-segment cross needs.
+    // Share the floor's grazing fade. LineMaterial interpolates the segment endpoints with
+    // clip w intact, keeping the world-position varying perspective-correct along each axis.
     applyAxisGrazingFade(
       this._axisLines.material as LineMaterial,
       this.grid.material.uniforms['uGrazingFade'] as { value: number },
       this.grid.material.uniforms['uPlaneNormal'] as { value: THREE.Vector3 },
     );
-    this._axisLines.visible = false;
     this._axisLines.layers.set(EDITOR_LAYER);
     scene.add(this._axisLines);
 
-    // The palette's viewport look is applied THROUGH the grid and the axis
-    // lines, so this subscription cannot be made before they exist:
-    // `subscribeNativeSelectionTheme` calls its listener SYNCHRONOUSLY once
-    // (native-selection-style.ts), and from higher in this constructor that
-    // first call read `this.grid.geometry` off an undefined grid — the whole
-    // viewport construction threw, and every 3D document died with
-    // "Cannot read properties of undefined (reading 'geometry')".
+    // Subscribe after constructing the grid and axis lines: subscribeNativeSelectionTheme
+    // invokes its listener synchronously, and that listener applies their viewport look.
     this._unsubscribeSelectionTheme = subscribeNativeSelectionTheme(canvas, () => {
       invalidateStages();
       // The selection marks carry their look whole (colour, box form and frame, wire colour and
@@ -1361,14 +1035,13 @@ export class EditorViewport {
       this._lookGizmoSizePx = nativeViewportGizmoSize(canvas);
       this._applyGizmoSize();
       this._applyGizmoArrows();
-      // WHAT FRAME THIS STAGE IS PRESENTING, and what a box select means in
-      // it. Like the size above, the first synchronous call runs before the
-      // gizmos exist and both appliers answer that by returning.
-      this._readLookStage(canvas);
+      // Refresh the gizmos for the current look and presentation frame.
+      // The initial callback precedes transform-control construction.
+      this._readLookStage();
     });
 
     // Editor lighting (on EDITOR_LAYER so game camera doesn't see them)
-    this._lightRig = options?.lightRig !== false;
+    this._lightRig = options.lightRig !== false;
     this._editorAmbient = new THREE.AmbientLight(0xffffff, 0.5);
     this._editorAmbient.layers.set(EDITOR_LAYER);
     scene.add(this._editorAmbient);
@@ -1376,7 +1049,7 @@ export class EditorViewport {
     this._editorDirLight.position.set(10, 20, 10);
     this._editorDirLight.layers.set(EDITOR_LAYER);
     scene.add(this._editorDirLight);
-    // `_setScene` is where the rig's visibility is decided for every scene
+    // `setScene` is where the rig's visibility is decided for every scene
     // AFTER this one; the first scene arrives here, so it is decided here too.
     this._editorAmbient.visible = this._lightRig;
     this._editorDirLight.visible = this._lightRig;
@@ -1386,15 +1059,7 @@ export class EditorViewport {
     this.batchedRenderer.layers.set(EDITOR_LAYER);
     scene.add(this.batchedRenderer);
 
-    // TRACKPAD CAMERA, before OrbitControls exists: listeners on one element
-    // run in registration order, so this must be first to win the wheel.
-    // A trackpad has no middle button (pan was unreachable) and its two-finger
-    // scroll arrived as plain zoom — a 20-minute human build session on one
-    // called moving the camera "nearly impossible" (runhuman pass 12,
-    // 2026-08-28). Semantics: pinch (ctrl+wheel) and pure-vertical wheel stay
-    // ZOOM (mouse wheels are pure-vertical, so mice are untouched); a wheel
-    // with a horizontal component — only trackpads produce one — or Shift
-    // held PANS in screen space, Figma-fashion.
+    // Register trackpad navigation before OrbitControls so it owns the wheel: horizontal or Shift wheel pans in screen space.
     interactionElement.addEventListener('wheel', this._onTrackpadWheel, { passive: false });
 
     // OrbitControls: the editor's own mouse is right-drag to orbit, middle-drag to pan and the
@@ -1403,24 +1068,21 @@ export class EditorViewport {
     // (its mouse look) the browser refuses capture with an uncaught InvalidStateError on each
     // click. Capture is meaningless under a lock (every move already comes to the locked
     // element), so it is skipped then.
-    const capture = interactionElement.setPointerCapture.bind(interactionElement);
+    // Look up capture on the element's prototype at each call so editor.document.click can
+    // suppress capture while dispatching a synthetic pointer, which has no browser pointer id.
+    const realm = (interactionElement.ownerDocument.defaultView ?? window) as Window & typeof globalThis;
     interactionElement.setPointerCapture = (pointerId: number) => {
       if (interactionElement.ownerDocument.pointerLockElement) return;
-      capture(pointerId);
+      realm.Element.prototype.setPointerCapture.call(interactionElement, pointerId);
     };
     this.orbitControls = new OrbitControls(this.camera, interactionElement);
     this.orbitControls.enableDamping = true;
     this.orbitControls.dampingFactor = 0.1;
     this.applyKeymapNavigation();
-    this._unsubscribeKeymap = subscribeEditorKeymap(() => this.applyKeymapNavigation());
+    this._unsubscribeKeymap = editorHost().keyboard.subscribe(() => this.applyKeymapNavigation());
     this._installTurntable();
 
-    // TransformControls — one instance per mode; 'combined' shows all three.
-    // Construction order IS pointer priority (each instance registers its own
-    // canvas listeners): translate, then SCALE, then rotate — the screen-space
-    // rotate ring's band can cross a scale cube's projected spot, and a
-    // pointer on that small explicit target means scale (measured: the ring
-    // stole the X-cube drag when rotate registered first).
+    // Register translate, scale and rotate controls in pointer-priority order; combined mode shows all three.
     this.transformControls = new TransformControls(this.camera, canvas);
     this._auxScaleControls = new TransformControls(this.camera, canvas);
     this._auxScaleControls.setMode('scale');
@@ -1428,12 +1090,7 @@ export class EditorViewport {
     this._auxRotateControls.setMode('rotate');
     this._activeGizmo = this.transformControls;
     const wireGizmo = (gizmoControls: TransformControls): void => {
-      // THE DRAG PLANE AS THE HOVER LEFT IT. The plane a drag intersects (`TransformControlsPlane`)
-      // turns to the hovered axis only when the helper next updates its matrices, a render away,
-      // and `pointerDown` reads it as it stands; a press within a frame of its hover (a quick
-      // flick onto an arrow, a touch, whose hover runs inside the press) started on the plane of
-      // no axis, which faces the camera, and the object moved by that plane's foreshortened
-      // offset: measured on a fresh model, 1.24 m where the cursor asked for 2.78 m.
+      // Refresh the hovered drag plane before pointerDown reads it, including a hover first established by a touch press.
       const pressed = gizmoControls.pointerDown.bind(gizmoControls);
       gizmoControls.pointerDown = (pointer) => {
         gizmoControls.getHelper().updateMatrixWorld(true);
@@ -1443,8 +1100,7 @@ export class EditorViewport {
       gizmoControls.getRaycaster().layers.enableAll();
       gizmoControls.addEventListener('dragging-changed', (event) => {
         const dragging = (event as unknown as { value: boolean }).value;
-        // The design session holds its remount SWAP while a drag runs
-        // (live-gesture-lock.ts) — a swap mid-drag snapped moved objects back.
+        // Hold the design-session remount while a transform drag owns the live objects.
         if (dragging) beginLiveGesture();
         else endLiveGesture();
         this.orbitControls.enabled = !dragging;
@@ -1454,7 +1110,7 @@ export class EditorViewport {
           for (const other of this._allGizmos()) {
             if (other !== gizmoControls) other.enabled = false;
           }
-          const gizmoObj = gizmoControls.object;
+          const gizmoObj = gizmoControls.object!;
           const channel =
             gizmoControls.mode === 'translate'
               ? 'position'
@@ -1464,63 +1120,61 @@ export class EditorViewport {
           const writable = (id: string): boolean =>
             this._authoring().transforms?.editability?.(id, channel).writable ?? true;
           const primaryDragId =
-            this._attachedAuthoringId ?? (gizmoObj && this._authoringIdForObject(gizmoObj)) ?? '';
-          if (gizmoObj) {
-            this._dragStartPos.copy(gizmoObj.position);
-            this._dragStartQuat.copy(gizmoObj.quaternion);
-            this._dragStartScale.copy(gizmoObj.scale);
-            this._otherDragObjects = [];
-            this._allDragObjects = [];
-            this._pivotPos.copy(gizmoObj.position);
-            const primaryId =
-              gizmoObj === this._pivotDummy ? null : this._authoringIdForObject(gizmoObj);
-            if (!primaryId) {
-              // Gizmo on pivot dummy (median-point mode or per-entity pivot)
-              for (const id of this._store.shell.selectedEntityIds) {
-                if (!writable(id)) continue;
-                const obj = this._objectForAuthoringId(id);
-                if (!obj) continue;
-                this._allDragObjects.push({
-                  id,
-                  obj,
-                  startPos: obj.position.clone(),
-                  startQuat: obj.quaternion.clone(),
-                  startScale: obj.scale.clone(),
-                });
-              }
-            } else {
-              for (const id of this._store.shell.selectedEntityIds) {
-                if (id === primaryDragId) continue;
-                if (!writable(id)) continue;
-                const obj = this._objectForAuthoringId(id);
-                if (!obj) continue;
-                this._otherDragObjects.push({
-                  id,
-                  obj,
-                  startPos: obj.position.clone(),
-                  startQuat: obj.quaternion.clone(),
-                  startScale: obj.scale.clone(),
-                });
-              }
+            this._attachedAuthoringId ?? this._authoringIdForObject(gizmoObj) ?? '';
+          this._dragStartPos.copy(gizmoObj.position);
+          this._dragStartQuat.copy(gizmoObj.quaternion);
+          this._dragStartScale.copy(gizmoObj.scale);
+          this._otherDragObjects = [];
+          this._allDragObjects = [];
+          this._pivotPos.copy(gizmoObj.position);
+          const primaryId =
+            gizmoObj === this._pivotDummy ? null : this._authoringIdForObject(gizmoObj);
+          if (!primaryId) {
+            // Without a semantic primary ID, derive drag subjects from the writable selection.
+            for (const id of this._store.shell.selectedEntityIds) {
+              if (!writable(id)) continue;
+              const obj = this._objectForAuthoringId(id);
+              if (!obj) continue;
+              this._allDragObjects.push({
+                id,
+                obj,
+                startPos: obj.position.clone(),
+                startQuat: obj.quaternion.clone(),
+                startScale: obj.scale.clone(),
+              });
+            }
+          } else {
+            for (const id of this._store.shell.selectedEntityIds) {
+              if (id === primaryDragId) continue;
+              if (!writable(id)) continue;
+              const obj = this._objectForAuthoringId(id);
+              if (!obj) continue;
+              this._otherDragObjects.push({
+                id,
+                obj,
+                startPos: obj.position.clone(),
+                startQuat: obj.quaternion.clone(),
+                startScale: obj.scale.clone(),
+              });
             }
-            const editIds =
-              gizmoObj === this._pivotDummy
-                ? this._allDragObjects.map(({ id }) => id)
-                : [primaryDragId, ...this._otherDragObjects.map(({ id }) => id)];
-            this._preservedChildObjects = this._preparePreservedChildren(editIds.filter(Boolean));
-            this._activeTransformEditIds = [
-              ...new Set([
-                ...editIds.filter(Boolean),
-                ...this._preservedChildObjects.map(({ id }) => id),
-              ]),
-            ];
-            // Begin every semantic source edit before TransformControls mutates
-            // any native object. Source-backed adapters need the pre-drag pose of
-            // secondary selections too; physics-backed adapters freeze each body.
-            const authoring = this._authoring();
-            for (const id of this._activeTransformEditIds)
-              beginAuthoringTransformEdit(authoring, id);
           }
+          const editIds =
+            gizmoObj === this._pivotDummy
+              ? this._allDragObjects.map(({ id }) => id)
+              : [primaryDragId, ...this._otherDragObjects.map(({ id }) => id)];
+          this._preservedChildObjects = this._preparePreservedChildren(editIds.filter(Boolean));
+          this._activeTransformEditIds = [
+            ...new Set([
+              ...editIds.filter(Boolean),
+              ...this._preservedChildObjects.map(({ id }) => id),
+            ]),
+          ];
+          // Begin every semantic source edit before TransformControls mutates
+          // any native object. Source-backed adapters need the pre-drag pose of
+          // secondary selections too; physics-backed adapters freeze each body.
+          const authoring = this._authoring();
+          for (const id of this._activeTransformEditIds)
+            beginAuthoringTransformEdit(authoring, id);
         } else {
           // Hide snap indicators when drag ends
           this._surfaceSnapIndicator.visible = false;
@@ -1530,8 +1184,7 @@ export class EditorViewport {
         }
       });
       gizmoControls.addEventListener('objectChange', () => {
-        const gizmoObj = gizmoControls.object;
-        if (!gizmoObj) return;
+        const gizmoObj = gizmoControls.object!;
         const mode = gizmoControls.mode;
         // A CENTRE-anchored gizmo takes the individual-origins math on purpose:
         // its anchor is where the handles are DRAWN, not a pivot the edit is
@@ -1599,9 +1252,8 @@ export class EditorViewport {
         }
         this._restorePreservedChildren();
 
-        // Keeps bounds visuals glued to the entity mid-drag. Both members of the
-        // union expose `update()`; the diagnostic's degenerate wire cube (a bare
-        // LineSegments) does not, hence the guard.
+        // Bounds helpers and selection brackets update mid-drag; mesh wires and
+        // diagnostic wire cubes are LineSegments without an update method.
         for (const helper of this._boxHelpers.values()) {
           if ('update' in helper) helper.update();
         }
@@ -1650,9 +1302,7 @@ export class EditorViewport {
     this._vertexSnapIndicator.layers.set(EDITOR_LAYER);
     scene.add(this._vertexSnapIndicator);
 
-    // Patch gizmo: recolour handles to the look's axis colours and fix plane geometry.
-    this._gizmoLook = nativeGizmoLook(canvas);
-    this._rebuildAxisLines();
+    // Install handle highlights and align the gizmo geometry.
     for (const controls of this._allGizmos()) this._installGizmoHighlight(controls);
     this._patchGizmo(this._gizmoHelper);
     this._patchGizmo(this._auxRotateControls.getHelper());
@@ -1661,22 +1311,14 @@ export class EditorViewport {
     this._dropNegativeAxisHandles(this._auxScaleControls.getHelper(), ['scale']);
     this._patchCombinedScaleGizmo(this._auxScaleControls.getHelper());
     this._applyGizmoArrows();
-    // The look's gizmo size, now that there are controls to set it on: the
-    // theme subscription above installed before they existed and its first
-    // synchronous call found none (see {@link _applyGizmoSize}).
-    this._lookGizmoSizePx = nativeViewportGizmoSize(canvas);
+    // Apply the look’s gizmo size once the controls exist; the theme subscription may run before
+    // their construction.
     this._applyGizmoSize();
-    // The look's AXIS FRAME, after the three patches above have run: the
-    // mirror is a difference over the geometry they produced, so it is the
-    // last word on where a handle is drawn.
-    // The stage's AXIS FRAME (its world's up axis, `setStageFunction`), after the three patches
-    // above have run: the mirror is a difference over the geometry they produced, so it is the
-    // last word on where a handle is drawn.
+    // Apply the stage's axis frame after constructing and patching its gizmo geometry.
     this._applyGizmoAxisFrame();
 
-    // Orientation gizmo (axis arrows overlay) — built in that same frame.
+    // The theme subscription builds the orientation gizmo; this camera draws it.
     this._vcCamera = new THREE.OrthographicCamera(-1.5, 1.5, 1.5, -1.5, 0.1, 10);
-    this._initOrientationGizmo();
 
     // -- Fly camera input (right-click + WASD) --
     window.addEventListener('keydown', this._onFlyKeyDown);
@@ -1688,58 +1330,22 @@ export class EditorViewport {
 
     // Alt+Left-drag = orbit (Unity-style), via capture phase so it fires before OrbitControls
     canvas.addEventListener('pointerdown', this._onAltOrbitStart, { capture: true });
-    // The restore listens on WINDOW: an Alt+drag released outside the canvas
-    // never fired the element-scoped pointerup, so LEFT stayed ROTATE — every
-    // later left-drag orbited the camera and the marquee never drew (a human
-    // tester lost rectangle-select entirely: "it's like a playing view" —
-    // runhuman pass 27). `pointercancel` covers an interrupted drag the same
-    // way. Registered in _onAltOrbitRelease so dispose can remove them.
+    // Listen on window so an Alt+drag released outside the canvas restores the controls.
+    // pointercancel handles interrupted drags; dispose removes both listeners.
     window.addEventListener('pointerup', this._onAltOrbitRelease, { capture: true });
     window.addEventListener('pointercancel', this._onAltOrbitRelease, { capture: true });
+    // A handle or constraint-control drag whose release never arrives (the pointer cancelled, the
+    // window lost focus mid-drag) ends here: its flags would otherwise keep `interacting()` true
+    // and the stage redrawing every frame (`StageHost`).
+    window.addEventListener('pointercancel', this._onInteractionDragLost, { capture: true });
+    window.addEventListener('blur', this._onInteractionDragLost);
     window.addEventListener('keydown', this._onSnapHoldKey);
     window.addEventListener('keyup', this._onSnapHoldKey);
 
-    // Click to select + marquee. The hazard this binding split defends against
-    // is only reproducible with REAL pointer input — synthetic `dispatchEvent`
-    // still works, so unit coverage cannot see it:
-    // OrbitControls (constructed over `interactionElement` above) calls
-    // `setPointerCapture` on its domElement on EVERY pointerdown — including
-    // the disabled LEFT button — so all subsequent pointermove/pointerup are
-    // RETARGETED to the interaction element and canvas-bound listeners
-    // silently die. Because the interaction element is NOT the canvas
-    // (right-drag-over-overlays orbit needs it off the canvas), canvas-bound
-    // move/up alone would kill click-select, marquee, and the alt-orbit
-    // release above.
-    //
-    // The combined mechanism:
-    //  - `pointerdown` binds to the CANVAS: a down anywhere else is not a
-    //    viewport gesture. It opens `_pointerSessionActive`, and the session
-    //    guards in `_onPointerUp` AND `_onPointerMove` keep gestures that
-    //    started on container chrome (toolbar buttons, overlay children)
-    //    from running selection/marquee against a stale down-pos.
-    //  - `pointermove` binds to the INTERACTION ELEMENT so marquee updates
-    //    keep firing mid-drag: once OrbitControls owns the capture, a
-    //    canvas-bound move never fires. (The DOM `RootSelectionOverlay` has
-    //    its own marquee via `world-overlay-gestures`, but the viewport's
-    //    must work bare too.)
-    //  - `pointerup` binds to the interaction element via the stored
-    //    `_onInteractionPointerUp` wrapper (removed in `dispose`). Its
-    //    target guard keeps overlay-OWNED ups (the overlay stopPropagation's
-    //    its own pointerdowns before OrbitControls can capture, so their ups
-    //    land on overlay children) routed exclusively through the overlay's
-    //    own selection logic. The `_pointerSessionActive` disjunct still
-    //    admits a CANVAS-origin gesture whose down was never captured
-    //    (handle drags stopPropagation the down too) and whose up therefore
-    //    lands on overlay chrome — dropping those would leave the
-    //    session/handle-drag flags stuck; `_onPointerUp`'s own guards make
-    //    such ups end the drag, never select.
+    // Bind pointer selection to the interaction element that OrbitControls captures, and handle pointerup there so real drags release their session flags.
     canvas.addEventListener('pointerdown', this._onPointerDown);
     interactionElement.addEventListener('pointermove', this._onPointerMove);
-    this._onInteractionPointerUp = (e: PointerEvent): void => {
-      if (e.target === canvas || e.target === interactionElement || this._pointerSessionActive)
-        this._onPointerUp(e);
-    };
-    interactionElement.addEventListener('pointerup', this._onInteractionPointerUp);
+    interactionElement.addEventListener('pointerup', this._onPointerUp);
 
     // Double-click = DRILL IN (see `_onDoubleClick`). Bound on the interaction
     // element for the same reason `pointerup` is: OrbitControls captures the
@@ -1751,15 +1357,10 @@ export class EditorViewport {
     };
     interactionElement.addEventListener('dblclick', this._onInteractionDblClick);
 
-    // Asset drag-and-drop onto viewport
-    canvas.addEventListener('dragover', this._onDragOver);
-    canvas.addEventListener('dragleave', this._onDragLeave);
-    canvas.addEventListener('drop', this._onDrop);
-
     // Collect editor infrastructure objects so they can be moved between scenes
     this._editorObjects = [
       this.grid,
-      ...(this._axisLines ? [this._axisLines] : []),
+      this._axisLines,
       this._editorAmbient,
       this._editorDirLight,
       this.batchedRenderer,
@@ -1771,11 +1372,9 @@ export class EditorViewport {
       this._vertexSnapIndicator,
     ];
 
-    // D12 (B4) — publish the camera/canvas seam `VolterSceneAuthoringAdapter.pickable`
-    // needs (it has no other way to reach them). Cleared in `dispose()`.
-    if (this._publishPickContext) {
-      this._installPickContext(this.camera);
-    }
+    // Publish this viewport's camera, canvas and editor controls for adapter raycasting.
+    // Cleared in dispose().
+    this._installPickContext(this.camera);
   }
 
   /** Swap the scene the viewport renders. Moves editor infrastructure objects to the new scene. */
@@ -1813,14 +1412,8 @@ export class EditorViewport {
     }
     this._scene = newScene;
     this._contentBoundsAt = 0; // different content → re-measure before the next draw
-    // The light rig is a design-time visibility aid for editor-owned scenes.
-    // An ADOPTED live game scene (play adoption, ingest, the R3F design
-    // session) owns its lighting completely — the editor camera sees
-    // EDITOR_LAYER lights, so the rig would add a white ambient+directional
-    // the game camera never sees, and the mismatch pops as a color/brightness
-    // shift the instant play takes over the draw. WYSIWYG for adopted scenes.
-    // A stage bound to a view presentation is lit by it instead (`bindPresentation`).
-    const rigOn = this._lightRig && !this._store.isAdoptedSceneActive && this._presentation === null;
+    // Use the editor rig only when enabled and no view presentation supplies the lighting.
+    const rigOn = this._lightRig && this._presentation === null;
     this._editorAmbient.visible = rigOn;
     this._editorDirLight.visible = rigOn;
   }
@@ -1829,11 +1422,9 @@ export class EditorViewport {
     return this._scene;
   }
 
-  /** Camera that currently paints the Scene document. Ordinarily this is the
-   *  free editor camera; view-through/pilot temporarily returns the authored
-   *  native camera without changing its ownership. */
+  /** Camera that paints the Scene document: the free editor camera. */
   get renderCamera(): THREE.Camera {
-    return this._cameraView ?? this.freeCamera;
+    return this.freeCamera;
   }
 
   get freeCamera(): THREE.PerspectiveCamera | THREE.OrthographicCamera {
@@ -1859,10 +1450,6 @@ export class EditorViewport {
   }
 
   setProjection(projection: ThreeViewportProjection): void {
-    if (this._cameraView) {
-      this._pendingProjection = projection;
-      return;
-    }
     if (this._projection === projection) return;
     if (projection === 'orthographic') this._syncOrthographicFromPerspective();
     else this._syncPerspectiveFromOrthographic();
@@ -1936,7 +1523,7 @@ export class EditorViewport {
    * the right button then does nothing here, as in Blender, where it is the context menu's.
    */
   private applyKeymapNavigation(): void {
-    const { orbit, turntable } = activeKeymapNavigation();
+    const { orbit, turntable } = editorHost().keyboard.navigation();
     // Only a turntable keeps a roll: under any other orbit the view comes back level (a Top
     // view's screen up, which is no roll, stands).
     if (!turntable && this.camera.up.y < 0.9999 && Math.abs(this.camera.up.z) < 0.9999) this.camera.up.set(0, 1, 0);
@@ -1947,7 +1534,7 @@ export class EditorViewport {
       RIGHT: orbit === 'middle' ? (-1 as THREE.MOUSE) : THREE.MOUSE.ROTATE,
     };
   }
-  private _unsubscribeKeymap: () => void = () => {};
+  private _unsubscribeKeymap: () => void;
 
   /**
    * A KEYMAP'S TURNTABLE (`KeymapNavigation.turntable`) in place of three's spherical orbit, on
@@ -1977,17 +1564,17 @@ export class EditorViewport {
     controls._handleMouseDownDolly = (event) => {
       dollyDown(event);
       dolly = null;
-      if (activeKeymapNavigation().zoom?.drag !== 'dolly') return;
+      if (editorHost().keyboard.navigation().zoom?.drag !== 'dolly') return;
       const top = this._canvas.getBoundingClientRect().top;
       const camera = this.orbitControls.object;
       dolly = {
         len0: Math.max(5 + event.clientY - top, 1),
         offset: camera.position.clone().sub(this.orbitControls.target),
-        zoom0: (camera as THREE.OrthographicCamera).zoom ?? 1,
+        zoom0: (camera as THREE.PerspectiveCamera | THREE.OrthographicCamera).zoom,
       };
     };
     controls._handleMouseMoveDolly = (event) => {
-      if (activeKeymapNavigation().zoom?.drag !== 'dolly' || !dolly) {
+      if (editorHost().keyboard.navigation().zoom?.drag !== 'dolly' || !dolly) {
         dollyMove(event);
         return;
       }
@@ -2017,13 +1604,13 @@ export class EditorViewport {
       down(event);
       drag = null;
       for (const listener of [...this._rotateStartListeners]) listener();
-      if (!activeKeymapNavigation().turntable) return;
+      if (!editorHost().keyboard.navigation().turntable) return;
       const camera = this.orbitControls.object;
       const viewUp = new THREE.Vector3(0, 1, 0).applyQuaternion(camera.quaternion);
       drag = { x: event.clientX, y: event.clientY, reverse: viewUp.y < 0 ? -1 : 1 };
     };
     controls._handleMouseMoveRotate = (event) => {
-      const turntable = activeKeymapNavigation().turntable;
+      const turntable = editorHost().keyboard.navigation().turntable;
       if (!turntable || !drag) {
         move(event);
         return;
@@ -2040,7 +1627,7 @@ export class EditorViewport {
     // Auto Perspective on a stage that draws with the viewport's own projection (a document's
     // session keeps its own and answers for it).
     () => {
-      if (!activeKeymapNavigation().autoPerspective || this._projection !== 'orthographic') return;
+      if (!editorHost().keyboard.navigation().autoPerspective || this._projection !== 'orthographic') return;
       const offset = this.camera.position.clone().sub(this.orbitControls.target);
       const up = new THREE.Vector3(0, 1, 0).applyQuaternion(this.camera.quaternion);
       if (axisViewName(offset, up) !== null) this.setProjection('perspective');
@@ -2054,7 +1641,7 @@ export class EditorViewport {
    */
   private readonly _axisViewListeners: (() => boolean)[] = [
     () => {
-      if (activeKeymapNavigation().autoPerspective) this.setProjection('orthographic');
+      if (editorHost().keyboard.navigation().autoPerspective) this.setProjection('orthographic');
       return true;
     },
   ];
@@ -2155,7 +1742,7 @@ export class EditorViewport {
    * orbit's pivot, as a whole gesture (a camera lock writes it).
    */
   zoomStep(direction: 1 | -1): void {
-    const step = activeKeymapNavigation().zoom?.step ?? 1.2;
+    const step = editorHost().keyboard.navigation().zoom?.step ?? 1.2;
     const factor = direction > 0 ? 1 / step : step;
     const camera = this.orbitControls.object;
     this.orbitControls.dispatchEvent({ type: 'start' });
@@ -2202,54 +1789,6 @@ export class EditorViewport {
     this.orbitControls.update();
   }
 
-  get cameraViewMode(): CameraViewMode | null {
-    return this._cameraViewMode;
-  }
-
-  /** Enter an exact native camera view. Pilot additionally hands OrbitControls
-   *  the authored camera; the caller owns begin/apply/end persistence. */
-  setCameraView(camera: THREE.Camera, mode: CameraViewMode): void {
-    this.clearCameraView();
-    this._cameraView = camera;
-    this._cameraViewMode = mode;
-    this._orbitEnabledBeforeCameraView = this.orbitControls.enabled;
-    this._orbitTargetBeforeCameraView.copy(this.orbitControls.target);
-    if (mode === 'pilot') {
-      const position = camera.getWorldPosition(new THREE.Vector3());
-      const forward = camera.getWorldDirection(new THREE.Vector3());
-      const distance = Math.max(1, this.freeCamera.position.distanceTo(this.orbitControls.target));
-      this.orbitControls.object = camera;
-      this.orbitControls.target.copy(position).add(forward.multiplyScalar(distance));
-      this.orbitControls.enabled = true;
-      this.orbitControls.update();
-    } else {
-      this.orbitControls.enabled = false;
-    }
-    if (this._publishPickContext) {
-      this._installPickContext(camera);
-    }
-  }
-
-  /** Restore the free editor camera exactly where it was before view-through. */
-  clearCameraView(): void {
-    if (!this._cameraView) return;
-    if (this._flyActive) this._exitFlyMode();
-    this.orbitControls.object = this.freeCamera;
-    this.orbitControls.target.copy(this._orbitTargetBeforeCameraView);
-    this.orbitControls.enabled = this._orbitEnabledBeforeCameraView;
-    this.orbitControls.update();
-    this._cameraView = null;
-    this._cameraViewMode = null;
-    const pendingProjection = this._pendingProjection;
-    this._pendingProjection = null;
-    if (pendingProjection && pendingProjection !== this._projection) {
-      this.setProjection(pendingProjection);
-    }
-    if (this._publishPickContext) {
-      this._installPickContext(this.freeCamera);
-    }
-  }
-
   get objectMap(): Map<string, THREE.Object3D> {
     return this._objectMap;
   }
@@ -2286,7 +1825,7 @@ export class EditorViewport {
   }
 
   private _authoringIdForObject(object: THREE.Object3D): string | null {
-    return this._authoring().hierarchy.idForObject3D?.(object) ?? entityIdOf(object) ?? null;
+    return this._authoring().hierarchy.idForNativeObject?.(object) ?? entityIdOf(object) ?? null;
   }
 
   /**
@@ -2315,22 +1854,20 @@ export class EditorViewport {
       color: new THREE.Color(nativeSelectionColors(this._canvas).visible),
       toneMapped: false,
     });
-    const wire = new THREE.LineSegments(edges, mat) as unknown as TaggedHelper;
+    const wire = new THREE.LineSegments(edges, mat) as THREE.LineSegments & TaggedHelper;
     obj.getWorldPosition(wire.position);
-    // Tag so we can update/dispose like BoxHelper
-    wire.isBoxHelper = true;
+    // Retain the source so the wire cube follows its world position each frame.
     wire._entityObj = obj;
     return wire;
   }
 
   /**
-   * Rebuild the bounds visuals: the Bounds DIAGNOSTIC (plain full boxes over
-   * every entity, a density view) and the non-renderable SELECTION fallback
-   * (corner brackets — see `selection-brackets.ts`). Renderable selections are
-   * painted by the native postprocessing silhouette instead.
+   * Rebuild diagnostic bounds and the presentation's selection wires/brackets.
+   * Non-renderable selections use brackets unless their document draws its own overlay;
+   * geometric selections can use wires, boxes and the native silhouette.
    */
   private _syncBoxHelpers(): void {
-    // Remove old + dispose geometry/materials on rebuild (LK6).
+    // Dispose the previous geometry and materials before rebuilding.
     for (const helper of this._boxHelpers.values()) {
       this._scene.remove(helper);
       helper.geometry.dispose();
@@ -2362,7 +1899,7 @@ export class EditorViewport {
         let index = 0;
         obj.traverse((child) => {
           const mesh = child as THREE.Mesh;
-          if (!mesh.isMesh || !mesh.geometry || isInEditorOwnedSubtree(mesh)) return;
+          if (!mesh.isMesh || isInEditorOwnedSubtree(mesh)) return;
           const look = nativeViewportWire(this._canvas);
           const wire = new THREE.LineSegments(
             new THREE.WireframeGeometry(mesh.geometry),
@@ -2399,7 +1936,7 @@ export class EditorViewport {
       if (this._standaloneAuthoring && (obj as THREE.Bone).isBone) continue;
       // Constraint owners, targets and poles already have a semantic native
       // viewport presentation (lines plus a target/pole handle). Drawing the
-      // legacy empty-transform corner brackets over that presentation creates
+      // empty-transform corner brackets over that presentation creates
       // two competing selection languages and obscures the draggable handle.
       if ([...this._constraintHelpers.values()].some((helper) => helper.presents(obj))) continue;
       // Nor over an object whose document draws its overlay itself, selection colour included
@@ -2420,12 +1957,12 @@ export class EditorViewport {
    * The source component stays an empty, ordinary transform node; these
    * helpers live on EDITOR_LAYER and therefore never enter Game view.
    */
-  private _syncReflectionProbeHelpers(changedIds: ReadonlySet<string> | null = null): void {
-    if (changedIds === null) {
+  private _syncReflectionProbeHelpers(reconcileMembership: boolean): void {
+    if (reconcileMembership) {
       const current = new Map<string, THREE.Object3D>();
       const admitted = new Set<THREE.Object3D>();
       for (const [id, object] of this._objectMap) {
-        if (!object || admitted.has(object) || !reflectionProbeOf(object)) continue;
+        if (admitted.has(object) || !reflectionProbeOf(object)) continue;
         admitted.add(object);
         current.set(id, object);
       }
@@ -2435,28 +1972,6 @@ export class EditorViewport {
         this._reflectionProbeHelpers.delete(id);
       }
       for (const [id, source] of current) this._ensureReflectionProbeHelper(id, source);
-    } else {
-      let requiresFullReconcile = false;
-      for (const id of changedIds) {
-        const source = this._objectMap.get(id);
-        const next = source && reflectionProbeOf(source) ? source : null;
-        const previous = this._reflectionProbeHelpers.get(id);
-        if (previous && previous.source !== next) {
-          if (next === null) requiresFullReconcile = true;
-          previous.dispose();
-          this._reflectionProbeHelpers.delete(id);
-        }
-        if (
-          next &&
-          ![...this._reflectionProbeHelpers.values()].some((helper) => helper.source === next)
-        ) {
-          this._ensureReflectionProbeHelper(id, next);
-        }
-      }
-      if (requiresFullReconcile) {
-        this._syncReflectionProbeHelpers();
-        return;
-      }
     }
     for (const [id, helper] of this._reflectionProbeHelpers) {
       helper.setSelected(this._store.shell.selectedEntityIds.has(id));
@@ -2475,21 +1990,13 @@ export class EditorViewport {
     this._scene.add(helper);
   }
 
-  /**
-   * WHERE A TRIGGER FIRES. A group whose `userData.triggerVolume.radius` decides
-   * where a hazard fires or a quest arrives has a hierarchy row and no geometry,
-   * so the viewport showed nothing at all where it sits. The game must not draw
-   * it: game source here is ecosystem-native and asks the runtime nothing about
-   * being authored. So the editor draws it, in the shape `_syncLightHelpers`
-   * already uses — editor-owned, on EDITOR_LAYER, never in the game's tree and
-   * never in Play.
-   */
-  private _syncTriggerVolumeHelpers(changedIds: ReadonlySet<string> | null = null): void {
-    if (changedIds === null) {
+  /** Draw editor-owned trigger-volume guides on EDITOR_LAYER without adding geometry to the project tree. */
+  private _syncTriggerVolumeHelpers(reconcileMembership: boolean): void {
+    if (reconcileMembership) {
       const current = new Map<string, THREE.Object3D>();
       const admitted = new Set<THREE.Object3D>();
       for (const [id, object] of this._objectMap) {
-        if (!object || admitted.has(object) || !triggerVolumeOf(object)) continue;
+        if (admitted.has(object) || !triggerVolumeOf(object)) continue;
         admitted.add(object);
         current.set(id, object);
       }
@@ -2498,27 +2005,6 @@ export class EditorViewport {
         this._disposeTriggerVolumeHelper(id, helper);
       }
       for (const [id, source] of current) this._ensureTriggerVolumeHelper(id, source);
-    } else {
-      let requiresFullReconcile = false;
-      for (const id of changedIds) {
-        const source = this._objectMap.get(id);
-        const next = source && triggerVolumeOf(source) ? source : null;
-        const previous = this._triggerVolumeHelpers.get(id);
-        if (previous && previous.source !== next) {
-          if (next === null) requiresFullReconcile = true;
-          this._disposeTriggerVolumeHelper(id, previous);
-        }
-        if (
-          next &&
-          ![...this._triggerVolumeHelpers.values()].some((helper) => helper.source === next)
-        ) {
-          this._ensureTriggerVolumeHelper(id, next);
-        }
-      }
-      if (requiresFullReconcile) {
-        this._syncTriggerVolumeHelpers();
-        return;
-      }
     }
     const visible =
       this._threeSurfaceShowing &&
@@ -2544,12 +2030,12 @@ export class EditorViewport {
   }
 
   /** Keep one editor-owned projection beside every source-owned constraint owner. */
-  private _syncConstraintHelpers(changedIds: ReadonlySet<string> | null = null): void {
-    if (changedIds === null) {
+  private _syncConstraintHelpers(reconcileMembership: boolean): void {
+    if (reconcileMembership) {
       const current = new Map<string, THREE.Object3D>();
       const admitted = new Set<THREE.Object3D>();
       for (const [id, object] of this._objectMap) {
-        if (!object || admitted.has(object) || constraintsOf(object).length === 0) continue;
+        if (admitted.has(object) || constraintsOf(object).length === 0) continue;
         admitted.add(object);
         current.set(id, object);
       }
@@ -2559,28 +2045,6 @@ export class EditorViewport {
         this._constraintHelpers.delete(id);
       }
       for (const [id, source] of current) this._ensureConstraintHelper(id, source);
-    } else {
-      let requiresFullReconcile = false;
-      for (const id of changedIds) {
-        const source = this._objectMap.get(id);
-        const next = source && constraintsOf(source).length > 0 ? source : null;
-        const previous = this._constraintHelpers.get(id);
-        if (previous && previous.source !== next) {
-          if (next === null) requiresFullReconcile = true;
-          this._disposeConstraintHelper(previous);
-          this._constraintHelpers.delete(id);
-        }
-        if (
-          next &&
-          ![...this._constraintHelpers.values()].some((helper) => helper.source === next)
-        ) {
-          this._ensureConstraintHelper(id, next);
-        }
-      }
-      if (requiresFullReconcile) {
-        this._syncConstraintHelpers();
-        return;
-      }
     }
 
     const selectedObjects = new Set<THREE.Object3D>();
@@ -2698,45 +2162,19 @@ export class EditorViewport {
   }
 
   /** Native camera frustums for the ordinary Helpers → Cameras overlay. */
-  private _syncCameraHelpers(changedIds: ReadonlySet<string> | null = null): void {
-    if (changedIds === null) {
-      const current = new Map<string, THREE.Camera>();
-      for (const [id, object] of this._objectMap) {
-        const camera = this._nativeCamera(object);
-        if (camera) current.set(id, camera);
-      }
-      for (const [id, entry] of this._cameraHelpers) {
-        if (current.get(id) === entry.source) continue;
-        this._disposeCameraHelper(id, entry);
-      }
-      for (const [id, camera] of current) this._ensureCameraHelper(id, camera);
-    } else {
-      let requiresFullReconcile = false;
-      for (const id of changedIds) {
-        const object = this._objectMap.get(id);
-        const next = object ? this._nativeCamera(object) : null;
-        const previous = this._cameraHelpers.get(id);
-        if (previous && previous.source !== next) {
-          if (next === null) requiresFullReconcile = true;
-          this._disposeCameraHelper(id, previous);
-        }
-        if (next && ![...this._cameraHelpers.values()].some((entry) => entry.source === next)) {
-          this._ensureCameraHelper(id, next);
-        }
-      }
-      if (requiresFullReconcile) {
-        this._syncCameraHelpers();
-        return;
-      }
-    }
-    // PERSISTENT, like every other engine's camera icon: Unity, Unreal, Godot
-    // and Blender all draw a camera in the viewport whether or not it is
-    // selected — that drawing is HOW you find it and click it. Gating it on a
-    // three selection meant a scene with nothing selected showed no cameras at
-    // all, and the only way to see one was to already have found it in the
-    // hierarchy. The surface gate is the same one the grid uses ("Blender's
-    // floor is persistent; only the gizmos need an owner"); a camera icon is
-    // furniture, not a gizmo.
+  private _syncCameraHelpers(): void {
+    const current = new Map<string, THREE.Camera>();
+    for (const [id, object] of this._objectMap) {
+      const camera = this._nativeCamera(object);
+      if (camera) current.set(id, camera);
+    }
+    for (const [id, entry] of this._cameraHelpers) {
+      if (current.get(id) === entry.source) continue;
+      this._disposeCameraHelper(id, entry);
+    }
+    for (const [id, camera] of current) this._ensureCameraHelper(id, camera);
+    // Keep camera icons visible with the stage’s persistent furniture so unselected cameras can be
+    // found and selected.
     const visible =
       this._threeSurfaceShowing && this._store.shell.showHelpers && this._store.shell.helperVisibility.cameras;
     for (const entry of this._cameraHelpers.values()) {
@@ -2746,55 +2184,28 @@ export class EditorViewport {
   }
 
   /**
-   * WHERE A LIGHT POINTS, drawn beside it — three's own light helpers on the
-   * editor layer, gated by the Helpers → Lights toggle that already existed
-   * with nothing behind it.
-   *
-   * Two testers asked for this in the same words: with a directional light
-   * selected there was no way to tell which way it threw ("is it on the left
-   * side, the right, downwards?" — runhuman passes 68/70), and a point light
-   * showed only its transform. Same shape as `_syncCameraHelpers`: one
-   * editor-owned overlay per native light, reconciled per notify, never in the
-   * game's tree and never in Game view.
+   * Reconcile one editor-owned three.js helper per native light when Helpers → Lights is enabled,
+   * using the same overlay lifecycle as camera helpers. Helpers remain outside the authored tree
+   * and hidden in Game view.
    */
-  private _syncLightHelpers(changedIds: ReadonlySet<string> | null = null): void {
-    if (changedIds === null) {
-      const current = new Map<string, THREE.Light>();
-      for (const [id, object] of this._objectMap) {
-        const light = this._nativeLight(object);
-        if (light) current.set(id, light);
-      }
-      for (const [id, entry] of this._lightHelpers) {
-        if (current.get(id) === entry.source) continue;
-        this._disposeLightHelper(id, entry);
-      }
-      for (const [id, light] of current) this._ensureLightHelper(id, light);
-    } else {
-      let requiresFullReconcile = false;
-      for (const id of changedIds) {
-        const object = this._objectMap.get(id);
-        const next = object ? this._nativeLight(object) : null;
-        const previous = this._lightHelpers.get(id);
-        if (previous && previous.source !== next) {
-          if (next === null) requiresFullReconcile = true;
-          this._disposeLightHelper(id, previous);
-        }
-        if (next && ![...this._lightHelpers.values()].some((entry) => entry.source === next)) {
-          this._ensureLightHelper(id, next);
-        }
-      }
-      if (requiresFullReconcile) {
-        this._syncLightHelpers();
-        return;
-      }
+  private _syncLightHelpers(): void {
+    const current = new Map<string, THREE.Light>();
+    for (const [id, object] of this._objectMap) {
+      const light = this._nativeLight(object);
+      if (light) current.set(id, light);
+    }
+    for (const [id, entry] of this._lightHelpers) {
+      if (current.get(id) === entry.source) continue;
+      this._disposeLightHelper(id, entry);
     }
+    for (const [id, light] of current) this._ensureLightHelper(id, light);
     // Persistent for the same reason as the camera frustum above: a light you
     // have not selected is exactly the light you are looking for.
     const visible =
       this._threeSurfaceShowing && this._store.shell.showHelpers && this._store.shell.helperVisibility.lights;
     for (const entry of this._lightHelpers.values()) {
       entry.helper.visible = visible;
-      entry.helper.update?.();
+      entry.helper.update();
     }
   }
 
@@ -2807,20 +2218,18 @@ export class EditorViewport {
 
   private _disposeLightHelper(
     id: string,
-    entry: { source: THREE.Light; helper: THREE.Object3D & { dispose?(): void } },
+    entry: { helper: THREE.Object3D & { dispose(): void } },
   ): void {
     entry.helper.removeFromParent();
-    entry.helper.dispose?.();
+    entry.helper.dispose();
     this._lightHelpers.delete(id);
   }
 
   private _ensureLightHelper(id: string, light: THREE.Light): void {
     if (this._lightHelpers.has(id)) return;
-    // An ambient/hemisphere light has no position or direction to draw, and a
-    // light class this `three` does not know gets no overlay rather than a
-    // wrong one — the same narrow refusal the camera overlay makes.
+    // Draw helpers for supported light classes, including hemisphere lights; ambient lights have no helper.
     const size = 0.5;
-    let helper: (THREE.Object3D & { update?(): void; dispose?(): void }) | null = null;
+    let helper: (THREE.Object3D & { update(): void; dispose(): void }) | null = null;
     const candidate = light as THREE.Light & {
       isDirectionalLight?: boolean;
       isPointLight?: boolean;
@@ -2844,26 +2253,13 @@ export class EditorViewport {
     helper.name = `Light helper: ${light.name || id}`;
     helper.userData['editorOnly'] = true;
     helper.traverse((child) => child.layers.set(EDITOR_LAYER));
-    helper.layers.set(EDITOR_LAYER);
     this._lightHelpers.set(id, { source: light, helper });
     this._scene.add(helper);
   }
 
-  /**
-   * WHERE A SOUND COMES FROM, and how far it carries — the Helpers → Audio
-   * toggle, which existed with nothing behind it exactly as Lights once did.
-   *
-   * A listener and a positional source have a place in the world and no
-   * geometry, so without an overlay they are invisible in the viewport: the
-   * hierarchy lists them and the scene shows nothing where they are. This
-   * small marker locates each source. Selected-source distance and direction
-   * guides belong to the adapter's spatial-handle provider, which understands
-   * the native audio model and owns the corresponding edits. Markers follow
-   * the same lifecycle as `_syncLightHelpers`: editor-owned, on the editor
-   * layer, never in the game's tree and never in Game view.
-   */
-  private _syncAudioHelpers(changedIds: ReadonlySet<string> | null = null): void {
-    if (changedIds === null) {
+  /** Locate native audio listeners/sources with editor-only markers. Adapter spatial handles own distance/direction edits. */
+  private _syncAudioHelpers(reconcileMembership: boolean): void {
+    if (reconcileMembership) {
       const current = new Map<string, THREE.Object3D>();
       for (const [id, object] of this._objectMap) {
         const audio = this._nativeAudio(object);
@@ -2874,16 +2270,6 @@ export class EditorViewport {
         this._disposeAudioHelper(id, entry);
       }
       for (const [id, audio] of current) this._ensureAudioHelper(id, audio);
-    } else {
-      for (const id of changedIds) {
-        const object = this._objectMap.get(id);
-        const next = object ? this._nativeAudio(object) : null;
-        const previous = this._audioHelpers.get(id);
-        if (previous && previous.source !== next) this._disposeAudioHelper(id, previous);
-        if (next && ![...this._audioHelpers.values()].some((entry) => entry.source === next)) {
-          this._ensureAudioHelper(id, next);
-        }
-      }
     }
     const visible =
       this._threeSurfaceShowing && this._store.shell.showHelpers && this._store.shell.helperVisibility.audio;
@@ -2912,22 +2298,20 @@ export class EditorViewport {
     helper.name = `Audio helper: ${source.name || id}`;
     helper.userData['editorOnly'] = true;
     helper.traverse((child) => child.layers.set(EDITOR_LAYER));
-    helper.layers.set(EDITOR_LAYER);
-    // Parented to the source so it rides the same transform: a footstep
-    // emitter on a walking character must not leave its ring behind.
+    // Parent the marker to its source so it follows the source's transform.
     source.add(helper);
     this._audioHelpers.set(id, { source, helper });
   }
 
   private _disposeAudioHelper(
     id: string,
-    entry: { source: THREE.Object3D; helper: THREE.Object3D & { dispose?(): void } },
+    entry: { helper: THREE.Group },
   ): void {
     entry.helper.traverse((child) => {
       const mesh = child as THREE.Mesh;
-      mesh.geometry?.dispose?.();
+      mesh.geometry?.dispose();
       const material = mesh.material as THREE.Material | undefined;
-      material?.dispose?.();
+      material?.dispose();
     });
     entry.helper.removeFromParent();
     this._audioHelpers.delete(id);
@@ -2935,7 +2319,7 @@ export class EditorViewport {
 
   private _disposeCameraHelper(
     id: string,
-    entry: { source: THREE.Camera; helper: THREE.CameraHelper },
+    entry: { helper: THREE.CameraHelper },
   ): void {
     entry.helper.removeFromParent();
     entry.helper.dispose();
@@ -2944,9 +2328,7 @@ export class EditorViewport {
 
   private _ensureCameraHelper(id: string, camera: THREE.Camera): void {
     if (this._cameraHelpers.has(id)) return;
-    // `CameraHelper` is the HOST's class reading fields off a camera the GAME may have made with
-    // its own, older `three`. The failure is the discriminator; every compatible camera keeps its
-    // overlay, while an incompatible revision records the narrow refusal below.
+    // Project camera helpers may come from a separate three instance. Keep compatible overlays and record a narrow refusal when CameraHelper cannot read the camera.
     let helper: THREE.CameraHelper;
     try {
       helper = new THREE.CameraHelper(camera);
@@ -2968,12 +2350,7 @@ export class EditorViewport {
     this._refusedCameraOverlays.add(id);
     editorConsole.warn(
       `Helpers → Cameras draws no frustum for "${camera.name || camera.type}": ` +
-        `${error instanceof Error ? error.message : String(error)}. This world's camera was ` +
-        "constructed by the GAME's own copy of three, and `THREE.CameraHelper` is the editor's " +
-        'class reading fields off it that that revision does not define. Every other camera ' +
-        'capability (framing, selection, inspection) is unaffected. It closes when the game ' +
-        "resolves `three` to the host's instance — a bare, un-rewritten `import 'three'` in its " +
-        'own source.',
+        `${error instanceof Error ? error.message : String(error)}. Framing, selection and inspection remain available.`,
       'authoring',
     );
   }
@@ -3040,13 +2417,13 @@ export class EditorViewport {
   }
 
   private _finishSpatialHandleDrag(commit: boolean): void {
-    const active = this._activeSpatialHandle;
+    const active = this._activeSpatialHandle!;
     this._activeSpatialHandle = null;
     this.orbitControls.enabled = this._orbitEnabledBeforeHandleDrag;
     this.transformControls.enabled = this._transformEnabledBeforeHandleDrag;
     this.syncFromStore();
     this._canvas.style.cursor = '';
-    if (commit && active) {
+    if (commit) {
       void spatialHandlesForAdapter(this._authoring())?.commit(active.nodeId, active.handle.id, [
         this._spatialHandleDragPoint.x,
         this._spatialHandleDragPoint.y,
@@ -3084,41 +2461,34 @@ export class EditorViewport {
     }
     setSpatialHandleHovered(hovered, true);
     const binding = spatialHandleBinding(hovered);
-    this._canvas.style.cursor = binding?.handle.writable ? 'grab' : 'not-allowed';
+    this._canvas.style.cursor = binding.handle.writable ? 'grab' : 'not-allowed';
   }
 
   private _updateEditorHandleInteraction(e: PointerEvent): boolean {
     return this._updateSpatialHandleDrag(e) || this._updateConstraintControlHover(e);
   }
 
-  private _previewInfrastructure(): THREE.Object3D[] {
-    return [
-      this.grid,
-      ...(this._axisLines ? [this._axisLines] : []),
-      this._gizmoHelper,
-      this._auxRotateControls.getHelper(),
-      this._auxScaleControls.getHelper(),
-      ...this._boxHelpers.values(),
-      ...this._constraintHelpers.values(),
-      ...this._reflectionProbeHelpers.values(),
-      ...this._triggerVolumeHelpers.values(),
-      ...[...this._cameraHelpers.values()].map(({ helper }) => helper),
-      ...this._spatialHandleRoots,
-    ];
+  private _allGizmos(): TransformControls[] {
+    return [this.transformControls, this._auxRotateControls, this._auxScaleControls];
   }
 
-  private _suspendPreviewInfrastructure(): () => void {
-    const visibility = this._previewInfrastructure().map(
-      (object) => [object, object.visible] as const,
-    );
-    for (const [object] of visibility) object.visible = false;
-    return () => {
-      for (const [object, visible] of visibility) object.visible = visible;
-    };
+  /** A drag is under way: a transform gizmo, a spatial handle or a constraint control. Every
+   *  frame of it is a change of the picture (`StageHost`), whatever the drag signals. */
+  interacting(): boolean {
+    return this._anyGizmoDragging() || this._activeSpatialHandle !== null || this._constraintControlPointerSession;
   }
 
-  private _allGizmos(): TransformControls[] {
-    return [this.transformControls, this._auxRotateControls, this._auxScaleControls];
+  /**
+   * WHAT INPUT CHANGES IN THE STAGE'S OWN FURNITURE: the hovered constraint control and spatial
+   * handle, and each transform gizmo's shown state, highlighted axis and drag. A stage counts a
+   * pointer move as a change of its picture only when this (or the camera) moves, so hovering
+   * over a still view does not start its accumulation over (`StageHost`).
+   */
+  interactionState(): string {
+    const gizmos = this._allGizmos()
+      .map((controls) => `${controls.getHelper().visible ? 1 : 0}${controls.enabled ? 1 : 0}${controls.axis ?? '-'}${controls.dragging ? 1 : 0}`)
+      .join(',');
+    return `${this._hoveredConstraintControl?.mesh.uuid ?? '-'}|${this._hoveredSpatialHandle?.uuid ?? '-'}|${gizmos}`;
   }
 
   private _anyGizmoDragging(): boolean {
@@ -3137,14 +2507,9 @@ export class EditorViewport {
 
   /** Sync mode/space/snap from store. */
   syncFromStore(): void {
-    // Ensure all gizmo children stay on EDITOR_LAYER (TransformControls rebuilds internally)
-    this._gizmoHelper.traverse((child) => child.layers.set(EDITOR_LAYER));
-
     const mode = this._store.shell.transformMode;
     const combined = mode === 'combined';
-    // `'select'` draws NO gizmo (Blender's Select Box — `TransformMode`'s own
-    // note), so there is no handle family to put the primary controls in; it
-    // keeps whatever it had and the attach block below detaches instead.
+    // Select uses translate mode with the controls detached, so it draws no transform gizmo.
     const primaryMode = combined || mode === 'select' ? 'translate' : mode;
     if (this.transformControls.mode !== primaryMode) {
       this.transformControls.setMode(primaryMode);
@@ -3152,18 +2517,14 @@ export class EditorViewport {
     this._applySnapToGizmos();
     for (const controls of this._allGizmos()) controls.setSpace(this._store.shell.transformSpace);
 
-    // Spec 28 step 2 — visibility says a Three.js surface is painted;
-    // selection ownership says it is the native world the user is editing.
-    // The grid, view cube and transform gizmo require BOTH.
-    // A pinned camera preview remains visible without a selection.
-    // Empty/organizational/cross-world selections deliberately leave only
-    // shell chrome rather than advertising an arbitrary coordinate system.
+    // Enable transform tools only for the visible three.js stage that owns this selection.
+    // Camera previews and persistent furniture have their own visibility gates.
     const policy = viewportAuthoringPolicy();
     const authoring = this._authoring();
     const toolOwner = policy.toolOwner(authoring, this._store.shell.selectedEntityIds);
     this._threejsToolContextActive =
       (this._standaloneAuthoring || policy.toolOwnerPainted(this._store.shell, toolOwner)) &&
-      toolOwner?.kind === 'three';
+      toolOwner?.kind === 'stage';
 
     // Grid visibility — the user's toggle, AND'd with a three stage showing at
     // all (selection or not: Blender's floor is persistent; the gizmos above
@@ -3174,30 +2535,12 @@ export class EditorViewport {
     this.grid.visible = this._presentationGrid && threeSurface;
     if (this._axisLines) this._axisLines.visible = this.grid.visible && this._axesWanted;
 
-    // The two passes below (apply gizmos + per-type helper/icon visibility) are
-    // idempotent and O(total scene nodes). Their only inputs are the objectMap
-    // membership and the visibility toggles — none of which change during a
-    // transform drag/scrub (which still fires syncFromStore every frame). Gate
-    // them on a cheap signature so a drag doesn't re-walk the whole graph 60×/s.
+    // Reconcile helper membership, icon visibility and camera/light helpers when
+    // the object map, gizmo epoch, helper settings or stage visibility changes.
     const vis = this._store.shell.helperVisibility;
-    // World-hidden eye (D9) folded into the SAME cheap signature/gate as the
-    // gizmo/helper passes below — see `world-hidden-viewport.ts`'s doc
-    // comment for why this must be recomputed from scratch on every rebuild
-    // (never a one-shot flip) and why folding it in here (rather than a
-    // separate always-on pass) is safe: the toggle itself
-    // (`GameHierarchy.tsx`'s `toggleRootHidden` + `store.notifyIngestEdit()`)
-    // changes `hiddenRootId`'s hidden state, which changes this signature,
-    // so it re-applies on the very next `syncFromStore()` call — exactly the
-    // same notify path that already re-triggers this whole method.
     const hiddenRootId = this._standaloneAuthoring ? null : policy.threeViewportRootId(this._store.shell);
     const hidden = hiddenRootId !== null && isRootHidden(hiddenRootId);
-    // While hidden, re-apply on EVERY notify, not just signature changes: a
-    // SINGLE-entity rebuild (scene-sync `updateEntityPreview`) mutates the
-    // existing objectMap in place — same instance, same size, so the gate
-    // below never re-fires — while re-stamping the rebuilt object visible
-    // from its descriptor. Cost is one map walk per notify only while a
-    // world is actually hidden; the gated call below still handles the
-    // hide→show transition (restoring per-entity visibility).
+    // Reapply hidden state on each notification, including in-place object replacements.
     if (hidden) policy.applyRootHiddenVisibility(this._objectMap, hiddenRootId);
     // Scene-LEVEL environment (background/skybox/fog/IBL). Nothing here has to
     // RESTORE it on the show edge — an adapter-backed world paints its own
@@ -3205,33 +2548,17 @@ export class EditorViewport {
     // same rationale as the per-notify `applyRootHiddenVisibility` above.
     if (hidden) policy.suppressRootEnvironment(this._scene);
     const gizmoEpoch = this._store.gizmoEpoch;
-    const gizmoSig = `${this._store.shell.showHelpers}|${this._store.shell.showGizmos}|${JSON.stringify(vis)}|${hiddenRootId ?? ''}|${hidden}|${this._threejsToolContextActive}`;
+    const gizmoSig = `${this._store.shell.showHelpers}|${JSON.stringify(vis)}|${threeSurface}`;
     const mapChanged = this._objectMap !== this._lastGizmoObjectMap;
     const settingsChanged = gizmoSig !== this._lastGizmoSig;
-    const membershipChanges = mapChanged
-      ? null
-      : this._store.ingestObjectMapMembershipChangesSince(this._lastGizmoEpoch);
-    const changedIds =
-      mapChanged || settingsChanged || membershipChanges === null
-        ? null
-        : membershipChanges.changedIds;
-    const reconcileMembership = changedIds === null || changedIds.size > 0;
+    const reconcileMembership =
+      mapChanged || settingsChanged || gizmoEpoch !== this._lastGizmoEpoch;
     this._lastGizmoObjectMap = this._objectMap;
     this._lastGizmoSig = gizmoSig;
     this._lastGizmoEpoch = gizmoEpoch;
     if (reconcileMembership) {
-      // Threejs roots have no DOM layer to `display:none` (unlike react/pixi
-      // — `design-time-layers.ts`'s `applySessionStyle`), so this is what
-      // actually makes a hidden three world's group-row eye hide its
-      // objects in THIS viewport. ABOVE the per-entity `visible` flag (ANDed
-      // in, never overwritten) — see `world-hidden-viewport.ts`.
-      policy.applyRootHiddenVisibility(this._objectMap, hiddenRootId);
-
       // Helper + icon visibility — per-type filtering
-      const helperRoots =
-        changedIds === null
-          ? topmostPublishedObjects(this._objectMap)
-          : topmostChangedObjects(this._objectMap, changedIds);
+      const helperRoots = topmostPublishedObjects(this._objectMap);
       for (const obj of helperRoots) {
         obj.traverse((child) => {
           if (getUserData(child, 'editorIcon')) {
@@ -3261,16 +2588,16 @@ export class EditorViewport {
         helper.visible =
           this._store.shell.showHelpers && (!(kind in vis) || (vis as Record<string, boolean>)[kind]!);
       }
-      this._syncCameraHelpers(changedIds);
-      this._syncLightHelpers(changedIds);
+      this._syncCameraHelpers();
+      this._syncLightHelpers();
     }
 
-    this._syncAudioHelpers(changedIds);
-    this._syncReflectionProbeHelpers(changedIds);
-    this._syncTriggerVolumeHelpers(changedIds);
-    this._syncConstraintHelpers(changedIds);
+    this._syncAudioHelpers(reconcileMembership);
+    this._syncReflectionProbeHelpers(reconcileMembership);
+    this._syncTriggerVolumeHelpers(reconcileMembership);
+    this._syncConstraintHelpers(reconcileMembership);
 
-    // Attach gizmo based on pivot mode. Spec 28: no gizmo without a visible
+    // Attach gizmo based on pivot mode. No gizmo without a visible
     // three surface — this whole block re-derives per notify, so detaching
     // here is self-healing (the un-hide notify re-attaches to the same
     // selection with no extra bookkeeping).
@@ -3284,8 +2611,7 @@ export class EditorViewport {
     // Combined mode filters/attaches on POSITION (its median-filter channel)
     // and attaches when ANY channel is writable — a scale-locked prefab
     // instance still gets move+rotate handles instead of no gizmo at all
-    // (which is also exactly what single-scale mode used to show a tester:
-    // an empty viewport with no visible refusal).
+    // (an empty viewport with no visible refusal).
     const activeTransformChannel =
       mode === 'translate' || mode === 'combined'
         ? 'position'
@@ -3315,12 +2641,8 @@ export class EditorViewport {
             }
             const obj = this._objectForAuthoringId(id);
             if (obj) {
-              // WORLD position, from `matrixWorld` — the pivot dummy lives at
-              // the scene root, so a median of LOCAL positions was already
-              // wrong for any nested node, and it is wrong a second way for a
-              // node whose driver owns its matrix (`authoring/
-              // live-object-transform.ts`: `.position` is frozen at spawn while
-              // the object renders wherever its matrix puts it).
+              // Compute the scene-root pivot from world matrices. Local position fields do not
+              // describe nested nodes or objects driven directly through their matrices.
               median.add(obj.getWorldPosition(_medianTmp));
               count++;
             }
@@ -3355,8 +2677,8 @@ export class EditorViewport {
             // `matrixWorld` (three's `getWorld*` decompose it), never from the
             // vector fields: a node whose driver owns its matrix keeps
             // `.position`/`.quaternion` frozen at spawn, so anchoring on those
-            // put the gizmo where the object USED to be while its bounds drew
-            // where it is (`authoring/live-object-transform.ts`).
+            // would put the gizmo where the object was at spawn while its bounds
+            // draw where it is (`authoring/live-object-transform.ts`).
             const pivotLocal = new THREE.Vector3(entityPivot[0], entityPivot[1], entityPivot[2]);
             pivotLocal.applyQuaternion(obj.getWorldQuaternion(_pivotQuat));
             this._pivotDummy.position.copy(obj.getWorldPosition(_pivotPos)).add(pivotLocal);
@@ -3381,13 +2703,6 @@ export class EditorViewport {
     this._syncCombinedGizmoHalves();
   }
 
-  /**
-   * The combined gizmo's halves: shown only in combined mode, each half only
-   * where its channel is WRITABLE for the attached entity — a prefab instance
-   * with a locked scale (the starter's Hero Box) shows move+rotate and
-   * honestly no scale handles, instead of a silently dead gizmo. Runs AFTER
-   * the attach block: it reads the attachment this same pass just made.
-   */
   /** Snap values reach the gizmos from the store's toggle OR a held
    *  Ctrl/⌘ (the Unity/Blender hold-to-snap convention) — three's controls
    *  read the snap on every pointer move, so a mid-drag hold takes effect. */
@@ -3407,7 +2722,7 @@ export class EditorViewport {
   private _modifiedZoom = false;
 
   private readonly _onAltOrbitStart = (e: PointerEvent): void => {
-    if (e.button === 1 && (e.ctrlKey || e.metaKey) && activeKeymapNavigation().orbit === 'middle') {
+    if (e.button === 1 && (e.ctrlKey || e.metaKey) && editorHost().keyboard.navigation().orbit === 'middle') {
       this._modifiedZoom = true;
       this.orbitControls.mouseButtons.MIDDLE = THREE.MOUSE.DOLLY;
     }
@@ -3417,9 +2732,9 @@ export class EditorViewport {
     }
   };
 
-  private readonly _onAltOrbitRelease = (event?: PointerEvent): void => {
+  private readonly _onAltOrbitRelease = (event: PointerEvent): void => {
     // The zoom is the middle button's gesture, and ends with that button's release.
-    if (this._modifiedZoom && (!event || event.type === 'pointercancel' || event.button === 1)) {
+    if (this._modifiedZoom && (event.type === 'pointercancel' || event.button === 1)) {
       this._modifiedZoom = false;
       this.applyKeymapNavigation();
     }
@@ -3435,14 +2750,15 @@ export class EditorViewport {
     if (hold === this._snapHold) return;
     this._snapHold = hold;
     this._applySnapToGizmos();
-    // Stepping reads as "slower/laggier" to someone who doesn't know it is
-    // snapping (human pass 10 said exactly that) — name it while it happens.
+    // Show a hint when the modifier temporarily enables snapping during a drag.
     if (hold && this._anyGizmoDragging() && !this._store.shell.snapEnabled) {
       const { translate, rotate, scale } = this._store.shell.snapValues;
       showTransientHint(`Snapping while held: ${translate} units · ${rotate}° · ×${scale}`);
     }
   };
 
+  /** In combined mode, show each transform half only when its channel is
+   * writable for the entity attached by the current sync pass. */
   private _syncCombinedGizmoHalves(): void {
     if (this._anyGizmoDragging()) return;
     const combined = this._store.shell.transformMode === 'combined';
@@ -3463,17 +2779,9 @@ export class EditorViewport {
     const scaleHelper = this._auxScaleControls.getHelper();
     rotateHelper.visible = rotateOn;
     scaleHelper.visible = scaleOn;
-    for (const helper of [rotateHelper, scaleHelper]) {
-      helper.traverse((child) => child.layers.set(EDITOR_LAYER));
-    }
     this.transformControls.enabled = true;
   }
 
-  /**
-   * Re-add editor infrastructure objects to the scene after play mode
-   * has cleared all scene children. Call this after loadDocument restores
-   * entities so the grid, lights, gizmos, and particle renderer are present.
-   */
   /** Move all editor gizmos from the editor scene into a target scene (e.g. the live game scene). */
   moveGizmosTo(target: THREE.Scene): void {
     const objs = this._gizmoObjects();
@@ -3505,22 +2813,14 @@ export class EditorViewport {
   }
 
   /**
-   * The active scene's content AABB, re-measured at most every
-   * {@link CONTENT_BOUNDS_MAX_AGE_MS}.
-   *
-   * A live game keeps building itself long after the editor adopts it (a
-   * level-streaming game parses its whole world in seconds after first
-   * capture), so this cannot be a one-shot measurement at scene swap —
-   * but neither can it run per frame over thousands of nodes. Cheap readers
-   * (the per-frame clip planes) take the cache; {@link focusOnScene} forces a
-   * fresh measurement, because framing on a stale box is exactly the miss it
-   * exists to prevent.
+   * Cache the active scene’s content AABB for CONTENT_BOUNDS_MAX_AGE_MS as its live graph changes.
+   * Per-frame clip planes use the cached extent; focusOnScene forces a fresh measurement.
    */
-  private _contentBounds(force = false): THREE.Box3 {
+  private _contentBounds(): THREE.Box3 {
     const now = performance.now();
     const stale =
       this._contentBoundsAt === 0 || now - this._contentBoundsAt > CONTENT_BOUNDS_MAX_AGE_MS;
-    if (force || stale) {
+    if (stale) {
       this._contentBoundsBox.makeEmpty();
       for (const child of this._scene.children) {
         if (isInEditorOwnedSubtree(child)) continue;
@@ -3551,15 +2851,9 @@ export class EditorViewport {
     return boxes;
   }
 
-  /**
-   * Grow the camera's clip planes to reach the content, every frame.
-   *
-   * See `viewport-clip-planes.ts` for the measured defect this closes: a world
-   * larger than the frozen `far = 1000` was clipped away to an empty viewport.
-   * Cheap — the bounds are cached, so a frame costs one distance and, only when
-   * the planes actually move, one `updateProjectionMatrix`.
-   */
+  /** Grow clip planes to reach cached content bounds. Update the projection only when the required planes change. */
   private _updateClipPlanes(): void {
+    if (this.projectionOwner.owned) return;
     const box = this._contentBounds();
     let distance = 0;
     let radius = 0;
@@ -3586,14 +2880,9 @@ export class EditorViewport {
    * Returns false — camera untouched — when that view cannot be used: the
    * world is behind it, on it, or PRESSED AGAINST IT (a camera placed inside
    * the geometry it is about to drive through is a fine gameplay camera and a
-   * useless first look — `seededViewShowsWorld` is the measurement, and the
-   * caller falls back to the framing, which always shows something).
+   * useless first look — `seededViewShowsWorld` is the measurement).
    *
-   * A caller inside the auto-frame window can simply ask again: a game builds
-   * itself asynchronously, and Cuberun's own `<PerspectiveCamera makeDefault>`
-   * is not in the scene at all on the frame the editor captures it (its
-   * `<Suspense>` content has not resolved), so a seed attempted only at mount
-   * misses the flagship case.
+   * A caller can retry as asynchronous scene content and its camera mount.
    */
   seedFromGameCamera(gameCamera: THREE.Camera): boolean {
     const box = frameableContentBounds(this._measureContentBounds());
@@ -3647,8 +2936,8 @@ export class EditorViewport {
         box.getSize(new THREE.Vector3()).x / this._viewportAspect,
       ) * 1.15;
     this._syncOrthographicFromPerspective(true);
-    // Before any draw: the framing distance for a world-sized scene is exactly
-    // what used to land past the far plane.
+    // Before any draw: the framing distance for a world-sized scene can land
+    // past a stale far plane.
     this._updateClipPlanes();
     return true;
   }
@@ -3752,7 +3041,7 @@ export class EditorViewport {
 
   /**
    * Show (or clear with null) the editor-only helper of `kind` —
-   * `setViewportHelper`'s implementation. The object joins the editor
+   * The object joins the editor
    * scene as a scene-root helper (`editorHelper`, `editorHelperType = kind`)
    * and follows the Helpers menu's toggle for its kind.
    */
@@ -3885,32 +3174,20 @@ export class EditorViewport {
     // every draw. Nothing here should shadow that with a second source.
   }
 
-  /**
-   * The presentation rig's lighting source for what the scene now holds: a view whose lighting is
-   * `auto` gives way to an adopted scene's own lights. Every draw runs it; a stage whose document
-   * is hidden (the game world during Play, drawn by the Game view) runs it too, so the editor's
-   * studio lights never light the game.
-   */
+  /** Resolve the current presentation source without applying the rig's own lights. */
   resolvePresentation(): void {
-    this._presentation?.rig.resolveSource({ light: this._store.isAdoptedSceneActive });
+    this._presentation?.rig.resolveSource({ light: false });
   }
 
-  update(dt = 0): void {
+  update(dt: number): void {
     this._ensureSparkRenderer();
     this._syncLookBackground();
-    // A remount can prune the attached object while the gizmos still hold it;
-    // three then errors EVERY FRAME ("must be a part of the scene graph" —
-    // human pass 10 recorded seven while authoring). Detach the moment the
-    // attachment goes stale; the store-driven sync re-attaches when the
-    // selection re-resolves onto the fresh object.
+    // Detach stale gizmo objects after a remount, then resolve the current selection again.
     const attachedObject = this.transformControls.object;
     if (attachedObject && attachedObject !== this._pivotDummy && !attachedObject.parent) {
       this._detachGizmos();
       this.syncFromStore();
     }
-    // Animate custom (shader) materials in edit mode — same tick the runtime
-    // preRender phase runs, so authored shaders preview live in the viewport.
-
     // Fly camera movement (before orbit so it takes priority)
     this._updateFlyCamera(dt);
 
@@ -3973,21 +3250,9 @@ export class EditorViewport {
   }
 
   /**
-   * W2b: enforce the editor-only forced-LOD-level preview every frame. The
-   * THREE.LOD instance is replaced by entity rebuilds and doesn't even exist
-   * until the glTF's async load resolves, so a one-shot apply at dropdown
-   * time would silently un-pin — per-frame enforcement over a map that is
-   * almost always empty is the robust (and cheap) form. 'Auto' removes the
-   * map entry and restores `autoUpdate` (see EditorShellStore.setLodForcedLevel),
-   * handing selection back to the renderer's own `LOD.update(camera)`.
-   *
-   * That last sentence is load-bearing and easy to disbelieve, because nothing
-   * in this repo calls `LOD.update`: THREE does it itself. `WebGLRenderer`'s
-   * `projectObject` runs `if (object.isLOD) { if (object.autoUpdate === true)
-   * object.update(camera); }` for every visible LOD, every render. `autoUpdate`
-   * is the ONE switch this whole feature turns, and pinning works by turning it
-   * off. Do not add an engine-side per-frame LOD tick to "fix" the missing
-   * call — it would duplicate the renderer's own work and fight the pin.
+   * Apply pinned LOD levels each frame so asynchronous loads and rebuilt instances inherit the view
+   * state. Auto removes the pin and restores autoUpdate; WebGLRenderer then calls
+   * LOD.update(camera) during rendering.
    */
   private _enforceLodForcedLevels(): void {
     const projectedObjects = new Set(this._objectMap.values());
@@ -4011,22 +3276,19 @@ export class EditorViewport {
    */
   renderWithInfrastructure(draw: () => void): void {
     const spark = this._sparkRenderer;
-    const restoreCameraView = this._cameraView ? this._suspendPreviewInfrastructure() : null;
     if (spark) this._scene.add(spark);
     try {
       draw();
     } finally {
       spark?.removeFromParent();
-      restoreCameraView?.();
     }
   }
 
-  /** Render the standard orientation gizmo in the viewport's top-right corner. */
+  /** Render the standard orientation gizmo in the corner selected by the look. */
   renderViewCube(renderer: THREE.WebGLRenderer): void {
     if (!this._threeSurfaceShowing) return; // no three stage, no compass (Blender's is persistent on one)
     if (this._navigation === 'hidden') return;
     if (!this._store.shell.showGizmos) return; // the stage's Show Gizmo is off
-    if (this._cameraView) return; // exact camera view owns the viewport
     const w = renderer.domElement.clientWidth;
     const h = renderer.domElement.clientHeight;
     const size = this._vcSize;
@@ -4068,47 +3330,7 @@ export class EditorViewport {
     }
   }
 
-  /** Paint an authored camera into the DOM preview body's exact canvas rect.
-   *  The surrounding label/actions are React chrome; this reuses the one
-   *  renderer and WebGL context rather than mounting a second viewport. */
-  renderCameraPreview(
-    renderer: THREE.WebGLRenderer,
-    entityCamera: THREE.Camera | null,
-    previewElement: HTMLElement | null,
-  ): void {
-    if (!entityCamera || !previewElement || this._cameraView) return;
-
-    const w = renderer.domElement.clientWidth;
-    const h = renderer.domElement.clientHeight;
-    const canvasRect = renderer.domElement.getBoundingClientRect();
-    const previewRect = previewElement.getBoundingClientRect();
-    const px = Math.round(previewRect.left - canvasRect.left);
-    const py = Math.round(canvasRect.bottom - previewRect.bottom);
-    const pw = Math.max(1, Math.round(previewRect.width));
-    const ph = Math.max(1, Math.round(previewRect.height));
-    if (px >= w || py >= h || px + pw <= 0 || py + ph <= 0) return;
-
-    const restoreInfrastructure = this._suspendPreviewInfrastructure();
-    // Save renderer state: the preview is a late scissored draw over the main
-    // frame and must leave the following frame's composer untouched.
-    const prevClearColor = renderer.getClearColor(this._previewClearColor);
-    const prevClearAlpha = renderer.getClearAlpha();
-    try {
-      renderer.setScissorTest(true);
-      renderer.setViewport(px, py, pw, ph);
-      renderer.setScissor(px, py, pw, ph);
-      renderer.setClearColor(0x111214, 1);
-      renderer.clear();
-      renderer.render(this._scene, entityCamera);
-    } finally {
-      renderer.setScissorTest(false);
-      renderer.setViewport(0, 0, w, h);
-      renderer.setClearColor(prevClearColor, prevClearAlpha);
-      restoreInfrastructure();
-    }
-  }
-
-  /** True when the fly camera is active (right-click + movement key held). */
+  /** True while the fly-camera session is active. */
   get isFlying(): boolean {
     return this._flyActive;
   }
@@ -4126,6 +3348,8 @@ export class EditorViewport {
     this._canvas.removeEventListener('pointerdown', this._onAltOrbitStart, { capture: true });
     window.removeEventListener('pointerup', this._onAltOrbitRelease, { capture: true });
     window.removeEventListener('pointercancel', this._onAltOrbitRelease, { capture: true });
+    window.removeEventListener('pointercancel', this._onInteractionDragLost, { capture: true });
+    window.removeEventListener('blur', this._onInteractionDragLost);
     window.removeEventListener('keydown', this._onSnapHoldKey);
     window.removeEventListener('keyup', this._onSnapHoldKey);
     this._interactionElement.removeEventListener('pointerup', this._onFlyPointerUp);
@@ -4134,15 +3358,8 @@ export class EditorViewport {
     this._interactionElement.removeEventListener('wheel', this._onTrackpadWheel);
     this._canvas.removeEventListener('pointerdown', this._onPointerDown);
     this._interactionElement.removeEventListener('pointermove', this._onPointerMove);
-    if (this._onInteractionPointerUp) {
-      this._interactionElement.removeEventListener('pointerup', this._onInteractionPointerUp);
-    }
-    if (this._onInteractionDblClick) {
-      this._interactionElement.removeEventListener('dblclick', this._onInteractionDblClick);
-    }
-    this._canvas.removeEventListener('dragover', this._onDragOver);
-    this._canvas.removeEventListener('dragleave', this._onDragLeave);
-    this._canvas.removeEventListener('drop', this._onDrop);
+    this._interactionElement.removeEventListener('pointerup', this._onPointerUp);
+    this._interactionElement.removeEventListener('dblclick', this._onInteractionDblClick);
     // Dispose controls now: deferred source cleanup must never disconnect
     // the reused element after the replacement controls have connected.
     this.orbitControls.dispose();
@@ -4150,9 +3367,9 @@ export class EditorViewport {
   }
 
   /**
-   * Paint the palette's viewport group (`EditorTheme.color.viewport`): the grid
-   * recoloured in place (its identity is held by the infrastructure lists), the
-   * axis lines shown and coloured when named, and a flat background when
+   * Apply the palette's viewport group (`EditorTheme.color.viewport`): cache the grid
+   * ink for `_applyGridLines`, paint axis-line colours and widths (the view owns visibility),
+   * and a flat background when
    * named — replacing only a background this viewport painted or none at all,
    * never a host's own (a document's declared colour, a world radiance).
    */
@@ -4164,9 +3381,7 @@ export class EditorViewport {
     // stage's colours or keeps none of them: Classic Graphite declares no
     // group and keeps its floor without the grazing fade. Which axis lines
     // show is the view's (`overlays.axes`), whatever the look.
-    const grazing = this.grid.material.uniforms['uGrazingFade'];
-    if (grazing) grazing.value = look.background !== null ? 1 : 0;
-    this._paintLookGrid();
+    this.grid.material.uniforms['uGrazingFade']!.value = look.background !== null ? 1 : 0;
     this._lookAxisHexes = [look.axisX, look.axisY, look.axisZ];
     if (this._axisLines) {
       (this._axisLines.material as LineMaterial).linewidth = this._axisLineCss(look.axisLineWidth);
@@ -4190,22 +3405,7 @@ export class EditorViewport {
   }
 
   /**
-   * The floor's TWO levels, from the palette's one grid colour. The grid is
-   * the ONE stage surface whose material is tone-mapped (see
-   * {@link toneMappedSourceColor}), so both levels are handed to it as the
-   * colours that MAP to the palette's.
-   *
-   * Blender draws both levels from ONE grid colour at two alphas. Measured in
-   * `modeling-object-none.png` over its #3f3f3f background: the 1 m line
-   * composites to lum 84 — exactly the palette's `#545454` — and the 10 m
-   * line to 102, a 1.86x contrast. The palette names the MINOR's finished
-   * appearance, so the major is that colour carried the rest of the way by
-   * the measured ratio — and the ratio is applied in the FINISHED sRGB space
-   * the 84 and the 102 were read in, before the inversion, because ACES is
-   * not linear and extrapolating on its far side lands somewhere else.
-   */
-  /**
-   * LIGHT AND DRESS THIS STAGE BY A VIEW'S PRESENTATION (`kit/viewport-presentation`): its studio
+   * LIGHT AND DRESS THIS STAGE BY A VIEW'S PRESENTATION (`@volter/sdk/viewport-presentation`): its studio
    * or preview lighting through a `StagePresentationRig` in this scene (in place of the
    * viewport's own ambient and directional), its selection marks and its grid's major step.
    * The stage's render pipeline keeps its tone mapping. The scene's own lighting is what an
@@ -4240,7 +3440,7 @@ export class EditorViewport {
         rig.dispose();
         this._editorObjects = this._editorObjects.filter((object) => !roots.includes(object));
         if (this._presentation === binding) this._presentation = null;
-        const rigOn = this._lightRig && !this._store.isAdoptedSceneActive;
+        const rigOn = this._lightRig;
         this._editorAmbient.visible = rigOn;
         this._editorDirLight.visible = rigOn;
       },
@@ -4252,11 +3452,11 @@ export class EditorViewport {
     return binding.stop;
   }
 
-  /** The view's selection marks; a change rebuilds the marks for the current selection. */
-  setSelectionMarks(marks: { readonly outline: boolean; readonly wire: boolean; readonly box: boolean }): void {
+  /** The view's wire and box marks; a change rebuilds them for the current selection. */
+  setSelectionMarks(marks: { readonly wire: boolean; readonly box: boolean }): void {
     const current = this._selectionMarks;
-    if (current.outline === marks.outline && current.wire === marks.wire && current.box === marks.box) return;
-    this._selectionMarks = { outline: marks.outline, wire: marks.wire, box: marks.box };
+    if (current.wire === marks.wire && current.box === marks.box) return;
+    this._selectionMarks = { wire: marks.wire, box: marks.box };
     this._syncBoxHelpers();
   }
 
@@ -4338,23 +3538,21 @@ export class EditorViewport {
 
   /** Minor cells per major line (`overlays.grid.majorEvery`; Blender 10, Godot 8). */
   setGridMajorEvery(every: number): void {
-    const uniform = this.grid.material.uniforms['uMajorEvery'];
-    if (uniform && Number.isFinite(every) && every >= 1) uniform.value = every;
+    if (Number.isFinite(every) && every >= 1) this.grid.material.uniforms['uMajorEvery']!.value = every;
   }
 
   /** The look's floor lines: widths in device pixels and the major level's contrast. */
-  private _gridMajorContrast = 1;
+  private _gridMajorContrast!: number;
   private _applyGridLines(lines: ReturnType<typeof nativeViewportGrid>): void {
     const uniforms = this.grid.material.uniforms;
-    if (uniforms['uLineWidth']) uniforms['uLineWidth'].value = lines.lineWidth;
-    if (uniforms['uMajorWidth']) uniforms['uMajorWidth'].value = lines.majorWidth;
+    uniforms['uLineWidth']!.value = lines.lineWidth;
+    uniforms['uMajorWidth']!.value = lines.majorWidth;
     this._gridMajorContrast = lines.majorContrast;
     this._paintLookGrid();
   }
 
   private _paintLookGrid(): void {
     const hex = this._lookGridHex;
-    if (hex === null) return;
     const backgroundHex = this._lookBackgroundHex ?? 0x3f3f3f;
     const channel = (shift: number) => {
       const line = (hex >> shift) & 0xff;
@@ -4364,18 +3562,11 @@ export class EditorViewport {
     const majorHex = (channel(16) << 16) | (channel(8) << 8) | channel(0);
     const minor = toneMappedSourceColor(hex, this._renderer);
     const major = toneMappedSourceColor(majorHex, this._renderer);
-    (this.grid.material.uniforms['uColor']?.value as THREE.Color | undefined)?.copy(minor);
-    (this.grid.material.uniforms['uMajorColor']?.value as THREE.Color | undefined)?.copy(major);
+    (this.grid.material.uniforms['uColor']!.value as THREE.Color).copy(minor);
+    (this.grid.material.uniforms['uMajorColor']!.value as THREE.Color).copy(major);
   }
 
-  /**
-   * THE WORLD'S AXIS LINES, rebuilt from the view's `overlays.axes`, the stage's axis frame and
-   * the look's colours. `floor` is the two world axes three's X and Z carry; each shown world
-   * axis is drawn along the three axis that carries it. The colours are RAW (`toneMapped: false`,
-   * opaque): what is set is what the screen shows — Blender's X plateaus at `#cb293f` and Y at
-   * `#69aa15` in `modeling-object-none.png`, which is what its palette names. An axis the look
-   * gives no colour takes the gizmo's.
-   */
+  /** Build shown world axes from overlays.axes and the stage axis frame. Use raw look colours, falling back to the gizmo palette for unspecified axes. */
   private _rebuildAxisLines(): void {
     const lines = this._axisLines;
     if (!lines) return;
@@ -4389,16 +3580,14 @@ export class EditorViewport {
     this._axesWanted = shown.length > 0;
     lines.visible = this.grid.visible && this._axesWanted;
     if (!this._axesWanted) return;
-    // A FRESH GEOMETRY per rebuild: three caches an instanced geometry's instance count at
-    // its first draw (`_maxInstanceCount`), so growing one from two lines to three drew only
-    // the first two.
+    // Replace geometry on rebuild so its cached instance count matches the current axes.
     const build = (threeAxes: readonly number[]): LineSegmentsGeometry => {
       const positions: number[] = [];
       const colors: number[] = [];
       for (const threeAxis of threeAxes) {
         const world = frame[threeAxis]![0];
-        const hex = this._lookAxisHexes[world];
-        const color = hex === null || hex === undefined ? this._gizmoAxisColor(world) : new THREE.Color(hex);
+        const hex = this._lookAxisHexes[world]!;
+        const color = hex === null ? this._gizmoAxisColor(world) : new THREE.Color(hex);
         positions.push(...axisSegmentPositions(threeAxis));
         for (let i = 0; i < AXIS_SEGMENTS_PER_AXIS * 2; i++) colors.push(color.r, color.g, color.b);
       }
@@ -4494,14 +3683,12 @@ export class EditorViewport {
       (this._axisLines.material as THREE.Material).dispose();
       this._axisLines = null;
     }
-    this.clearCameraView();
     if (this._sparkRenderer) {
       this._scene.remove(this._sparkRenderer);
       disposeSparkRendererWhenIdle(this._sparkRenderer);
       this._sparkRenderer = null;
     }
     this.disconnectInput();
-    this._hideDropOverlay();
     for (const helper of this._helpers.values()) this._scene.remove(helper);
     this._helpers.clear();
     for (const helper of this._boxHelpers.values()) {
@@ -4526,8 +3713,9 @@ export class EditorViewport {
   // --- Private ---
 
   private _ensureSparkRenderer(): void {
+    const renderer = this._renderer;
     if (
-      !this._renderer ||
+      !renderer ||
       this._sparkRenderer ||
       this._sparkRendererLoading ||
       this._sparkRendererFailed
@@ -4540,8 +3728,8 @@ export class EditorViewport {
     this._sparkRendererLoading = true;
     void import('@sparkjsdev/spark')
       .then(({ SparkRenderer }) => {
-        if (this._disposed || !this._renderer) return;
-        const spark = new SparkRenderer({ renderer: this._renderer, enableLod: false });
+        if (this._disposed) return;
+        const spark = new SparkRenderer({ renderer, enableLod: false });
         spark.traverse((node) => setUserData(node, 'engineInternal', true));
         this._sparkRenderer = spark;
         invalidateStages();
@@ -4557,21 +3745,7 @@ export class EditorViewport {
   }
 
   /**
-   * BLENDER'S NAVIGATION GIZMO — six balls on three axis stalks, not an arrow
-   * rig. Measured in `modeling-object-none.png` at matched scale: a 72 CSS px
-   * circle of 16 px balls on a 28 px radius; the three POSITIVE balls are
-   * filled in their axis colour and carry a dark letter, the three negative
-   * ones are a 2 px ring of the same colour over the stage; a 3 px stalk runs
-   * from the centre to each positive ball only; and the whole thing fades
-   * back-to-front with depth (`_syncOrientationGizmoDepth`, run per frame),
-   * which is what makes the near balls read as near.
-   *
-   * The gizmo camera's frustum is +/-1.5, and the scissored box it draws into
-   * is `COMPASS_BOX_PX`, so one unit is `COMPASS_BOX_PX / 3` screen px — every
-   * size below is a measured pixel count divided by that.
-   */
-  /**
-   * BUILD (or REBUILD) THE NAVIGATION GIZMO in the look's axis frame.
+   * BUILD (or REBUILD) THE NAVIGATION GIZMO in the presented world's axis frame.
    *
    * Blender's gizmo draws a stalk and a FILLED, LETTERED ball on each axis's
    * POSITIVE side and a hollow one opposite, and the axis it calls Z is the
@@ -4586,16 +3760,15 @@ export class EditorViewport {
    * a fact about the scene and not about what the axis is called.
    */
   private _buildOrientationGizmo(): void {
-    if (this._vcScene === undefined) return;
     // Rebuilt on every look change, so what it held is released, textures included.
     for (const held of [...this._vcScene.children]) {
       this._vcScene.remove(held);
       const drawn = held as THREE.Mesh | THREE.Sprite;
       // A sprite's geometry is three's one shared quad: left alone.
-      if (!(drawn as THREE.Sprite).isSprite) drawn.geometry?.dispose();
-      const material = drawn.material as (THREE.Material & { map?: THREE.Texture | null }) | undefined;
-      material?.map?.dispose();
-      material?.dispose();
+      if (!(drawn as THREE.Sprite).isSprite) drawn.geometry.dispose();
+      const material = drawn.material as THREE.Material & { map?: THREE.Texture | null };
+      material.map?.dispose();
+      material.dispose();
     }
     this._vcBalls.length = 0;
     this._vcStalks.length = 0;
@@ -4631,7 +3804,7 @@ export class EditorViewport {
       // The look's navigation colours, else its axis colours, else the editor's own.
       const lookAxes = this._gizmoLook.navigation ?? this._gizmoLook.axes;
       const color =
-        lookAxes === null ? new THREE.Color(...KIT_GIZMO_AXIS_RGB[sourceAxis]!) : new THREE.Color(lookAxes[sourceAxis]!);
+        lookAxes === null ? this._gizmoAxisColor(sourceAxis) : new THREE.Color(lookAxes[sourceAxis]!);
       const letter = AXIS_LETTER[sourceAxis]!;
       const axis = axes[i]!.clone().multiplyScalar(positive);
 
@@ -4701,11 +3874,11 @@ export class EditorViewport {
     for (let i = 0; i < 3; i++) {
       const [sourceAxis, positive] = this._stageAxisFrame[i]!;
       const color =
-        lookAxes === null ? new THREE.Color(...KIT_GIZMO_AXIS_RGB[sourceAxis]!) : new THREE.Color(lookAxes[sourceAxis]!);
+        lookAxes === null ? this._gizmoAxisColor(sourceAxis) : new THREE.Color(lookAxes[sourceAxis]!);
       const letter = AXIS_LETTER[sourceAxis]!;
       const axis = axes[i]!.clone().multiplyScalar(positive);
       if (form === 'triad') {
-        // Unreal's triad is about 40 px, opaque and undimmed by facing (`level-editor.png`); its
+        // Unreal's triad is about 40 px, opaque and undimmed by facing; its
         // size is the look's (`navigationSize`, a multiple of this 24 px).
         const scale = this._gizmoLook.navigationSize ?? 1;
         const length = (24 * scale) / perUnit;
@@ -4752,14 +3925,7 @@ export class EditorViewport {
     }
   }
 
-  /**
-   * The gizmo's depth cue, per frame: a ball pointing AWAY from the viewer is
-   * drawn behind, dimmer and SMALLER, exactly as Blender's is. Both laws are
-   * measured off the reference's own six balls and stated where they are
-   * applied below. Sprites carry no depth of their own here
-   * (`depthTest: false`, so the stage never occludes the gizmo), so the draw
-   * ORDER is set here too.
-   */
+  /** Order navigation sprites by depth and dim and shrink balls that point away from the viewer. */
   private _syncOrientationGizmoDepth(): void {
     const perUnit = COMPASS_BOX_PX / 3;
     const view = this._vcDir.copy(this._vcCamera.position).normalize();
@@ -4767,9 +3933,7 @@ export class EditorViewport {
     // a ball's colour is its axis colour mixed with the viewport's background by its depth
     // (`fading_color`: `(depth + 1) · 0.25 + 0.5`), a negative ball a 25% tint of it ringed in
     // that colour, and a view looking straight down an axis (`axis_align`) hides that axis's far
-    // ball, fills its near negative one (ringed halfway to white) and letters it `-Y`. Checked
-    // against both reference frames: the default view's +X fill (245,54,81) is this mix at depth
-    // 0.82, the front view's (204,55,78) at depth 0.
+    // ball, fills its near negative one (ringed halfway to white) and letters it `-Y`. Use the view-depth mix for the visible axis colours.
     if (this._gizmoLook.navigationForm === 'godot') {
       this._syncGodotNavigation(view);
       return;
@@ -4812,15 +3976,12 @@ export class EditorViewport {
         ringMaterial.color.copy(fading);
         ringMaterial.opacity = 1;
       }
-      // The letter's ink is the fill darkened, as measured on Blender's frames (0.356; Blender
-      // draws it black at 0.9 over a small glyph, and this is what that reads as).
+      // Letter ink uses the axis fill darkened by 0.356.
       letterMaterial.color.copy(mix(black, fillMaterial.color, COMPASS_LETTER_INK, scratch));
       fill.visible = !alignedBack;
       ring.visible = !alignedBack;
       letter.visible = (positive || axis === aligned) && !alignedBack;
-      // The ball's SIZE, on the same quantity: an orthographic gizmo camera gives no depth scale
-      // for free, and Blender's six balls measure a straight line in `facing` (the fit is in the
-      // box's docblock).
+      // Scale each ball linearly with facing; orthographic projection supplies no depth scaling.
       const scale = (COMPASS_BALL_BACK_PX + COMPASS_BALL_DEPTH_GAIN_PX * facing) / perUnit;
       const order = 10 + Math.round(facing * 100) * 3;
       for (const [part, rank] of [[fill, 0], [ring, 1], [letter, 2]] as const) {
@@ -4893,12 +4054,8 @@ export class EditorViewport {
   }
 
   /**
-   * Is this pointer over the orientation cube's screen-space box? The HIT
-   * TEST alone, with no side effect, because two gestures need the answer for
-   * different reasons: the single click snaps the camera with it, and the
-   * double click (drill-in) must simply not treat the cube as geometry —
-   * without this guard, double-clicking the cube drilled into whatever the
-   * pointer found BEHIND it.
+   * Test the pointer against the orientation cube’s screen-space box without changing state. Single
+   * clicks use it for axis navigation; double-click selection excludes it from scene geometry.
    */
   private _isOverViewCube(clientX: number, clientY: number): boolean {
     // An indicator is only drawn, and a triad has nothing to click: clicks pass to the stage.
@@ -4911,15 +4068,10 @@ export class EditorViewport {
     return x >= vcLeft && x <= vcLeft + this._vcSize && y >= vcTop && y <= vcTop + this._vcSize;
   }
 
-  /**
-   * WHERE THE NAVIGATION GIZMO'S BOX SITS, top-left in CSS px from the canvas's top-left: the
-   * look's corner (`navigationCorner`) — Blender's top right, set by its measured margins, or
-   * Unreal's bottom left, one small margin in from both edges — inset by the canvas's bleed.
-   */
+  /** Place the gizmo box in the look’s navigation corner, inset by canvas bleed. */
   private _vcOrigin(width: number, height: number, inset: number): { left: number; top: number } {
     if (this._gizmoLook.navigationCorner === 'bottom-left') {
-      // Clear of the stage's own camera readout, two lines along the bottom edge (measured: a
-      // 4 px margin put the triad's lower half under it).
+      // Leave room above the stage’s two-line camera readout.
       const left = 4;
       const bottom = 48;
       return { left: left + inset, top: height - this._vcSize - bottom - inset };
@@ -5005,8 +4157,8 @@ export class EditorViewport {
       });
     };
     // Primary (if it's a real entity, not pivot dummy)
-    const obj = this._activeGizmo.object;
-    if (obj && obj !== this._pivotDummy) {
+    const obj = this._activeGizmo.object!;
+    if (obj !== this._pivotDummy) {
       applyLive(this._attachedAuthoringId ?? this._authoringIdForObject(obj), obj);
     }
     // Other selected objects (active-element / individual-origins)
@@ -5195,9 +4347,6 @@ export class EditorViewport {
     targets: {
       id: string;
       obj: THREE.Object3D;
-      startPos: THREE.Vector3;
-      startQuat: THREE.Quaternion;
-      startScale: THREE.Vector3;
     }[],
   ): void {
     // Collect all dragged entity IDs to exclude from raycast
@@ -5214,11 +4363,6 @@ export class EditorViewport {
     // Also include the grid as a snap target
     sceneTargets.push(this.grid);
 
-    if (sceneTargets.length === 0) {
-      this._surfaceSnapIndicator.visible = false;
-      return;
-    }
-
     // Raycast downward from the gizmo object position
     const origin = gizmoObj.position.clone();
     origin.y += 50; // Start high above
@@ -5269,7 +4413,7 @@ export class EditorViewport {
       obj.traverse((child) => {
         if (isInEditorOwnedSubtree(child)) return;
         const mesh = child as THREE.Mesh;
-        if (!mesh.isMesh || !mesh.geometry) return;
+        if (!mesh.isMesh) return;
         const posAttr = mesh.geometry.getAttribute('position') as THREE.BufferAttribute | undefined;
         if (!posAttr) return;
         const count = Math.min(posAttr.count, MAX_PER_MESH);
@@ -5289,7 +4433,7 @@ export class EditorViewport {
    */
   private _applyVertexSnap(
     gizmoObj: THREE.Object3D,
-    targets: { obj: THREE.Object3D; startPos: THREE.Vector3 }[],
+    targets: { obj: THREE.Object3D }[],
   ): void {
     const entityPos = gizmoObj.position;
     const projected = entityPos.clone().project(this._screenCamera);
@@ -5323,7 +4467,7 @@ export class EditorViewport {
       }
       this._vertexSnapIndicator.position.copy(bestVertex);
       this._vertexSnapIndicator.visible = true;
-      // Constant screen size for indicator
+      // Scale the indicator with its distance from the drawing camera.
       const dist = bestVertex.distanceTo(this._screenCamera.position);
       this._vertexSnapIndicator.scale.setScalar(dist * 0.008);
     } else {
@@ -5339,7 +4483,7 @@ export class EditorViewport {
     this._otherDragObjects = [];
     this._allDragObjects = [];
     this._preservedChildObjects = [];
-    // Persist the final transform + mark dirty (ED2). A mid-drag autosave may
+    // Persist the final transform and mark dirty. A mid-drag autosave may
     // have already fired and cleared dirty; this re-schedules the final write.
     const authoring = this._authoring();
     for (const id of editIds) endAuthoringTransformEdit(authoring, id);
@@ -5354,61 +4498,7 @@ export class EditorViewport {
     return false;
   }
 
-  /** Recolor gizmo handles to Godot axis colors & shift plane geometry to meet at center. */
-  /**
-   * THE GIZMO IS A CONSTANT NUMBER OF PIXELS WHEN THE LOOK STATES ONE (owner,
-   * 2026-09-21: *"is gizmo perhaps the wrong size?"*).
-   *
-   * Our gizmo is three's `TransformControls`, whose handles scale as
-   * `factor · size / 4` (`TransformControls.js:1539-1551` at the pinned
-   * 0.180.0). Work the projection through that and the distance cancels:
-   *
-   *   perspective — `factor = d · min(1.9·tan(fov/2)/zoom, 7)`, and one world
-   *     unit at distance `d` spans `H·zoom / (2·d·tan(fov/2))` px, so one
-   *     gizmo-LOCAL unit spans `1.9·size·H/8 = 0.2375 · size · H` px. Constant
-   *     in `d` and in `zoom`, and a FRACTION OF THE VIEWPORT: at `size` 1 an
-   *     800 px viewport gave 190 px per local unit and a 1400 px one gave 332.
-   *   orthographic — `factor = (top − bottom)/zoom` and one world unit spans
-   *     `H·zoom / (top − bottom)` px, so one local unit spans `size · H / 4`.
-   *
-   * Blender's rule is the same SHAPE with its own unit: one gizmo unit is
-   * `U.gizmo_size` CSS px, flat (`wm_gizmo.cc:450-474`, and
-   * `StageContribution.gizmoSize` for the whole derivation). So the
-   * look states Blender's number and this converts it — and the conversion is
-   * the one thing neither side can state, because THREE'S UNIT IS HALF
-   * BLENDER'S. Measured off the two libraries' own handle geometry, all three
-   * families agreeing within 5%:
-   *
-   *   translate arm, origin → arrow tip
-   *       three     0.6  (stem `lineGeometry2` 0→0.5, `TransformControls.js:1207`;
-   *                       cone 0.1 long placed at 0.5, `:1198-1199`, `:1235`)
-   *       Blender   1.25 (stem ends at `gizmo_line_range`'s `end` 1.0,
-   *                       `transform_gizmo_3d.cc:1173-1203`; head 0.25,
-   *                       `arrow3d_gizmo.cc:191`)            ratio 2.08
-   *   rotate ring radius
-   *       three     0.5  (`CircleGeometry(0.5, …)`, `TransformControls.js:1315-1323`)
-   *       Blender   1.0  (`imm_draw_circle_wire_3d(…, 1.0f, …)`,
-   *                       `dial3d_gizmo.cc:162`)              ratio 2.00
-   *   scale handle, origin → outer face
-   *       three     0.58 (0.08 box lifted to 0.54, `:1235`-family)
-   *       Blender   1.10 (line end 1.0 + box `size` 0.05 ×2,
-   *                       `arrow3d_gizmo.cc:175-177`)         ratio 1.90
-   *
-   * so `pixels per three unit = 2 · gizmoSize`, which lands the rotate ring on
-   * Blender's 75 px radius exactly and the move arrow at 90 px against
-   * Blender's 93.75. The brief this was built from proposed
-   * `size = px / (0.2375·H)` — that reads Blender's number as px per THREE
-   * unit, which would draw every handle at half Blender's, and the three
-   * ratios above are why it is not what landed.
-   *
-   * A look that states no size keeps `size` 1 — three's own default and what
-   * every non-Blender look drew before this existed.
-   *
-   * CALLED ON EVERY RESIZE (the px↔local conversion has `H` in it), on a
-   * projection change (the two branches differ) and on a theme change. It is
-   * NOT called per frame: `getComputedStyle` is the expensive half and the
-   * theme subscription is what invalidates it.
-   */
+  /** Resolve look-defined transform-handle size into TransformControls.size using camera projection and viewport height. Recompute on look changes rather than reading computed style every frame. */
   private _applyGizmoSize(): void {
     // The theme subscription fires SYNCHRONOUSLY on install, which is earlier
     // in the constructor than the controls — the same ordering the grid's own
@@ -5428,39 +4518,11 @@ export class EditorViewport {
     for (const controls of this._allGizmos()) controls.size = size;
   }
 
-  /**
-   * THE MOVE AND SCALE GIZMOS HAVE THREE ARMS, NOT SIX.
-   *
-   * three's translate gizmo draws each axis TWICE — a stem with an arrowhead
-   * at `+0.5` and a second bare arrowhead at `-0.5`
-   * (`TransformControls.js`'s `gizmoTranslate`, two `arrowGeometry` entries
-   * per axis) — so the handle set reads as six directions. No editor we draw
-   * against does that: Blender's move gizmo is three arms out of the origin
-   * plus the plane squares and the white view circle
-   * (`transform_gizmo_3d.cc`'s `gizmo_line_range`, and the reference frame
-   * `b6/blender-reference/gizmo-move.png`), and measured on the Model
-   * document at walk 5 parity row 2 the stray heads read as three extra
-   * "axes" pointing back through the object.
-   *
-   * The PLANE squares, the centre octahedron and every rotate ring are
-   * untouched; this drops only the negative-side handles and the pick volumes
-   * behind them, so nothing that used to be draggable stops being draggable —
-   * a negative handle and its positive twin drive the same axis.
-   *
-   * WHICH CHILD IS WHICH is read off the GEOMETRY, because three's
-   * `setupGizmo` bakes each handle's placement into a cloned geometry and
-   * resets the object transform to the identity every frame — the same reason
-   * {@link _patchCombinedScaleGizmo} measures bounding boxes rather than
-   * positions. A stem spans 0 → 0.5 and centres at +0.25, so only the bare
-   * `-0.5` head has a centre on the negative side of its own axis.
-   */
-  private _dropNegativeAxisHandles(helper: THREE.Object3D, modes: readonly string[]): void {
+  /** Keep only the positive translate and scale heads; identify the negative heads by their geometry centres rather than helper names. */
+  private _dropNegativeAxisHandles(helper: THREE.Object3D, modes: readonly ('translate' | 'scale')[]): void {
     const gizmoNode = helper.children.find(
       (child) => (child as { isTransformControlsGizmo?: boolean }).isTransformControlsGizmo,
-    ) as unknown as
-      | { gizmo: Record<string, THREE.Object3D>; picker: Record<string, THREE.Object3D> }
-      | undefined;
-    if (!gizmoNode) return;
+    ) as TransformControlsGizmo;
     const axisOf: Record<string, THREE.Vector3> = {
       X: new THREE.Vector3(1, 0, 0),
       Y: new THREE.Vector3(0, 1, 0),
@@ -5468,23 +4530,19 @@ export class EditorViewport {
     };
     for (const mode of modes)
       for (const group of [gizmoNode.gizmo[mode], gizmoNode.picker[mode]]) {
-        if (!group) continue;
         for (const child of [...group.children]) {
           const axis = axisOf[child.name];
           if (axis === undefined) continue;
           const mesh = child as THREE.Mesh;
-          if (!mesh.geometry) continue;
           mesh.geometry.computeBoundingBox();
-          const bounds = mesh.geometry.boundingBox;
-          if (!bounds) continue;
+          const bounds = mesh.geometry.boundingBox!;
           if (bounds.getCenter(new THREE.Vector3()).dot(axis) < 0) group.remove(child);
         }
       }
   }
 
   /**
-   * THE COLOUR EACH HANDLE CARRIES, in the frame the look says this stage is
-   * presenting.
+   * THE COLOUR EACH HANDLE CARRIES, in the world frame the view presentation supplies.
    *
    * A handle is NAMED for three's axis and COLOURED for the source axis that
    * three axis carries ({@link StageAxisFrame}) — under three's own frame the
@@ -5507,15 +4565,8 @@ export class EditorViewport {
     };
   }
 
-  /**
-   * READ WHAT THE LOOK SAYS ABOUT THIS STAGE and put the gizmos in that frame.
-   *
-   * Called once the gizmos exist and again on every theme change, and it is
-   * idempotent by construction: the mirror below is applied as the DIFFERENCE
-   * between the frame the geometry is already in ({@link _appliedAxisSigns})
-   * and the one the look now asks for, and a mirror is its own inverse.
-   */
-  private _readLookStage(_canvas: HTMLElement): void {
+  /** Apply the current stage axis frame and rebuild the orientation gizmo after a look change. */
+  private _readLookStage(): void {
     this._applyGizmoAxisFrame();
     this._buildOrientationGizmo();
   }
@@ -5523,7 +4574,7 @@ export class EditorViewport {
   /**
    * THE STAGE'S FUNCTION from its view's presentation (ARCHITECTURE.md rule 7): which axis of
    * the presented world is up — what the gizmos name and orient their axes by — and what a box
-   * drag selects. Never from the look: a Blender look over a Y-up game world named its axes Z-up.
+   * drag selects. The look does not determine the world's coordinate system.
    */
   setStageFunction(
     world: { readonly upAxis: 'y' | 'z'; readonly handedness: 'right' | 'left' },
@@ -5561,8 +4612,8 @@ export class EditorViewport {
    * colour.
    *
    * three authors its translate arms, its scale stalks and its plane squares
-   * on the POSITIVE side of each of its own axes, and B6 drops the stray
-   * negative-side heads so the set reads as three arms rather than six. Under
+   * on the positive side of each axis. Negative-side heads are hidden so
+   * the set reads as three arms rather than six. Under
    * a Z-up world one of those three arms is pointing the wrong WAY: the
    * source's +Y is three's −Z, and Blender draws an arm along +Y and nothing
    * along −Y. So the handles of a flipped axis are MIRRORED onto the other
@@ -5598,9 +4649,8 @@ export class EditorViewport {
     // its geometry is not mirrored — doing either would apply the permutation
     // a second time.
     //
-    // MEASURED 2026-09-21: with the permutation applied to all three families,
-    // the scale handle that had pointed up was mirrored to point DOWN and a
-    // drag where it used to be moved nothing at all.
+    // With the permutation applied to all three families, the scale handle
+    // that points up would be mirrored to point DOWN.
     const identity: Record<string, THREE.Color> = {
       X: this._gizmoAxisColor(0),
       Y: this._gizmoAxisColor(1),
@@ -5609,48 +4659,43 @@ export class EditorViewport {
       YZ: this._gizmoAxisColor(0),
       XZ: this._gizmoAxisColor(1),
     };
-    // A HANDLE'S MATERIAL IS SHARED ACROSS THE WHOLE INSTANCE — three builds
-    // ONE `materialLib` per `TransformControlsGizmo` and hands the same
-    // `matGreen` to the translate arm, the rotate ring and the scale stalk of
-    // that axis (`TransformControls.js`'s `materialLib`, and the public
-    // `setColors` that writes it). So a family that needs its OWN ink must
-    // take its own material first; without that the last paint wins for every
-    // family at once (measured 2026-09-21: painting scale identity turned the
-    // translate arms back to three's colours in the same call).
+    // Clone shared handle materials when a gizmo family needs separate colours, so changing scale colours cannot recolour translate or rotate.
     const paint = (
-      group: THREE.Object3D | undefined,
+      group: THREE.Object3D,
       map: Record<string, THREE.Color>,
       flip: boolean,
       ownMaterial: boolean,
       handles: boolean,
     ) => {
-      if (!group) return;
       group.traverse((child) => {
-        const mesh = child as THREE.Mesh;
+        const mesh = child as THREE.Object3D & {
+          geometry?: THREE.BufferGeometry;
+          material?: (THREE.MeshBasicMaterial | THREE.LineBasicMaterial) & {
+            _color?: THREE.Color | undefined;
+            _opacity?: number | undefined;
+          };
+        };
         if (flip && mesh.geometry) mesh.geometry.scale(delta[0]!, delta[1]!, delta[2]!);
         if (
           ownMaterial &&
           mesh.material &&
-          !Array.isArray(mesh.material) &&
           !mesh.userData['volterOwnMaterial']
         ) {
-          mesh.material = (mesh.material as THREE.Material).clone();
+          mesh.material = mesh.material.clone();
           mesh.userData['volterOwnMaterial'] = true;
         }
-        const material = mesh.material as
-          | (THREE.MeshBasicMaterial & { _color?: THREE.Color | undefined })
-          | undefined;
-        if (!material || Array.isArray(material)) return;
+        const material = mesh.material;
+        if (!material) return;
         if (flip) material.side = THREE.DoubleSide;
         const ink = map[child.name];
-        if (ink && material.color) {
+        if (ink) {
           // THE LOOK'S RESTING OPACITY over the handle's own (three draws its plane squares
           // translucent); three caches it like the colour, so the cache is dropped too.
           // Handles only: the drag's axis lines (the `helper` family) keep three's own.
           if (handles) {
             const base = (material.userData['volterBaseOpacity'] ??= material.opacity) as number;
             material.opacity = base * (this._gizmoLook.opacity ?? 1);
-            (material as { _opacity?: number | undefined })._opacity = undefined;
+            material._opacity = undefined;
           }
           material.color.copy(ink);
           // THREE CACHES A HANDLE'S RESTING COLOUR ON ITS FIRST UPDATE
@@ -5668,22 +4713,15 @@ export class EditorViewport {
         .getHelper()
         .children.find(
           (child) => (child as { isTransformControlsGizmo?: boolean }).isTransformControlsGizmo,
-        ) as unknown as
-        | {
-            gizmo: Record<string, THREE.Object3D>;
-            picker: Record<string, THREE.Object3D>;
-            helper: Record<string, THREE.Object3D>;
-          }
-        | undefined;
-      if (!node) continue;
+        ) as TransformControlsGizmo;
       for (const family of ['gizmo', 'picker', 'helper'] as const) {
         // ONLY THE TRANSLATE ARMS ARE MIRRORED. A rotate RING is symmetric
         // about every axis it spans, so the permutation is visible in its
         // colour alone; the scale family is in the object's own frame (above).
         const handles = family === 'gizmo';
-        paint(node[family]?.['translate'], permuted, mirrored, false, handles);
-        paint(node[family]?.['rotate'], permuted, false, false, handles);
-        paint(node[family]?.['scale'], identity, false, true, handles);
+        paint(node[family].translate, permuted, mirrored, false, handles);
+        paint(node[family].rotate, permuted, false, false, handles);
+        paint(node[family].scale, identity, false, true, handles);
       }
     }
     if (mirrored) this._appliedAxisSigns = want as readonly (1 | -1)[];
@@ -5713,17 +4751,7 @@ export class EditorViewport {
       .getHelper()
       .children.find(
         (child) => (child as { isTransformControlsGizmo?: boolean }).isTransformControlsGizmo,
-      ) as
-      | (THREE.Object3D & {
-          gizmo: Record<string, THREE.Object3D>;
-          picker: Record<string, THREE.Object3D>;
-          axis: string | null;
-          mode: string;
-          enabled: boolean;
-          dragging: boolean;
-        })
-      | undefined;
-    if (!node) return;
+      ) as TransformControlsGizmo & Pick<TransformControls, 'axis' | 'mode' | 'enabled' | 'dragging'>;
     const threeUpdate = node.updateMatrixWorld.bind(node);
     node.updateMatrixWorld = (force?: boolean) => {
       threeUpdate(force);
@@ -5741,7 +4769,7 @@ export class EditorViewport {
             : null;
       if (hidden !== null) {
         for (const family of [node.gizmo, node.picker]) {
-          for (const handle of family[node.mode]?.children ?? []) {
+          for (const handle of family[node.mode].children) {
             if (handle.name === hidden) handle.visible = false;
           }
         }
@@ -5757,12 +4785,10 @@ export class EditorViewport {
       )
         return;
       const fixed = node.dragging ? (look.drag ?? look.hover) : look.hover;
-      for (const handle of node.gizmo[node.mode]?.children ?? []) {
+      for (const handle of node.gizmo[node.mode].children) {
         if (handle.name !== axis && !axis.split('').some((letter) => handle.name === letter)) continue;
-        const material = (handle as THREE.Mesh).material as
-          | (THREE.MeshBasicMaterial & { _color?: THREE.Color })
-          | undefined;
-        if (!material || Array.isArray(material) || !material.color) continue;
+        const material = (handle as THREE.Mesh | THREE.Line).material as
+          (THREE.MeshBasicMaterial | THREE.LineBasicMaterial) & { _color?: THREE.Color };
         if (fixed !== null) {
           material.color.setHex(fixed);
           continue;
@@ -5808,19 +4834,15 @@ export class EditorViewport {
       .getHelper()
       .children.find(
         (child) => (child as { isTransformControlsGizmo?: boolean }).isTransformControlsGizmo,
-      ) as unknown as
-      | { gizmo: Record<string, THREE.Object3D>; picker: Record<string, THREE.Object3D> }
-      | undefined;
-    if (!node) return;
+      ) as TransformControlsGizmo;
     const axisIndex: Record<string, number> = { X: 0, Y: 1, Z: 2 };
     const along = (index: number, factor: number): [number, number, number] =>
       [0, 1, 2].map((i) => (i === index ? factor : 1)) as [number, number, number];
-    for (const handle of node.gizmo['translate']?.children ?? []) {
+    for (const handle of node.gizmo.translate.children) {
       const index = axisIndex[handle.name];
-      const geometry = (handle as THREE.Mesh).geometry as THREE.BufferGeometry | undefined;
-      if (index === undefined || !geometry) continue;
-      const cylinder = geometry as THREE.CylinderGeometry;
-      const isHead = cylinder.parameters?.radiusTop === 0;
+      if (index === undefined) continue;
+      const geometry = (handle as THREE.Mesh<THREE.CylinderGeometry>).geometry;
+      const isHead = geometry.parameters.radiusTop === 0;
       if (!isHead) {
         geometry.scale(...along(index, stretch));
         continue;
@@ -5838,10 +4860,10 @@ export class EditorViewport {
       offset[index] = base * stretch;
       geometry.translate(...offset);
     }
-    for (const handle of node.picker['translate']?.children ?? []) {
+    for (const handle of node.picker.translate.children) {
       const index = axisIndex[handle.name];
-      const geometry = (handle as THREE.Mesh).geometry as THREE.BufferGeometry | undefined;
-      if (index === undefined || !geometry) continue;
+      if (index === undefined) continue;
+      const geometry = (handle as THREE.Mesh<THREE.CylinderGeometry>).geometry;
       geometry.scale(...along(index, tipScale));
     }
     this._appliedArrow = want;
@@ -5866,14 +4888,13 @@ export class EditorViewport {
         .getHelper()
         .children.find(
           (child) => (child as { isTransformControlsGizmo?: boolean }).isTransformControlsGizmo,
-        ) as unknown as { gizmo: Record<string, THREE.Object3D> } | undefined;
-      for (const handle of node?.gizmo['rotate']?.children ?? []) {
-        const geometry = (handle as THREE.Mesh).geometry as THREE.BufferGeometry | undefined;
+        ) as TransformControlsGizmo;
+      for (const handle of node.gizmo.rotate.children) {
         // The axis rings only: the trackball circle and the view ring stay hairlines (Godot's
         // grey circle is one).
         if (!['X', 'Y', 'Z'].includes(handle.name)) continue;
-        if (!geometry || (geometry as THREE.TorusGeometry).type !== 'TorusGeometry') continue;
-        const radius = (geometry as THREE.TorusGeometry).parameters.radius;
+        const geometry = (handle as THREE.Mesh<THREE.TorusGeometry>).geometry;
+        const radius = geometry.parameters.radius;
         geometry.computeBoundingBox();
         geometry.boundingBox!.getSize(size);
         const normal = size.x <= size.y && size.x <= size.z ? 0 : size.y <= size.z ? 1 : 2;
@@ -5894,8 +4915,6 @@ export class EditorViewport {
   }
 
   private _patchGizmo(gizmoHelper: THREE.Object3D): void {
-    const colorMap = this._axisColorMap();
-
     // Plane geometry offsets to bring inner corners to object center
     const planeOffsets: Record<string, [number, number, number]> = {
       XY: [-0.075, -0.075, 0],
@@ -5904,44 +4923,20 @@ export class EditorViewport {
     };
 
     gizmoHelper.traverse((child) => {
-      const mesh = child as THREE.Mesh;
-
-      // Recolor handle materials
-      const newColor = colorMap[child.name];
-      if (newColor && mesh.material) {
-        const mat = mesh.material as THREE.MeshBasicMaterial | THREE.LineBasicMaterial;
-        if (mat.color) mat.color.copy(newColor);
-      }
-
       // Shift plane handle geometry
       const offset = planeOffsets[child.name];
-      if (offset && mesh.geometry) {
-        mesh.geometry.translate(offset[0], offset[1], offset[2]);
+      if (offset) {
+        (child as THREE.Mesh).geometry.translate(offset[0], offset[1], offset[2]);
       }
     });
   }
 
-  /**
-   * Combined-mode surgery on the aux SCALE gizmo. The stock scale handles
-   * share their axis span with the translate arrows (cubes at ±0.5, picker
-   * cones 0–0.6 — identical to translate's pickers), so with three
-   * synchronized gizmos the translate picker always wins the pointer and
-   * scale is undraggable (measured: dragging the X cube moved position).
-   * Slide the axis cubes and their pickers outward past the arrow tips, and
-   * drop the plane/uniform handles and axis lines whose footprint translate
-   * already owns. Placement is baked into geometry by three's setupGizmo, so
-   * geometry.translate is frame-safe where object transforms are not
-   * (TransformControlsGizmo.updateMatrixWorld resets handle transforms every
-   * frame). Single-mode scale (R) uses the primary gizmo and is untouched.
-   */
+  /** Shift auxiliary scale cubes and picker geometry clear of the combined tool's translate controls. */
   private _patchCombinedScaleGizmo(helper: THREE.Object3D): void {
     const AXIS_OFFSET = 0.55;
     const gizmoNode = helper.children.find(
       (child) => (child as { isTransformControlsGizmo?: boolean }).isTransformControlsGizmo,
-    ) as unknown as
-      | { gizmo: Record<string, THREE.Object3D>; picker: Record<string, THREE.Object3D> }
-      | undefined;
-    if (!gizmoNode) return;
+    ) as TransformControlsGizmo;
     const axisOf: Record<string, THREE.Vector3> = {
       X: new THREE.Vector3(1, 0, 0),
       Y: new THREE.Vector3(0, 1, 0),
@@ -5953,24 +4948,22 @@ export class EditorViewport {
     const CUBE_CENTER = 0.54 + AXIS_OFFSET;
     const PICKER_SIZE = 0.3;
     for (const [group, isPicker] of [
-      [gizmoNode.gizmo['scale'], false],
-      [gizmoNode.picker['scale'], true],
+      [gizmoNode.gizmo.scale, false],
+      [gizmoNode.picker.scale, true],
     ] as const) {
-      if (!group) continue;
       for (const child of [...group.children]) {
-        const mesh = child as THREE.Mesh;
+        const mesh = child as THREE.Mesh<THREE.BoxGeometry | THREE.CylinderGeometry>;
         const axis = axisOf[child.name];
         const isAxisLine =
           axis !== undefined &&
-          mesh.geometry?.type === 'CylinderGeometry' &&
+          mesh.geometry.type === 'CylinderGeometry' &&
           (mesh.geometry as THREE.CylinderGeometry).parameters.radiusTop < 0.05;
         if (axis === undefined || isAxisLine) {
           group.remove(child);
           continue;
         }
         mesh.geometry.computeBoundingBox();
-        const bounds = mesh.geometry.boundingBox;
-        if (!bounds) continue;
+        const bounds = mesh.geometry.boundingBox!;
         const sign = Math.sign(bounds.getCenter(new THREE.Vector3()).dot(axis)) || 1;
         if (isPicker) {
           const at = axis.clone().multiplyScalar(sign * CUBE_CENTER);
@@ -6005,8 +4998,6 @@ export class EditorViewport {
   private static _FLY_KEYS = new Set(['w', 'a', 's', 'd', 'q', 'e']);
 
   private _enterFlyMode(): void {
-    if (this._flyActive) return;
-    if (this._cameraViewMode === 'view') return;
     this._flyActive = true;
     this._snapAnimating = false; // cancel any view snap
     this.orbitControls.enabled = false;
@@ -6017,10 +5008,9 @@ export class EditorViewport {
   }
 
   private _exitFlyMode(): void {
-    if (!this._flyActive) return;
     this._flyActive = false;
     this._flyKeys.clear();
-    this.orbitControls.enabled = this._cameraViewMode !== 'view';
+    this.orbitControls.enabled = true;
     document.exitPointerLock();
     // Sync orbit target to a point in front of the camera
     const camera = this.renderCamera;
@@ -6078,10 +5068,6 @@ export class EditorViewport {
 
   private _onFlyKeyUp = (e: KeyboardEvent): void => {
     const key = e.key.toLowerCase();
-    if (key === 'shift') {
-      this._flyKeys.delete('shift');
-      return;
-    }
     this._flyKeys.delete(key);
   };
 
@@ -6120,11 +5106,8 @@ export class EditorViewport {
     const distance = this.camera.position.distanceTo(this.orbitControls.target);
     const worldPerPixel =
       (2 * Math.tan(((this.camera.fov / 2) * Math.PI) / 180) * distance) / height;
-    // Trackpads report fine per-frame pixel deltas; a mouse wheel NOTCH is
-    // ±100+ px (or line-mode units), so unclamped Shift+wheel panned a third
-    // of the viewport per click and flung a human tester off the map ("went
-    // to the bottom, can't get out" — runhuman pass 17). Clamp each event to
-    // a modest step; trackpad deltas sit far below the clamp and keep 1:1.
+    // Clamp mouse-wheel pan events to a modest step. Fine trackpad deltas stay below the clamp and
+    // preserve their scale.
     const unit = e.deltaMode === 1 ? 16 : 1;
     const clampStep = (value: number): number =>
       Math.sign(value) * Math.min(Math.abs(value * unit), 30);
@@ -6156,8 +5139,9 @@ export class EditorViewport {
     if (e.button === 0 && !e.altKey) {
       if (this._selectConstraintControlAt(e)) return;
       const mesh = this._raycastSpatialHandle(e);
-      const binding = mesh ? spatialHandleBinding(mesh) : null;
-      if (mesh && binding?.handle.writable) {
+      if (!mesh) return;
+      const binding = spatialHandleBinding(mesh);
+      if (binding.handle.writable) {
         e.stopPropagation();
         this._activeSpatialHandle = binding;
         this._spatialHandleDragPoint.copy(mesh.position);
@@ -6203,21 +5187,14 @@ export class EditorViewport {
 
       if (!this._marqueeDiv) {
         this._marqueeDiv = document.createElement('div');
-        // V-12 — was the string `'999'` (a stray string literal in an
-        // otherwise-numeric z-index scale); now the canonical `zIndex.sticky`
-        // token. Sticky chrome stays above the editor root while dropdowns
-        // retain their distinct higher tier.
+        // Use the sticky chrome tier above the editor root and below dropdowns.
         Object.assign(this._marqueeDiv.style, {
           position: 'fixed',
           pointerEvents: 'none',
           zIndex: zIndex.sticky,
         });
-        // INSIDE the theme scope, never document.body: the `--volter-*` tokens
-        // live on `#editor-chrome-root` (deliberately not `:root`), so a
-        // body-parented div resolves both colors to nothing and the rubber
-        // band is INVISIBLE — three human passes marqueed blind, reading the
-        // selection count jump 4/0 and calling the tool broken (runhuman
-        // 27–29). `position: fixed` keeps the client-coordinate math.
+        // Mount inside the theme scope so --volter-* colors resolve. Fixed positioning keeps the
+        // client-coordinate math.
         (document.getElementById('editor-chrome-root') ?? document.body).appendChild(
           this._marqueeDiv,
         );
@@ -6228,12 +5205,12 @@ export class EditorViewport {
       Object.assign(this._marqueeDiv.style, marqueeStyle(nativeViewportMarqueeDash(this._canvas)));
     }
 
-    if (this._marqueeActive && this._marqueeDiv) {
+    if (this._marqueeActive) {
       const left = Math.min(this._pointerDownPos.x, e.clientX);
       const top = Math.min(this._pointerDownPos.y, e.clientY);
       const w = Math.abs(e.clientX - this._pointerDownPos.x);
       const h = Math.abs(e.clientY - this._pointerDownPos.y);
-      Object.assign(this._marqueeDiv.style, {
+      Object.assign(this._marqueeDiv!.style, {
         left: `${left}px`,
         top: `${top}px`,
         width: `${w}px`,
@@ -6243,6 +5220,14 @@ export class EditorViewport {
     }
   };
 
+  /** A drag lost its release: a spatial handle goes back uncommitted, a constraint-control
+   *  session closes, and the pointer session with them. */
+  private _onInteractionDragLost = (): void => {
+    if (this._activeSpatialHandle) this._finishSpatialHandleDrag(false);
+    this._constraintControlPointerSession = false;
+    this._pointerSessionActive = false;
+  };
+
   private _onPointerUp = (e: PointerEvent): void => {
     // Only complete gestures that STARTED on the canvas (`_onPointerDown`) —
     // this listener lives on the interaction element (see the binding comment
@@ -6260,18 +5245,12 @@ export class EditorViewport {
       return;
     }
 
-    // Handle marquee select. D12 (B4) scope note: marquee stays THREEJS-ONLY —
-    // it only ever scans `this._objectMap` (the Three world's live
-    // objects), never the composite's other (react/pixi) layered children. A
-    // layered/rect-based marquee across every visible layer is out of scope
-    // for this task (D12) — single-click picking is layered (below), marquee
-    // is not.
+    // Marquee scans this viewport's native object map. Other composite roots are outside
+    // its screen-projection selection; single-click picking below can cross those roots.
     if (this._marqueeActive) {
       this._marqueeActive = false;
       this.orbitControls.enabled = true;
-      if (this._marqueeDiv) {
-        this._marqueeDiv.style.display = 'none';
-      }
+      this._marqueeDiv!.style.display = 'none';
 
       // Find all entities whose screen projection falls within the marquee
       const left = Math.min(this._pointerDownPos.x, e.clientX);
@@ -6283,33 +5262,12 @@ export class EditorViewport {
       const corner = new THREE.Vector3();
       const bounds = new THREE.Box3();
       for (const [id, obj] of this._objectMap) {
-        // Skip invisible entities — mirrors `raycastPick`'s single-click
-        // behavior for free (THREE.Raycaster's own `intersectObject` already
-        // stops descending into an `obj.visible === false` subtree, so a
-        // single click can never land on one). Marquee did its own screen-
-        // space rect test with no such check, so a world hidden via the
-        // group-row eye (`world-hidden-viewport.ts` — forces `obj.visible =
-        // false` for the whole world while hidden) stayed marquee-selectable
-        // even though it was invisible and unclickable. Also correctly skips
-        // an entity hidden via its OWN eye, for the same reason.
+        // Skip objects whose own visibility is off.
         if (!obj.visible) continue;
-        // A CAMERA never joins a marquee. Its empty bounds fall to the
-        // origin test, so a rectangle around scene content kept catching the
-        // template's authored camera — and camera selection pops the live
-        // preview overlay, which two consecutive human passes read as "it
-        // instantly plays" and which then sat over the viewport blocking
-        // their next drag (runhuman passes 27/28; play state was measured
-        // stopped throughout). Click and hierarchy selection still reach it.
+        // Exclude cameras from marquee selection; click and hierarchy selection still reach them.
         if ((obj as THREE.Camera).isCamera === true) continue;
-        // CONTAINMENT of the projected bounds, not origin-in-rect: every
-        // environment fixture's ORIGIN (the ground plane, the sky dome, the
-        // Environment group — all at scene center) landed inside any central
-        // rectangle, so circling three boxes selected seven things and a
-        // human tester gave up on marquee ("I still select more than what is
-        // needed" — runhuman pass 25). A rectangle dragged AROUND something
-        // selects what fits inside it; a fixture larger than the rectangle
-        // cannot. Entities with no renderable bounds (lights, cameras,
-        // empty groups) keep the origin test — circling a light selects it.
+        // Test projected geometry bounds against the rectangle using the presentation’s selection rule.
+        // Objects with no renderable bounds use their projected origin.
         bounds.setFromObject(obj);
         if (bounds.isEmpty()) {
           const screen = this._projectToScreen(obj);
@@ -6318,21 +5276,7 @@ export class EditorViewport {
           }
           continue;
         }
-        // WHAT THE RECTANGLE MEANS IS THE LOOK'S TO SAY (`boxSelect`): the
-        // editor's own answer is CONTAINMENT, and Blender's Select Box is
-        // TOUCH — its object-mode box select reads the object-id buffer under
-        // the rectangle, so any drawn part inside it selects the object. Both
-        // are real answers and the field's own note carries why neither can be
-        // the other's default. Measured 2026-09-21 on the Model document: a
-        // rectangle holding the whole cube and cutting the torus selected the
-        // cube alone, where Blender takes both.
-        //
-        // TOUCH is the projected bounding box INTERSECTING the rectangle,
-        // which is a superset of Blender's drawn-pixel test — an honest
-        // approximation, and the closest one available without a picking
-        // buffer. It is stated rather than hidden: a long thin diagonal object
-        // whose box crosses the rectangle while none of its pixels do is the
-        // case where the two differ.
+        // Use the presentation’s boxSelect rule: containment or overlap. Geometry bounds approximate Blender’s pixel-touch selection and can include a thin diagonal that draws outside the rectangle.
         const touch = this._stageBoxSelect === 'touch';
         const rect = this._canvas.getBoundingClientRect();
         // Through the camera on screen: an orthographic document view or a camera view draws with
@@ -6369,8 +5313,7 @@ export class EditorViewport {
       }
 
       if (e.shiftKey) {
-        // Add to existing selection (additive modifier — SelectionProvider
-        // extension is Phase-F; first-party store op for now).
+        // Extend the store selection for the additive modifier.
         for (const id of hitIds) this._store.shell.addToSelection(id);
       } else {
         setAuthoringSelection(this._authoring(), hitIds);
@@ -6389,63 +5332,26 @@ export class EditorViewport {
     // Don't interfere with gizmo clicks
     if (this._anyGizmoDragging()) return;
 
-    // Check orientation gizmo click first (spec 28 — the cube isn't rendered
-    // without a visible three surface, so it can't be clicked either)
+    // Check the orientation gizmo first; it is clickable only on a visible three surface.
     if (this._threejsToolContextActive && this._handleViewCubeClick(e)) return;
 
-    // D12 (B4) — topmost-first layered pick: the composite's non-threejs
-    // children (react/pixi design-time layers) are tried topmost-first before
-    // falling through to the three raycast (now `VolterSceneAuthoringAdapter
-    // .pickable`) — see `pickTopmost`'s doc comment. Note: an INTERACTIVE
-    // layer (session `interactive` toggle, B1) is mutually exclusive with this
-    // walk running at all, by construction — its `pointer-events:auto` DOM
-    // intercepts the event before it ever reaches this canvas listener, so
-    // there is no special-case here for it.
+    // Try the active adapter’s pickable layers from topmost to bottommost. Interactive DOM layers
+    // intercept their own pointer events before they reach this canvas.
     const deepSelection = e.shiftKey && (e.metaKey || e.ctrlKey);
-    // Figma's outside-click rule: a click the open scope does not contain
-    // LEAVES that scope, and empty space closes every level. The pick resolves
-    // against the scope that WAS open, so `pickAcrossScopeExit` lets the stack
-    // follow the hit and re-resolves once when it moved — without that, a
-    // three-deep stack answered one level too shallow and took a second click
-    // to land (`authoring/selection-scope.ts`).
+    // A click outside the open scope leaves it; empty space closes every level. pickAcrossScopeExit
+    // updates the scope stack and resolves the hit again when the stack changes.
     const entityId = pickAcrossScopeExit(this._scopeAuthoring(), () =>
       this._pickAt(e.clientX, e.clientY, deepSelection ? 'deep' : 'normal'),
     );
 
-    if (deepSelection) {
-      setAuthoringSelection(this._authoring(), entityId ? [entityId] : []);
-    } else if (e.shiftKey && entityId) {
-      // TOGGLE, not add. On a canvas this modifier is the ONE gesture for
-      // "and also this / no, not that one" — Figma, Blender and Unity all
-      // remove an already-selected object on a second shift-click, and adding
-      // only meant a mis-click was unrecoverable: "if it's like 20 items and
-      // you mess up one, you're gonna have to start all over" (runhuman pass
-      // 94, their top finding). The Hierarchy keeps the LIST convention
-      // instead — shift extends a RANGE there — because a row list has an
-      // order for a range to mean something and a viewport does not.
-      this._store.shell.toggleSelection(entityId);
-    } else if ((e.metaKey || e.ctrlKey) && entityId) {
+    if (!deepSelection && entityId && (e.shiftKey || e.metaKey || e.ctrlKey)) {
       this._store.shell.toggleSelection(entityId);
     } else {
       setAuthoringSelection(this._authoring(), entityId ? [entityId] : []);
     }
   };
 
-  /**
-   * The adapter a selection SCOPE is keyed on.
-   *
-   * `authoring/selection-scope.ts` keys its stack by adapter IDENTITY, and the
-   * Hierarchy — its breadcrumb, and its own double-click scope entry — resolves
-   * the PANEL adapter (`authoring/panel-authoring.ts`), which for a Scene
-   * document is the composite's Three child, not the composite itself.
-   * A scope opened against a different object of the same tree is invisible
-   * there (measured: a viewport drill-in selected the deeper member correctly
-   * and the breadcrumb never appeared). One resolution, so the viewport gesture
-   * and the panel are talking about the same scope.
-   *
-   * A host that INJECTED its own adapter (the Object3D document's own viewport)
-   * is not driving the shared panels at all and keeps its own.
-   */
+  /** Key selection scopes to the same panel adapter used by the Hierarchy. An injected document adapter keeps its own scope. */
   private _scopeAuthoring(): AuthoringAdapter {
     return this._standaloneAuthoring
       ? this._authoring()
@@ -6461,25 +5367,10 @@ export class EditorViewport {
   }
 
   /**
-   * Double-click = DRILL IN — the viewport's way INTO a component instance.
-   *
-   * A single click resolves to the OUTERMOST component boundary under the
-   * pointer (`SelectionProvider.resolve`), which is why a whole arena selects
-   * as one instance no matter where you click it. That is Figma's instance
-   * semantics and it is correct; what was missing was the way in. Double-click
-   * opens that instance's scope (`enterSelectionScope`) and selects the next
-   * member down the same owner chain — repeat to keep descending, Escape
-   * (`editor-hotkeys.ts`) walks back out, and a click outside the open scope
-   * leaves it (`_onPointerUp`).
-   *
-   * The deeper member is not computed here: `layered-pick.ts` already hands
-   * `currentSelectionScopeId()` to the adapter's own resolve, so re-running the
-   * ORDINARY pick with the scope open is what answers. No second chain rule,
-   * nothing per-surface, no new state.
-   *
-   * The two single-clicks that precede this both select that same outermost
-   * boundary, so they cannot conflict with the drill — they are the step it
-   * starts from.
+   * Double-click opens the selected component’s scope and selects the next member down its owner
+   * chain. Escape walks out and an outside click leaves the scope. The ordinary layered pick
+   * resolves through the adapter with currentSelectionScopeId, including the two single-clicks
+   * preceding this gesture.
    */
   private _onDoubleClick = (e: MouseEvent): void => {
     if (e.button !== 0) return;
@@ -6498,181 +5389,4 @@ export class EditorViewport {
       this._pickAt(e.clientX, e.clientY, 'normal'),
     );
   };
-
-  // --- Asset drag-and-drop onto viewport ---
-
-  /**
-   * Screen → world point for the path-probe tool (W1a): prefer a hit on the
-   * baked navmesh overlay (guarantees a point on the mesh), fall back to the
-   * ground plane so probing still lands a marker pre-bake.
-   */
-  /**
-   * Raycast from screen coordinates to the DECLARED ground plane. Returns world
-   * position or null.
-   */
-  private _raycastGroundPlane(e: { clientX: number; clientY: number }): THREE.Vector3 | null {
-    const rect = this._canvas.getBoundingClientRect();
-    const mouse = new THREE.Vector2(
-      ((e.clientX - rect.left) / rect.width) * 2 - 1,
-      -((e.clientY - rect.top) / rect.height) * 2 + 1,
-    );
-    this.raycaster.setFromCamera(mouse, this._screenCamera);
-    const basis = presentationRegionBasis('three');
-    this._groundPlane.set(
-      basis.up === 'z' ? UP_Z : UP_Y,
-      // `Plane.constant` is the SIGNED distance from the origin along -normal,
-      // so a ground at `h` is `-h` here.
-      -basis.groundHeight,
-    );
-    const target = new THREE.Vector3();
-    const hit = this.raycaster.ray.intersectPlane(this._groundPlane, target);
-    return hit;
-  }
-
-  private _showDropOverlay(): void {
-    if (this._dropOverlay) return;
-    const overlay = document.createElement('div');
-    // V-12 — the stray string `'5'` (below every named tier in the z-index
-    // scale) becomes the numeric `zIndex.base`, the lowest defined tier,
-    // preserving its relative order (still below the marquee's `zIndex.
-    // sticky` and every dropdown/menu). The semantic accent tokens reconcile this
-    // block's former one-off blue onto the canonical palette accent tint per
-    // the audit's own §3 absorption list.
-    Object.assign(overlay.style, {
-      position: 'fixed',
-      inset: '0',
-      pointerEvents: 'none',
-      border: `2px dashed ${themeVars.accent.default}`,
-      background: themeVars.accent.muted,
-      zIndex: zIndex.base,
-    });
-    // Same class as the marquee band: `--volter-*` resolves only under
-    // `#editor-chrome-root`, so a body-parented overlay draws with NO border
-    // or fill — the drag-to-viewport highlight has been invisible.
-    (document.getElementById('editor-chrome-root') ?? document.body).appendChild(overlay);
-    this._dropOverlay = overlay;
-  }
-
-  private _hideDropOverlay(): void {
-    if (this._dropOverlay) {
-      this._dropOverlay.remove();
-      this._dropOverlay = null;
-    }
-  }
-
-  private _onDragOver = (e: DragEvent): void => {
-    if (!e.dataTransfer?.types.includes('application/x-editor-asset')) return;
-    e.preventDefault();
-    e.dataTransfer.dropEffect = 'copy';
-    this._showDropOverlay();
-  };
-
-  private _onDragLeave = (_e: DragEvent): void => {
-    this._hideDropOverlay();
-  };
-
-  private _onDrop = (e: DragEvent): void => {
-    this._hideDropOverlay();
-    const raw = e.dataTransfer?.getData('application/x-editor-asset');
-    if (!raw) return;
-    e.preventDefault();
-
-    let data: {
-      path: string;
-      kind: string;
-      name: string;
-      component?: AssetDropContext['item'];
-      online?: OnlineAssetDrop;
-    };
-    try {
-      data = JSON.parse(raw);
-    } catch {
-      return;
-    }
-
-    // Find drop position via ground-plane raycast, fallback to the ground's own
-    // origin. The two in-plane components are rounded to centimetres; the UP
-    // component is pinned to the DECLARED ground height rather than to a
-    // hardcoded 0 — which axis that is comes from the region's basis, not from
-    // an assumption that every game is Y-up.
-    const basis = presentationRegionBasis('three');
-    const worldPos = this._raycastGroundPlane(e);
-    const cm = (value: number): number => Math.round(value * 100) / 100;
-    const pos: [number, number, number] =
-      basis.up === 'z'
-        ? [cm(worldPos?.x ?? 0), cm(worldPos?.y ?? 0), basis.groundHeight]
-        : [cm(worldPos?.x ?? 0), basis.groundHeight, cm(worldPos?.z ?? 0)];
-
-    // A viewport drop is an AUTHORING op, so it goes through the active
-    // adapter's `assetDrop` provider — not straight into the first-party
-    // document. An adapter that declares no `assetDrop` (for example a LIVE
-    // adopted play scene) accepts nothing: dropping into it used to mutate the
-    // retired descriptor document of a world that was not even on screen.
-    // Absent ⇒ nothing happens, which is the honest degrade.
-    const authoring = this._authoring();
-    const assetDrop = authoring.assetDrop;
-    const item: AssetDropContext['item'] = data.component ?? {
-      kind: 'file',
-      name: data.name,
-    };
-    // A refused drop SAYS so: the silent degrade read as "drag and drop is
-    // not working" to a human who tried it both ways (runhuman pass 45).
-    if (!assetDrop) {
-      editorConsole.warn(
-        `Dropped “${data.name}” was not placed: this document does not accept dropped assets.`,
-        'editor',
-      );
-      return;
-    }
-
-    // Online asset: the SHELL's resolver turns it into a project-local path
-    // (cache, file list, download, history — see `OnlineAssetResolver`), then
-    // it takes the same adapter drop path a local asset takes.
-    //
-    // The shell owns no document, so there is nothing to place a progress
-    // placeholder INTO: the resolve settles silently and a failure is reported
-    // to the console.
-    if (data.online) {
-      const online = data.online;
-      const resolveOnline = this._onlineAssetResolver;
-      // Same rule as a missing `assetDrop` above: a refused drop SAYS so,
-      // naming the missing collaborator rather than swallowing the gesture.
-      if (!resolveOnline) {
-        editorConsole.warn(
-          `Dropped “${data.name}” was not placed: this viewport has no online-asset resolver installed.`,
-          'editor',
-        );
-        return;
-      }
-      // The download takes seconds and used to be silent: "it does not
-      // seem to be adding… oh, that took some time, but it did happen"
-      // (runhuman pass 136). Say it where the hand is — a cached asset
-      // answers at once and the two hints simply follow each other.
-      showTransientHint(`Downloading ${online.name} from the library…`);
-      resolveOnline(online)
-        .then((path) => {
-          // `null` = the resolver already reported why on the console.
-          if (path) {
-            showTransientHint(`${online.name} downloaded — placing it.`);
-            void dropAuthoringAsset(authoring, '', path, { position: pos });
-          } else {
-            showTransientHint(`Could not download ${online.name} — see the Console.`);
-          }
-        })
-        // Browser mode (no Node dev server) throws instead of resolving —
-        // the one failure nobody else reported, and no unhandled rejection.
-        .catch(() => {
-          showTransientHint(`Could not download ${online.name} — see the Console.`);
-          editorConsole.error(`Could not download ${online.name}.`, 'asset');
-        });
-      return;
-    }
-
-    // Model / image / audio / component: the adapter owns what an asset path
-    // MEANS in its world, and its `drop` plans the same answer `accepts` would
-    // — but when it refuses it SAYS WHY (transient hint + console), which a
-    // boolean pre-check never could. The viewport contributes only the world
-    // point under the cursor.
-    void dropAuthoringAsset(authoring, '', data.path, { position: pos, item });
-  };
 }