@volter/editor-game 0.5.65 → 0.5.67

package/src/host/game-realm-page.ts

@@ -42,16 +42,24 @@
  */
 
 /**
- * What the host stamps on an adopted surface so a game's `position:fixed`
- * overlay is contained to the pane.
+ * What the host stamps on an adopted surface so it behaves as the game's own page.
  *
  * `contain: layout` makes the element a containing block for absolutely AND
- * fixed positioned descendants — the one CSS primitive that does this without
- * the side effects of the alternatives (`transform`/`filter` also create the
- * containing block but force a compositing layer and, on the ADOPTED element
- * itself, are exactly the stamp {@link claimHostSurfaceBox} exists to clear).
+ * fixed positioned descendants, so a game's `position:fixed` overlay is contained to the
+ * pane — the one CSS primitive that does this without the side effects of the alternatives
+ * (`transform`/`filter` also create the containing block but force a compositing layer and,
+ * on the ADOPTED element itself, are exactly the stamp {@link claimHostSurfaceBox} exists to
+ * clear).
+ *
+ * The inherited text properties start from a page's defaults, as the game's `<body>` does
+ * when it ships: otherwise the editor's own typography (11px, its line height and colour)
+ * inherited into the game's DOM, and a game's text rendered smaller in the editor than in
+ * its build.
  */
-export const GAME_SURFACE_CONTAINMENT_CSS = 'contain: layout;';
+export const GAME_SURFACE_CONTAINMENT_CSS =
+  'contain: layout; font: initial; color: initial; letter-spacing: normal; word-spacing: normal;' +
+  ' text-align: start; text-indent: 0; text-transform: none; white-space: normal;' +
+  ' direction: ltr; cursor: auto; visibility: visible;';
 
 /** `EventTarget`'s own listener identity is (type, callback, capture) — read
  *  the capture flag out of either options form so the page's registration
@@ -82,7 +90,7 @@ export const SCOPED_STYLE_MARK = 'vgaiScopedCss';
 let gameCssScoper: Promise<(css: string) => string> | null = null;
 export function loadGameCssScoper(): Promise<(css: string) => string> {
   gameCssScoper ??= Promise.all([
-    import('@volter/editor-core/game-css-scope-transform'),
+    import('./game-css-scope-transform'),
     import('@volter/editor-sdk/session/game-css-scope'),
   ]).then(
     ([{ scopeGameCss }, { GAME_CSS_SCOPE_SELECTOR }]) =>

package/src/host/game-realm-reclaim.ts

@@ -14,7 +14,7 @@
  * attached AND ungated.
  */
 
