@vgai/engine 0.5.5 → 0.5.6

package/dist/adapter/root-adapter.d.ts

@@ -0,0 +1,195 @@
+/**
+ * RootAdapter — the host ⇄ runtime contract. A ROOT is *anything that mounts*.
+ *
+ * This is the interface the HOST depends on. It replaces the old
+ * `{ setup, components }` shape: the host no longer knows about `GameSetupFn`
+ * — that is the internal of ONE implementer
+ * (`SetupThreeRootAdapter`). First-party content and an unmodified external game
+ * are peer implementers of THIS interface; the host has no branch on which.
+ *
+ * It was `GameAdapter` until WO-9 #60, and the rename is an ONTOLOGY fix, not
+ * taste. Under D20 a *game* is the manifest's whole `roots` array — that is
+ * what `runtime/game.ts`'s `Game` is. Every implementer of THIS interface
+ * adapts exactly ONE root. So `Game` and `GameAdapter` sat at different levels
+ * of the ontology while sharing a name-stem, which reads as though one were
+ * the adapter for the other. The surrounding vocabulary had already moved:
+ * `MountedRootBase`, `MountedRoot`, `MountedRootFor`, `RootStateObserver`,
+ * `SurfaceAdapterFor`, `RootInstance`, `mountManifestRoots` — and, decisively,
+ * the resolver that PRODUCES these (`resolveRootAdapter`, `RootAdapterSchema`,
+ * `resolveThreeRootAdapter`) already said root. The interface was the last
+ * holdout, out of step with its own resolver.
+ *
+ * The `K = 'three'` default below is KEPT deliberately (see the note on the
+ * interface).
+ */
+import type { Container } from 'pixi.js';
+import type * as THREE from 'three';
+import type { AdapterSurface } from './adapter-surface';
+import type { AuthoringAdapter } from './authoring';
+import type { HostContextFor } from './host-context';
+import type { SystemAdapters } from './system-adapter';
+/**
+ * The ingested-world observation contract (T7.4 slice 2, "the
+ * must-answer"). Cross-world data flow with a
+ * foreign game is observation via an adapter-provided interface, not ordinary
+ * shared state (that's D7's answer for first-party↔first-party flow).
+ * Optional on {@link MountedThreeRoot} —
+ * absence means the adapter has nothing genuinely observable to expose (the
+ * anti-shim rule: never fabricate state), and the world takes the honest
+ * "no state bridge" tier hit (see `Game.registerRoot` in `runtime/game.ts`)
+ * rather than silently offering an `undefined`-forever subscription.
+ */
+export interface RootStateObserver {
+    /**
+     * Notified at most once per frame IF the adapter can hook the game's own
+     * update (`loop: 'gated'` roots, §(d)); self-driven roots (`loop:
+     * 'self-driven'`, raw-rAF) may notify on their OWN rAF cadence instead —
+     * consumers must not assume our frame timing. Returns an unsubscribe
+     * function.
+     */
+    subscribe(onChange: () => void): () => void;
+    /**
+     * A cheap, adapter-chosen snapshot of this world's observable state.
+     * Returns a STABLE reference while nothing has changed (so a selector run
+     * over it can cheaply bail out by reference, same spirit as
+     * `GameStateBridge`'s frame-version cache). Shape is adapter-defined —
+     * not centrally schematized in v1.
+     */
+    snapshot(): unknown;
+}
+/**
+ * Everything a mounted world provides EXCEPT its render surface: THREE.Scene/
+ * THREE.Camera typing is replaced with kind-tagged world surfaces. Split out
+ * of the old flat
+ * `MountedThreeRoot` so a non-threejs world can carry its own kind-appropriate
+ * surface field (a pixi `stage`, a react `container`) instead of being
+ * force-fit through THREE `scene`/`camera` fields it doesn't have.
+ */
+export interface MountedRootBase {
+    /**
+     * Loop model:
+     *  - `false` (host-driven): first-party + "clean" externals. The host ticks
+     *    `update(dt)` in its loop.
+     *  - `true` (self-driven): an unmodified game that owns its renderer + rAF.
+     *    The host does NOT tick it. Pause/step control is a DECLARED CAPABILITY,
+     *    not a promise: implement `setPaused`/`step` only where the game exposes
+     *    a sanctioned pause/step mechanism. Gating a raw-rAF loop from outside
+     *    was demonstrated and REJECTED (D5 — it halts the loop rather than
+     *    pausing it); such games are the "composited, unsynchronized" tier:
+     *    `setPaused` absent, host degrades loudly (T7.6 owns the tier surface).
+     */
+    readonly drivesOwnLoop: boolean;
+    update?(dt: number): void;
+    fixedUpdate?(dt: number): void;
+    setPaused?(paused: boolean): void;
+    step?(): void;
+    resize?(width: number, height: number): void;
+    dispose(): void;
+    /** Optional capability providers — absence = "not supported", host degrades. */
+    readonly authoring?: AuthoringAdapter;
+    readonly systems?: SystemAdapters;
+    /** Optional state-observation capability (T7.4 slice 2, §4) — absent means
+     *  "no state bridge"; `Game.registerRoot` reports this loudly, once, for
+     *  any non-first-party mount. First-party mounts are exempt — their state
+     *  is observed through `Game.state`/`useWorldState` instead (§3), not this
+     *  field. */
+    readonly observe?: RootStateObserver;
+}
+/** A live, mounted three world. The host obtains `scene`/`camera` to
+ *  render+author. Until WO-9 task #9 this type also had a `MountedGame` alias,
+ *  which every pre-T7.5 threejs call site named; the alias is deleted, because
+ *  what it aliased is one three ROOT and a game is the manifest's whole set of
+ *  roots (D20). */
+export interface MountedThreeRoot extends MountedRootBase {
+    readonly kind: 'three';
+    /** The live scene + camera the editor inspects/renders for authoring. */
+    readonly scene: THREE.Scene;
+    readonly camera: THREE.Camera;
+}
+/** A live, mounted canvas world (T7.3) — the pixi analog of
+ *  {@link MountedThreeRoot}. `stage` is the pixi world container the host
+ *  renders/authors, the surface `RootInstance.pixiStage()` returns. */
+export interface MountedPixiRoot extends MountedRootBase {
+    readonly kind: 'canvas';
+    readonly stage: Container;
+}
+/** A live, mounted react world (T6.2) — the react analog of
+ *  {@link MountedThreeRoot}. `container` is the DOM-root layer the host
+ *  handed the adapter's `mount` (the SAME element `RootInstance.reactRoot()`
+ *  returns) — a react world's tree renders into it via `createRoot`. */
+export interface MountedReactRoot extends MountedRootBase {
+    readonly kind: 'dom';
+    readonly container: HTMLElement;
+}
+/** Every kind of live, mounted world (T7.5) — the union `RootInstance.mounted`
+ *  is typed against now, replacing the THREE-only `MountedThreeRoot`. */
+export type MountedRoot = MountedThreeRoot | MountedPixiRoot | MountedReactRoot;
+/** Map a {@link AdapterSurface} to its mounted-world shape (mirrors `NodeOf`/
+ *  `BodyOf`/`ColliderOf` in `ecs/behavior.ts`) — lets generic code over
+ *  `K extends AdapterSurface` name the right surface without a manual union. */
+export type MountedRootFor<K extends AdapterSurface> = K extends 'three' ? MountedThreeRoot : K extends 'canvas' ? MountedPixiRoot : K extends 'dom' ? MountedReactRoot : never;
+/**
+ * The interface every game implements to run on the host. Generic over
+ * {@link AdapterSurface} (T7.5) so a non-threejs implementer's `mount` returns
+ * its OWN kind-tagged surface instead of being cast through the three shape —
+ * defaults to `'three'` so every pre-T7.5 implementer/call site
+ * (`RootAdapter`, unparameterized) keeps compiling unchanged.
+ *
+ * `K` parameterizes BOTH halves of `mount` (P-8): until then only the RETURN
+ * type was kind-tagged, while the PARAMETER was always the three-shaped
+ * `ThreeHostContext` — so a `RootAdapter<'canvas'>` was, by its own type, handed a
+ * `THREE.WebGLRenderer` it cannot use, and the production Pixi/React adapters
+ * could not be `RootAdapter`s at all (they were separate structural types over
+ * `CanvasHostContext`/`DomHostContext`, and `RootAdapter<'canvas'>` existed only in
+ * tests). With `HostContextFor<K>` the surface tag picks the context type, and
+ * those production adapters are now genuine `RootAdapter<K>` subtypes —
+ * `Pixi2DRootAdapter extends RootAdapter<'canvas'>`, `ReactRootAdapter extends
+ * RootAdapter<'dom'>` (`runtime/create-runtime.ts`).
+ */
+/**
+ * On the `= 'three'` default (WO-9 #60 considered removing it, and did not):
+ * this default is type-level only: an author who writes bare `RootAdapter` for
+ * a pixi root gets a compile error on `mount`'s return type, because
+ * `MountedRootFor<'three'>` demands `scene`/`camera` a `MountedPixiRoot` has
+ * not got. Wrong-by-default is caught by tsc, so removing this default would
+ * be churn across ~125 bare call sites for no defect it could catch.
+ */
+export interface RootAdapter<K extends AdapterSurface = 'three'> {
+    /** Stable id (telemetry/registry/conformance). */
+    readonly id: string;
+    /** Build/start the game against the host context for ITS surface; return the
+     *  handle. */
+    mount(host: HostContextFor<K>): Promise<MountedRootFor<K>>;
+}
+/**
+ * One surface tag paired with an adapter typed FOR that surface (WO-34).
+ *
+ * Why this exists: a resolver that turns a manifest root into a mountable
+ * adapter handles every surface in one function, so its return type has to
+ * span all three. Returning the bare union `RootAdapter<'three'> |
+ * RootAdapter<'canvas'> | RootAdapter<'dom'>` does NOT work — a union of
+ * function types INTERSECTS its parameters, so `.mount(host)` becomes
+ * uncallable with any single host value (no one object is simultaneously a
+ * `ThreeHostContext`, a `CanvasHostContext` and a `DomHostContext`). The historical
+ * workaround was to declare the whole channel `RootAdapter<'three'>` and
+ * re-assert the real kind at each call site with `as unknown as` — kind
+ * ERASURE: the surface tag the manifest already knew was thrown away and
+ * guessed back.
+ *
+ * Carrying the tag ALONGSIDE the adapter fixes that structurally: this is a
+ * discriminated union on `surface`, so `switch (resolved.surface)` narrows
+ * `resolved.adapter` to ONE `RootAdapter<K>` inside each branch — a single
+ * signature again, hence `.mount(host)` is callable with that surface's own
+ * host context, checked by the compiler instead of asserted.
+ */
+export type SurfaceAdapterFor<K extends AdapterSurface> = {
+    readonly surface: K;
+    readonly adapter: RootAdapter<K>;
+};
+/** Every surface's {@link SurfaceAdapterFor}, as one discriminated union.
+ *  Written out member-by-member (rather than as a distributive conditional)
+ *  so `assertNever` sees exactly three variants and a hypothetical 4th
+ *  `AdapterSurface` member fails to compile HERE, at the vocabulary, rather
+ *  than silently widening every consumer's exhaustiveness guard. */
+export type SurfaceAdapter = SurfaceAdapterFor<'three'> | SurfaceAdapterFor<'canvas'> | SurfaceAdapterFor<'dom'>;
+//# sourceMappingURL=root-adapter.d.ts.map

