@volter/editor-threejs 0.5.211 → 0.5.212

package/src/kit/three-viewport/camera-fit.ts

@@ -5,7 +5,6 @@ export function perspectiveDistanceToFitBox(
   box: THREE.Box3,
   camera: THREE.PerspectiveCamera,
   direction: THREE.Vector3,
-  padding = 1.15,
 ): number {
   if (box.isEmpty()) return 3;
   const viewDirection = direction.clone().normalize();
@@ -33,9 +32,6 @@ export function perspectiveDistanceToFitBox(
     halfHeight / Math.tan(verticalHalfFov),
     halfWidth / Math.tan(horizontalHalfFov),
   );
-  // The floor is the camera's own near plane, not a metre count: a 3 m floor
-  // framed every prop under two metres at the same distance, so a 0.5 m
-  // mushroom opened as a thumb-sized thing in the middle of the viewport
-  // and Frame did nothing (measured 2026-09-06: fit 0.62 m, answer 3.0 m).
-  return Math.max(fitDistance * padding + halfDepth, camera.near * 4, 0.01);
+  // Use the camera’s near plane as the minimum fit distance so small props can fill the viewport.
+  return Math.max(fitDistance * 1.15 + halfDepth, camera.near * 4, 0.01);
 }

package/src/kit/three-viewport/selection-brackets.ts

@@ -9,7 +9,7 @@
  *
  * Drawn with three's fat-line addons (`LineSegments2` + `LineSegmentsGeometry`
  * + `LineMaterial`) so the stroke is a real screen-space width rather than the
- * driver's 1px `gl.LINES`, which is the other half of why the old box vanished.
+ * driver's 1px `gl.LINES`, which vanishes at small sizes.
  * The screen-space width needs `LineMaterial.resolution`; nothing here or in
  * the viewport sets it, because `LineSegments2.onBeforeRender` already pushes
  * the live renderer viewport into that uniform on every draw. A second writer
@@ -33,16 +33,7 @@ import { LineSegmentsGeometry } from 'three/addons/lines/LineSegmentsGeometry.js
 /** Stroke width in CSS pixels (`LineMaterial` screen-space units). */
 export const SELECTION_BRACKET_LINEWIDTH = 3;
 
-/**
- * How far the cage stands OFF the entity, as a fraction of each axis extent.
- *
- * Owner ask (2026-08-11): "the corner highlights are exactly ON the model. I
- * frequently do not see it." Drawn on the exact AABB, a bracket on anything
- * box-shaped is coplanar with the surface it is supposed to be marking — it
- * z-fights, it takes the object's own shading, and on a flat face it simply
- * disappears into the edge it lies along. The cage has to float clear of the
- * silhouette to read as a separate thing.
- */
+/** Stand selection brackets clear of each axis extent to keep them visible above coplanar surfaces. */
 export const BRACKET_STANDOFF_FRACTION = 0.05;
 
 /** World-unit floor for that stand-off, so a tiny prop still gets clearance. */
@@ -60,11 +51,7 @@ export const BRACKET_ARM_MIN = 0.08;
 /** World-unit ceiling, so a terrain-scale box does not draw multi-meter arms. */
 export const BRACKET_ARM_MAX = 3;
 