-import { editorConsole } from '@volter/editor-core/editor-console';
+import { editorConsole } from '@volter/editor-sdk/kit/editor-console';
 import { disposeGameRealm } from './gated-globals';
 
 /**

package/src/host/gameplay-export.ts

@@ -1,4 +1,3 @@
-import { pcmStats } from '@volter/game-runtime/audio/wav-encode';
 import type { OfflineAudioRenderer } from '@volter/editor-project/adapter';
 import {
   AudioBufferSource,
@@ -10,8 +9,25 @@ import {
   Quality,
   WebMOutputFormat,
 } from 'mediabunny';
-import type { CaptureOptions } from '@volter/editor-core/composite-screenshot';
-import { createImageSnapshotCache, drawPlayCompositeFrame } from '@volter/editor-core/composite-screenshot';
+import type { CaptureOptions } from '@volter/editor-sdk/kit/composite-screenshot';
+import { createImageSnapshotCache, drawPlayCompositeFrame } from '@volter/editor-sdk/kit/composite-screenshot';
+
+/** RMS and peak over all channels and samples: evidence the track is sound, not an all-zero
+ *  buffer. */
+function pcmStats(channelData: readonly Float32Array[]): { rms: number; peak: number } {
+  let sumSquares = 0;
+  let peak = 0;
+  let count = 0;
+  for (const data of channelData) {
+    for (let i = 0; i < data.length; i++) {
+      const v = data[i] ?? 0;
+      sumSquares += v * v;
+      peak = Math.max(peak, Math.abs(v));
+      count++;
+    }
+  }
+  return { rms: count > 0 ? Math.sqrt(sumSquares / count) : 0, peak };
+}
 
 /**
  * Opus in the SAME WebM `Output` the video track already uses — the whole
@@ -25,14 +41,10 @@ import { createImageSnapshotCache, drawPlayCompositeFrame } from '@volter/editor
  * second container pipeline beside the first is how one export's timing,
  * metadata and codec support drift away from the other's.
  *
- * Consequently `audio/wav-encode.ts` is NOT used to make the track.
- * `encodeWav16` exists for the one place that genuinely needs a file on a
- * wire — `runtime/render-audio-control.ts` base64s a complete WAV across
- * `page.evaluate` to a Node capture driver. Here the `AudioBuffer` and the
- * muxer are in the same JS heap, so encoding to 16-bit WAV and handing the
- * bytes back to an encoder would quantize the samples for no reason at all.
- * `pcmStats` from that module IS used, for the non-silence evidence in the
- * result.
+ * The `AudioBuffer` and the muxer are in the same JS heap, so the samples go
+ * to the encoder as they are; encoding to 16-bit WAV on the way would quantize
+ * them for no reason at all. {@link pcmStats} gives the non-silence evidence in
+ * the result.
  *
  * Opus rather than a PCM track (Matroska can carry `A_PCM/INT/LIT`) because
  * WebM's normal audio codec is what every player and every `ffprobe` build
@@ -105,9 +117,8 @@ export interface GameplayExportResult {
 /** How the export gets sound: the world's own audio for the ABSOLUTE sim
  *  window the frame walk covers, rendered offline.
  *
- *  THE OFFSET TRAP, restated at the call site because it is the correctness
- *  argument of this whole path (`runtime/render-audio-control.ts` states it
- *  first): an offline render of `[10, 10.72)` schedules its first event at
+ *  THE OFFSET TRAP, stated at the call site because it is the correctness
+ *  argument of this whole path: an offline render of `[10, 10.72)` schedules its first event at
  *  LOCAL time 0, not absolute 10. `startSeconds` is where the paused run
  *  stands on its own canonical clock when frame 0 is captured; `render` is
  *  asked for `[startSeconds, startSeconds + frames / fps)` and must subtract

package/src/host/gameplay-recording.ts

@@ -36,22 +36,22 @@ import type {
   CompositeFrame,
   ImageSnapshotCache,
   OverlayFrameCache,
-} from '@volter/editor-core/composite-screenshot';
+} from '@volter/editor-sdk/kit/composite-screenshot';
 import {
   createImageSnapshotCache,
   createOverlayFrameCache,
   drawPlayCompositeFrame,
   isRootCanvas,
-} from '@volter/editor-core/composite-screenshot';
+} from '@volter/editor-sdk/kit/composite-screenshot';
 import {
   abortGameplayRecordingSink,
   appendGameplayRecordingChunk,
   beginGameplayRecordingSink,
   finishGameplayRecordingSink,
   type GameplayRecordingSink,
-} from '@volter/editor-core/editor-api';
-import { type GameplayDomRecording, startGameplayDomRecording } from '@volter/editor-core/gameplay-dom-recording';
-import { publishToolContributionRecording } from '@volter/editor-core/gameplay-sessions';
+} from '@volter/editor-sdk/kit/editor-api';
+import { type GameplayDomRecording, startGameplayDomRecording } from '@volter/editor-sdk/kit/gameplay-dom-recording';
+import { publishToolContributionRecording } from '@volter/editor-sdk/kit/gameplay-sessions';
 import { createRecordingPreviewEncoder } from './recording-preview';
 
 export interface GameplayRecordingStartOptions {

package/src/host/gated-globals.ts

@@ -26,10 +26,10 @@
  *  Defined in a DOM-free module so the Node-side Vite plugin can import the same
  *  constant — see `game-globals-prelude.ts`. Re-exported here for the browser
  *  callers that already reach for it alongside the proxies. */