package/dist/adapter/root-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/root-adapter.ts"],"names":[],"mappings":"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"}

package/dist/adapter/root-adapter.js

@@ -0,0 +1,25 @@
+/**
+ * RootAdapter — the host ⇄ runtime contract. A ROOT is *anything that mounts*.
+ *
+ * This is the interface the HOST depends on. It replaces the old
+ * `{ setup, components }` shape: the host no longer knows about `GameSetupFn`
+ * — that is the internal of ONE implementer
+ * (`SetupThreeRootAdapter`). First-party content and an unmodified external game
+ * are peer implementers of THIS interface; the host has no branch on which.
+ *
+ * It was `GameAdapter` until WO-9 #60, and the rename is an ONTOLOGY fix, not
+ * taste. Under D20 a *game* is the manifest's whole `roots` array — that is
+ * what `runtime/game.ts`'s `Game` is. Every implementer of THIS interface
+ * adapts exactly ONE root. So `Game` and `GameAdapter` sat at different levels
+ * of the ontology while sharing a name-stem, which reads as though one were
+ * the adapter for the other. The surrounding vocabulary had already moved:
+ * `MountedRootBase`, `MountedRoot`, `MountedRootFor`, `RootStateObserver`,
+ * `SurfaceAdapterFor`, `RootInstance`, `mountManifestRoots` — and, decisively,
+ * the resolver that PRODUCES these (`resolveRootAdapter`, `RootAdapterSchema`,
+ * `resolveThreeRootAdapter`) already said root. The interface was the last
+ * holdout, out of step with its own resolver.
+ *
+ * The `K = 'three'` default below is KEPT deliberately (see the note on the
+ * interface).
+ */
+export {};

