@vgai/engine 0.2.0 → 0.3.0

package/dist/ecs/game-component.d.ts

@@ -0,0 +1,97 @@
+import type RAPIER2D from '@dimforge/rapier2d-compat';
+import type RAPIER3D from '@dimforge/rapier3d-compat';
+import type * as PIXI from 'pixi.js';
+import type * as THREE from 'three';
+import type { z } from 'zod';
+import type { SystemPhaseName } from '../core/types';
+import type { WorldInstance, WorldKind } from '../runtime/game';
+import type { GameContext } from '../runtime/types';
+/**
+ * Map a {@link WorldKind} to its native world node type (T7.2, D8 —
+ * `docs/GAME-COMPONENT-GENERALIZATION.md` §2). `react` maps to `never`: react
+ * entities host no GameComponents (they render from game state via the T7.4
+ * state bridge instead).
+ */
+export type NodeOf<K extends WorldKind> = K extends 'threejs' ? THREE.Object3D : K extends 'pixijs' ? PIXI.Container : never;
+/** Map a {@link WorldKind} to its native Rapier rigid-body type. */
+export type BodyOf<K extends WorldKind> = K extends 'threejs' ? RAPIER3D.RigidBody : K extends 'pixijs' ? RAPIER2D.RigidBody : never;
+/** Map a {@link WorldKind} to its native Rapier collider type. */
+export type ColliderOf<K extends WorldKind> = K extends 'threejs' ? RAPIER3D.Collider : K extends 'pixijs' ? RAPIER2D.Collider : never;
+/**
+ * Base class for game components attached to entities.
+ *
+ * Generalized (T7.2, D8 — `docs/GAME-COMPONENT-GENERALIZATION.md`) over the
+ * world kind `K` (default `'threejs'`, so every existing component — all of
+ * which extend the bare `GameComponent` — compiles and runs unchanged). The
+ * world's native node IS the entity — there is no separate entity id and no
+ * mirror/sync layer (Track A). Each component instance holds a direct
+ * reference to its node and (if any) its Rapier rigid body/collider. The
+ * ComponentManager wires these up in `attach()`.
+ *
+ * Similar to Unity's MonoBehaviour or Godot's Node scripts:
+ * - `init()` — called once after the entity is fully constructed
+ * - `update(dt, ctx)` — called every fixed timestep, in the component's phase
+ * - `dispose(ctx)` — called when the entity is destroyed
+ * - `onTriggerEnter/onTriggerExit` — called when a sensor collider overlap
+ *   starts/stops, with the other party's native node
+ *
+ * State lives on `this` (instance properties). On HMR, the engine swaps the
+ * prototype via Object.setPrototypeOf — instance state survives, method bodies
+ * update to the new code.
+ */
+export declare abstract class GameComponent<K extends WorldKind = 'threejs'> {
+    /** Which phase this component's update runs in. Override in subclasses. */
+    static phase: SystemPhaseName;
+    /**
+     * Runtime-checkable declaration of which {@link WorldKind} this component
+     * is written for (T7.2, D8 §3 — `docs/GAME-COMPONENT-GENERALIZATION.md`).
+     * TS's `K` type parameter is erased at runtime, so this static is what the
+     * ComponentManager checks at attach time: a node whose world's kind
+     * doesn't match `declaredKind` THROWS at attach (a `GameComponent<'pixijs'>`
+     * attached to a threejs entity, or vice versa). Kind-agnostic components —
+     * written only against `node`/`this.world`, never the typed `object3D`
+     * accessor or a kind-specific field — may declare `'any'` and attach in
+     * any world components are legal in (every world except `'react'`, which
+     * always throws regardless of `declaredKind` — see the ComponentManager).
+     */
+    static declaredKind: WorldKind | 'any';
+    /**
+     * Optional Zod object schema for this component's authored fields. When set,
+     * scene data is validated + defaulted through `schema.parse(data)` before being
+     * assigned onto the instance. Also powers (later) the editor's schema-driven
+     * inspector and HMR defaults.
+     */
+    static schema?: z.ZodObject<z.ZodRawShape>;
+    /** The native world node. The node IS the entity. */
+    node: NodeOf<K>;
+    /** The world instance this component's entity lives in (wired at attach). */
+    world: WorldInstance;
+    /**
+     * Typed accessor, threejs worlds only — kept for compatibility. On a
+     * `GameComponent` (default `K`) this types as `THREE.Object3D`, so every
+     * existing component compiles unchanged. On a non-threejs instance it
+     * THROWS a descriptive error rather than ever returning a wrong-kind node —
+     * use `this.node` (or `this.world.kind` to check first) instead.
+     */
+    get object3D(): THREE.Object3D;
+    /** The entity's native rigid body, if it has physics. */
+    rigidBody: BodyOf<K> | null;
+    /** The entity's native collider, if it has physics. */
+    collider: ColliderOf<K> | null;
+    /** Called once after the entity is fully constructed (node, physics, etc.). */
+    init?(ctx: GameContext): void | Promise<void>;
+    /** Called every fixed timestep. */
+    abstract update(dt: number, ctx: GameContext): void;
+    /** Called when the entity is destroyed or the component is removed. */
+    dispose?(ctx: GameContext): void;
+    /** Called when a sensor overlap with `other` begins. */
+    onTriggerEnter?(other: NodeOf<K>, ctx: GameContext): void;
+    /** Called when a sensor overlap with `other` ends. */
+    onTriggerExit?(other: NodeOf<K>, ctx: GameContext): void;
+}
+/** Constructor type for GameComponent subclasses (carries static phase/schema). */
+export type GameComponentClass = (new () => GameComponent) & {
+    phase?: SystemPhaseName;
+    schema?: z.ZodObject<z.ZodRawShape>;
+};
+//# sourceMappingURL=game-component.d.ts.map

