@vgai/engine 0.5.15 → 0.5.16

package/dist/asset-formats/mesh.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const MeshDescriptorSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        capsule: "capsule";
-        box: "box";
         sphere: "sphere";
+        box: "box";
+        capsule: "capsule";
         plane: "plane";
         cylinder: "cylinder";
         gltf: "gltf";

package/dist/asset-formats/particles.d.ts

@@ -1387,8 +1387,8 @@ export declare const ParticlesDescriptorSchema: z.ZodObject<{
             anisotropy: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         blending: z.ZodOptional<z.ZodEnum<{
-            additive: "additive";
             normal: "normal";
+            additive: "additive";
         }>>;
         transparent: z.ZodOptional<z.ZodBoolean>;
         depthWrite: z.ZodOptional<z.ZodBoolean>;

package/dist/canvas-react/engine-bridge.d.ts

@@ -12,17 +12,17 @@
  * engine services, `@pixi/react`'s own `useTick` is the per-frame hook, and
  * `useApplication` is the door to the live `Application`.
  */
-import type { GameContext } from '../runtime/types';
+import type { CanvasGameContext } from './world-context';
 export interface EngineBridgeValue {
-    /** This root's `GameContext` — `input`, `debug`, `random`, `clock`, `game`,
+    /** This root's `CanvasGameContext` — `input`, `debug`, `random`, `clock`, `game`,
      *  `roots`, `systems`, `registerSystemAdapter`. Present so ordinary
      *  components can reach engine services with a HOOK (see
      *  {@link useGameContext}). */
-    readonly ctx?: GameContext | undefined;
+    readonly ctx?: CanvasGameContext | undefined;
 }
 export declare const EngineBridge: import("react").Context<EngineBridgeValue | null>;
 /**
- * This canvas root's `GameContext`, for use inside any component in the tree.
+ * This canvas root's `CanvasGameContext`, for use inside any component in the tree.
  *
  * An ordinary component does what a model would write:
  *
@@ -31,7 +31,7 @@ export declare const EngineBridge: import("react").Context<EngineBridgeValue | n
  *   const { input } = useGameContext();
  *   const ref = useRef<Sprite>(null);
  *   useTick(({ deltaMS }) => {
- *     if (input.isPressed('move_right')) ref.current!.x += speed * (deltaMS / 1000);
+ *     if (input?.isPressed('move_right')) ref.current!.x += speed * (deltaMS / 1000);
  *   });
  *   return <pixiSprite ref={ref} texture={Texture.WHITE} />;
  * }
@@ -41,5 +41,5 @@ export declare const EngineBridge: import("react").Context<EngineBridgeValue | n
  * `createPixiReactAdapter` — absent context is a wiring bug, and a silent
  * `null` would surface as a mystery `undefined` deep in a tick callback.
  */
-export declare function useGameContext(): GameContext;
+export declare function useGameContext(): CanvasGameContext;
 //# sourceMappingURL=engine-bridge.d.ts.map

package/dist/canvas-react/engine-bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine-bridge.d.ts","sourceRoot":"","sources":["../../src/canvas-react/engine-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,iBAAiB;IAChC;;;mCAG+B;IAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CACxC;AAED,eAAO,MAAM,YAAY,mDAAgD,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAU5C"}
+{"version":3,"file":"engine-bridge.d.ts","sourceRoot":"","sources":["../../src/canvas-react/engine-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IAChC;;;mCAG+B;IAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;CAC9C;AAED,eAAO,MAAM,YAAY,mDAAgD,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,IAAI,iBAAiB,CAUlD"}

package/dist/canvas-react/engine-bridge.js

@@ -15,7 +15,7 @@
 import { createContext, useContext } from 'react';
 export const EngineBridge = createContext(null);
 /**
- * This canvas root's `GameContext`, for use inside any component in the tree.
+ * This canvas root's `CanvasGameContext`, for use inside any component in the tree.
  *
  * An ordinary component does what a model would write:
  *
@@ -24,7 +24,7 @@ export const EngineBridge = createContext(null);
  *   const { input } = useGameContext();
  *   const ref = useRef<Sprite>(null);
  *   useTick(({ deltaMS }) => {
- *     if (input.isPressed('move_right')) ref.current!.x += speed * (deltaMS / 1000);
+ *     if (input?.isPressed('move_right')) ref.current!.x += speed * (deltaMS / 1000);
  *   });
  *   return <pixiSprite ref={ref} texture={Texture.WHITE} />;
  * }

package/dist/canvas-react/index.d.ts

@@ -22,7 +22,7 @@
  *  - `PixiPrimitive` / `adoptNow` — the canvas surface's `<primitive object={…}>`:
  *    render a container the game already owns, and place a spawn in the
  *    display tree ahead of the commit that renders it.
- *  - `useGameContext()` — this root's `GameContext` (`input`, `debug`,
+ *  - `useGameContext()` — this root's `CanvasGameContext` (`input`, `debug`,
  *    `random`, `clock`, `game`, `roots`) from inside any component in the tree.
  *    Behavior in a canvas world is components + hooks, never a class under a
  *    string key.
@@ -38,5 +38,5 @@ export { EngineBridge, type EngineBridgeValue, useGameContext } from './engine-b
 export { adoptNow, PixiPrimitive, type PixiPrimitiveProps } from './pixi-primitive';
 export { type CreatePixiReactAdapterOptions, createPixiReactAdapter, } from './pixi-react-adapter';
 export { pixiReactRootFactory, resolveCanvasEntryAdapter } from './pixi-react-root-factory';
-export { type CanvasRootContextOptions, type CanvasRootRuntime, createCanvasRootContext, DEFAULT_INPUT_MAP_PATH, } from './world-context';
+export { type CanvasGameContext, type CanvasRootContextOptions, type CanvasRootRuntime, createCanvasRootContext, DEFAULT_INPUT_MAP_PATH, } from './world-context';
 //# sourceMappingURL=index.d.ts.map

package/dist/canvas-react/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/canvas-react/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,EACL,KAAK,6BAA6B,EAClC,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/canvas-react/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,EACL,KAAK,6BAA6B,EAClC,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC"}

package/dist/canvas-react/index.js

@@ -22,7 +22,7 @@
  *  - `PixiPrimitive` / `adoptNow` — the canvas surface's `<primitive object={…}>`:
  *    render a container the game already owns, and place a spawn in the
  *    display tree ahead of the commit that renders it.
- *  - `useGameContext()` — this root's `GameContext` (`input`, `debug`,
+ *  - `useGameContext()` — this root's `CanvasGameContext` (`input`, `debug`,
  *    `random`, `clock`, `game`, `roots`) from inside any component in the tree.
  *    Behavior in a canvas world is components + hooks, never a class under a
  *    string key.

package/dist/canvas-react/pixi-react-adapter.d.ts

@@ -6,20 +6,20 @@
  * this returns a `MountedPixiRoot` (`../adapter/root-adapter.ts`) whose `stage`
  * is the REAL `PIXI.Container` the reconciler renders into.
  *
- * This is the canvas surface's exact sibling of `world3d-react`'s
+ * This is the canvas surface's sibling of `world3d-react`'s
  * `createR3FAdapter`, with `@pixi/react` where that one has
- * react-three-fiber. Everything structural is the same, because the seam is
- * the same: one loop (the host's), one canvas (the host's), a world-local
- * `SystemRunner` ticked in engine phase order before the renderer advances,
- * and a `GameContext` threaded into the tree through `EngineBridge`.
+ * react-three-fiber. The explicit factory still supplies the engine context
+ * used by the current first-party Canvas examples while their app-owned input
+ * and debugger migration remains tracked in `docs/WORK.md`; `useTick` hooks
+ * stay registered on Pixi's real ticker throughout that migration.
  *
  * ## The loop contract
  *
  * `Application` is initialized with `autoStart: false` and `sharedTicker:
- * false`, so it owns a ticker that is NEVER started and therefore never
- * requests an animation frame. `mounted.update(dt)` is the only thing that
- * advances it, and it feeds GAME time, not wall time — which is what makes the
- * world freeze exactly when the host freezes it, and what makes
+ * false`, so it owns a native Pixi ticker that is NEVER started and therefore
+ * never requests an animation frame. `mounted.update(dt)` is the only thing
+ * that advances that ticker, and it feeds GAME time, not wall time — which is
+ * what makes the world freeze exactly when the host freezes it, and what makes
  * `game.waitSimTime` work in a hidden tab (a hidden tab has no rAF; the engine
  * loop's own catch-up still calls `update`, and Pixi has no independent clock
  * to disagree with it).
@@ -50,6 +50,12 @@ export interface CreatePixiReactAdapterOptions {
      *  actions). A missing/invalid map degrades loudly without failing the
      *  mount — see `world-context.ts`. */
     readonly inputMapPath?: string | null | undefined;
+    /**
+     * Transitional compatibility for component trees that still consume the
+     * engine context. Native trees opt out once their input, observation and
+     * debugger state are application-owned.
+     */
+    readonly engineRuntime?: boolean | undefined;
     /**
      * Extra `Application.init` options merged UNDER this adapter's own — e.g.
      * `{ antialias: false }`, `{ roundPixels: true }`. The loop-critical ones

package/dist/canvas-react/pixi-react-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pixi-react-adapter.d.ts","sourceRoot":"","sources":["../../src/canvas-react/pixi-react-adapter.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE/D,OAAO,EAAiB,KAAK,SAAS,EAAmB,MAAM,OAAO,CAAC;AACvE,OAAO,KAAK,EAAsC,WAAW,EAAE,MAAM,YAAY,CAAC;AAyBlF,sFAAsF;AACtF,MAAM,WAAW,6BAA6B;IAC5C,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;yDACqD;IACrD,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B;;;;0CAIsC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClD;;;;;;;;OAQG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,SAAS,CAAC;CACvE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,6BAA6B,GACrC,WAAW,CAAC,QAAQ,CAAC,CA8LvB"}
+{"version":3,"file":"pixi-react-adapter.d.ts","sourceRoot":"","sources":["../../src/canvas-react/pixi-react-adapter.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE/D,OAAO,EAA2B,KAAK,SAAS,EAA8B,MAAM,OAAO,CAAC;AAC5F,OAAO,KAAK,EAAsC,WAAW,EAAE,MAAM,YAAY,CAAC;AA2BlF,sFAAsF;AACtF,MAAM,WAAW,6BAA6B;IAC5C,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;yDACqD;IACrD,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B;;;;0CAIsC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C;;;;;;;;OAQG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,SAAS,CAAC;CACvE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,6BAA6B,GACrC,WAAW,CAAC,QAAQ,CAAC,CA2MvB"}

package/dist/canvas-react/pixi-react-adapter.js

@@ -6,20 +6,20 @@
  * this returns a `MountedPixiRoot` (`../adapter/root-adapter.ts`) whose `stage`
  * is the REAL `PIXI.Container` the reconciler renders into.
  *
- * This is the canvas surface's exact sibling of `world3d-react`'s
+ * This is the canvas surface's sibling of `world3d-react`'s
  * `createR3FAdapter`, with `@pixi/react` where that one has
- * react-three-fiber. Everything structural is the same, because the seam is
- * the same: one loop (the host's), one canvas (the host's), a world-local
- * `SystemRunner` ticked in engine phase order before the renderer advances,
- * and a `GameContext` threaded into the tree through `EngineBridge`.
+ * react-three-fiber. The explicit factory still supplies the engine context
+ * used by the current first-party Canvas examples while their app-owned input
+ * and debugger migration remains tracked in `docs/WORK.md`; `useTick` hooks
+ * stay registered on Pixi's real ticker throughout that migration.
  *
  * ## The loop contract
  *
  * `Application` is initialized with `autoStart: false` and `sharedTicker:
- * false`, so it owns a ticker that is NEVER started and therefore never
- * requests an animation frame. `mounted.update(dt)` is the only thing that
- * advances it, and it feeds GAME time, not wall time — which is what makes the
- * world freeze exactly when the host freezes it, and what makes
+ * false`, so it owns a native Pixi ticker that is NEVER started and therefore
+ * never requests an animation frame. `mounted.update(dt)` is the only thing
+ * that advances that ticker, and it feeds GAME time, not wall time — which is
+ * what makes the world freeze exactly when the host freezes it, and what makes
  * `game.waitSimTime` work in a hidden tab (a hidden tab has no rAF; the engine
  * loop's own catch-up still calls `update`, and Pixi has no independent clock
  * to disagree with it).
@@ -36,8 +36,9 @@
  */
 import { createRoot, extend } from '@pixi/react';
 import * as PIXI from 'pixi.js';
-import { createElement, useLayoutEffect } from 'react';
+import { createElement, Fragment, useEffect, useLayoutEffect } from 'react';
 import { WorldProvider } from '../react/world-state';
+import { getDebugRegistry } from '../runtime/debug-registry';
 import { EngineBridge } from './engine-bridge';
 import { createCanvasRootContext } from './world-context';
 /** How long `mount()` waits for the tree's first commit before failing loudly
@@ -61,18 +62,18 @@ const MOUNTED_CANVASES = new WeakSet();
  * `requestAnimationFrame` loop.
  */
 export function createPixiReactAdapter(options) {
-    const { id, content, inputMapPath, applicationOptions } = options;
+    const { id, content, inputMapPath, engineRuntime = true, applicationOptions } = options;
     return {
         id,
         async mount(host) {
-            const runtime = createCanvasRootContext(host, { id, inputMapPath });
-            const bridge = { ctx: runtime.ctx };
+            const runtime = engineRuntime ? createCanvasRootContext(host, { id, inputMapPath }) : null;
+            const bridge = runtime ? { ctx: runtime.ctx } : null;
             // Actions must exist before any component's first tick reads them — wait
             // for the (never-rejecting) input-map load before the first commit.
-            await runtime.inputMapReady;
+            await runtime?.inputMapReady;
             const canvas = host.canvas;
             if (MOUNTED_CANVASES.has(canvas)) {
-                runtime.dispose();
+                runtime?.dispose();
                 throw new Error(`createPixiReactAdapter: root "${id}" was handed a canvas this lane has already ` +
                     'mounted. @pixi/react keys its reconciler roots off the canvas element, so re-using ' +
                     'one would resurrect a root whose Application is destroyed. Hand each mount a fresh ' +
@@ -85,6 +86,10 @@ export function createPixiReactAdapter(options) {
             const committed = new Promise((resolve) => {
                 resolveCommitted = resolve;
             });
+            let resolveEffectsReady;
+            const effectsReady = new Promise((resolve) => {
+                resolveEffectsReady = resolve;
+            });
             let resolveUnmounted;
             const unmounted = new Promise((resolve) => {
                 resolveUnmounted = resolve;
@@ -108,16 +113,23 @@ export function createPixiReactAdapter(options) {
                     resolveCommitted();
                     return resolveUnmounted;
                 }, []);
+                // This component is the last sibling. Reaching its passive effect
+                // means the initial tree's useDebugProvider/useDebugCommand effects
+                // have registered, so mount() can truthfully back Play's ack.
+                useEffect(resolveEffectsReady, []);
                 return null;
             }
-            const game = runtime.ctx.game;
+            const game = runtime?.ctx.game;
             // The React seam every dom root already has — `useWorldState`,
             // `useDebugProvider`/`useDebugCommand`/`useDebugEmit`
             // (`../react/world-state`) — works identically inside a canvas root
             // because a canvas root IS React. `host.game` is genuinely absent in
             // bare/foreign hosts, so the provider is conditional and those hooks
             // stay the inert no-ops they already document themselves to be.
-            const element = createElement(EngineBridge.Provider, { value: bridge }, game ? createElement(WorldProvider, { game }, content) : content, createElement(Lifecycle));
+            const world = createElement(Fragment, null, content, createElement(Lifecycle));
+            const element = bridge
+                ? createElement(EngineBridge.Provider, { value: bridge }, game ? createElement(WorldProvider, { game }, world) : world)
+                : world;
             const root = createRoot(canvas);
             // The host owns size, dpr, transparency and capture cost; the loop
             // contract owns `autoStart`/`sharedTicker`. Both are applied AFTER the
@@ -140,7 +152,7 @@ export function createPixiReactAdapter(options) {
             // creates the renderer) and only then hands the tree to the reconciler.
             // A crash inside init rejects here, which is the loud failure we want.
             const app = await root.render(element, initOptions);
-            runtime.setApplication(app);
+            runtime?.setApplication(app);
             // A reconcile-time crash (e.g. an un-extended component) surfaces as an
             // uncaught window error and the first commit never lands — without this
             // guard `mount()` would await `committed` forever. Convert that class of
@@ -154,7 +166,7 @@ export function createPixiReactAdapter(options) {
                     catch {
                         /* the world never fully came up; teardown failure must not mask why */
                     }
-                    runtime.dispose();
+                    runtime?.dispose();
                     reject(new Error(`createPixiReactAdapter: root "${id}" — ${why}`));
                 };
                 const onError = (event) => fail(`the Pixi tree crashed before its first commit — ${event.message} ` +
@@ -166,7 +178,7 @@ export function createPixiReactAdapter(options) {
                     globalThis.removeEventListener?.('error', onError);
                 };
                 globalThis.addEventListener?.('error', onError);
-                void committed.then(() => {
+                void Promise.all([committed, effectsReady]).then(() => {
                     cleanup();
                     resolve();
                 });
@@ -180,24 +192,26 @@ export function createPixiReactAdapter(options) {
             app.ticker.lastTime = 0;
             let elapsedMs = 0;
             let disposed = false;
+            const registry = host.game ? getDebugRegistry(host.game) : null;
+            const systemAdapters = runtime?.systemAdapters ?? (registry ? { debug: registry.adapter } : {});
             return {
                 kind: 'canvas',
                 // The reconciler's real root container — the same `PIXI.Container`
                 // `RootInstance.pixiStage()` hands the editor.
                 stage: app.stage,
                 drivesOwnLoop: false,
-                // Adapter surface: `debug` pre-seeded (the shared game registry's
-                // adapter); game code adds capabilities via `ctx.registerSystemAdapter`.
-                systems: runtime.systemAdapters,
+                // Adapter surface: the host's shared debug registry. A native component
+                // tree registers nothing; its entry-module `debug` export is projected
+                // after mount by the shared native adapter.
+                systems: systemAdapters,
                 update(dt) {
                     if (disposed)
                         return;
                     elapsedMs += dt * 1000;
-                    // Engine phases FIRST (registered systems mutate transforms), then
-                    // the ticker — so `useTick` callbacks and the render that follows
-                    // them at `UPDATE_PRIORITY.LOW` both see the fresh state. Both are
-                    // host-gated: neither runs while this world is frozen.
-                    runtime.systems.run(dt);
+                    // The optional legacy runtime drains first when explicitly enabled;
+                    // the native path has none. The real Pixi ticker remains the one
+                    // scheduler `useTick` observes, and the host only gates/advances it.
+                    runtime?.systems.run(dt);
                     app.ticker.update(elapsedMs);
                 },
                 resize(width, height) {
@@ -221,7 +235,7 @@ export function createPixiReactAdapter(options) {
                     // `removeView` stays false — the canvas belongs to the HOST.
                     void root.render(null, initOptions);
                     void unmounted.then(() => app.destroy(false, { children: true }));
-                    runtime.dispose();
+                    runtime?.dispose();
                 },
             };
         },

package/dist/canvas-react/pixi-react-root-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pixi-react-root-factory.d.ts","sourceRoot":"","sources":["../../src/canvas-react/pixi-react-root-factory.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAUnE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,MAAM,GACb,WAAW,CAAC,QAAQ,CAAC,GAAG,IAAI,CAU9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,qBAQlC,CAAC"}
+{"version":3,"file":"pixi-react-root-factory.d.ts","sourceRoot":"","sources":["../../src/canvas-react/pixi-react-root-factory.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAUnE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,MAAM,GACb,WAAW,CAAC,QAAQ,CAAC,GAAG,IAAI,CAc9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,qBAQlC,CAAC"}

package/dist/canvas-react/pixi-react-root-factory.js

@@ -53,6 +53,10 @@ export function resolveCanvasEntryAdapter(entryModule, rootId) {
         return createPixiReactAdapter({
             id: rootId,
             content: createElement(mod.default),
+            // The supported Canvas portfolio still consumes the compatibility
+            // context. Removing it belongs to the tracked component-root migration;
+            // disabling it here first made every current default-exported game fail
+            // to mount before that migration had happened.
         });
     }
     return null;

package/dist/canvas-react/world-context.d.ts

@@ -11,7 +11,8 @@
  *     the ONE game-scoped registry (`getDebugRegistry(host.game)`), so a
  *     component's effect can `ctx.debug.registerStateProvider(...)` and be
  *     visible to `vgai eval`/the editor's debug panels.
- *  2. **`ctx.input` is the game-owned `InputManager`** (`host.game.input` — the
+ *  2. **`ctx.input` is the game-owned `InputManager` when a Game hosts the
+ *     root** (`host.game.input` — the
  *     same instance every sibling root shares), and this module registers the
  *     per-world debug-registry seams (`setVirtualInputTarget`/
  *     `setInputActionsSource`/`setInputTraceSource`) that make `game.input.*`
@@ -19,13 +20,14 @@
  *     `DEBUG_INPUT_UNAVAILABLE`. The project's input map loads through
  *     `Game.loadInputMap` (the game-owned, load-once path every root shares).
  *     A missing/unparseable map degrades LOUDLY without failing the mount — a
- *     canvas world with no declared actions is legal.
- *  3. **Absent subsystems fail loudly at the ctx surface.** A canvas world
- *     builds no THREE scene/camera, no Rapier world, no composer, no first-party
- *     audio/particles/debug-draw, and is handed no `AssetCache` (the canvas host
- *     context carries none — see `adapter/host-context.ts`). Reading those
- *     `ctx` fields yields a throwing getter naming the limitation and the
- *     sanctioned alternative, never a silent `undefined`.
+ *     canvas world with no declared actions is legal. A bare/foreign mount
+ *     receives `null`, visibly in the type, rather than a throwing getter.
+ *  3. **Absent subsystems are absent from the type.** A canvas world builds no
+ *     THREE scene/camera, Rapier world, composer, first-party audio/particles/
+ *     debug-draw, or Three-flavoured `AssetCache`. Its explicit
+ *     {@link CanvasGameContext} cannot name those fields, so misuse fails at
+ *     the call site during typechecking instead of from a throwing getter at
+ *     runtime.
  *
  * The Pixi handles themselves are deliberately NOT re-exposed here: a component
  * reaches the live `Application` (and therefore `app.stage`, `app.renderer`,
@@ -36,8 +38,9 @@
 import type { Application } from 'pixi.js';
 import type { CanvasHostContext } from '../adapter';
 import type { SystemAdapters } from '../adapter/system-adapter';
+import type { SimClock } from '../core/sim-clock';
 import { createSystemRunner } from '../core/system-runner';
-import type { GameContext } from '../runtime/types';
+import type { ComponentContextBase } from '../runtime/types';
 /** The conventional input-map location every scaffolded project ships. Shared
  *  verbatim with the three lane — a project has ONE input map, whatever surface
  *  reads it. */
@@ -55,12 +58,19 @@ export interface CanvasRootContextOptions {
      */
     readonly inputMapPath?: string | null | undefined;
 }
+/** The engine services a Canvas component genuinely receives. Pixi's own
+ * `useApplication()` and `Assets` remain the doors to rendering and assets.
+ * `disposeAfter` is excluded because it accepts a `THREE.Object3D`; Canvas
+ * code schedules `displayObject.destroy()` with `clock.after()` instead. */
+export type CanvasGameContext = ComponentContextBase & {
+    readonly clock: Omit<SimClock, 'disposeAfter'>;
+};
 /** What {@link createCanvasRootContext} returns — the engine runtime one canvas
  *  world owns, plus the wiring hooks the adapter's `mount()` drives. */
 export interface CanvasRootRuntime {
-    /** The (partial, loud-on-absence) `GameContext` this world's components read
-     *  through `useGameContext`. See this module's header for what is present. */
-    readonly ctx: GameContext;
+    /** The explicit Canvas context this world's components read through
+     *  `useGameContext`. See {@link CanvasGameContext}. */
+    readonly ctx: CanvasGameContext;
     /** The world-local phase runner `mount().update(dt)` ticks. */
     readonly systems: ReturnType<typeof createSystemRunner>;
     /** The mounted world's `SystemAdapters` bag (`mounted.systems`) —

package/dist/canvas-react/world-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world-context.d.ts","sourceRoot":"","sources":["../../src/canvas-react/world-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAOhE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAM3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;gBAEgB;AAChB,eAAO,MAAM,sBAAsB,qCAAqC,CAAC;AAEzE,MAAM,WAAW,wBAAwB;IACvC;6BACyB;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACnD;AAED;wEACwE;AACxE,MAAM,WAAW,iBAAiB;IAChC;kFAC8E;IAC9E,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IACxD;6EACyE;IACzE,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC;qEACiE;IACjE,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC;gFAC4E;IAC5E,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAAC;IACvC,6EAA6E;IAC7E,QAAQ,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC;;8CAE0C;IAC1C,OAAO,IAAI,IAAI,CAAC;CACjB;AA4BD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,wBAAwB,GAChC,iBAAiB,CAoMnB"}
+{"version":3,"file":"world-context.d.ts","sourceRoot":"","sources":["../../src/canvas-react/world-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAMhE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAM3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D;;gBAEgB;AAChB,eAAO,MAAM,sBAAsB,qCAAqC,CAAC;AAEzE,MAAM,WAAW,wBAAwB;IACvC;6BACyB;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACnD;AAED;;;4EAG4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,GAAG;IACrD,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;CAChD,CAAC;AAEF;wEACwE;AACxE,MAAM,WAAW,iBAAiB;IAChC;2DACuD;IACvD,QAAQ,CAAC,GAAG,EAAE,iBAAiB,CAAC;IAChC,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IACxD;6EACyE;IACzE,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC;qEACiE;IACjE,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC;gFAC4E;IAC5E,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAAC;IACvC,6EAA6E;IAC7E,QAAQ,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC;;8CAE0C;IAC1C,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,wBAAwB,GAChC,iBAAiB,CAwInB"}

package/dist/canvas-react/world-context.js

@@ -11,7 +11,8 @@
  *     the ONE game-scoped registry (`getDebugRegistry(host.game)`), so a
  *     component's effect can `ctx.debug.registerStateProvider(...)` and be
  *     visible to `vgai eval`/the editor's debug panels.
- *  2. **`ctx.input` is the game-owned `InputManager`** (`host.game.input` — the
+ *  2. **`ctx.input` is the game-owned `InputManager` when a Game hosts the
+ *     root** (`host.game.input` — the
  *     same instance every sibling root shares), and this module registers the
  *     per-world debug-registry seams (`setVirtualInputTarget`/
  *     `setInputActionsSource`/`setInputTraceSource`) that make `game.input.*`
@@ -19,13 +20,14 @@
  *     `DEBUG_INPUT_UNAVAILABLE`. The project's input map loads through
  *     `Game.loadInputMap` (the game-owned, load-once path every root shares).
  *     A missing/unparseable map degrades LOUDLY without failing the mount — a
- *     canvas world with no declared actions is legal.
- *  3. **Absent subsystems fail loudly at the ctx surface.** A canvas world
- *     builds no THREE scene/camera, no Rapier world, no composer, no first-party
- *     audio/particles/debug-draw, and is handed no `AssetCache` (the canvas host
- *     context carries none — see `adapter/host-context.ts`). Reading those
- *     `ctx` fields yields a throwing getter naming the limitation and the
- *     sanctioned alternative, never a silent `undefined`.
+ *     canvas world with no declared actions is legal. A bare/foreign mount
+ *     receives `null`, visibly in the type, rather than a throwing getter.
+ *  3. **Absent subsystems are absent from the type.** A canvas world builds no
+ *     THREE scene/camera, Rapier world, composer, first-party audio/particles/
+ *     debug-draw, or Three-flavoured `AssetCache`. Its explicit
+ *     {@link CanvasGameContext} cannot name those fields, so misuse fails at
+ *     the call site during typechecking instead of from a throwing getter at
+ *     runtime.
  *
  * The Pixi handles themselves are deliberately NOT re-exposed here: a component
  * reaches the live `Application` (and therefore `app.stage`, `app.renderer`,
@@ -41,24 +43,6 @@ import { createDebugRegistry, getDebugRegistry, } from '../runtime/debug-registr
  *  verbatim with the three lane — a project has ONE input map, whatever surface
  *  reads it. */
 export const DEFAULT_INPUT_MAP_PATH = '/inputmaps/default.inputmap.json';
-/** Install a throwing getter for a `GameContext` field this world genuinely
- *  does not build — a component reaching for it fails LOUDLY at its own call
- *  site, naming the limitation, instead of reading `undefined` and breaking
- *  somewhere downstream. Non-enumerable so spreads/serialization of the ctx
- *  never trip it. */
-function defineAbsentCtxField(target, worldId, key, why) {
-    Object.defineProperty(target, key, {
-        configurable: true,
-        enumerable: false,
-        get() {
-            throw new Error(`canvas world "${worldId}": ctx.${key} is not available — ${why} ` +
-                '(A canvas world ctx provides: input, systems, clock, debug, random, game, roots, ' +
-                "registerSystemAdapter. The Pixi runtime itself comes from @pixi/react's " +
-                'useApplication() — app.stage, app.renderer, app.ticker — and assets from Pixi`s own ' +
-                'Assets.)');
-        },
-    });
-}
 /**
  * Build the engine runtime for one canvas world from a `CanvasHostContext`.
  * React-free on purpose: everything here is plain engine wiring the adapter
@@ -76,6 +60,7 @@ export function createCanvasRootContext(host, options) {
     let app = null;
     const ctxRaw = {
         systems,
+        input: host.game?.input ?? null,
         registerSystemAdapter: (kind, adapter) => {
             // biome-ignore lint/suspicious/noExplicitAny: same per-key record write the three lane performs; correct by construction
             systemAdapters[kind] = adapter;
@@ -113,7 +98,7 @@ export function createCanvasRootContext(host, options) {
                     '`container.destroy({ children: true })`, scheduled with `clock.after(seconds, ...)`.');
             },
         });
-    ctx.clock = clock;
+    ctxRaw['clock'] = clock;
     // --- ctx.input + the debug-registry input seams — the game-owned
     // InputManager, polled by the game-scoped runner each frame; this world
     // registers the per-world seams so `game.input.*` (virtual input) and the
@@ -122,7 +107,6 @@ export function createCanvasRootContext(host, options) {
     if (host.game) {
         const game = host.game;
         const input = game.input;
-        ctxRaw['input'] = input;
         debugRegistry.setInputActionsSource(id, () => input.actionNames().map((name) => ({ name, valueType: input.getActionValueType(name) })));
         debugRegistry.setInputTraceSource(id, () => {
             const raw = input.getInputTrace();
@@ -159,29 +143,6 @@ export function createCanvasRootContext(host, options) {
             });
         }
     }
-    else {
-        defineAbsentCtxField(ctxRaw, id, 'input', 'input is game-owned and this mount has no Game host (host.game is absent — bare ' +
-            'harness/foreign host); mount through the vgai host to get the shared InputManager.');
-    }
-    // --- Loud absence for everything a canvas world genuinely does not build. ---
-    const threeWhy = 'a canvas world renders through PixiJS and owns no THREE scene graph; the world root is ' +
-        "the Pixi stage, reached with @pixi/react's useApplication().app.stage.";
-    defineAbsentCtxField(ctxRaw, id, 'scene', threeWhy);
-    defineAbsentCtxField(ctxRaw, id, 'camera', threeWhy);
-    defineAbsentCtxField(ctxRaw, id, 'sceneIndex', 'the live scene index walks a THREE.Scene; a canvas world has none (walk the Pixi display ' +
-        'tree from useApplication().app.stage instead).');
-    const rapierWhy = 'canvas worlds do not build the first-party Rapier runtime; drive physics from inside the ' +
-        'tree with the 2D physics library of your choice.';
-    defineAbsentCtxField(ctxRaw, id, 'rapierWorld', rapierWhy);
-    defineAbsentCtxField(ctxRaw, id, 'rapier', rapierWhy);
-    defineAbsentCtxField(ctxRaw, id, 'physics', rapierWhy);
-    defineAbsentCtxField(ctxRaw, id, 'collisions', rapierWhy);
-    defineAbsentCtxField(ctxRaw, id, 'assets', 'the canvas host context carries no AssetCache (that cache is a GLTF/texture loader ' +
-        "resolving THREE objects); load textures/spritesheets with Pixi's own `Assets`.");
-    defineAbsentCtxField(ctxRaw, id, 'composer', 'a canvas world has no postprocessing EffectComposer; use Pixi filters on a Container.');
-    defineAbsentCtxField(ctxRaw, id, 'audio', 'canvas worlds build no first-party audio context; use Web Audio directly (or @pixi/sound).');
-    defineAbsentCtxField(ctxRaw, id, 'particles', 'canvas worlds build no three.quarks particle runtime; use a Pixi particle container.');
-    defineAbsentCtxField(ctxRaw, id, 'debugDraw', 'canvas worlds build no debug-draw helper; draw into a Pixi `Graphics` in the tree.');
     return {
         ctx,
         systems,

package/dist/ecs/user-data.d.ts

@@ -111,12 +111,15 @@
  *                           JSX props for renderer/editor integration.
  * - `constraints`         — live project-owned spatial constraints projected
  *                           into the shared Inspector and viewport.
+ * - `authoringSubject`    — transient identity/inspection for an ecosystem-native
+ *                           subject represented by an Object3D proxy.
  * - `splineControlPoint`  — index of a spline control-point drag handle.
  * - `vcDirIdx`            — view-cube face direction index (0=+X,1=-X,2=+Y,...).
  */
 import type * as THREE from 'three';
 import type { ParticleSystem } from 'three.quarks';
 import type { ConstraintMark } from '../adapter/constraint';
+import type { Object3DAuthoringSubjectMark } from '../adapter/object3d-authoring-subject';
 import type { RapierEditableBody } from '../adapter/rapier-physics-adapter';
 import type { ReflectionProbeMark } from '../adapter/reflection-probe';
 import type { AnimationRuntimeInspection } from '../animation/runtime-inspection';
@@ -174,6 +177,7 @@ export interface UserDataSchema {
     skeletonEnabled: boolean;
     envObject: boolean;
     constraints: readonly ConstraintMark[];
+    authoringSubject: Object3DAuthoringSubjectMark;
     reflectionProbe: ReflectionProbeMark;
     vcDirIdx: number;
     /** W1a navmesh path-probe preview polyline: the routed waypoints, mirrored
@@ -231,6 +235,7 @@ export declare const UserDataKeys: {
     readonly skeletonEnabled: "skeletonEnabled";
     readonly envObject: "envObject";
     readonly constraints: "constraints";
+    readonly authoringSubject: "authoringSubject";
     readonly reflectionProbe: "reflectionProbe";
     readonly vcDirIdx: "vcDirIdx";
     readonly navPathPoints: "navPathPoints";

package/dist/ecs/user-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-data.d.ts","sourceRoot":"","sources":["../../src/ecs/user-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmHG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAClF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E,wEAAwE;AACxE,MAAM,MAAM,gBAAgB,GACxB,QAAQ,GACR,SAAS,GACT,OAAO,GACP,WAAW,GAGX,QAAQ,GAGR,KAAK,GACL,SAAS,GAMT,WAAW,GACX,gBAAgB,GAChB,OAAO,GACP,SAAS,GACT,aAAa,GACb,mBAAmB,GACnB,WAAW,CAAC;AAEhB;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IACtD,OAAO,EAAE,UAAU,GAAG,UAAU,CAAC;IACjC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACxC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC;IACtB,eAAe,EAAE,cAAc,CAAC;IAChC,aAAa,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAClD,UAAU,EAAE,KAAK,CAAC,cAAc,CAAC;IACjC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAC7C,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,iBAAiB,EAAE,0BAA0B,CAAC;IAC9C,eAAe,EAAE,wBAAwB,CAAC;IAC1C,gBAAgB,EAAE,sBAAsB,CAAC;IACzC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC/C,YAAY,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,kBAAkB,CAAC;IAClC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE;QACjB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;QAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,YAAY,EAAE,OAAO,CAAC;IACtB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,SAAS,cAAc,EAAE,CAAC;IACvC,eAAe,EAAE,mBAAmB,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB;;4DAEwD;IACxD,aAAa,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACtD;AAED,qCAAqC;AACrC,MAAM,MAAM,WAAW,GAAG,MAAM,cAAc,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CuB,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,WAAW,EAC/C,GAAG,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,EACtC,GAAG,EAAE,CAAC,GACL,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS,CAE/B;AAED,sCAAsC;AACtC,wBAAgB,WAAW,CAAC,CAAC,SAAS,WAAW,EAC/C,GAAG,EAAE,KAAK,CAAC,QAAQ,EACnB,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GACvB,IAAI,CAEN;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAE7F;AAED,+BAA+B;AAC/B,wBAAgB,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI,CAE1E"}
+{"version":3,"file":"user-data.d.ts","sourceRoot":"","sources":["../../src/ecs/user-data.ts"],"names":[],"mappings":"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"}

package/dist/ecs/user-data.js

@@ -111,6 +111,8 @@
  *                           JSX props for renderer/editor integration.
  * - `constraints`         — live project-owned spatial constraints projected
  *                           into the shared Inspector and viewport.
+ * - `authoringSubject`    — transient identity/inspection for an ecosystem-native
+ *                           subject represented by an Object3D proxy.
  * - `splineControlPoint`  — index of a spline control-point drag handle.
  * - `vcDirIdx`            — view-cube face direction index (0=+X,1=-X,2=+Y,...).
  */
@@ -158,6 +160,7 @@ export const UserDataKeys = {
     skeletonEnabled: 'skeletonEnabled',
     envObject: 'envObject',
     constraints: 'constraints',
+    authoringSubject: 'authoringSubject',
     reflectionProbe: 'reflectionProbe',
     vcDirIdx: 'vcDirIdx',
     navPathPoints: 'navPathPoints',