@vgai/engine 0.2.0 → 0.3.0

package/dist/render/render-features.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+export const RENDER_FEATURES = [
+    {
+        key: 'autoBatch',
+        label: 'Auto-batching',
+        description: 'Automatically batch entities sharing geometry+material into one draw call (InstancedMesh/BatchedMesh) while keeping each Object3D as the handle. The headline perf win; opt out per-entity for custom-shader/skinned meshes.',
+        kind: 'toggle',
+        default: true,
+        apply: 'live',
+        perEntity: true,
+    },
+    {
+        key: 'frustumCulling',
+        label: 'Frustum culling',
+        description: 'Per-instance frustum culling for batched content.',
+        kind: 'toggle',
+        default: true,
+        apply: 'live',
+        perEntity: true,
+    },
+    {
+        key: 'lod',
+        label: 'Level of detail',
+        description: 'Distance-based geometry swap (LOD) for eligible entities.',
+        kind: 'toggle',
+        default: true,
+        apply: 'live',
+        perEntity: true,
+    },
+    {
+        key: 'shadows',
+        label: 'Shadows',
+        description: 'Enable the shadow map. Per-entity cast/receive still applies.',
+        kind: 'toggle',
+        default: true,
+        apply: 'live',
+        perEntity: true,
+    },
+    {
+        key: 'postProcessing',
+        label: 'Post-processing',
+        description: 'Master switch for the post-processing stack (individual effects nest beneath it).',
+        kind: 'toggle',
+        default: true,
+        apply: 'live',
+        perEntity: false,
+    },
+    {
+        key: 'resolutionScale',
+        label: 'Resolution scale',
+        description: 'Device-pixel-ratio multiplier (1.0 = native). The cheapest perf dial.',
+        kind: 'number',
+        default: 1,
+        apply: 'live',
+        perEntity: false,
+        range: [0.25, 2],
+    },
+    {
+        key: 'antialias',
+        label: 'Antialiasing',
+        description: 'MSAA via renderer construction. Applies on reload (renderer re-init).',
+        kind: 'toggle',
+        default: true,
+        apply: 'reload',
+        perEntity: false,
+    },
+    {
+        key: 'backend',
+        label: 'Renderer backend',
+        description: 'GPU backend: auto picks WebGPU when available, else WebGL2. Applies on reload.',
+        kind: 'enum',
+        default: 'auto',
+        apply: 'reload',
+        perEntity: false,
+        options: ['auto', 'webgl', 'webgpu'],
+    },
+];
+/** Map for O(1) lookup by key. */
+export const RENDER_FEATURE_BY_KEY = new Map(RENDER_FEATURES.map((f) => [f.key, f]));
+/**
+ * Build a Zod object for the render settings, derived from the registry so the
+ * schema can never drift from the feature list. All fields optional — absence
+ * means "inherit" in the cascade. `perEntityOnly` builds the per-entity override
+ * schema (only features whose `perEntity` is true).
+ */
+export function buildRenderingZod(opts = {}) {
+    const shape = {};
+    for (const f of RENDER_FEATURES) {
+        if (opts.perEntityOnly && !f.perEntity)
+            continue;
+        let base;
+        if (f.kind === 'toggle')
+            base = z.boolean();
+        else if (f.kind === 'number')
+            base = z.number();
+        else
+            base = z.enum(f.options);
+        shape[f.key] = base.optional().describe(f.description);
+    }
+    return z
+        .object(shape)
+        .describe(opts.perEntityOnly
+        ? 'Per-entity render overrides (omit a field to inherit from the scene/engine default)'
+        : 'Scene render settings (omit a field to inherit the engine default)');
+}

package/dist/render/render-settings.d.ts

