@volter/editor-game 0.5.65

package/contributions/scene-document.service.ts

@@ -0,0 +1,32 @@
+/**
+ * THE SCENE DOCUMENT (`@volter/editor-sdk/services`, a `workspace.service`
+ * contribution). The kit routes every three root's edit document to
+ * `workspace:scene` and no longer synthesizes it: what that document shows is
+ * the project's world, mounted by the game runtime this package carries, so
+ * the document is this package's (`src/host/components/scene-document.tsx`).
+ *
+ * The session store arrives after the contribution pass, and a project switch
+ * brings a new one, so the document binds on each store's ARRIVAL
+ * (`@volter/editor-core/shell-store-door`'s `onShellStore`, as Play's
+ * autoplay entry does) and unbinds the previous store's binding first.
+ */
+import { onShellStore } from '@volter/editor-core/shell-store-door';
+import { unregisterAvailableWorkspaceDocument } from '@volter/editor-core/workspace-available-documents';
+import { SCENE_DOCUMENT_ID } from '@volter/editor-core/workspace-document-ids';
+import { bindSceneDocument } from '../src/host/components/scene-document';
+
+export const point = 'workspace.service';
+
+export function start(): () => void {
+  let unbind: (() => void) | null = null;
+  const stopStore = onShellStore((store) => {
+    unbind?.();
+    unbind = bindSceneDocument(store);
+  });
+  return () => {
+    stopStore();
+    unbind?.();
+    unbind = null;
+    unregisterAvailableWorkspaceDocument(SCENE_DOCUMENT_ID);
+  };
+}

package/contributions/state-watch.action.ts

@@ -0,0 +1,17 @@
+/**
+ * `Open State Watch` in the command palette — the same reveal as Debug ▸
+ * State Watch. The host lists a contributed action unconditionally, so the
+ * reveal is a no-op while nothing registers the tab (`available` gates it).
+ */
+import type { ActionContribution } from '@volter/editor-sdk/chrome';
+import { editorHost } from '@volter/editor-sdk/host';
+
+export const point = 'workspace.action';
+
+export const actions: ActionContribution['actions'] = [
+  {
+    id: 'state-watch',
+    label: 'Open State Watch',
+    execute: () => editorHost().workspace.showUtility('tool:state-watch.utility'),
+  },
+];

package/contributions/state-watch.menu.ts

@@ -0,0 +1,23 @@
+/**
+ * Debug ▸ State Watch — disabled while no game exposes a `DebugAdapter`, the
+ * same predicate the drawer tab's own `available` gate reads. `disabled` is
+ * asked at render, so it follows the session.
+ */
+import { getActiveDebug } from '@volter/editor-core/authoring/active-systems';
+import type { MenuContribution } from '@volter/editor-sdk/chrome';
+import { editorHost } from '@volter/editor-sdk/host';
+
+export const point = 'workspace.menu';
+
+export const menu: MenuContribution = {
+  menu: 'debug',
+  items: [
+    {
+      id: 'state-watch',
+      label: 'State Watch',
+      testId: 'menu-state-watch',
+      disabled: () => getActiveDebug() == null,
+      execute: () => editorHost().workspace.showUtility('tool:state-watch.utility'),
+    },
+  ],
+};

package/contributions/state-watch.utility.tsx

@@ -0,0 +1,20 @@
+/**
+ * State Watch as a drawer tab: a read-only tree and per-project pins over the
+ * focused game's native `DebugAdapter` providers — the same adapter
+ * `@volter/editor-live` reads. On offer only while that seam exists; a tab over no
+ * providers would be a measurement nobody made.
+ *
+ * `available` reads the PRIMARY authoring mount's debug adapter, exactly what
+ * the panel itself reads, so the gate and the content can never disagree.
+ */
+import { getActiveDebug } from '@volter/editor-core/authoring/active-systems';
+import { StateWatchPanel } from '../src/state-watch/StateWatchPanel';
+
+export const point = 'workspace.utility';
+export const title = 'State Watch';
+export const order = 19;
+export const available = (): boolean => getActiveDebug() != null;
+
+export default function StateWatchUtility() {
+  return <StateWatchPanel />;
+}

