@volter/editor-game 0.5.66 → 0.5.67

package/src/host/authoring/pixi-still-presentation.ts

@@ -12,7 +12,7 @@
  * whose camera pose) — handed in as `renderScene`.
  */
 
-import { registerPresentedCanvasFrame } from '@volter/editor-core/canvas-preview-frames';
+import { registerPresentedCanvasFrame } from '../canvas-preview-frames';
 import type { RootViewController } from '@volter/editor-sdk/kit/world-pan-state';
 
 /**

package/src/host/authoring/pixi-structure-history.ts

@@ -31,7 +31,7 @@
 
 import type { Container } from 'pixi.js';
 import { editorConsole } from '@volter/editor-sdk/kit/editor-console';
-import type { EditorShellStore } from '@volter/editor-core/editor-shell-store';
+import type { EditorShellStore } from '@volter/editor-threejs/kit/editor-shell-store';
 import { type JournalSubject, JsonHistoryResource } from '../history/json-history-resource';
 
 /** The stage root's stand-in uid: it is not one of the adapter's nodes, but it
@@ -113,7 +113,7 @@ export class CanvasStructureHistory {
     /** Re-index + notify after a restore put objects back. */
     private readonly onRestored: () => void,
   ) {
-    const history = store.projectHistory;
+    const history = store.shell.projectHistory;
     this.resource = history
       ? new JsonHistoryResource<CanvasStructureState>({
           history,

package/src/host/authoring/pixi-transform-channels.ts

@@ -23,15 +23,16 @@
  * `<pixiContainer scale={0.5}>` is the shipped idiom (see any prefab under an
  * example project's `prefabs/`), and Pixi's own setter takes a number or a
  * `PointData` — never an array. So a UNIFORM scale writes the scalar back, and
- * a NON-UNIFORM one is only expressible through `@pixi/react`'s dashed-prop
- * piercing (`scale-x`/`scale-y`, which land on `container.scale.x`/`.y`). This
- * module writes the dashed pair when the tag already authors it, and otherwise
- * REFUSES a non-uniform scale in a sentence naming the pair — never a silently
- * lossy uniform write, and never an array literal Pixi would reject at
- * runtime.
+ * a NON-UNIFORM one writes the `{ x, y }` point the same setter takes. Not the
+ * dashed pair (`scale-x`/`scale-y`) as a new write: `@pixi/react` 8.0.5 hands
+ * every prop to the Pixi constructor, which copies `scale-x` onto the object as
+ * a plain property, so the pierce never runs when the node mounts (measured: a
+ * source with `scale-x={1.29}` mounts at scale 1). A tag that already authors
+ * the pair keeps it. Never a silently lossy uniform write, and never an array
+ * literal Pixi would reject at runtime.
  */
 
-import type { Transform2DValue } from '@volter/game-runtime/pixi/authoring';
+import type { Transform2DValue } from '../../runtime/pixi/authoring';
 import type { Transform } from '@volter/editor-project/adapter';
 
 /** Quaternion (xyzw) about Z ⇄ scalar radians — the one mapping both canvas
@@ -83,6 +84,8 @@ export type PixiChannelPlan =
   | { readonly writable: false; readonly reason: string };
 
 const NUMBER_RE = /^-?\d+(\.\d+)?$/;
+/** A number-point literal, `{ x: 1.2, y: 0.8 }` (the JSX expression's inside). */
+const POINT_RE = /^\{\s*x\s*:\s*-?\d*\.?\d+(e[+-]?\d+)?\s*,\s*y\s*:\s*-?\d*\.?\d+(e[+-]?\d+)?\s*,?\s*\}$/i;
 const EPS = 1e-6;
 
 /** ≤4 decimals, no trailing zeros, no negative zero — the same source-number
@@ -165,21 +168,20 @@ export function planChannelWrite(
   const refusal = propRefusal(attrs, 'scale');
   if (refusal) return { writable: false, reason: refusal };
   const authored = attr(attrs, 'scale');
-  if (authored && !NUMBER_RE.test(authored.rawValue.trim())) {
+  if (authored && !NUMBER_RE.test(authored.rawValue.trim()) && !POINT_RE.test(authored.rawValue.trim())) {
     return {
       writable: false,
       reason:
-        `scale is authored as {${authored.rawValue}} — this editor writes the scalar ` +
-        'shorthand or the `scale-x`/`scale-y` pair, not an object literal.',
+        `scale is authored as {${authored.rawValue}} — this editor writes a number or an ` +
+        '`{ x, y }` point, not an expression.',
     };
   }
   const [sx, sy] = next.scale;
   if (Math.abs(sx - sy) >= EPS) {
+    // Two values: the `PointData` Pixi's own setter takes, which applies when the node mounts.
     return {
-      writable: false,
-      reason:
-        'A non-uniform scale needs the `scale-x`/`scale-y` props — this tag authors the ' +
-        'uniform `scale` shorthand, which cannot hold two values.',
+      writable: true,
+      writes: [{ prop: 'scale', value: `{ x: ${formatSourceNumber(sx)}, y: ${formatSourceNumber(sy)} }` }],
     };
   }
   return { writable: true, writes: [{ prop: 'scale', value: formatSourceNumber(sx) }] };

package/src/host/authoring/source-persistence-backend.ts

@@ -46,11 +46,11 @@ import type {
   CreationSiteLiteralReport,
   CreationSiteSurface,
   CreationSiteWriteScope,
-} from '@volter/editor-core/creation-site-edit';
+} from '@volter/editor-sdk/kit/creation-site-edit';
 import { editorConsole } from '@volter/editor-sdk/kit/editor-console';
 import { editorIsAuthoring } from '@volter/editor-sdk/kit/editor-session-mode';
-import type { HistoryService } from '@volter/editor-core/history/history-service';
-import { ingestSourceWritesRecordedIfPrimed } from '@volter/editor-core/ui-source/tier-source-write-backend';
+import type { HistoryService } from '@volter/editor-sdk/kit/history/history-service';
+import { ingestSourceWritesRecordedIfPrimed } from '@volter/editor-sdk/kit/ui-source/tier-source-write-backend';
 import type { IngestInspectRequest } from './ingest-source-persistence';
 import {
   IngestSourcePersistence,

package/src/host/authoring/struct-write-pipe.ts

@@ -28,7 +28,7 @@
  */
 
 import { showTransientHint } from '@volter/editor-sdk/kit/transient-hint';
-import type { SourceWriteBackend } from '@volter/editor-core/ui-source/source-write-backend';
+import type { SourceWriteBackend } from '@volter/editor-sdk/kit/ui-source/source-write-backend';
 import { resolvesLiveOnly, runWritePipe, type WriteAck, type WriteResolution } from '@volter/editor-sdk/kit/write-pipe';
 
 /** The `writeStruct` options bag, spelled once (the backend's own shape). */

package/src/host/binding-resolver.ts

@@ -41,9 +41,9 @@ import {
 import {
   nativeDebugBindingFromEntryModule,
   nativeSystemsBindingFromEntryModule,
-} from '@volter/game-runtime/adapter/native-debug-module';
-import type { RootMountSpec } from '@volter/game-runtime/runtime/create-runtime';
-import type { MountEntry } from '@volter/game-runtime/runtime/mount-manifest';
+} from '../runtime/adapter/native-debug-module';
+import type { RootMountSpec } from '../runtime/create-runtime';
+import type { MountEntry } from '../runtime/mount-manifest';
 import type { SurfaceAdapter } from '@volter/editor-project/adapter';
 import type { AdapterDefinition } from '@volter/editor-project/adapter/adapter-module';
 import { assertNever } from '@volter/editor-project/adapter/adapter-surface';
@@ -51,7 +51,7 @@ import type { RootDeclaration } from '@volter/editor-project/adapter/binding';
 import { declaredRoots } from '@volter/editor-project/adapter/manifest-interpreter';
 import type { ResolvedAdapterRoot, ResolvedGameManifest } from '@volter/editor-project/manifest/load';
 import { adjudicateThreeEntry } from './entry-adjudication';
-import { projectAdapterDefinition } from '@volter/editor-core/project-adapter';
+import { projectAdapterDefinition } from '@volter/editor-sdk/kit/project-adapter';
 import { activeRealmServices, type RealmServices } from './realm-services';
 import { resolveModuleAdapter } from './roots/module-root';
 import { resolveDomAdapter, resolveIngestReactAdapter } from './roots/react-root';
@@ -193,11 +193,10 @@ async function resolveThreeRoot(
 /**
  * A canvas root is source-as-truth exactly like a three root: its `entry` is a
  * TSX world file, and what that file EXPORTS is adjudicated in ONE place —
- * `resolveCanvasEntryAdapter` (`@volter/game-runtime/canvas-react`, reached through the
- * realm so the packaged runtime takes it from the PROJECT's graph), the same
- * function the standalone mount path uses. Keeping the adjudication there
- * rather than here is what stops the editor and the standalone build from
- * disagreeing about what a world file means.
+ * `resolveCanvasEntryAdapter` (`roots/canvas-root.tsx`, reached through the
+ * realm so the packaged runtime mounts with the PROJECT's graph), shared by
+ * Play and the design-time layer so the two never disagree about what a world
+ * file means.
  */
 async function resolveCanvasRoot(
   root: ResolvedAdapterRoot,

package/src/host/browser-transpile.ts

@@ -30,7 +30,7 @@ import { init as esModuleLexerInit, parse as parseEsModule } from 'es-module-lex
 import * as esbuild from 'esbuild-wasm';
 // Vite serves the wasm binary as a static asset URL — fully local, no CDN.
 import esbuildWasmUrl from 'esbuild-wasm/esbuild.wasm?url';
-import { GAME_GLOBALS_PRELUDE } from '@volter/editor-core/game-globals-prelude';
+import { GAME_GLOBALS_PRELUDE } from '@volter/editor-sdk/kit/game-globals-prelude';
 
 /** Live runtime modules, keyed by the bare specifier used to import them. */
 type ModuleNamespace = Record<string, unknown>;

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

@@ -1,28 +1,26 @@
 /**
- * Resolve the canvas entry adapter from the same module graph as project
- * worlds — the `@pixi/react` sibling of `r3f-entry-runtime.ts`.
+ * The React, `@pixi/react` and `pixi.js` a project's canvas world is mounted
+ * with — the sibling of `r3f-entry-runtime.ts`.
  *
  * The packaged editor's UI is prebuilt with its own React, `@pixi/react` and
  * `pixi.js`, 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: the reconciler's hooks and the
- * component's hooks come from two Reacts, the tree never commits, and
- * the canvas mount fails its own first-commit ceiling ten seconds
- * later. See `../vite-plugin-module-doorways.ts` for the measured failure.
+ * project-rooted Vite server. Mounting a project component with the UI
+ * bundle's reconciler crosses those graphs: the reconciler's hooks and the
+ * component's hooks come from two Reacts, the tree never commits, and the
+ * canvas mount fails its own first-commit ceiling ten seconds later. See
+ * `vite-plugin-module-doorways.ts` for the measured failure.
  *
- * `@volter/game-runtime/canvas-react` is dynamic-imported on BOTH branches, deliberately: a
- * static import would put `pixi.js` and the Pixi reconciler in every editor
- * bundle, including one opening a three-only project — the same reason the
- * call sites this replaces were already dynamic.
+ * `pixi.js` and `@pixi/react` are dynamic-imported on the checkout branch,
+ * deliberately: a static import would put the Pixi renderer and reconciler in
+ * every editor bundle, including one opening a three-only project.
  */
 
-import type { resolveCanvasEntryAdapter } from '@volter/game-runtime/canvas-react';
 import type { RootAdapter } from '@volter/editor-project/adapter';
-import type * as PIXI from 'pixi.js';
 import { CANVAS_RUNTIME_PATH } from '@volter/editor-sdk/host';
 import { isPackagedRuntime } from '@volter/editor-sdk/kit/packaged-runtime';
-
-type CanvasEntryResolver = typeof resolveCanvasEntryAdapter;
+import type * as PIXI from 'pixi.js';
+import { createElement, Fragment, useEffect, useLayoutEffect } from 'react';
+import { type CanvasRuntime, resolveCanvasEntryAdapter } from './roots/canvas-root';
 
 /**
  * The `pixi.js` module namespace a canvas surface constructs and class-checks
@@ -32,36 +30,57 @@ type CanvasEntryResolver = typeof resolveCanvasEntryAdapter;
  */
 export type CanvasPixiNamespace = typeof PIXI;
 
-interface PackagedCanvasRuntime {
-  readonly resolve: CanvasEntryResolver;
-  readonly projectPixi: CanvasPixiNamespace;
-}
+let cachedRuntime: Promise<CanvasRuntime> | null = null;
 
-let cachedPackagedRuntime: Promise<PackagedCanvasRuntime> | null = null;
+const DOORWAY_MEMBERS = [
+  'createElement',
+  'Fragment',
+  'useEffect',
+  'useLayoutEffect',
+  'createPixiRoot',
+  'extendPixi',
+  'projectPixi',
+] as const;
 
-async function packagedRuntime(): Promise<PackagedCanvasRuntime> {
-  const mod = (await import(/* @vite-ignore */ CANVAS_RUNTIME_PATH)) as {
-    resolveCanvasEntryAdapter?: unknown;
-    projectPixi?: unknown;
-  };
-  if (typeof mod.resolveCanvasEntryAdapter !== 'function') {
-    throw new Error(
-      "The packaged runtime's synthetic canvas module did not export " +
-        '`resolveCanvasEntryAdapter` — see vite-plugin-module-doorways.ts.',
-    );
-  }
-  if (typeof mod.projectPixi !== 'object' || mod.projectPixi === null) {
+async function packagedRuntime(): Promise<CanvasRuntime> {
+  const mod = (await import(/* @vite-ignore */ CANVAS_RUNTIME_PATH)) as Record<string, unknown>;
+  const missing = DOORWAY_MEMBERS.filter((name) => mod[name] === undefined || mod[name] === null);
+  if (missing.length > 0) {
     throw new Error(
-      "The packaged runtime's synthetic canvas module did not export " +
-        '`projectPixi` — see vite-plugin-module-doorways.ts.',
+      `The packaged runtime's synthetic canvas module did not export ${missing.join(', ')} — ` +
+        'see CANVAS_DOORWAY in vite-plugin-module-doorways.ts.',
     );
   }
   return {
-    resolve: mod.resolveCanvasEntryAdapter as CanvasEntryResolver,
-    projectPixi: mod.projectPixi as CanvasPixiNamespace,
+    createElement: mod['createElement'] as CanvasRuntime['createElement'],
+    Fragment: mod['Fragment'] as CanvasRuntime['Fragment'],
+    useEffect: mod['useEffect'] as CanvasRuntime['useEffect'],
+    useLayoutEffect: mod['useLayoutEffect'] as CanvasRuntime['useLayoutEffect'],
+    createRoot: mod['createPixiRoot'] as CanvasRuntime['createRoot'],
+    extend: mod['extendPixi'] as CanvasRuntime['extend'],
+    pixi: mod['projectPixi'] as CanvasPixiNamespace,
   };
 }
 
+async function checkoutRuntime(): Promise<CanvasRuntime> {
+  const [pixiReact, pixi] = await Promise.all([import('@pixi/react'), import('pixi.js')]);
+  return {
+    createElement,
+    Fragment,
+    useEffect,
+    useLayoutEffect,
+    createRoot: pixiReact.createRoot,
+    extend: pixiReact.extend,
+    pixi,
+  };
+}
+
+/** The canvas runtime of the graph a canvas world mounts in, loaded once per session. */
+async function canvasRuntime(): Promise<CanvasRuntime> {
+  cachedRuntime ??= (async () => ((await isPackagedRuntime()) ? packagedRuntime() : checkoutRuntime()))();
+  return cachedRuntime;
+}
+
 /**
  * THE `pixi.js` OF THE GRAPH A CANVAS WORLD MOUNTS IN — the project's under the
  * packaged runtime, this bundle's own copy otherwise.
@@ -75,21 +94,13 @@ async function packagedRuntime(): Promise<PackagedCanvasRuntime> {
  * between two collaborators of the same surface is the bug, not the seam.
  */
 export async function resolveCanvasPixiForEditor(): Promise<CanvasPixiNamespace> {
-  if (!(await isPackagedRuntime())) return import('pixi.js');
-  if (!cachedPackagedRuntime) cachedPackagedRuntime = packagedRuntime();
-  return (await cachedPackagedRuntime).projectPixi;
+  return (await canvasRuntime()).pixi;
 }
 
-/** The adjudicator `resolveCanvasEntryAdapter` — from the PROJECT's graph
- *  under the packaged runtime, from this bundle's own engine copy otherwise. */
+/** The canvas entry adjudicator, handed the runtime of the graph the world mounts in. */
 export async function resolveCanvasEntryAdapterForEditor(
   entryModule: unknown,
   rootId: string,
 ): Promise<RootAdapter<'canvas'> | null> {
-  if (!(await isPackagedRuntime())) {
-    const { resolveCanvasEntryAdapter } = await import('@volter/game-runtime/canvas-react');
-    return resolveCanvasEntryAdapter(entryModule, rootId);
-  }
-  if (!cachedPackagedRuntime) cachedPackagedRuntime = packagedRuntime();
-  return (await cachedPackagedRuntime).resolve(entryModule, rootId);
+  return resolveCanvasEntryAdapter(entryModule, rootId, await canvasRuntime());
 }