@@ -0,0 +1,36 @@
+import { type RenderFeatureValue } from './render-features';
+/**
+ * Cascade resolution for render settings: engine default → scene → entity, with
+ * tri-state inherit (an absent value inherits from the next level up). See
+ * docs/research/RENDER-SETTINGS-UX.md.
+ */
+/** A partial override map (scene-level or entity-level). Absent key = inherit. */
+export type RenderScope = Partial<Record<string, RenderFeatureValue>>;
+/** Fully-resolved settings: every registry key present. */
+export type ResolvedRenderSettings = Record<string, RenderFeatureValue>;
+/**
+ * Resolve effective settings. `entity` overrides only apply to features whose
+ * `perEntity` flag is set; non-per-entity features resolve across engine→scene
+ * only. `??` walks up the chain on `undefined` (inherit) but lets an explicit
+ * `false`/`0` override (they are not nullish).
+ */
+export declare function resolveRenderSettings(scene?: RenderScope, entity?: RenderScope): ResolvedRenderSettings;
+/**
+ * A small observable holding the live scene-level resolved settings. Live
+ * features re-apply when a value changes (subscribers are notified with the
+ * changed key). This is the seam a future player-facing graphics menu would
+ * drive — for now it backs the editor toggles + the runtime systems.
+ */
+export declare class RenderSettings {
+    private values;
+    private listeners;
+    constructor(scene?: RenderScope);
+    get(key: string): RenderFeatureValue;
+    /** Set a scene-level value; notifies subscribers if it changed. */
+    set(key: string, value: RenderFeatureValue): void;
+    /** Resolve the effective value for an entity (entity override → scene → default). */
+    forEntity(key: string, entity?: RenderScope): RenderFeatureValue;
+    subscribe(fn: (key: string, value: RenderFeatureValue) => void): () => void;
+    snapshot(): ResolvedRenderSettings;
+}
+//# sourceMappingURL=render-settings.d.ts.map

package/dist/render/render-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-settings.d.ts","sourceRoot":"","sources":["../../src/render/render-settings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE7E;;;;GAIG;AAEH,kFAAkF;AAClF,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC;AAEtE,2DAA2D;AAC3D,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,CAAC,EAAE,WAAW,EACnB,MAAM,CAAC,EAAE,WAAW,GACnB,sBAAsB,CAOxB;AAED;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,SAAS,CAA+D;gBAEpE,KAAK,CAAC,EAAE,WAAW;IAI/B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IAIpC,mEAAmE;IACnE,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAMjD,qFAAqF;IACrF,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,kBAAkB;IAKhE,SAAS,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,MAAM,IAAI;IAK3E,QAAQ,IAAI,sBAAsB;CAGnC"}

package/dist/render/render-settings.js