-/**
- * Hard cap as a fraction of the extent. Without it the clamped MIN would make
- * arms from opposite corners meet on a small box — which is a full box outline
- * again, i.e. exactly the shape we are moving away from.
- */
+/** Cap bracket arms below half the extent so opposite corners remain separate. */
 export const BRACKET_ARM_EXTENT_CAP = 0.45;
 
 /**
@@ -234,7 +221,7 @@ export class SelectionBrackets extends LineSegments2 {
     this._objectFrame = options.frame === 'object';
     // A static hierarchy's world bounds do not change because the camera did.
     // Detect the cases whose vertices can move without an editor transform
-    // notification; those keep the old every-frame bounds refresh. Ordinary
+    // notification; those refresh their bounds every frame. Ordinary
     // terrain/building groups instead refresh only when their root transform
     // changes (and `_syncBoxHelpers` reconstructs them after source/store
     // changes), avoiding one recursive Box3 walk per selected subtree per RAF.
@@ -304,9 +291,7 @@ export class SelectionBrackets extends LineSegments2 {
       this._fixedExtent.setScalar(this._fixedSize);
       this._box.setFromCenterAndSize(this._worldPos, this._fixedExtent);
     } else {
-      // Content only — a built-internal child (a world-space particle renderer
-      // at identity, a pooled batch) would otherwise drag the cage off to
-      // wherever its machinery lives. See `content-bounds.ts`.
+      // The one content walk every bounds consumer shares (`content-bounds.ts`).
       if (objectFrame) {
         this._toObject.copy(this.entityObject.matrixWorld).invert();
         contentBoundsInFrame(this.entityObject, this._toObject, this._box);

package/src/kit/three-viewport/selection-outline.ts

@@ -19,19 +19,7 @@ import {
 import type { EffectPass, OutlineEffect } from 'postprocessing';
 import type * as THREE from 'three';
 
-/**
- * The three postprocessing bindings {@link createThreeSelectionOutline} needs,
- * passed in rather than statically imported.
- *
- * `postprocessing` is ~200 kB of shaders and passes, and the surfaces this
- * module serves do not all want it: `editor-viewport.ts` imports only
- * {@link collectThreeSelectionOutlineTargets} (a pure traversal), and the
- * Asset Lab 3D document builds its composer on its FIRST frame, not at module
- * load. A static import here put the whole library in both closures
- * eagerly. A caller that already loaded postprocessing for its own composer
- * hands over its own bindings (`the world root's stage`); one that has not opens the
- * lazy door {@link loadThreeSelectionOutline}.
- */
+/** Caller-supplied postprocessing bindings keep pure target traversal independent of renderer/composer loading. */
 export interface ThreeSelectionOutlineEffects {
   readonly OutlineEffect: typeof import('postprocessing').OutlineEffect;
   readonly BlendFunction: typeof import('postprocessing').BlendFunction;
@@ -70,14 +58,7 @@ export function createThreeSelectionOutline(
   // the effect's own layer and both masks cancel to no visible edge.
   effect.selectionLayer = EDITOR_SELECTION_LAYER;
   camera.layers.disable(EDITOR_SELECTION_LAYER);
-  // A CRISP LINE NEEDS ITS COLOUR UNSCALED. postprocessing's composite multiplies the edge colour
-  // by the edge value and uses that value again as alpha, so a partial edge darkens (Blender's
-  // orange read brown) and a strength above one pushes the colour past itself (it read white).
-  // Under `volterCrisp` the colour is divided back out of the edge value, leaving only the alpha
-  // to follow the edge; the editor's own halo keeps the library's composite. And the library
-  // draws an edge only OUTSIDE the silhouette (it scales the edge by the mask, which is zero on
-  // the selection); Blender's detect marks the pixels on both sides of it, so a crisp line keeps
-  // its inner half.
+  // Crisp outlines retain unscaled colour on both sides of the silhouette; the halo uses the library composite.
   const shader = effect.getFragmentShader();
   const stock = 'vec3 color=edge.x*visibleEdgeColor+edge.y*hiddenEdgeColor;';
   const outsideOnly = 'edge*=(edgeStrength*mask.x*pulse);';
@@ -94,12 +75,7 @@ export function createThreeSelectionOutline(
     // Any `{ value }` is a uniform to three; no runtime three import in this module.
     effect.uniforms.set('volterCrisp', { value: 0 } as THREE.Uniform<number>);
   }
-  // THE EDITOR'S OWN OVERLAYS DO NOT HIDE THE SELECTION. The effect measures what stands in
-  // front of the selected object with a depth pass under an override material, which writes
-  // depth for everything the camera sees — the floor grid included, though it writes none
-  // itself — so the grid hid the outline's lower half wherever it crossed the object (measured
-  // on Unity's look). Its layer is off the camera for the effect's update only; the effect
-  // saves and restores the camera's mask around its own mask pass.
+  // Exclude editor overlay layers from the outline effect’s depth update, restoring the camera mask around that pass.
   const update = effect.update.bind(effect);
   effect.update = (renderer, inputBuffer, deltaTime) => {
     const current = (effect as unknown as { camera: THREE.Camera }).camera;
@@ -116,17 +92,7 @@ export function createThreeSelectionOutline(
   return effect;
 }
 
-/**
- * ONE EFFECT PER RENDERER, REUSED. `OutlineEffect` constructs its `Selection`
- * with a render layer from a module-wide counter that warns "Layer out of
- * range, resetting to 2" on its 30th construction in a page; the editor
- * overrides that layer, but built one effect per document session and per
- * world pipeline rebuild, the warning sat on every session's console as
- * unresolved work. A released effect goes back to its renderer's pool — its
- * render targets belong to that renderer's context — and the next surface on
- * that renderer re-points it at its own scene and camera. Constructions are
- * bounded by the surfaces open at once.
- */
+/** Reuse released effects within their renderer context. Clear selection on release and rebind scene/camera on acquire. */
 const pooled = new WeakMap<object, OutlineEffect[]>();
 
 /** An outline for `renderer`: a released one re-pointed at `scene` and `camera`, or a new one. */
@@ -165,24 +131,6 @@ export function releaseThreeSelectionOutline(
   pooled.set(renderer, free);
 }
 
-/** THE LAZY DOOR: load `postprocessing` on demand and build the effect. For a
- *  caller with no composer of its own, so the library arrives with the
- *  silhouette rather than with the surface. Repeat calls are free — the module
- *  is cached after the first. */
-export async function loadThreeSelectionOutline(
-  scene: THREE.Scene,
-  camera: THREE.Camera,
-  colors: OutlineColors,
-): Promise<OutlineEffect> {
-  const { BlendFunction, KernelSize, OutlineEffect } = await import('postprocessing');
-  return createThreeSelectionOutline(
-    { BlendFunction, KernelSize, OutlineEffect },
-    scene,
-    camera,
-    colors,
-  );
-}
-
 type OutlineColors = {
   readonly visible: number;
   readonly hidden: number;

package/src/kit/three-viewport/skeleton-helper.ts

@@ -1,5 +1,5 @@
 import { EDITOR_LAYER } from '@volter/editor-threejs/viewport/editor-layers';
-import { getObjectMark, setObjectMark } from '@volter/editor-threejs/ecs/object-marks';
+import { setObjectMark } from '@volter/editor-threejs/ecs/object-marks';
 import * as THREE from 'three';
 
 const SKELETON_HELPER_TYPE = 'skeletons';
@@ -28,34 +28,3 @@ export function styleEditorSkeletonHelper(helper: THREE.SkeletonHelper): void {
   setObjectMark(helper, 'editorHelperType', SKELETON_HELPER_TYPE);
   helper.traverse((child) => child.layers.set(EDITOR_LAYER));
 }
-
-export function ensureSkeletonHelper(root: THREE.Object3D): THREE.SkeletonHelper | null {
-  let existing: THREE.SkeletonHelper | null = null;
-  let hasSkinnedMesh = false;
-  root.traverse((object) => {
-    if (getObjectMark(object, 'editorHelperType') === SKELETON_HELPER_TYPE) {
-      existing = object as THREE.SkeletonHelper;
-    }
-    if ((object as THREE.SkinnedMesh).isSkinnedMesh) hasSkinnedMesh = true;
-  });
-  if (existing || !hasSkinnedMesh) return existing;
-
-  const helper = new THREE.SkeletonHelper(root);
-  if (helper.bones.length === 0) {
-    helper.dispose();
-    return null;
-  }
-  styleEditorSkeletonHelper(helper);
-
-  // SkeletonHelper normally expects to be a scene-root sibling. Keeping it
-  // under the entity makes lifecycle cleanup automatic, so use entity-local
-  // coordinates instead of applying the entity world transform twice.
-  helper.matrix = new THREE.Matrix4();
-  helper.matrixAutoUpdate = false;
-  helper.name = 'EditorSkeletonHelper';
-  helper.visible = Boolean(getObjectMark(root, 'skeletonVisible'));
-  setObjectMark(helper, 'skeletonEnabled', helper.visible);
-  root.add(helper);
-  root.updateMatrixWorld(true);
-  return helper;
-}

package/src/kit/three-viewport/source-color.ts

@@ -1,38 +1,6 @@
 import * as THREE from 'three';
 
-/**
- * The colour to give a TONE-MAPPED material so the screen shows the palette's
- * exact sRGB hex — the inverse of three's ACES fit (the input and output
- * matrices and the RRT/ODT rational, `tonemapping_pars_fragment`) through the
- * exposure; Linear divides by it; no tone mapping passes through; any other
- * operator is left as-is.
- *
- * WHICH SURFACES ACTUALLY WANT IT, measured on the live Model stage
- * (`document-script` over the session's scene, beside a `capture-editor-chrome`
- * frame of the same instant — the chrome door serves the PRESENTED frame, so
- * the two are the same pixels):
- *
- *  - `scene.background` as a `THREE.Color`: **no**. three does not shade a
- *    colour background, it CLEARS to it (`WebGLBackground.setClear` →
- *    `glClearColor`), so no fragment shader and no tone map ever touches it.
- *    Measured: the scene held `#494949` — this function's inversion of the
- *    palette's `#3f3f3f` — and the screen read `#494949` exactly, luminance
- *    73 against Blender's 63. The inversion was compensating for a transform
- *    that does not run, and that alone is what made the stage light.
- *  - the floor grid (`editor-floor-grid`, a `ShaderMaterial` with
- *    `toneMapped: true`): **yes**. Measured: `uColor` held `#575757` — this
- *    function's inversion of the palette's `#545454` — and the 1 m line read
- *    83–84 on screen, i.e. the operator ran and landed it on the palette.
- *  - the floor axes (`LineSegments2`/`LineMaterial`, `toneMapped: false`):
- *    **no**. `toneMapped: false` is honoured per material (three compiles the
- *    tone-map chunk per program, not as a composer output pass), so the
- *    inverted colour reached the screen raw and over-saturated: `#ee234d`
- *    where Blender's X axis is `#cb293f`.
- *
- * So the operator runs PER MATERIAL here, not in a final composer pass: the
- * grid's `toneMapped: true` was mapped and the axes' `toneMapped: false` was
- * not, in the same frame, through the same composer.
- */
+/** Invert the current tone-mapping operator for a material that must display an exact palette sRGB colour. Apply at the material because other materials in the same composer may disable tone mapping. */
 export function toneMappedSourceColor(
   hex: number,
   renderer: THREE.WebGLRenderer | undefined,

package/src/kit/three-viewport/studio-environment.ts

@@ -1,35 +1,4 @@
-/**
- * The LOOK LANES' neutral studio IBL — `scene.environment` for every surface
- * that photographs an asset instead of displaying it: the Asset Lab capture
- * path (`asset-preview.ts`: the model-file lane, the editor's `screenshot <module>` command
- * through `project.bake.preview`, labeled shot sets, source-review sheets,
- * splats) and the asset-browser thumbnails (`model-thumbnail.ts`).
- *
- * Why it exists: a `MeshStandardMaterial` with `metalness: 1` has NO diffuse
- * term — everything it shows is reflected environment. Lit by directional
- * lights alone it renders BLACK with a pinprick specular, so iron reads as
- * painted plastic, and the measured cost of that (cold barrel, 2026-08-29) is
- * that agents detune `metalness` to survive the screenshot — the look lane
- * silently teaching a wrong material value into shipped assets.
- *
- * The bake is three's own `RoomEnvironment` through `PMREMGenerator`, reused
- * verbatim from the document viewport's dressing
- * ({@link createStandardEnvironment}) so a capture and the open document light
- * the same subject the same way. Procedural: no HDRI binary, deterministic
- * frame to frame.
- *
- * Two rules this module exists to hold:
- *
- *  - **`environment` only, never `background`.** Each lane keeps its own
- *    backdrop (the Asset Lab's neutral clear colour, or transparent). An IBL
- *    that also painted the background would change every existing frame's
- *    composition, not just its materials.
- *  - **One bake per renderer.** A PMREM target is GL-context-bound, so it
- *    cannot be shared across renderers, and baking it per SCENE would pay for
- *    it once per shot in a 24-frame orbit. The cache is keyed by renderer and
- *    freed through {@link disposeStudioEnvironment}, which every caller that
- *    disposes its renderer must call — a PMREM render target leaks otherwise.
- */
+/** Provide neutral studio IBL for asset captures and thumbnails so metallic surfaces have an environment to reflect. Cache per renderer and dispose through disposeStudioEnvironment. */
 
 import {
   createStandardEnvironment,
@@ -38,33 +7,13 @@ import {
 import type * as THREE from 'three';
 
 /**
- * How hard the IBL pushes against the lane's existing key/fill rig.
- *
- * The key and fill are UNCHANGED — they still own the form, the direction of
- * the shading and the highlight. This is a reflection budget, not a second key.
- *
- * The blend was picked by reading before/after pairs of the barrel GLB and a
- * metalness sweep in the module lane, holding the wood constant and asking how
- * little environment buys back the metal:
- *  - 1.0 with the ambient untouched: the iron reads, the wood lifts and flattens
- *    — the shadow side of the staves fills in and the stave-to-stave tone
- *    variation collapses;
- *  - 0.55 with {@link STUDIO_AMBIENT_WITH_ENVIRONMENT} at 0.35: metal good,
- *    wood still visibly brighter and lower-contrast than the historical frame;
- *  - 0.45 with the ambient at 0.25 (shipped): the wood frame is indistinguishable
- *    from the historical one at full scale — same warmth, same grain, same
- *    terminator — while every hoop gains a gradient across the band and the
- *    bottom hoop stops reading as a shadow.
+ * Environment-light intensity relative to the studio’s key and fill rig.
  */
 export const STUDIO_ENVIRONMENT_INTENSITY = 0.45;
 
 /**
- * The lanes' ambient fill is REDUCED when the IBL is present: a
- * hemisphere/ambient light is a crude stand-in for exactly what the environment
- * now does properly, and leaving both at full strength double-pays the ambient
- * term and washes the subject. Each lane multiplies its own historical ambient
- * intensity by this, so the total ambient energy lands near where it was and
- * only its DIRECTIONALITY improves.
+ * Scale ambient fill when environment lighting is present so both sources do not duplicate the
+ * ambient term.
  */
 export const STUDIO_AMBIENT_WITH_ENVIRONMENT = 0.25;
 

package/src/kit/three-viewport-presentation.ts

@@ -0,0 +1,23 @@
+export type ThreeViewportProjection = 'perspective' | 'orthographic';
+
+export interface ThreeViewportPresentationState {
+  readonly projection: ThreeViewportProjection;
+}
+
+let state: ThreeViewportPresentationState = { projection: 'perspective' };
+const listeners = new Set<() => void>();
+
+export function threeViewportPresentation(): ThreeViewportPresentationState {
+  return state;
+}
+
+export function subscribeThreeViewportPresentation(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function setThreeViewportProjection(projection: ThreeViewportProjection): void {
+  if (state.projection === projection) return;
+  state = { ...state, projection };
+  for (const listener of listeners) listener();
+}

package/src/kit/transport-strip.tsx

@@ -0,0 +1,147 @@
+/**
+ * Draw controls for the stage’s transport when a subject is attached. Read every value from its
+ * subscribed snapshot; this component owns no clock or local playhead. Blender’s Timeline offers
+ * another view of the same transport handle.
+ */
+
+import {
+  EditorIcon,
+  editorIcons,
+  IconButton,
+  Text,
+  TextInput,
+  themeVars,
+} from '@volter/sdk/widgets';
+import { useCallback, useSyncExternalStore } from 'react';
+import type { StageTransportHandle } from '@volter/sdk/host';
+
+/** The speeds the strip offers. Not a free number field: a speed is a viewing
+ *  choice with a few useful values, and a text box invites 0.37. */
+const SPEEDS = [0.25, 0.5, 1, 2] as const;
+
+function formatSeconds(seconds: number, fps: number): string {
+  const frame = Math.round(seconds * fps);
+  return `${seconds.toFixed(2)}s · f${frame}`;
+}
+
+export function TransportStrip({ transport }: { transport: StageTransportHandle | null }) {
+  const snapshot = useSyncExternalStore(
+    useCallback(
+      (listener: () => void) => (transport ? transport.subscribe(listener) : () => {}),
+      [transport],
+    ),
+    useCallback(() => transport?.snapshot() ?? null, [transport]),
+  );
+
+  if (!transport || !snapshot || snapshot.activeSubject === null) return null;
+
+  const playing = snapshot.playbackState === 'playing';
+  const { start, end, fps, loop } = snapshot.range;
+  const active = snapshot.subjects.find((s) => s.id === snapshot.activeSubject);
+  // Two different pickers, and they are not the same question: SUBJECTS are
+  // the several things this stage can show at a time, CLIPS are the several
+  // animations one subject has. A Blender action is a subject with no clips.
+  const subjects = snapshot.subjects.length > 1 ? snapshot.subjects : null;
+  const clips = transport.activeClips();
+
+  return (
+    <section
+      aria-label="Transport"
+      data-testid="stage-transport-strip"
+      style={{
+        display: 'flex',
+        alignItems: 'center',
+        gap: 'var(--volter-space-2)',
+        padding: 'var(--volter-space-1) var(--volter-space-3)',
+        borderTop: `var(--volter-stroke-resting) solid ${themeVars.boundary.default}`,
+        background: themeVars.surface.raised,
+      }}
+    >
+      <IconButton
+        size="compact"
+        aria-label={playing ? 'Pause' : 'Play'}
+        onClick={() => (playing ? transport.pause() : transport.play())}
+      >
+        <EditorIcon icon={playing ? editorIcons.transport.pause : editorIcons.transport.play} />
+      </IconButton>
+      <IconButton
+        size="compact"
+        aria-label="Stop"
+        onClick={() => transport.stop()}
+      >
+        <EditorIcon icon={editorIcons.transport.stop} />
+      </IconButton>
+
+      <TextInput
+        aria-label="Playhead"
+        type="range"
+        min={start}
+        max={end}
+        step={1 / fps}
+        value={snapshot.time}
+        onChange={(event) => transport.seek(Number(event.target.value))}
+        style={{ flex: 1 }}
+      />
+
+      <Text as="span" variant="caption">
+        {formatSeconds(snapshot.time, fps)}
+      </Text>
+
+      {subjects ? (
+        <select
+          aria-label="Subject"
+          value={snapshot.activeSubject}
+          onChange={(event) => transport.setActiveSubject(event.target.value)}
+        >
+          {subjects.map((subject) => (
+            <option key={subject.id} value={subject.id}>
+              {subject.label}
+            </option>
+          ))}
+        </select>
+      ) : null}
+
+      {clips ? (
+        <select
+          aria-label="Clip"
+          onChange={(event) => transport.setActiveClip(event.target.value)}
+        >
+          {clips.map((clip) => (
+            <option key={clip.id} value={clip.id}>
+              {clip.label}
+            </option>
+          ))}
+        </select>
+      ) : null}
+
+      <label style={{ display: 'flex', alignItems: 'center', gap: 'var(--volter-space-1)' }}>
+        <input
+          type="checkbox"
+          checked={loop}
+          onChange={(event) => transport.setLoop(event.target.checked)}
+        />
+        <Text as="span" variant="caption">
+          Loop
+        </Text>
+      </label>
+
+      <select
+        aria-label="Speed"
+        value={String(snapshot.timeScale)}
+        onChange={(event) => transport.setTimeScale(Number(event.target.value))}
+      >
+        {SPEEDS.map((speed) => (
+          <option key={speed} value={String(speed)}>
+            {speed}×
+          </option>
+        ))}
+      </select>
+
+      {active ? (
+        <Text as="span" variant="caption">
+          {active.label}
+        </Text>
+      ) : null}
+    </section>
+  );
+}

package/src/kit/viewport-actions.ts

@@ -6,57 +6,16 @@
  * stage's own store: the same stage its keys drive (`viewport-hotkeys.ts`).
  */
 import type { ActionContribution, ContributedAction } from '@volter/sdk/chrome';
-import {
-  alignCameraToViewport,
-  cameraAuthoringPresentation,
-  currentCameraAuthoringSubject,
-  leaveCameraView,
-  pilotCamera,
-  subscribeCameraAuthoring,
-  toggleCameraPreviewPin,
-  viewThroughCamera,
-} from './camera-authoring';
-import { registerContributedActions } from '@volter/sdk/kit/chrome-registry';
+import { registerContributedActions } from '@volter/sdk/chrome-registry';
 import type { EditorShellStore } from './editor-shell-store';
 import { object3DDocumentSession } from './authoring/object3d-document-session-registry';
-import { requestTransformMode } from '@volter/sdk/kit/transform-mode-request';
-import { activeWorkspaceDocumentId } from '@volter/sdk/kit/workspace-document-registry';
+import { requestTransformMode } from '@volter/sdk/transform-mode-request';
+import { activeWorkspaceDocumentId } from '@volter/sdk/workspace-document-registry';
 import {
   setViewGridVisible,
   viewGridVisible,
   viewPresentationBinding,
-} from '@volter/sdk/kit/viewport-presentation';
-
-function cameraActions(): ContributedAction[] {
-  const presentation = cameraAuthoringPresentation();
-  if (presentation.view) {
-    return [{ id: 'camera.exitView', label: 'Exit Camera View', execute: leaveCameraView }];
-  }
-  const subject = currentCameraAuthoringSubject();
-  if (!subject) return [];
-  return [
-    {
-      id: 'camera.viewThrough',
-      label: `View Through ${subject.name}`,
-      execute: () => viewThroughCamera(subject),
-    },
-    ...(subject.canAuthorPose
-      ? [
-          { id: 'camera.pilot', label: `Pilot ${subject.name}`, execute: () => pilotCamera(subject) },
-          {
-            id: 'camera.alignToView',
-            label: `Align ${subject.name} to Current View`,
-            execute: () => alignCameraToViewport(subject),
-          },
-        ]
-      : []),
-    {
-      id: 'camera.pinPreview',
-      label: presentation.previewPinned ? 'Unpin Camera Preview' : 'Pin Camera Preview',
-      execute: toggleCameraPreviewPin,
-    },
-  ];
-}
+} from '@volter/sdk/viewport-presentation';
 
 function activeObject3DDocumentSession() {
   const documentId = activeWorkspaceDocumentId();
@@ -84,7 +43,7 @@ export function registerViewportActions(store: EditorShellStore): () => void {
       id: 'toggle.grid',
       label: 'Toggle Grid',
       execute: () => {
-        // The ACTIVE view's grid switch, one per view (`kit/viewport-presentation`).
+        // The ACTIVE view's grid switch, one per view (`@volter/sdk/viewport-presentation`).
         const viewId = activeWorkspaceDocumentId();
         if (viewId && viewPresentationBinding(viewId)) setViewGridVisible(viewId, !viewGridVisible(viewId));
       },
@@ -120,9 +79,8 @@ export function registerViewportActions(store: EditorShellStore): () => void {
     { id: 'view.camera', label: 'Camera View', shortcut: 'view.camera', execute: () => store.shell.toggleCameraView() },
     { id: 'focus.selected', label: 'Focus Selected', shortcut: 'viewport.frameSelection', execute: () => store.shell.focusOnSelection() },
   ];
-  const contribution: ActionContribution = {
-    actions: () => [...fixed, ...cameraActions()],
-    subscribe: subscribeCameraAuthoring,
-  };
+  // Supply a live action set for each bound stage. Resolve it when the palette opens so repeated
+  // stage registrations do not claim the same fixed ids.
+  const contribution: ActionContribution = { actions: () => fixed };
   return registerContributedActions(contribution);
 }