package/contributions/team-playtest.service.ts

@@ -0,0 +1,124 @@
+/**
+ * THE TEAM PLAYTEST — a collaborator with the `test` capability starts a
+ * playtest, and this editor joins it (`@volter/editor-sdk/services`, a
+ * `workspace.service` contribution): the snapshot's `activePlaytest` decides
+ * whether this tab enters play with the team's seed and room key, and the
+ * playtest's presence row reports the play and networking states back.
+ *
+ * It left `components/AppRoot.tsx` when Play left the host (WORK.md §The
+ * workbench, P3b): the shell must not name Play to run one. Collaboration,
+ * presence and the active networking adapter stay the host's and are reached
+ * through the `@editor/*` alias.
+ */
+
+import { getActiveNetworking, subscribeActiveNetworking } from '@volter/editor-core/authoring/active-systems';
+import { connectCollaboration } from '@volter/editor-core/collaboration-client';
+import { reportCollaborationPresence } from '@volter/editor-core/collaboration-presence';
+import { EDITOR_PARTICIPANT_ID } from '@volter/editor-core/editor-presence';
+import { activePlaytest, enterPlayMode, exitPlayMode } from '../src/play/play-mode';
+
+export const point = 'workspace.service';
+
+export function start(): () => void {
+  let requestedPlaytestId: string | null = null;
+  const failedPlaytests = new Set<string>();
+  let unsubscribeNetworking: (() => void) | null = null;
+  let unsubscribeNetworkingReplacement: (() => void) | null = null;
+  let subscribedNetworking = getActiveNetworking();
+  const stopNetworking = () => {
+    unsubscribeNetworking?.();
+    unsubscribeNetworking = null;
+    unsubscribeNetworkingReplacement?.();
+    unsubscribeNetworkingReplacement = null;
+    subscribedNetworking = null;
+  };
+  const disconnect = connectCollaboration((snapshot) => {
+    const canTest =
+      snapshot.participants
+        .find((participant) => participant.participantId === EDITOR_PARTICIPANT_ID)
+        ?.capabilities.includes('test') ?? false;
+    const team = snapshot.activePlaytest;
+    const active = activePlaytest();
+    if (!canTest || !team) {
+      requestedPlaytestId = null;
+      stopNetworking();
+      reportCollaborationPresence({ playtest: null });
+      if (active?.mode === 'team') exitPlayMode();
+      if (!team) failedPlaytests.clear();
+      return;
+    }
+    if (active?.mode === 'team' && active.id === team.id) return;
+    if (requestedPlaytestId === team.id) return;
+    if (failedPlaytests.has(team.id)) return;
+    requestedPlaytestId = team.id;
+    reportCollaborationPresence({
+      playtest: {
+        id: team.id,
+        play: 'starting',
+        networking: 'connecting',
+        roomName: null,
+        problem: null,
+      },
+    });
+    void enterPlayMode(team.seed, {
+      mode: 'team',
+      id: team.id,
+      roomKey: team.roomKey,
+      revision: team.revision,
+      participantId: EDITOR_PARTICIPANT_ID,
+    })
+      .then(() => {
+        if (requestedPlaytestId !== team.id) return;
+        stopNetworking();
+        const report = () => {
+          const networking = getActiveNetworking();
+          const state = networking?.getConnectionState?.();
+          const room = networking?.getRoomInfo?.();
+          reportCollaborationPresence({
+            playtest: {
+              id: team.id,
+              play: 'ready',
+              networking: !networking
+                ? 'not-declared'
+                : state === 'connected' && room
+                  ? 'ready'
+                  : state === 'error'
+                    ? 'error'
+                    : 'connecting',
+              roomName: room?.roomName ?? null,
+              problem: state === 'error' ? 'The game networking adapter reported an error.' : null,
+            },
+          });
+        };
+        const bindNetworking = () => {
+          const networking = getActiveNetworking();
+          if (networking !== subscribedNetworking) {
+            unsubscribeNetworking?.();
+            subscribedNetworking = networking;
+            unsubscribeNetworking = networking?.subscribe(report) ?? null;
+          }
+          report();
+        };
+        unsubscribeNetworkingReplacement = subscribeActiveNetworking(bindNetworking);
+        bindNetworking();
+      })
+      .catch((error) => {
+        if (requestedPlaytestId !== team.id) return;
+        requestedPlaytestId = null;
+        failedPlaytests.add(team.id);
+        reportCollaborationPresence({
+          playtest: {
+            id: team.id,
+            play: 'error',
+            networking: 'error',
+            roomName: null,
+            problem: error instanceof Error ? error.message : String(error),
+          },
+        });
+      });
+  });
+  return () => {
+    stopNetworking();
+    disconnect();
+  };
+}