package/dist/ecs/game-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-component.d.ts","sourceRoot":"","sources":["../../src/ecs/game-component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,KAAK,IAAI,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,SAAS,SAAS,GACzD,KAAK,CAAC,QAAQ,GACd,CAAC,SAAS,QAAQ,GAChB,IAAI,CAAC,SAAS,GACd,KAAK,CAAC;AAEZ,oEAAoE;AACpE,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,SAAS,SAAS,GACzD,QAAQ,CAAC,SAAS,GAClB,CAAC,SAAS,QAAQ,GAChB,QAAQ,CAAC,SAAS,GAClB,KAAK,CAAC;AAEZ,kEAAkE;AAClE,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,SAAS,SAAS,GAC7D,QAAQ,CAAC,QAAQ,GACjB,CAAC,SAAS,QAAQ,GAChB,QAAQ,CAAC,QAAQ,GACjB,KAAK,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8BAAsB,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IACjE,2EAA2E;IAC3E,MAAM,CAAC,KAAK,EAAE,eAAe,CAAe;IAE5C;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,YAAY,EAAE,SAAS,GAAG,KAAK,CAAa;IAEnD;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IAE3C,qDAAqD;IACrD,IAAI,EAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAEjB,6EAA6E;IAC7E,KAAK,EAAG,aAAa,CAAC;IAEtB;;;;;;OAMG;IACH,IAAI,QAAQ,IAAI,KAAK,CAAC,QAAQ,CAsB7B;IAED,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAEnC,uDAAuD;IACvD,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAEtC,+EAA+E;IAC/E,IAAI,CAAC,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE7C,mCAAmC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI;IAEnD,uEAAuE;IACvE,OAAO,CAAC,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI;IAEhC,wDAAwD;IACxD,cAAc,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI;IAEzD,sDAAsD;IACtD,aAAa,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI;CACzD;AAED,mFAAmF;AACnF,MAAM,MAAM,kBAAkB,GAAG,CAAC,UAAU,aAAa,CAAC,GAAG;IAC3D,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;CACrC,CAAC"}

package/dist/ecs/game-component.js

