@volter/editor-game 0.5.66 → 0.5.68

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,7 +26,7 @@
  *  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-sdk/kit/creation-site-registry';
 import { setConsoleRealmAttribution } from '@volter/editor-sdk/kit/editor-console';
@@ -93,7 +93,7 @@ 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
+ * 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

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

@@ -1,5 +1,5 @@
 import { sha256Hex } from '@volter/editor-sdk/kit/bytes-codec';
-import { HistoryOperationError, type HistoryService } from '@volter/editor-core/history/history-service';
+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();

package/src/host/projection/pixi.ts

@@ -9,8 +9,8 @@
  * 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-sdk/kit/projection-types';
 
@@ -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 type { RootAdapter, ThreeHostContext } from '@volter/editor-project/adapter';
-import type * as THREE from 'three';
 import {
-  R3F_ENTRY_RUNTIME_PATH,
-  R3F_RUNTIME_PATH,
-} from '@volter/editor-sdk/host';
+  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 { 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,
@@ -30,9 +27,8 @@ import { REACT_WORLD_RUNTIME_PATH } from '@volter/editor-sdk/host';
 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

@@ -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. */