package/contributions/three/camera-runtime.inspector.tsx

@@ -0,0 +1,34 @@
+/**
+ * The Runtime Camera Inspector section (`selection.inspector`): what the
+ * engine's camera director is actually doing with a selected camera — the
+ * active one, its priority, and a blend in flight.
+ *
+ * `match` asks the adapter for the node's `Object3D` and answers only for a
+ * real camera the director knows, so the section cannot render for a subject
+ * the runtime has never seen.
+ *
+ * On the contributed band, see `constraints.inspector.tsx`'s note; the number
+ * below is this section's relative order among its siblings.
+ */
+import type { AuthoringAdapter } from '@volter/editor-project/adapter';
+import type {
+  ToolContributionNode,
+  ToolInspectorContributionProps,
+} from '@volter/editor-sdk/contributions';
+import { CameraRuntimeSection, matches } from '../../src/three/authoring/camera-runtime-inspector-section';
+
+export const point = 'selection.inspector';
+export const title = 'Runtime Camera';
+export const icon = 'camera';
+export const order = 350;
+
+export function match(node: ToolContributionNode | null, adapter: unknown): boolean {
+  return matches(node as never, adapter as AuthoringAdapter);
+}
+
+export default function CameraRuntimeInspector({
+  adapter,
+  nodeId,
+}: ToolInspectorContributionProps) {
+  return <CameraRuntimeSection adapter={adapter as AuthoringAdapter} nodeId={nodeId} />;
+}

package/contributions/three/component-board.service.ts

@@ -0,0 +1,24 @@
+/**
+ * THE THREE MEDIUM'S COMPONENT BOARD (`@volter/editor-sdk/services`, a
+ * `workspace.service` contribution): `@volter/editor-game` tells the host's component
+ * board registry that this project's `three` stories have a `3D` board.
+ *
+ * TRANSCRIBED from `@volter/editor-game/contributions/react/component-board.service.ts`,
+ * landed in the same unit.
+ *
+ * WHY A PACKAGE AND NOT THE KIT'S CSF LANE. The board builds a THREE.Scene of
+ * the project's three-medium stories on the host's Object3D stage — it is the
+ * sibling of this package's `three-story-documents.tsx` (the turntable), and
+ * the substrate rule decides it. Portable CSF is medium-neutral and pulls in
+ * no three; a THREE.Scene builder inside it would make "do you want stories?"
+ * the same question as "do you want three?".
+ */
+
+import { registerComponentBoard } from '@volter/editor-core/component-board-registry';
+import { threeComponentBoard } from '../../src/three/three-board/three-component-board';
+
+export const point = 'workspace.service';
+
+export function start(): () => void {
+  return registerComponentBoard(threeComponentBoard);
+}

package/contributions/three/component-verbs.command.ts