package/dist/adapter/setup-three-root-adapter.d.ts

@@ -0,0 +1,87 @@
+/**
+ * SetupThreeRootAdapter — the first-party implementer of {@link RootAdapter}
+ * that mounts ONE three root from an imperative `setup(ctx)` function.
+ *
+ * This is where Rapier lives now: the host no longer knows about it.
+ * `mount(host)` builds the full first-party runtime (the body
+ * that used to live inline in `create-runtime.ts`) from a neutral
+ * {@link ThreeHostContext}, runs the game's `setup`, and returns a
+ * {@link MountedThreeRoot}. First-party content is now just one implementer of
+ * the same interface an unmodified external game implements (Phase B).
+ *
+ * It was `VgaiSceneGameAdapter` until WO-9 tasks #6/#9. Both halves of that
+ * name had stopped being true: it loads no scene (the `.vscn.json` branches
+ * went with the format in WO-8 — `setup` is the only mount path left), and what
+ * it mounts is one three ROOT, not a game (a game is the manifest's whole set
+ * of roots). The R3F/TSX world root is a SEPARATE adapter; this one is
+ * specifically the `fromSetup` path.
+ *
+ * `GameSetupFn` / `GameContext` are imported ONLY here (and in the example
+ * `fromSetup` wrappers) — never by the host. That confinement is the inversion.
+ */
+import type { EffectComposer } from 'postprocessing';
+import { type ViewportShadingMode } from '../render/viewport-shading';
+import { type RootFrameHooks } from '../runtime/game';
+import type { EditorPreview, GameContext, GameSetupFn } from '../runtime/types';
+import type { ThreeHostContext } from './host-context';
+import type { MountedThreeRoot, RootAdapter } from './root-adapter';
+/** How a {@link SetupThreeRootAdapter} builds its game (the former RuntimeConfig). */
+export interface SetupThreeRootConfig {
+    /** Game setup function — registers systems and loads scenes. */
+    setup?: GameSetupFn | undefined;
+    /** Editor context — passed to setup() when launched from the editor. */
+    editorPreview?: EditorPreview | undefined;
+    /** Input map JSON path. Defaults to 'inputmaps/default.inputmap.json'. */
+    inputMapPath?: string | undefined;
+    /** URL prefix for relative asset paths. Defaults to '/'. */
+    assetPrefix?: string | undefined;
+    /** Stable adapter id (for registry/conformance). Defaults to 'setup-three'. */
+    id?: string | undefined;
+}
+/**
+ * The first-party `MountedThreeRoot`, with concrete extras the editor host uses for
+ * first-party features (HMR, physics sync) that are NOT part of the neutral
+ * interface. The generic host only touches the `MountedThreeRoot` surface.
+ */
+export interface MountedSetupThreeRoot extends MountedThreeRoot {
+    /**
+     * First-party brand (checklist item 1 / T7.3 lookahead): a plain `'ctx' in
+     * mounted` structural check misfires against any foreign mount that happens
+     * to carry an unrelated `ctx` key. This literal-`true`
+     * property is what `isFirstPartyMounted` (`runtime/game.ts`) actually
+     * checks; `game.ts` reads it via a structural `{ firstParty?: unknown }`
+     * probe so it never needs a value import of this module (the existing
+     * import is type-only and must stay that way).
+     */
+    readonly firstParty: true;
+    readonly ctx: GameContext;
+    readonly composer: EffectComposer | null;
+    /** Render-only developer view; native game materials are restored before the frame returns. */
+    setViewportShadingMode(mode: ViewportShadingMode): void;
+    /** Warm-restart: dispose the current game, re-run a new setup on the same ctx. */
+    hotReload(newSetup: GameSetupFn, editorPreview?: EditorPreview): Promise<void>;
+    /**
+     * Phase-partitioned frame entry point (T7.1 slice 2) — wired onto this
+     * world's `RootInstance` by `registerThreeRoot` (`create-runtime.ts`).
+     * `Game.runFrame` is the CANONICAL driver going forward: it calls
+     * `frame.runPhase` once per (phase, substep) for every world, then
+     * `frame.endFrame` once per substep after all roots finish all phases.
+     * `update` (below) remains the legacy/direct entry point to the exact same
+     * `SystemRunner` — direct callers (editor HMR, adapter conformance tests)
+     * keep using it unchanged.
+     */
+    readonly frame: RootFrameHooks;
+}
+/**
+ * Wrap a first-party `setup` function as a {@link RootAdapter}. This is how every
+ * first-party example becomes an implementer of the same interface an external
+ * game implements — with no change to the setup's body.
+ */
+export declare function fromSetup(id: string, setup: GameSetupFn): RootAdapter;
+export declare class SetupThreeRootAdapter implements RootAdapter {
+    private readonly config;
+    readonly id: string;
+    constructor(config?: SetupThreeRootConfig);
+    mount(host: ThreeHostContext): Promise<MountedSetupThreeRoot>;
+}
+//# sourceMappingURL=setup-three-root-adapter.d.ts.map

package/dist/adapter/setup-three-root-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-three-root-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/setup-three-root-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAiCrD,OAAO,EAAE,KAAK,mBAAmB,EAA2B,MAAM,4BAA4B,CAAC;AAM/F,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAe,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAM7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGpE,sFAAsF;AACtF,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,KAAK,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAChC,wEAAwE;IACxE,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC1C,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,+EAA+E;IAC/E,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC7D;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IACzC,+FAA+F;IAC/F,sBAAsB,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACxD,kFAAkF;IAClF,SAAS,CAAC,QAAQ,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/E;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;CAChC;AAeD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,WAAW,CAErE;AAED,qBAAa,qBAAsB,YAAW,WAAW;IAE3C,OAAO,CAAC,QAAQ,CAAC,MAAM;IADnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBACS,MAAM,GAAE,oBAAyB;IAKxD,KAAK,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAmuBpE"}