@@ -0,0 +1,80 @@
+/**
+ * Base class for game components attached to entities.
+ *
+ * Generalized (T7.2, D8 — `docs/GAME-COMPONENT-GENERALIZATION.md`) over the
+ * world kind `K` (default `'threejs'`, so every existing component — all of
+ * which extend the bare `GameComponent` — compiles and runs unchanged). The
+ * world's native node IS the entity — there is no separate entity id and no
+ * mirror/sync layer (Track A). Each component instance holds a direct
+ * reference to its node and (if any) its Rapier rigid body/collider. The
+ * ComponentManager wires these up in `attach()`.
+ *
+ * Similar to Unity's MonoBehaviour or Godot's Node scripts:
+ * - `init()` — called once after the entity is fully constructed
+ * - `update(dt, ctx)` — called every fixed timestep, in the component's phase
+ * - `dispose(ctx)` — called when the entity is destroyed
+ * - `onTriggerEnter/onTriggerExit` — called when a sensor collider overlap
+ *   starts/stops, with the other party's native node
+ *
+ * State lives on `this` (instance properties). On HMR, the engine swaps the
+ * prototype via Object.setPrototypeOf — instance state survives, method bodies
+ * update to the new code.
+ */
+export class GameComponent {
+    /** Which phase this component's update runs in. Override in subclasses. */
+    static phase = 'gameLogic';
+    /**
+     * Runtime-checkable declaration of which {@link WorldKind} this component
+     * is written for (T7.2, D8 §3 — `docs/GAME-COMPONENT-GENERALIZATION.md`).
+     * TS's `K` type parameter is erased at runtime, so this static is what the
+     * ComponentManager checks at attach time: a node whose world's kind
+     * doesn't match `declaredKind` THROWS at attach (a `GameComponent<'pixijs'>`
+     * attached to a threejs entity, or vice versa). Kind-agnostic components —
+     * written only against `node`/`this.world`, never the typed `object3D`
+     * accessor or a kind-specific field — may declare `'any'` and attach in
+     * any world components are legal in (every world except `'react'`, which
+     * always throws regardless of `declaredKind` — see the ComponentManager).
+     */
+    static declaredKind = 'threejs';
+    /**
+     * Optional Zod object schema for this component's authored fields. When set,
+     * scene data is validated + defaulted through `schema.parse(data)` before being
+     * assigned onto the instance. Also powers (later) the editor's schema-driven
+     * inspector and HMR defaults.
+     */
+    static schema;
+    /** The native world node. The node IS the entity. */
+    node;
+    /** The world instance this component's entity lives in (wired at attach). */
+    world;
+    /**
+     * Typed accessor, threejs worlds only — kept for compatibility. On a
+     * `GameComponent` (default `K`) this types as `THREE.Object3D`, so every
+     * existing component compiles unchanged. On a non-threejs instance it
+     * THROWS a descriptive error rather than ever returning a wrong-kind node —
+     * use `this.node` (or `this.world.kind` to check first) instead.
+     */
+    get object3D() {
+        const kind = this.world?.kind;
+        if (kind !== undefined && kind !== 'threejs') {
+            throw new Error(`${this.constructor.name}.object3D: this component's world (kind: "${kind}") is not a ` +
+                'threejs world — `object3D` only ever returns a THREE.Object3D; use `this.node` instead.');
+        }
+        // When the world isn't wired yet (silo-attached 2D components until
+        // T7.3; bare instances), fall back to the static declaration so a
+        // GameComponent<'pixijs'> can never silently hand out its Container
+        // typed as an Object3D.
+        if (kind === undefined) {
+            const declared = this.constructor.declaredKind;
+            if (declared !== 'threejs' && declared !== 'any') {
+                throw new Error(`${this.constructor.name}.object3D: this component declares kind "${declared}" — ` +
+                    '`object3D` only ever returns a THREE.Object3D; use `this.node` instead.');
+            }
+        }
+        return this.node;
+    }
+    /** The entity's native rigid body, if it has physics. */
+    rigidBody = null;
+    /** The entity's native collider, if it has physics. */
+    collider = null;
+}