@@ -0,0 +1,110 @@
+/**
+ * THE COMPONENT-VERB commands of the session wire
+ * (`@volter/editor-sdk/commands`, a `workspace.command` contribution):
+ * `extract-component` and `fork-component`.
+ *
+ * These are the same two operations the hierarchy row's menu items perform
+ * (`component-verbs.service.ts`), over the control API, because an agent
+ * authoring through the editor has no pointer to right-click with. They left
+ * `command-listener.ts`'s switch — and their rows left `command-table.ts` —
+ * with the menus, the same way the Blender verbs did when Blender's editor
+ * half left the host (`blender.command.ts`'s header, WORK.md §The workbench,
+ * item D).
+ *
+ * EACH ROW CARRIES ITS OWN RELAY BUDGET, transcribed from the host table rows
+ * they left (`command-table.ts`, `alwaysRefresh(30_000)` on both): the write
+ * goes through the dev server's source-plan route, and `derivedRefresh` is
+ * `'always'` because both rewrite the project's own TSX.
+ *
+ * `id` defaults to the current selection — the menu's own subject — so the
+ * command reads the same way the click does. The answer is the action's
+ * sentence (created, naming the new files, or the plan's own named refusal),
+ * and `ok` mirrors whether the write landed: the ok/error split is decided by
+ * `isExtractedHint`/`isForkedHint`, owned beside the wording they match, so
+ * the two cannot drift.
+ */
+
+import { getActiveAuthoring } from '@volter/editor-core/authoring/active-adapter';
+import type { EditorShellStore } from '@volter/editor-core/editor-shell-store';
+import { canExtractNode, isExtractedHint } from '../../src/host/instance-extract-actions';
+import { canForkInstance, isForkedHint } from '../../src/host/instance-fork-actions';
+import { shellStoreForHost } from '@volter/editor-core/shell-store-door';
+import type { CommandContribution } from '@volter/editor-sdk/commands';
+import { instanceExtractSourceFor } from '../../src/three/component-verbs/extract-menu';
+import { instanceForkSourceFor } from '../../src/three/component-verbs/fork-menu';
+
+/** The shell store, or the refusal that says the page has not installed one —
+ *  the same shape `bridge.command.ts` takes it in, made explicit because both
+ *  verbs need the SELECTION as well as the adapter. */
+const NO_STORE = { ok: false as const, error: 'the editor shell has not started yet.' };
+
+/** The row's id, or the one selected row — the menu's subject. */
+function subjectId(cmd: Record<string, unknown>, store: EditorShellStore): string | undefined {
+  const given = cmd['id'];
+  if (typeof given === 'string' && given.trim() !== '') return given;
+  return [...store.selectedEntityIds][0];
+}
+
+export const commands: CommandContribution['commands'] = {
+  'extract-component': {
+    timeoutMs: 30_000,
+    derivedRefresh: 'always',
+    handle: async (cmd) => {
+      try {
+        const store = shellStoreForHost();
+        if (!store) return NO_STORE;
+        const id = subjectId(cmd, store);
+        if (!id) return { ok: false, error: 'extract-component needs an id or a selected row.' };
+        const adapter = getActiveAuthoring(store);
+        const source = instanceExtractSourceFor(adapter, id);
+        if (!canExtractNode(adapter.hierarchy.node(id), source, id)) {
+          return {
+            ok: false,
+            error:
+              `"${id}" is not extractable: only a native source element row (not a component ` +
+              'instance, group row, or document) with a writable source backend can be extracted.',
+          };
+        }
+        const name = cmd['name'];
+        const hint = await source?.extractComponent?.(
+          id,
+          typeof name === 'string' && name.trim() !== '' ? name : undefined,
+        );
+        if (hint === undefined) return { ok: false, error: `"${id}" lost its extract seam.` };
+        return isExtractedHint(hint) ? { ok: true, data: { hint } } : { ok: false, error: hint };
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+  },
+  'fork-component': {
+    timeoutMs: 30_000,
+    derivedRefresh: 'always',
+    handle: async (cmd) => {
+      try {
+        const store = shellStoreForHost();
+        if (!store) return NO_STORE;
+        const id = subjectId(cmd, store);
+        if (!id) return { ok: false, error: 'fork-component needs an id or a selected row.' };
+        const adapter = getActiveAuthoring(store);
+        const source = instanceForkSourceFor(adapter, id);
+        if (!canForkInstance(adapter.hierarchy.node(id), source, id)) {
+          return {
+            ok: false,
+            error:
+              `"${id}" is not forkable: only a component-instance row whose callsite AND ` +
+              'definition both resolve, on an adapter with a writable source backend, can be ' +
+              'forked.',
+          };
+        }
+        const hint = await source?.forkComponent?.(id);
+        if (hint === undefined) return { ok: false, error: `"${id}" lost its fork seam.` };
+        return isForkedHint(hint) ? { ok: true, data: { hint } } : { ok: false, error: hint };
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+  },
+};
+
+export const point = 'workspace.command';

package/contributions/three/component-verbs.service.ts

@@ -0,0 +1,92 @@
+/**
+ * THE COMPONENT-INSTANCE VERBS of an R3F world's hierarchy row
+ * (`@volter/editor-sdk/services`, a `workspace.service` contribution):
+ * "Extract Component…", "Fork Component…" and "Reveal / Hide Internals".
+ *
+ * ## Why this is a package and not the host's
+ *
+ * They were three host modules registered at boot by three bare side-effect
+ * imports in `main.tsx` (`./authoring/instance-extract-menu-register` and its
+ * two siblings). Their subject is a project's TSX COMPONENT ESTATE — a row
+ * that came from `<HeroBox/>` in `src/prefabs/hero.tsx`, whose subtree becomes
+ * a new prefab with a portable CSF story, whose module gets copied and
+ * retargeted, whose internal nodes a component rendered itself. A MODEL
+ * DOCUMENT HAS NONE OF THOSE: the open-source `models` build authors geometry
+ * and has no component instances at all, so it paid eight files of the host's
+ * eager closure for three menu items it can never show.
+ *
+ * ## Why `@volter/editor-game` and not a package named for the substrate
+ *
+ * The substrate rule (WORK.md §The open-source launch, unit 9) sends a module
+ * to a package named for its substrate only when a SECOND sibling package
+ * imports it. Measured 2026-09-18: nothing outside the editor imports these
+ * three, and the only implementer of `extractComponent`/`forkComponent`
+ * anywhere in the estate is the host's own `r3f-source-authoring-adapter.ts`.
+ * With no second sibling, the rule's default stands — the game lane's, because
+ * a prefab estate with CSF stories is what a game's scene is made of.
+ *
+ * ## The seam, which is not a new one
+ *
+ * `@editor/hierarchy-menu-registry` is the host's own registry and has always
+ * been the "escape hatch, registered elsewhere by the adapter modules"
+ * (`components/GameHierarchy.tsx:26`, `hierarchy-menu-registry.ts:50`); the
+ * package REGISTERS and the panel names no lane. The service point is
+ * transcribed from `@volter/editor-game`'s `react-inspector.service.ts`, which installs
+ * a contributed Inspector section the same way and for the same reason: a menu
+ * item is not a document, so it never opens and never persists, and what a
+ * contribution pass owns is when its registration exists. Host internals are
+ * reached through the `@editor/*` alias the editor's Vite serves to every
+ * contribution — the precedent `@volter/editor-game`'s own `bridge.command.ts` and
+ * `instances.command.ts` already set.
+ *
+ * ## What did NOT come, and why
+ *
+ * `instance-extract-actions.ts` and `instance-fork-actions.ts` — the pure
+ * applicability rules and every sentence these verbs can say — stay HOST
+ * FILES, because the host's `authoring/r3f-source-authoring-adapter.ts` mints
+ * those sentences when it performs the write. They leave the EAGER closure
+ * with this cut (nothing in the boot path reaches them any more), which is the
+ * shape units 5 and 11 landed; they become this package's own when the R3F
+ * source adapter moves.
+ *
+ * The SOURCE verbs ("Go to Callsite" / "Open Component Source") did not come
+ * either, and the measurement says why: four host callers, three of them in
+ * `keep` buckets and one of them the launch's own feature —
+ * `components/GameHierarchy.tsx:115` (the panel's double-click),
+ * `three-board/ThreeBoardDocument.tsx:71` and
+ * `authoring/creation-site-related.ts:25`. (A fourth was
+ * `authoring/model-drill.ts`, deleted 2026-09-19 with the TypeScript model
+ * module it drilled into.) Moving them needs a row-activation
+ * seam and a locator extraction; that is its own unit, not a rider on this one.
+ */
+
+import {
+  ensureInstanceExtractMenuRegistered,
+  unregisterInstanceExtractMenu,
+} from '../../src/three/component-verbs/extract-menu';
+import {
+  ensureInstanceForkMenuRegistered,
+  unregisterInstanceForkMenu,
+} from '../../src/three/component-verbs/fork-menu';
+import {
+  ensureInstanceInternalsMenuRegistered,
+  unregisterInstanceInternalsMenu,
+} from '../../src/three/component-verbs/internals-menu';
+
+export const point = 'workspace.service';
+
+export function start(): () => void {
+  ensureInstanceExtractMenuRegistered();
+  ensureInstanceForkMenuRegistered();
+  ensureInstanceInternalsMenuRegistered();
+  // Unlike the inspector section this point is transcribed from, the stop is
+  // REAL: `registerHierarchyMenuItems` hands back an unregister and the
+  // registry is a plain list the panel reads on every open, so a pass that
+  // ends without calling these would leave three matchers answering for a
+  // lane that is no longer loaded.
+  return () => {
+    unregisterInstanceExtractMenu();
+    unregisterInstanceForkMenu();
+    unregisterInstanceInternalsMenu();
+  };
+}

package/contributions/three/constraints.inspector.tsx

@@ -0,0 +1,34 @@
+/**
+ * The Constraints Inspector section (`selection.inspector`): the IK and
+ * look-at constraints the engine's `constraintsOf` marks on a selected
+ * `Object3D`, with each one's resolve status.
+ *
+ * `match` reads the marks off the adapter's own `hierarchy.object3D`, so it
+ * matches only a node that actually carries one — the section cannot render
+ * for a subject with no constraints.
+ *
+ * IT SITS IN THE CONTRIBUTED BAND NOW, after the kit's own blocks rather than
+ * between the group and stories blocks. That is what a contribution IS: the
+ * built-in band is the kit's and `contributedSectionOrder` adds
+ * `CONTRIBUTED_SECTION_ORDER` to whatever a module declares. The number below
+ * is the relative order this section kept among its three siblings.
+ */
+import type { AuthoringAdapter } from '@volter/editor-project/adapter';
+import type {
+  ToolContributionNode,
+  ToolInspectorContributionProps,
+} from '@volter/editor-sdk/contributions';
+import { ConstraintStackSection, matches } from '../../src/three/authoring/constraint-inspector-section';
+
+export const point = 'selection.inspector';
+export const title = 'Constraints';
+export const icon = 'link';
+export const order = 450;
+
+export function match(node: ToolContributionNode | null, adapter: unknown): boolean {
+  return matches(node as never, adapter as AuthoringAdapter);
+}
+
+export default function ConstraintsInspector({ adapter, nodeId }: ToolInspectorContributionProps) {
+  return <ConstraintStackSection adapter={adapter as AuthoringAdapter} nodeId={nodeId} />;
+}

package/contributions/three/model-asset-sections.service.ts

@@ -0,0 +1,26 @@
+/**
+ * THE OBJECT3D MODEL DOCUMENT'S INSPECTOR SECTIONS
+ * (`@volter/editor-sdk/services`, a `workspace.service` contribution): the
+ * Source / Geometry / Materials / Animation rail a loaded three model shows,
+ * and the per-node sections inside it.
+ *
+ * A SERVICE and not a `selection.inspector`, unlike the three sections beside
+ * it, and the reason is measured rather than stylistic: these are SECTION
+ * PRODUCERS (`InspectorSectionsProducer` — `sections(node, adapter)` returning
+ * a list), because one subject earns a whole rail of identified sections, and
+ * the `selection.inspector` point carries exactly ONE component. Registering
+ * through `registerInspectorSections` from a service reaches the same registry
+ * the point reaches, with the shape this subject actually has.
+ *
+ * The stop is a no-op: the registrations live in an HMR group the module owns,
+ * and the model document outlives any one contribution pass.
+ */
+
+import { ensureModelAssetSectionsRegistered } from '../../src/three/authoring/model-asset-inspector-section';
+
+export const point = 'workspace.service';
+
+export function start(): () => void {
+  ensureModelAssetSectionsRegistered();
+  return () => {};
+}

package/contributions/three/reflection-probe-capture.inspector.tsx

@@ -0,0 +1,32 @@
+/**
+ * The reflection probe's Capture Inspector section (`selection.inspector`):
+ * the probe's own capture controls for a selected probe node.
+ *
+ * On the contributed band, see `constraints.inspector.tsx`'s note; the number
+ * below is this section's relative order among its siblings.
+ */
+import type { AuthoringAdapter } from '@volter/editor-project/adapter';
+import type {
+  ToolContributionNode,
+  ToolInspectorContributionProps,
+} from '@volter/editor-sdk/contributions';
+import {
+  matches,
+  ReflectionProbeCaptureSection,
+} from '../../src/three/authoring/reflection-probe-inspector-section';
+
+export const point = 'selection.inspector';
+export const title = 'Capture';
+export const icon = 'camera-rotate';
+export const order = 500;
+
+export function match(node: ToolContributionNode | null, adapter: unknown): boolean {
+  return matches(node as never, adapter as AuthoringAdapter);
+}
+
+export default function ReflectionProbeCaptureInspector({
+  adapter,
+  nodeId,
+}: ToolInspectorContributionProps) {
+  return <ReflectionProbeCaptureSection adapter={adapter as AuthoringAdapter} nodeId={nodeId} />;
+}

package/contributions/three/story-documents.service.ts

@@ -0,0 +1,31 @@
+/**
+ * THE THREE STORY TURNTABLE (`@volter/editor-sdk/services`, a
+ * `workspace.service` contribution): the center document a portable CSF story
+ * whose medium is `three` opens as — the story's R3F world mounted on the
+ * kit's Object3D stage, with its `Story Args` Inspector section.
+ *
+ * The DOM/canvas isolated story document is `@volter/editor-game`'s contribution of the
+ * same name. They were one service while both documents lived in
+ * `@volter/editor-game`; splitting them is what lets a product compose one medium
+ * without the other, and neither registers anything the other needs.
+ *
+ * A SERVICE and not a `workspace.document`, for the same reason as its
+ * sibling: this is a kind with an unbounded set of documents, one per
+ * (module, story). The document opens through its address
+ * (`@editor/document-open-registry`) and restores through its own restorer
+ * (`@editor/workspace-document-restore`).
+ */
+
+import { ensureThreeStoryContributionsRegistered } from '../../src/three/story-documents/three-story-documents';
+
+export const point = 'workspace.service';
+
+export function start(): () => void {
+  // The module registers its opener and restorer at module scope; this call
+  // installs the story-scoped Inspector section. It is idempotent and returns
+  // nothing; the registration group it owns is HMR-safe by construction.
+  ensureThreeStoryContributionsRegistered();
+  // The stop is a no-op: the registration group is HMR-owned and an open story
+  // document outlives any one contribution pass.
+  return () => {};
+}