-export { GAME_GLOBALS_PRELUDE } from '@volter/editor-core/game-globals-prelude';
+export { GAME_GLOBALS_PRELUDE } from '@volter/editor-sdk/kit/game-globals-prelude';
 
-import { installCreationSiteRecorder } from '@volter/editor-core/creation-site-registry';
-import { setConsoleRealmAttribution } from '@volter/editor-core/editor-console';
+import { installCreationSiteRecorder } from '@volter/editor-sdk/kit/creation-site-registry';
+import { setConsoleRealmAttribution } from '@volter/editor-sdk/kit/editor-console';
 import { guardedGameLocation, refusedNavigationMessage } from './game-location-guard';
 import { GameRealmPage } from './game-realm-page';
 import {
@@ -44,7 +44,7 @@ import {
   type SameRealmLoopGate,
   type SameRealmLoopGateStats,
 } from './same-realm-loop-gate';
-import { surfaceHoldsKeyboard } from '@volter/editor-core/surface-keyboard';
+import { surfaceHoldsKeyboard } from '@volter/editor-sdk/kit/surface-keyboard';
 
 /**
  * The SAME-REALM LOOP GATE (S-5) — the scheduling half of the same idea.
@@ -93,8 +93,8 @@ const INPUT_EVENT_TYPES = new Set<string>([
  * the keyboard and pointer, and it stopped keyup/mouseup/pointerup the same
  * way — so a key pressed while the gate was open and released after it closed
  * (Stop with W still held) left the game's OWN input manager holding KeyW for
- * good: the editor flushes only the session's InputManager, never a
- * project-owned copy (`src/lib/input`). With both vertical keys stuck the hero
+ * good: the editor flushes only the session's own input state, never a
+ * project-owned one. With both vertical keys stuck the hero
  * could not move up or down while A/D worked (runhuman pass 129; Opus
  * reproduction 2026-09-03 — forcing KeyW+KeyS into `keysDown` reproduced the
  * report verbatim, a single stuck key does not). Each proxy remembers the

package/src/host/history/json-history-resource.ts

@@ -1,6 +1,6 @@
-import { sha256Hex } from '@volter/editor-core/bytes-codec';
-import { HistoryOperationError, type HistoryService } from '@volter/editor-core/history/history-service';
-import type { ResourceDescriptor, ResourceDriver, ResourceKind } from '@volter/editor-core/history/types';
+import { sha256Hex } from '@volter/editor-sdk/kit/bytes-codec';
+import { HistoryOperationError, type HistoryService } from '@volter/editor-sdk/kit/history/history-service';
+import type { ResourceDescriptor, ResourceDriver, ResourceKind } from '@volter/editor-sdk/kit/history-types';
 
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();

package/src/host/instance-extract-actions.ts

@@ -20,7 +20,7 @@
  * action that writes NEW FILES — this one writes two.
  */
 
-import type { InstanceSourceLocator } from '@volter/editor-core/instance-source-actions';
+import type { InstanceSourceLocator } from '@volter/editor-sdk/kit/instance-source-actions';
 
 export const EXTRACT_COMPONENT_LABEL = 'Extract Component…';
 

package/src/host/instance-fork-actions.ts

@@ -19,7 +19,7 @@
  * FILE, which no other hierarchy item does.
  */
 
-import type { InstanceSourceLocator } from '@volter/editor-core/instance-source-actions';
+import type { InstanceSourceLocator } from '@volter/editor-sdk/kit/instance-source-actions';
 
 export const FORK_COMPONENT_LABEL = 'Fork Component…';
 

package/src/host/projection/dom.ts

@@ -28,9 +28,9 @@
  * raycast the projector can own the way {@link ThreeProjector.pick} does.
  */
 
-import type { ProjectedNode, Projection } from '@volter/editor-core/projection/types';
+import type { ProjectedNode, Projection } from '@volter/editor-sdk/kit/projection-types';
 
-export type { ProjectedNode, Projection } from '@volter/editor-core/projection/types';
+export type { ProjectedNode, Projection } from '@volter/editor-sdk/kit/projection-types';
 
 /**
  * The minimum shape a live DOM walk needs. Deliberately not `Element` so a

package/src/host/projection/pixi.ts

@@ -9,10 +9,10 @@
  * where an edit lands.
  */
 
-import type { AuthoringAdapter2D, EditorNode2D } from '@volter/game-runtime/pixi/authoring';
-import type { DOMRectLike } from '@volter/editor-project/adapter';
+import type { AuthoringAdapter2D, EditorNode2D } from '../../runtime/pixi/authoring';
+import type { DOMRectLike, FrameCorners } from '@volter/editor-project/adapter';
 import type { Container, PointData } from 'pixi.js';
-import type { ProjectedNode, Projection } from '@volter/editor-core/projection/types';
+import type { ProjectedNode, Projection } from '@volter/editor-sdk/kit/projection-types';
 
 export type PixiNode = ProjectedNode<Container>;
 
@@ -214,6 +214,28 @@ export class PixiProjector {
     return { x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height };
   }
 
+  /** The node's local bounds carried by its global transform — its turned box's corners. */
+  frame(id: string): FrameCorners | null {
+    const object = this.object(id) as
+      | (Container & { getLocalBounds?: () => { x: number; y: number; width: number; height: number } })
+      | null;
+    if (!object || typeof object.getLocalBounds !== 'function') return null;
+    const local = object.getLocalBounds();
+    if (!(local.width > 0) || !(local.height > 0)) return null;
+    // `toGlobal` brings the transform up to date itself, as `getBounds` does; the cached
+    // `worldTransform` is only as fresh as the last render, and an Edit surface renders on demand.
+    const at = (x: number, y: number) => {
+      const point = object.toGlobal({ x, y });
+      return { x: point.x, y: point.y };
+    };
+    return {
+      tl: at(local.x, local.y),
+      tr: at(local.x + local.width, local.y),
+      br: at(local.x + local.width, local.y + local.height),
+      bl: at(local.x, local.y + local.height),
+    };
+  }
+
   contextRects(id: string): { parent?: DOMRectLike; siblings: DOMRectLike[] } {
     const node = this.node(id);
     if (!node) return { siblings: [] };

package/src/host/r3f-entry-runtime.ts

@@ -1,57 +1,88 @@
 /**
- * Resolve the R3F entry factory from the same module graph as project worlds.
- * The packaged editor's UI is prebuilt with its own React/Fiber instances,
- * while project modules are transformed by a separate project-rooted Vite
- * server. Building a project component's adapter with the UI bundle's factory
- * crosses those graphs and crashes Fiber hooks on a null React dispatcher.
+ * The React and Fiber a project's three world is mounted with. The packaged
+ * editor's UI is prebuilt with its own React/Fiber instances, while project
+ * modules are transformed by a separate project-rooted Vite server. Mounting a
+ * project component with the UI bundle's copies crosses those graphs and
+ * crashes Fiber hooks on a null React dispatcher, so under the packaged
+ * runtime the mount takes the project's own through the R3F doorway
+ * (`R3F_DOORWAY` in `vite-plugin-module-doorways.ts`); in a checkout one Vite
+ * graph already shares them, and this module's own imports are they.
  */
 
-import { resolveR3FEntryAdapter } from '@volter/game-runtime/world3d-react';
+import {
+  advance,
+  createRoot,
+  events,
+  extend,
+  flushSync,
+} from '@react-three/fiber';
 import type { RootAdapter, ThreeHostContext } from '@volter/editor-project/adapter';
+import { R3F_RUNTIME_PATH } from '@volter/editor-sdk/host';
+import { isPackagedRuntime } from '@volter/editor-sdk/kit/packaged-runtime';
+import { Component, createElement, Fragment, useEffect } from 'react';
 import type * as THREE from 'three';
-import {
-  R3F_ENTRY_RUNTIME_PATH,
-  R3F_RUNTIME_PATH,
-} from '@volter/editor-sdk/host';
-import { isPackagedRuntime } from '@volter/editor-core/packaged-runtime';
+import { type R3FRuntime, resolveR3FEntryAdapter } from './roots/r3f-root';
 
-type R3FEntryResolver = typeof resolveR3FEntryAdapter;
+const CHECKOUT_RUNTIME: R3FRuntime = {
+  createElement,
+  Fragment,
+  Component,
+  useEffect,
+  createRoot,
+  extend,
+  advance,
+  flushSync,
+  events,
+};
 
 interface PackagedR3FRuntime {
-  readonly resolve: R3FEntryResolver;
+  readonly runtime: R3FRuntime;
   readonly projectThree: typeof THREE;
 }
 
 let cachedPackagedRuntime: Promise<PackagedR3FRuntime> | null = null;
 
+const RUNTIME_MEMBERS = [
+  'createElement',
+  'Fragment',
+  'Component',
+  'useEffect',
+  'createR3FRoot',
+  'extendThree',
+  'advance',
+  'flushSync',
+  'events',
+] as const;
+
 async function packagedRuntime(): Promise<PackagedR3FRuntime> {
-  const [entry, mod] = await Promise.all([
-    import(/* @vite-ignore */ R3F_ENTRY_RUNTIME_PATH) as Promise<{
-      resolveR3FEntryAdapter?: unknown;
-    }>,
-    import(/* @vite-ignore */ R3F_RUNTIME_PATH) as Promise<{ projectThree?: unknown }>,
-  ]);
-  if (typeof entry.resolveR3FEntryAdapter !== 'function') {
-    throw new Error(
-      "The packaged runtime's synthetic R3F entry module did not export " +
-        '`resolveR3FEntryAdapter` — see R3F_ENTRY_DOORWAY in vite-plugin-module-doorways.ts.',
-    );
-  }
-  if (typeof mod.projectThree !== 'object' || mod.projectThree === null) {
+  const mod = (await import(/* @vite-ignore */ R3F_RUNTIME_PATH)) as Record<string, unknown>;
+  const missing = RUNTIME_MEMBERS.filter((name) => mod[name] === undefined);
+  if (missing.length > 0 || typeof mod['projectThree'] !== 'object' || mod['projectThree'] === null) {
     throw new Error(
       "The packaged runtime's synthetic R3F module did not export " +
-        '`projectThree` — see R3F_DOORWAY in vite-plugin-module-doorways.ts.',
+        `${[...missing, ...(mod['projectThree'] ? [] : ['projectThree'])].join(', ')} — see ` +
+        'R3F_DOORWAY in vite-plugin-module-doorways.ts.',
     );
   }
   return {
-    resolve: entry.resolveR3FEntryAdapter as R3FEntryResolver,
-    projectThree: mod.projectThree as typeof THREE,
+    runtime: {
+      createElement: mod['createElement'] as R3FRuntime['createElement'],
+      Fragment: mod['Fragment'] as R3FRuntime['Fragment'],
+      Component: mod['Component'] as R3FRuntime['Component'],
+      useEffect: mod['useEffect'] as R3FRuntime['useEffect'],
+      createRoot: mod['createR3FRoot'] as R3FRuntime['createRoot'],
+      extend: mod['extendThree'] as R3FRuntime['extend'],
+      advance: mod['advance'] as R3FRuntime['advance'],
+      flushSync: mod['flushSync'] as R3FRuntime['flushSync'],
+      events: mod['events'] as R3FRuntime['events'],
+    },
+    projectThree: mod['projectThree'] as typeof THREE,
   };
 }
 
 /**
  * The packaged editor shell and project modules are separate Vite graphs. The
- * adapter itself comes from the project graph, so its Three host namespace
+ * world's Fiber comes from the project graph, so its Three host namespace
  * must come from there too: Fiber seeds its intrinsic catalogue from
  * `host.three`, and mixing in the shell's constructors makes applyProps turn a
  * typed `DirectionalLight.color` into the raw JSX string.
@@ -69,9 +100,9 @@ export function withPackagedProjectThree(
 }
 
 export async function resolveR3FEntryAdapterForEditor(entryModule: unknown, rootId: string) {
-  if (!(await isPackagedRuntime())) return resolveR3FEntryAdapter(entryModule, rootId);
+  if (!(await isPackagedRuntime())) return resolveR3FEntryAdapter(entryModule, rootId, CHECKOUT_RUNTIME);
   if (!cachedPackagedRuntime) cachedPackagedRuntime = packagedRuntime();
-  const runtime = await cachedPackagedRuntime;
-  const adapter = runtime.resolve(entryModule, rootId);
-  return adapter ? withPackagedProjectThree(adapter, runtime.projectThree) : null;
+  const { runtime, projectThree } = await cachedPackagedRuntime;
+  const adapter = resolveR3FEntryAdapter(entryModule, rootId, runtime);
+  return adapter ? withPackagedProjectThree(adapter, projectThree) : null;
 }

package/src/host/react-mount-runtime.ts

@@ -16,10 +16,7 @@
  * (confirmed live; see `packaged.ts`'s header).
  */
 
-import { WorldProvider as EngineWorldProvider } from '@volter/game-runtime/react/world-state';
-import type { Game } from '@volter/game-runtime/runtime/game';
 import {
-  type ComponentType,
   createElement,
   useEffect as reactUseEffect,
   useRef as reactUseRef,
@@ -27,12 +24,11 @@ import {
 import { flushSync } from 'react-dom';
 import { createRoot } from 'react-dom/client';
 import { REACT_WORLD_RUNTIME_PATH } from '@volter/editor-sdk/host';
-import { isPackagedRuntime } from '@volter/editor-core/packaged-runtime';
+import { isPackagedRuntime } from '@volter/editor-sdk/kit/packaged-runtime';
 
 /**
- * The pieces of "react itself" a react-world mount needs:
- * `createElement`/`createRoot` (to build + render the `<WorldProvider><Entry/>
- * </WorldProvider>` tree) and the engine-published `WorldProvider`.
+ * The pieces of "react itself" a react-world mount needs: `createElement`/`createRoot`
+ * to build and render `<Entry />`, and the hooks the editor's own wrappers use.
  */
 export interface ReactRootMountRuntime {
   createElement: typeof createElement;
@@ -43,7 +39,6 @@ export interface ReactRootMountRuntime {
    *  layer mount needs it from the SAME react-dom peer as `createRoot` above
    *  (both are entry points of the same installed package). */
   flushSync: typeof flushSync;
-  engineWorldProvider: ComponentType<{ game: Game; children?: unknown }>;
 }
 
 /** The dev default: this module's own static imports. */
@@ -54,10 +49,6 @@ function staticReactRootMountRuntime(): ReactRootMountRuntime {
     useEffect: reactUseEffect,
     useRef: reactUseRef,
     flushSync,
-    engineWorldProvider: EngineWorldProvider as unknown as ComponentType<{
-      game: Game;
-      children?: unknown;
-    }>,
   };
 }
 
@@ -77,20 +68,18 @@ async function loadPackagedReactRootMountRuntime(): Promise<ReactRootMountRuntim
     useEffect?: unknown;
     useRef?: unknown;
     flushSync?: unknown;
-    EngineWorldProvider?: unknown;
   };
   if (
     typeof mod.createElement !== 'function' ||
     typeof mod.createRoot !== 'function' ||
     typeof mod.useEffect !== 'function' ||
     typeof mod.useRef !== 'function' ||
-    typeof mod.flushSync !== 'function' ||
-    typeof mod.EngineWorldProvider !== 'function'
+    typeof mod.flushSync !== 'function'
   ) {
     throw new Error(
       "The packaged runtime's synthetic react-world-runtime module " +
-        `("${REACT_WORLD_RUNTIME_PATH}") did not export createElement/createRoot/useEffect/useRef/flushSync/` +
-        'EngineWorldProvider as functions — see vite-plugin-module-doorways.ts.',
+        `("${REACT_WORLD_RUNTIME_PATH}") did not export createElement/createRoot/useEffect/useRef/flushSync ` +
+        'as functions — see vite-plugin-module-doorways.ts.',
     );
   }
   return {
@@ -99,10 +88,6 @@ async function loadPackagedReactRootMountRuntime(): Promise<ReactRootMountRuntim
     useEffect: mod.useEffect as typeof reactUseEffect,
     useRef: mod.useRef as typeof reactUseRef,
     flushSync: mod.flushSync as typeof flushSync,
-    engineWorldProvider: mod.EngineWorldProvider as ComponentType<{
-      game: Game;
-      children?: unknown;
-    }>,
   };
 }
 
@@ -112,8 +97,8 @@ let cachedPackagedReactRootMountRuntime: Promise<ReactRootMountRuntime> | null =
  * Resolve the react-world mount's own react. A react world is an ISOLATED
  * `createRoot` (its own DOM subtree / react tree) that does NOT need to share
  * react with the editor's own UI — it only needs to be internally consistent
- * (the wrapper + `WorldProvider` + the project's entry component all sharing
- * ONE react instance), which is exactly what the packaged branch restores.
+ * (the editor's wrapper and the project's entry component sharing ONE react
+ * instance), which is exactly what the packaged branch restores.
  *
  * Memoized twice over: `isPackagedRuntime()` is itself session-memoized, and
  * the packaged module load is cached here, so this performs at most one
@@ -129,32 +114,6 @@ export async function resolveReactRootMountRuntime(): Promise<ReactRootMountRunt
   return cachedPackagedReactRootMountRuntime;
 }
 
-/**
- * `WorldProvider` is the canonical engine export from
- * `@volter/game-runtime/react/world-state`, reached through the mount runtime above so
- * the project's copy is used under the packaged runtime. Hosts and game
- * entries therefore share ONE module and one React context identity.
- *
- * WHY THIS IS AN ENGINE EXPORT AND NOT A PER-PROJECT FILE — a finding verified
- * empirically, kept because the trap it describes is still live for anyone
- * tempted to reintroduce a project-local provider. Back when each project
- * owned its own bridge module, a hand-built runtime `import('/@fs/' +
- * projectRoot + '/…')` for it did NOT reliably land on the same module
- * instance a react-world entry's own STATIC relative import resolved to:
- * Vite's dev server treated the two differently at the HTTP level (a
- * query-string divergence, confirmed by logging `import.meta.url` inside two
- * otherwise-identical fetches) even though both targeted the identical file on
- * disk, and browser ES module identity is keyed by the exact request URL. That
- * alone produced TWO separate `createContext()` calls. The whole apparatus is
- * gone: one engine module, no per-project path to diverge on.
- */
-export async function resolveWorldProviderForProject(): Promise<
-  ComponentType<{ game: Game; children?: unknown }>
-> {
-  const runtime = await resolveReactRootMountRuntime();
-  return runtime.engineWorldProvider;
-}
-
 /** Test-only: reset the packaged react-world mount runtime cache between
  *  tests that toggle `isPackagedRuntime()`'s own (separately memoized) result. */
 export function resetReactRootMountRuntimeCacheForTest(): void {

package/src/host/realm-services.ts

@@ -50,7 +50,7 @@ import {
 } from '@volter/editor-sdk/session/project-module-url';
 import type { AdapterSurface } from '@volter/editor-project/adapter/adapter-surface';
 import { resolveCanvasEntryAdapterForEditor } from './canvas-entry-runtime';
-import { isPackagedRuntime } from '@volter/editor-core/packaged-runtime';
+import { isPackagedRuntime } from '@volter/editor-sdk/kit/packaged-runtime';
 import { type ReactRootMountRuntime, resolveReactRootMountRuntime } from './react-mount-runtime';
 import {
   resolveThreeIngestRuntimeForEditor,
@@ -92,7 +92,7 @@ export interface RealmServices {
   readonly entryReach: 'full';
   /** The canvas doorway: turn a canvas entry namespace into its adapter. */
   readonly pixiRuntime: typeof resolveCanvasEntryAdapterForEditor;
-  /** The react-world mount's own react/react-dom/WorldProvider. */
+  /** The react-world mount's own react/react-dom. */
   readonly reactDomRuntime: () => Promise<ReactRootMountRuntime>;
   /** The three-ingest doorway: the namespace an ingested three game captures
    *  against. */