package/dist/ecs/hmr-swap-report.d.ts

@@ -0,0 +1,53 @@
+/**
+ * HMR swap-miss report — T5.4 (docs/BACKBONE-TASKS.md's Track 5 table:
+ * "Deterministic HMR: registry-keyed hotSwap (not `constructor.name`), schema
+ * re-parse on swap, loud swap-miss warnings"). `ComponentManager.hotSwap` keys
+ * live instances by the `componentRegistry` name recorded on them at attach
+ * (see `component-manager.ts`'s `attach`/`hotSwap`), NOT the live
+ * `constructor.name` — fragile under minification, class renames, or two
+ * classes sharing one name. This module is the structured, greppable
+ * `console.warn` a swap-miss warrants, mirrored on the established
+ * prefix + JSON-payload pattern (`packages/editor/src/achieved-tier.ts`'s
+ * `TIER_SHORTFALL_PREFIX`, `packages/editor/src/authoring/overlay-report.ts`'s
+ * `OVERLAY_REPORT_PREFIX`) — kept dependency-free (no `window`/editor-console
+ * import) so it stays importable from a headless engine/runtime context,
+ * same discipline as those two files.
+ *
+ * Two independent miss reasons, per the BACKBONE-TASKS detail note:
+ *   - `'no-live-instance'` — the incoming hot update's key (the
+ *     `componentRegistry` name the recompiled module was re-exported under)
+ *     matches no currently-attached instance's recorded registry key (nor,
+ *     for an instance attached WITHOUT a registry key — an ad-hoc,
+ *     code-attached component — its `constructor.name`). This is the
+ *     "renamed class → loud miss" case: a class rename changes the export
+ *     key a hot update arrives under, so no live instance is found under the
+ *     NEW key — the OLD prototype is simply left in place (never silently
+ *     dropped, never crashed).
+ *   - `'schema-reparse-failed'` — at least one matched instance's swap
+ *     succeeded (prototype replaced), but re-validating its authored props
+ *     against the NEW class's `static schema` threw; that instance's fields
+ *     are left exactly as they were (last-good props), never partially or
+ *     invalidly overwritten.
+ */
+/** Greppable prefix shared by every swap-miss log line this module produces. */
+export declare const HMR_SWAP_MISS_PREFIX = "hmr-swap-miss";
+export type HmrSwapMissReport = {
+    key: string;
+    reason: 'no-live-instance';
+} | {
+    key: string;
+    reason: 'schema-reparse-failed';
+    error: string;
+};
+/**
+ * The one shared message shape — greppable on the prefix, JSON-parseable on
+ * the trailing payload (the LAST `{...}` in the string — the human-readable
+ * `detail` clause never itself contains a brace, even for the
+ * `'schema-reparse-failed'` reason, whose full Zod error text — itself a
+ * JSON-issues blob, braces included — is carried only in `report.error`
+ * inside that trailing payload, never inlined into `detail`).
+ */
+export declare function formatHmrSwapMissMessage(report: HmrSwapMissReport): string;
+/** Emit the ONE structured `console.warn` a swap-miss warrants — never a silent no-op. */
+export declare function logHmrSwapMiss(report: HmrSwapMissReport): void;
+//# sourceMappingURL=hmr-swap-report.d.ts.map

package/dist/ecs/hmr-swap-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr-swap-report.d.ts","sourceRoot":"","sources":["../../src/ecs/hmr-swap-report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,kBAAkB,CAAC;AAEpD,MAAM,MAAM,iBAAiB,GACzB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAA;CAAE,GAC3C;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,uBAAuB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAW1E;AAED,0FAA0F;AAC1F,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAG9D"}

package/dist/ecs/hmr-swap-report.js