@@ -0,0 +1,51 @@
+import { RENDER_FEATURES } from './render-features';
+/**
+ * Resolve effective settings. `entity` overrides only apply to features whose
+ * `perEntity` flag is set; non-per-entity features resolve across engine→scene
+ * only. `??` walks up the chain on `undefined` (inherit) but lets an explicit
+ * `false`/`0` override (they are not nullish).
+ */
+export function resolveRenderSettings(scene, entity) {
+    const out = {};
+    for (const f of RENDER_FEATURES) {
+        const entityVal = f.perEntity ? entity?.[f.key] : undefined;
+        out[f.key] = entityVal ?? scene?.[f.key] ?? f.default;
+    }
+    return out;
+}
+/**
+ * A small observable holding the live scene-level resolved settings. Live
+ * features re-apply when a value changes (subscribers are notified with the
+ * changed key). This is the seam a future player-facing graphics menu would
+ * drive — for now it backs the editor toggles + the runtime systems.
+ */
+export class RenderSettings {
+    values;
+    listeners = new Set();
+    constructor(scene) {
+        this.values = resolveRenderSettings(scene);
+    }
+    get(key) {
+        return this.values[key];
+    }
+    /** Set a scene-level value; notifies subscribers if it changed. */
+    set(key, value) {
+        if (this.values[key] === value)
+            return;
+        this.values[key] = value;
+        for (const fn of this.listeners)
+            fn(key, value);
+    }
+    /** Resolve the effective value for an entity (entity override → scene → default). */
+    forEntity(key, entity) {
+        const f = entity?.[key];
+        return f ?? this.values[key];
+    }
+    subscribe(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    snapshot() {
+        return { ...this.values };
+    }
+}

package/dist/runtime/create-runtime.d.ts

@@ -0,0 +1,280 @@
+import * as THREE from 'three';
+import type { GameAdapter, MountedGame, MountedReactWorld } from '../adapter/game-adapter';
+import { type VgaiSceneConfig } from '../adapter/vgai-scene-game-adapter';
+import type { MountedGame2D, World2DHost } from '../world2d/pixi-game-adapter';
+import { type Game, type GameInternal, type WorldInstance } from './game';
+export { adoptSceneCamera } from '../adapter/vgai-scene-game-adapter';
+/**
+ * Register a threejs world onto the Game shell. `opts.id` defaults to
+ * `'main'` — the single-world callers (`createGameRuntime`, slice-1/2 tests)
+ * are unaffected; a second/third world (T7.1 slice 3's two-world proof, and
+ * real multi-world manifests later) pass an explicit id. This is the ONE
+ * registration code path for a threejs world, whatever its id.
+ */
+export declare function registerThreeWorld(game: GameInternal, adapter: GameAdapter, mounted: MountedGame, opts?: {
+    id?: string | undefined;
+    pausable?: boolean | undefined;
+}): WorldInstance;
+/** Thin alias kept for existing single-world callers (`createGameRuntime`,
+ *  `test/game-root.test.ts`, `test/frame-order.test.ts`) — registers the
+ *  default `'main'` world via the SAME `registerThreeWorld` code path. */
+export declare function registerDefaultThreeWorld(game: GameInternal, adapter: GameAdapter, mounted: MountedGame): WorldInstance;
+export declare function registerPixiWorld(game: GameInternal, adapter: Pixi2DGameAdapter, mounted: MountedGame2D, opts?: {
+    id?: string | undefined;
+    pausable?: boolean | undefined;
+}): WorldInstance;
+/**
+ * Register a react world onto the Game shell (T6.2 slice 1,
+ * `docs/REACT-WORLD-DESIGN.md` §1.B) — the react analog of
+ * {@link registerThreeWorld}/{@link registerPixiWorld}. A react world has no
+ * `ComponentManager` to adopt (D8: react entities host no GameComponents —
+ * there is nothing for `adoptWorld` to backfill, unlike the three/pixi
+ * siblings above) and no `frame` hooks (react's own `createRoot` schedules
+ * its commits; `GameInternal.runFrame` correctly leaves a world with no
+ * `frame` untouched by its opaque-`update` fallback too, since
+ * `MountedReactGame` declares no `update`). `adapter` is typed as the real
+ * {@link ReactWorldAdapter} shape (T7.5, same reasoning as
+ * `registerPixiWorld`'s doc comment above) — `WorldInstance.adapter` only
+ * needs `.id`, so this passes through with zero cast.
+ */
+export declare function registerReactWorld(game: GameInternal, adapter: ReactWorldAdapter, mounted: MountedReactGame, container: HTMLElement, opts?: {
+    id?: string | undefined;
+    pausable?: boolean | undefined;
+}): WorldInstance;
+/**
+ * Configuration for {@link createGameRuntime}.
+ *
+ * The host depends on a {@link GameAdapter}. For convenience, the legacy
+ * first-party fields (`setup`/`scenePath`/`sceneData`/…) are accepted and wrapped
+ * in a {@link VgaiSceneGameAdapter} when no explicit `adapter` is given — so the
+ * host's default implementer is first-party, but the host itself only ever
+ * mounts "a GameAdapter".
+ *
+ * This is the LEGACY (single-world) shape — preserved byte-for-byte (T6.1
+ * slice 1, docs/MULTI-WORLD-DESIGN.md §1.A): every existing caller and test
+ * passes this shape unmodified. See {@link WorldsRuntimeConfig} for the new
+ * multi-world alternative and {@link RuntimeConfig} for the union.
+ */
+export interface LegacyRuntimeConfig extends VgaiSceneConfig {
+    canvas: HTMLCanvasElement;
+    width?: number | undefined;
+    height?: number | undefined;
+    /** An explicit game adapter to mount (first-party OR external). */
+    adapter?: GameAdapter | undefined;
+}
+/**
+ * A pixijs-shaped adapter — the structural contract `WorldMountSpec`'s
+ * `pixijs` variant requires. `PixiSceneGameAdapter` (`world2d/
+ * pixi-game-adapter.ts`) satisfies this today; it is deliberately NOT named
+ * here as a concrete type so an external pixi adapter can satisfy the same
+ * shape without importing the first-party implementer.
+ */
+export interface Pixi2DGameAdapter {
+    readonly id: string;
+    mount(host: World2DHost): Promise<MountedGame2D>;
+}
+/**
+ * One world to mount in the {@link WorldsRuntimeConfig} worlds path (T6.1
+ * slice 1) — the host-facing mirror of `manifest/load.ts`'s
+ * `ResolvedWorldEntry` (same `id`/`zOrder`/`pausable`/`loop` fields; the
+ * manifest-to-host translation itself is the editor's job, not this file's).
+ *
+ * `react` (T6.2 slice 1, `docs/REACT-WORLD-DESIGN.md`) mounts as a DOM-root
+ * layer `<div>` in the SAME stack instead of a canvas — see
+ * {@link ReactWorldMountSpec}/{@link ReactWorldAdapter} below.
+ */
+export interface WorldMountSpecBase {
+    /** Manifest id — must be unique within one `worlds` array. */
+    readonly id: string;
+    /** Canvas stacking order (COMPOSITION-DESIGN D5 §1); ties broken by array
+     *  order, mirroring `manifest/load.ts`'s `loadGameManifest` sort. Defaults
+     *  to `0`. */
+    readonly zOrder?: number | undefined;
+    /** Whether play-mode pause/step applies to this world (D10). Defaults to `true`. */
+    readonly pausable?: boolean | undefined;
+    /** `'gated'` (host-driven, default) or `'self-driven'` (this world drives
+     *  its own loop — D5's "composited, unsynchronized" tier). Carried through
+     *  for parity with `ResolvedWorldEntry`; T6.1 slice 1 does not yet
+     *  validate it against the mounted adapter's actual `drivesOwnLoop` (that
+     *  cross-check, if ever needed, is T7.6's loop-gate surface). */
+    readonly loop?: 'gated' | 'self-driven' | undefined;
+    /**
+     * Optional claim predicate for the delegating input router (D5 §2a), over
+     * a point RELATIVE TO THE CONTAINER. Absent means: this world claims only
+     * if it ends up the bottom (lowest zOrder) world — see
+     * `input-router.ts`'s `resolveClaimingWorld`. A pixijs world with no
+     * explicit `hitTest` gets a REAL default derived from its own mounted
+     * stage's `EventBoundary.hitTest` (see `derivePixiHitTest` below) — a
+     * threejs world with no explicit `hitTest` gets no default (three has no
+     * cheap universal "is this pixel interactive" answer).
+     */
+    readonly hitTest?: ((x: number, y: number) => boolean) | undefined;
+}
+export interface ThreeWorldMountSpec extends WorldMountSpecBase {
+    readonly kind: 'threejs';
+    readonly adapter: GameAdapter;
+}
+export interface PixiWorldMountSpec extends WorldMountSpecBase {
+    readonly kind: 'pixijs';
+    readonly adapter: Pixi2DGameAdapter;
+}
+/**
+ * The host-facing surface handed to a {@link ReactWorldAdapter}'s `mount`
+ * (T6.2 slice 1, `docs/REACT-WORLD-DESIGN.md` §1.B) — the react analog of
+ * {@link World2DHost}. `container` is the absolutely-positioned, z-ordered
+ * DOM-root layer `<div>` the host already created and stacked (same box/
+ * z-order rules as a canvas per COMPOSITION-DESIGN D5 §1) — the adapter's
+ * `mount` renders its react tree INTO this exact element via `createRoot`;
+ * it must never create its own root element (mirrors `HostContext`'s
+ * "the world's runtime renders into the surface it is handed" rule for
+ * canvases, `docs/GAME-ROOT-DESIGN.md` §2).
+ */
+export interface ReactWorldHost {
+    readonly container: HTMLElement;
+    /**
+     * The Game this world is being mounted into — symmetric with
+     * `HostContext.game`; what a react adapter hands to `<GameProvider>` so
+     * `useGameState` selectors read live state (T7.4 bridge).
+     *
+     * Optional as of D-V3 (docs/WAVE5-MULTIWORLD-INGEST-DESIGN.md, F24
+     * composite): a `default-react` sibling mounted BESIDE an ingest world
+     * (`packages/editor/src/ingest-siblings.ts`) has no native `Game` to hand
+     * it — there is no first-party `GameContext`/loop for the sibling to join,
+     * only the ingested world's own foreign runtime — so its host carries no
+     * `game` at all rather than fabricating an empty one (anti-shim rule); the
+     * sibling mounts its entry component bare, with no `<GameProvider>` wrap.
+     * `mountOneReactWorld` below (the NATIVE multi-world runtime path) still
+     * ALWAYS supplies a real `game` — this optionality is reached only by the
+     * composite sibling's own hand-built host, never by weakening the native
+     * path's guarantee.
+     */
+    readonly game?: Game;
+}
+/**
+ * A live, mounted react world (T6.2 slice 1) — the react analog of
+ * {@link MountedGame2D}. React worlds host no ticking components (D8 —
+ * `ecs/component-manager.ts` already throws on any attach to a react-kind
+ * manager) and render from game state via the T7.4 bridge instead of a
+ * per-frame `update`, so this shape carries no `update`/`fixedUpdate`/
+ * `ctx`/`frame` — `drivesOwnLoop` is always `false` (react's `createRoot`
+ * schedules its OWN commits; the host's fixed-step loop never drives it,
+ * and it is correctly skipped by `GameInternal.runFrame`'s per-world
+ * `frame`-hooks/opaque-`update` dispatch — see `registerReactWorld` below,
+ * which registers this `WorldInstance` with no `frame`, same as any other
+ * opaque mount with nothing to tick).
+ *
+ * Deliberately carries NO `firstParty: true` brand: that brand specifically
+ * means "has a `.ctx: GameContext`" (`isFirstPartyMounted`,
+ * `runtime/game.ts`) — a react world has no Rapier/ComponentManager/
+ * GameContext at all, so branding it first-party would be a type lie.
+ * `Game.registerWorld`'s "no state bridge" console warning
+ * (`docs/REACT-STATE-BRIDGE.md` §4) explicitly exempts `kind: 'react'`
+ * (§7.1-15): a react world has no `observe` BY DESIGN — that hook is scoped
+ * to `useWorldObservation` (the ingested/foreign-world case), not
+ * `useGameState` (`ui/game-state.tsx`), which a react world's own mounted
+ * tree uses instead — it reads `Game.state` directly (T7.4's actual bridge
+ * for first-party-observable state), never a per-world `observe`.
+ *
+ * `kind`/`container` (T7.5) satisfy `MountedReactWorld` (`adapter/
+ * game-adapter.ts`) — `container` is the SAME `ReactWorldHost.container` the
+ * adapter's `mount` was handed (identity matters, mirroring `threeRoot()`/
+ * `pixiRoot()`'s "same instance the adapter mounted" contract); every
+ * `ReactWorldAdapter` implementer echoes it back here so `mounted` alone
+ * (with no separately-threaded `container`) satisfies the union
+ * `WorldInstanceInit.mounted`/`WorldInstance.mounted` with zero cast.
+ */
+export interface MountedReactGame extends MountedReactWorld {
+    readonly drivesOwnLoop: false;
+}
+/**
+ * A react-shaped adapter — the structural contract `WorldMountSpec`'s
+ * `react` variant requires. Mirrors {@link Pixi2DGameAdapter}: deliberately
+ * NOT tied to a concrete implementer here so an editor-resolved adapter (the
+ * `default-react` resolver branch, T6.2's editor-side follow-up) can satisfy
+ * this shape without this file importing react-dom or any editor code.
+ */
+export interface ReactWorldAdapter {
+    readonly id: string;
+    mount(host: ReactWorldHost): Promise<MountedReactGame>;
+}
+export interface ReactWorldMountSpec extends WorldMountSpecBase {
+    readonly kind: 'react';
+    readonly adapter: ReactWorldAdapter;
+}
+export type WorldMountSpec = ThreeWorldMountSpec | PixiWorldMountSpec | ReactWorldMountSpec;
+/**
+ * The NEW multi-world alternative to {@link LegacyRuntimeConfig} (T6.1 slice
+ * 1, docs/MULTI-WORLD-DESIGN.md §1.A; react worlds T6.2 slice 1,
+ * docs/REACT-WORLD-DESIGN.md §1.B): mount N worlds (threejs + pixijs + react)
+ * on ONE `Game`, stacked in `container` per COMPOSITION-DESIGN D5 §1.
+ * Internally the legacy signature maps to a one-element worlds list —
+ * `worlds[0]` (by `Game.defaultWorld`'s existing "first threejs world, else
+ * first world" rule) is the default world, so
+ * `GameSession.scene`/`.camera`/`.mounted` keep aliasing exactly as they do
+ * today.
+ */
+export interface WorldsRuntimeConfig {
+    /** The host creates one absolutely-positioned surface per world inside
+     *  this element (D5 §1) — a canvas for threejs/pixijs, a DOM-root `<div>`
+     *  layer for react — plus one shared UI overlay above all of them. */
+    container: HTMLElement;
+    worlds: WorldMountSpec[];
+    width?: number | undefined;
+    height?: number | undefined;
+    /**
+     * Mirrors `HostContext.headless` (Node conformance tests — no GPU): skips
+     * real `WebGLRenderer` construction for every threejs world in this
+     * session (a stand-in renderer is used instead, exactly as
+     * `VgaiSceneGameAdapter.mount` already special-cases `host.headless`
+     * internally). Pixijs worlds are unaffected — Pixi already falls back to
+     * a 2D canvas renderer with no GPU. Never set `true` in a real host.
+     */
+    headless?: boolean | undefined;
+}
+/** The full config union `createGameRuntime` accepts — the legacy
+ *  single-`{canvas, adapter}` shape, or the new worlds path. */
+export type RuntimeConfig = LegacyRuntimeConfig | WorldsRuntimeConfig;
+/**
+ * Handle returned by createGameRuntime() for controlling the running game.
+ *
+ * This is the GENERIC host handle — it has no first-party concepts (no
+ * `GameContext`, no `GameSetupFn`). First-party features (the live `GameContext`,
+ * warm-restart hot reload) are reached by casting `mounted` to `VgaiMountedGame`
+ * (the editor does this for HMR/physics-sync — those are inherently first-party).
+ *
+ * `scene`/`camera`/`mounted` alias the Game's `defaultWorld` (T6.1 slice 1):
+ * for the legacy single-world path this is the only world, byte-identical to
+ * before; for the worlds path it is the first threejs world (else the first
+ * world) by DECLARATION order, per `Game.defaultWorld`'s existing rule —
+ * independent of `zOrder`/canvas stacking, which is a rendering-only concern.
+ */
+export interface GameSession {
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    step(): void;
+    resize(width: number, height: number): void;
+    readonly scene: THREE.Scene;
+    readonly camera: THREE.PerspectiveCamera;
+    /** The mounted game (interface surface). Cast to `VgaiMountedGame` for first-party extras. */
+    readonly mounted: MountedGame;
+    /** The Game root (T6.1 slice 1) — the multi-world entry point
+     *  (`game.worlds`/`game.world(id)`/`game.queryByComponent`) for callers
+     *  that need more than the default-world aliases above. */
+    readonly game: Game;
+}
+/**
+ * Bootstrap the game host and mount a game adapter.
+ *
+ * `createGameRuntime` is the HOST: it owns the canvas/renderer(s), the loop,
+ * the UI overlay, and the asset cache, and it mounts a {@link GameAdapter}
+ * (or several, via the worlds path — T6.1 slice 1) against that context. It
+ * knows nothing about `.vscn`, `GameComponent`, Rapier, or `GameSetupFn` —
+ * those live inside the first-party {@link VgaiSceneGameAdapter}, which is
+ * the default implementer when no explicit `adapter` is supplied on the
+ * legacy path. Dispatches on `config`'s shape: {@link WorldsRuntimeConfig}
+ * (`worlds` present) goes through {@link createWorldsGameRuntime};
+ * everything else is the byte-compatible legacy single-world path.
+ */
+export declare function createGameRuntime(config: RuntimeConfig): Promise<GameSession>;
+//# sourceMappingURL=create-runtime.d.ts.map

package/dist/runtime/create-runtime.d.ts.map

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