@@ -0,0 +1,55 @@
+/**
+ * HMR swap-miss report — T5.4 (docs/BACKBONE-TASKS.md's Track 5 table:
+ * "Deterministic HMR: registry-keyed hotSwap (not `constructor.name`), schema
+ * re-parse on swap, loud swap-miss warnings"). `ComponentManager.hotSwap` keys
+ * live instances by the `componentRegistry` name recorded on them at attach
+ * (see `component-manager.ts`'s `attach`/`hotSwap`), NOT the live
+ * `constructor.name` — fragile under minification, class renames, or two
+ * classes sharing one name. This module is the structured, greppable
+ * `console.warn` a swap-miss warrants, mirrored on the established
+ * prefix + JSON-payload pattern (`packages/editor/src/achieved-tier.ts`'s
+ * `TIER_SHORTFALL_PREFIX`, `packages/editor/src/authoring/overlay-report.ts`'s
+ * `OVERLAY_REPORT_PREFIX`) — kept dependency-free (no `window`/editor-console
+ * import) so it stays importable from a headless engine/runtime context,
+ * same discipline as those two files.
+ *
+ * Two independent miss reasons, per the BACKBONE-TASKS detail note:
+ *   - `'no-live-instance'` — the incoming hot update's key (the
+ *     `componentRegistry` name the recompiled module was re-exported under)
+ *     matches no currently-attached instance's recorded registry key (nor,
+ *     for an instance attached WITHOUT a registry key — an ad-hoc,
+ *     code-attached component — its `constructor.name`). This is the
+ *     "renamed class → loud miss" case: a class rename changes the export
+ *     key a hot update arrives under, so no live instance is found under the
+ *     NEW key — the OLD prototype is simply left in place (never silently
+ *     dropped, never crashed).
+ *   - `'schema-reparse-failed'` — at least one matched instance's swap
+ *     succeeded (prototype replaced), but re-validating its authored props
+ *     against the NEW class's `static schema` threw; that instance's fields
+ *     are left exactly as they were (last-good props), never partially or
+ *     invalidly overwritten.
+ */
+/** Greppable prefix shared by every swap-miss log line this module produces. */
+export const HMR_SWAP_MISS_PREFIX = 'hmr-swap-miss';
+/**
+ * The one shared message shape — greppable on the prefix, JSON-parseable on
+ * the trailing payload (the LAST `{...}` in the string — the human-readable
+ * `detail` clause never itself contains a brace, even for the
+ * `'schema-reparse-failed'` reason, whose full Zod error text — itself a
+ * JSON-issues blob, braces included — is carried only in `report.error`
+ * inside that trailing payload, never inlined into `detail`).
+ */
+export function formatHmrSwapMissMessage(report) {
+    const detail = report.reason === 'no-live-instance'
+        ? `no live instance's registry key (or, for an ad-hoc/unregistered instance, its class name) ` +
+            `matches "${report.key}" — the hot update had nothing to swap (old class, if any, left in place)`
+        : `schema re-parse failed for "${report.key}" after swap — keeping the instance's last-good ` +
+            `props (Zod error in the trailing payload's "error" field)`;
+    return (`${HMR_SWAP_MISS_PREFIX} ${detail} (T5.4, docs/BACKBONE-TASKS.md). ` +
+        `${HMR_SWAP_MISS_PREFIX} ${JSON.stringify(report)}`);
+}
+/** Emit the ONE structured `console.warn` a swap-miss warrants — never a silent no-op. */
+export function logHmrSwapMiss(report) {
+    // biome-ignore lint/suspicious/noConsole: structured, greppable swap-miss warning (T5.4) — mirrors achieved-tier.ts/overlay-report.ts's deliberate direct console.warn
+    console.warn(formatHmrSwapMissMessage(report));
+}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `@vgai/engine`'s package `"."` entry — what `import '@vgai/engine'`
+ * resolves to.
+ *
+ * This is a SMALL, CURATED barrel, not a re-export-everything convenience
+ * import. The engine's own doctrine (CLAUDE.md: "the engine code in
+ * `packages/engine/src/` is meant to be read and edited directly — it is
+ * not a black-box library") means subpath imports
+ * (`@vgai/engine/<path>`, matching this package's `"./*"` exports entry)
+ * remain the primary way to reach engine internals — reach for a subpath
+ * first. This barrel exists only so the package's bare-name entry point is
+ * HONEST (resolves to something real and useful) instead of dangling; it
+ * covers just the handful of symbols a game/consumer needs to author a
+ * first-party `setup()` and mount it, plus the scene/manifest file
+ * entry points. Keep it small when extending it — prefer a new subpath
+ * export over growing this file into a firehose.
+ *
+ * Groups (import order below is alphabetical-by-specifier, per the repo's
+ * biome `organizeImports` rule, not by group — see this list instead):
+ *   - game setup contract: `GameContext`/`GameCleanup`/`GameSetupFn`, `fromSetup`
+ *   - component model: `GameComponent`, `WorldKind`
+ *   - manifest-driven mount: `mountManifestWorlds` + its option/result types
+ *   - scene file entry point: `parseSceneFile`/`parsePrefabFile`
+ *   - game manifest (vgai.game.json) entry point: `loadGameManifest`
+ */
+export { fromSetup } from './adapter/vgai-scene-game-adapter';
+export type { WorldKind } from './adapter/world-kind';
+export { GameComponent } from './ecs/game-component';
+export type { GameManifest, ResolvedAdapter, ResolvedGameManifest, ResolvedWorldEntry, WorldAdapter, WorldEntry, } from './manifest';
+export { CAPABILITY_CEILINGS, DEFAULT_SERVER_MODULE, loadGameManifest } from './manifest';
+export type { GameSession } from './runtime/create-runtime';
+export type { MountEntry, MountedManifestSession, MountManifestOptions, } from './runtime/mount-manifest';
+export { mountManifestWorlds } from './runtime/mount-manifest';
+export type { GameCleanup, GameContext, GameSetupFn } from './runtime/types';
+export { parsePrefabFile, parseSceneFile, SceneParseError } from './scene/parse';
+export type { PrefabFile, SceneFile } from './scene/schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC9D,YAAY,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,YAAY,EACV,YAAY,EACZ,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,EACZ,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC1F,YAAY,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,YAAY,EACV,UAAU,EACV,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACjF,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,30 @@
+/**
+ * `@vgai/engine`'s package `"."` entry — what `import '@vgai/engine'`
+ * resolves to.
+ *
+ * This is a SMALL, CURATED barrel, not a re-export-everything convenience
+ * import. The engine's own doctrine (CLAUDE.md: "the engine code in
+ * `packages/engine/src/` is meant to be read and edited directly — it is
+ * not a black-box library") means subpath imports
+ * (`@vgai/engine/<path>`, matching this package's `"./*"` exports entry)
+ * remain the primary way to reach engine internals — reach for a subpath
+ * first. This barrel exists only so the package's bare-name entry point is
+ * HONEST (resolves to something real and useful) instead of dangling; it
+ * covers just the handful of symbols a game/consumer needs to author a
+ * first-party `setup()` and mount it, plus the scene/manifest file
+ * entry points. Keep it small when extending it — prefer a new subpath
+ * export over growing this file into a firehose.
+ *
+ * Groups (import order below is alphabetical-by-specifier, per the repo's
+ * biome `organizeImports` rule, not by group — see this list instead):
+ *   - game setup contract: `GameContext`/`GameCleanup`/`GameSetupFn`, `fromSetup`
+ *   - component model: `GameComponent`, `WorldKind`
+ *   - manifest-driven mount: `mountManifestWorlds` + its option/result types
+ *   - scene file entry point: `parseSceneFile`/`parsePrefabFile`
+ *   - game manifest (vgai.game.json) entry point: `loadGameManifest`
+ */
+export { fromSetup } from './adapter/vgai-scene-game-adapter';
+export { GameComponent } from './ecs/game-component';
+export { CAPABILITY_CEILINGS, DEFAULT_SERVER_MODULE, loadGameManifest } from './manifest';
+export { mountManifestWorlds } from './runtime/mount-manifest';
+export { parsePrefabFile, parseSceneFile, SceneParseError } from './scene/parse';