@vgai/engine 0.5.13 → 0.5.14

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

@@ -0,0 +1,447 @@
+/**
+ * `vgai.adapter.ts` — THE ADAPTER MODULE CONTRACT.
+ *
+ * ARCHITECTURE-CORE §The editor protocol, "The adapter is the game's own
+ * module": the editor is a universal CLIENT of a fixed protocol and every game
+ * supplies a SERVER — its adapter. That adapter is the game's OWN module,
+ * `vgai.adapter.ts`, sitting beside `vgai.project.json`, default-exporting
+ * {@link defineAdapter}'s result.
+ *
+ * It is CODE (bindings are expressions — a scene entry may carry a closure the
+ * host evaluates against the mounted game) with a CONFIG's discipline: the top
+ * level is a STATICALLY EVALUABLE BINDING TABLE, readable without booting the
+ * game. Concretely, that is the split this module enforces:
+ *
+ *   - the TABLE SHAPE — regions, the scene table, observation declarations —
+ *     is plain data, validated by {@link AdapterDefinitionSchema} the moment
+ *     the module is evaluated. `.strict()` throughout: an unrecognized key is
+ *     an error naming the key, never a silent pass-through (CLAUDE.md,
+ *     "Unknown input must REJECT LOUDLY").
+ *   - individual FIELDS may be closures, evaluated lazily against the mounted
+ *     game (`ObservationDeclaration.answer`). A closure is never required to
+ *     read the table.
+ *
+ * **Zero inference.** A binding is a DECLARATION or a finder SELECTION the
+ * adapter makes — never something the host sniffs out. Finder algorithms
+ * (scenes from an entrypoint selection, prefabs from story registrations, …)
+ * ship host-side under `adapter/finders/`, and this module names them by
+ * SELECTION only ({@link FinderSelection}). That is deliberate and load-bearing
+ * twice over:
+ *   1. the engine never runs a finder nobody selected — enforced mechanically
+ *      by `packages/engine/test/finder-import-boundary.test.ts`, whose only
+ *      sanctioned importer of the finder namespace is the editor's adapter
+ *      loader;
+ *   2. this module therefore imports NOTHING from `adapter/finders/`, so a
+ *      game's `vgai.adapter.ts` pulls no finder implementation (and no source
+ *      parser) into its own bundle. The dependency runs one way: finders
+ *      import their parameter types from HERE.
+ *
+ * The manifest keeps only what must be readable without evaluating any module
+ * — identity, roots, boot mode, `server.room`. Everything that binds behavior
+ * is the adapter's. This wave adds NO manifest field.
+ */
+import { z } from 'zod';
+import type { ResolvedAdapterRoot } from '../manifest/load';
+import type { AdapterSurface } from './adapter-surface';
+import { type WriteAnchorKind } from './authoring';
+/**
+ * The projector serving a surface — one per surface, host-owned
+ * (ARCHITECTURE-CORE: "Projection — nodes, stable identity, bounds, picking …
+ * one projector per surface"). Named, never imported: the adapter states WHICH
+ * library serves the region; the host binds the implementation.
+ */
+export declare const PROJECTOR_NAMES: readonly ["three", "pixi", "dom"];
+export type ProjectorName = (typeof PROJECTOR_NAMES)[number];
+/**
+ * A region's WORLD BASIS — which axis points up, and where its ground sits.
+ *
+ * The editor needs a ground plane to place a dropped asset or a probe point on.
+ * That plane used to be the constant `y = 0` compiled into `editor-viewport.ts`,
+ * which is a guess about the GAME's convention: a Z-up world (the CAD/Blender
+ * idiom foreign R3F games routinely carry) got its drops silently projected onto
+ * the wrong plane. It is exactly the shape "zero inference" names — a fact the
+ * game's author can state, so the fix is a declaration slot rather than a
+ * smarter sniff (ARCHITECTURE-CORE §The editor protocol).
+ */
+export interface AdapterRegionBasis {
+    /** World axis pointing away from the ground. */
+    readonly up: 'y' | 'z';
+    /** Ground offset along {@link up}, in world units. */
+    readonly groundHeight: number;
+}
+/**
+ * The NATIVE basis — what {@link regionsFromManifestRoots} emits and what a
+ * region that declares none is read as. +Y up, ground at 0: three.js' own
+ * convention, which every first-party root is authored in. Stated as a value so
+ * "the default" has one home instead of a copy at each reader.
+ */
+export declare const NATIVE_REGION_BASIS: AdapterRegionBasis;
+/**
+ * One matrix REGION: a root, its surface, and the library selections that
+ * serve it. Universality lives at region granularity — which libraries serve a
+ * surface is a per-surface ENGINE fact, so a new surface root in an existing
+ * game is one manifest line and one derived region, never new adapter code
+ * (that is exactly what {@link regionsFromManifestRoots} does).
+ */
+export interface AdapterRegion {
+    /** The manifest root this region grades. */
+    readonly id: string;
+    /** What the host hands this root. */
+    readonly surface: AdapterSurface;
+    /**
+     * `true` = this region grades the game's own DEV LAYER (the manifest root's
+     * `dev: true`), not shipped game content.
+     *
+     * Carried here because a dev root occupies the same MEDIUM as the content
+     * root beside it — a dev GUI is a `dom` root next to the HUD's `dom` root —
+     * and anything that maps a subject to "the region on this surface" would
+     * otherwise be choosing between them by array order. A region consumer that
+     * means shipped content says so by skipping `dev` regions (the loader's
+     * `regionForSurface` does), rather than by guessing which one matched.
+     */
+    readonly dev: boolean;
+    /** Projection library, by name. */
+    readonly projector: ProjectorName;
+    /**
+     * Dialect writer, by name (`r3f`, `jsx`, `pixi-react`, …) — the truth
+     * family's source writer for this region. `null` states outright that the
+     * host writes no source here: the region's truth is the game's own code,
+     * which the host does not author (a module or ingest root).
+     */
+    readonly dialect: string | null;
+    /**
+     * Anchor kinds this region's writer serves, drawn from the compile-pinned
+     * {@link WRITE_ANCHOR_KINDS} vocabulary. A kind absent here is a red cell in
+     * the matrix, which is a work order — never a silently unsupported edit.
+     */
+    readonly anchors: readonly WriteAnchorKind[];
+    /**
+     * This region's world basis. Omitted = {@link NATIVE_REGION_BASIS}, which is
+     * a DECLARED default (the native adapter emits it outright), not a silent
+     * fallback — same shape as an absent `vgai.adapter.ts` meaning
+     * `nativeAdapter()`.
+     */
+    readonly basis?: AdapterRegionBasis;
+    /**
+     * Project-relative globs naming source files this region OWNS, for the
+     * ambiguous remainder that import reach cannot place.
+     *
+     * A file's surface/dialect is derived from WHICH REGION'S IMPORT CLOSURE
+     * reaches it — a load-bearing fact, because the region's manifest entry is
+     * what the host actually executes at mount (the game would break first if it
+     * lied). Reach through several regions of the SAME surface is unambiguous;
+     * reach through regions of DIFFERING surfaces, or through none at all, is
+     * genuinely undecidable from outside, and this is where the game's author
+     * states the answer instead of the host guessing it from the file's bytes.
+     *
+     * READER: `packages/editor/src/ui-source/file-region-resolver.ts`'s
+     * `resolveFileRegion`, consulted BEFORE reach — a declared include wins,
+     * because it is a first-party statement about this exact file. Every OID
+     * stamping tier, the HMR classifier, the R3F authoring diagnostics and
+     * Content's component grouping read that one resolver.
+     *
+     * {@link regionsFromManifestRoots} emits none: the native default is PURE
+     * reach, and a first-party project that needs an include has a module its
+     * roots do not reach, which is a fact worth stating rather than absorbing.
+     *
+     * Glob vocabulary is deliberately the small one every reader already knows:
+     * `**` (any depth, including none), `*` (one segment, no `/`), `?` (one
+     * character). No brace expansion, no negation — a second syntax to learn is
+     * how a declaration slot turns back into a language.
+     */
+    readonly include?: readonly string[];
+}
+/**
+ * How a definition supplies its regions: the RULE `'manifest-roots'` (the
+ * native default — a declaration may be a rule rather than a list, the way
+ * `roots[]` never enumerates a world's contents), or an explicit list a game
+ * with novel bindings states outright.
+ */
+export type RegionBinding = 'manifest-roots' | readonly AdapterRegion[];
+/**
+ * The MECHANICAL derivation behind the `'manifest-roots'` rule: one region per
+ * declared root, its surface and adapter identity read straight off the
+ * RESOLVED manifest (`@engine/manifest/load` already decided both — this never
+ * re-derives them).
+ *
+ * The per-surface library table below is an ENGINE fact, stated once:
+ *
+ * | root `adapter`        | projector | dialect       | anchors                            |
+ * |-----------------------|-----------|---------------|------------------------------------|
+ * | `three`               | `three`   | `r3f`         | source-prop, construction-literal   |
+ * | `canvas`              | `pixi`    | `pixi-react`  | source-prop, construction-literal   |
+ * | `dom`                 | `dom`     | `jsx`         | source-prop                        |
+ * | `{module,surface}`    | (surface) | `null`        | live-only                          |
+ * | `{ingest,surface}`    | (surface) | `null`        | live-only                          |
+ *
+ * A module/ingest root's truth is the game's own source, which no first-party
+ * dialect writer authors — so it declares `live-only` rather than implying a
+ * write path it does not have. That is a red cell and therefore a work order,
+ * which is the point of stating it.
+ *
+ * Every derived region carries {@link NATIVE_REGION_BASIS} outright, so the
+ * editor's ground plane READS a declaration on the native path too — the
+ * default is published, never assumed at the read site.
+ */
+export declare function regionsFromManifestRoots(roots: readonly ResolvedAdapterRoot[]): AdapterRegion[];
+/**
+ * The rule form of a finder's region targeting: every region the host mounts
+ * from an exported composition (a root with an `entry`) that is not a declared
+ * DEV layer. A dev root is the game's own dev GUI — the manifest already says
+ * so (`dev: true`), so skipping it reads a declaration rather than guessing.
+ */
+export declare const EXPORTED_COMPOSITION_REGIONS = "exported-composition-regions";
+/**
+ * `scenesFromEntrypointSelection` — read the entrypoint's ACTIVE-SCENE
+ * SELECTION, the load-bearing reference (the game itself executes it, so it
+ * cannot drift: the game would break first).
+ */
+export interface ScenesFromEntrypointSelectionParams {
+    readonly finder: 'scenesFromEntrypointSelection';
+    /**
+     * Which regions' entrypoints to read: named region ids, or the rule
+     * {@link EXPORTED_COMPOSITION_REGIONS}.
+     */
+    readonly regions: readonly string[] | typeof EXPORTED_COMPOSITION_REGIONS;
+    /**
+     * Identifier of the entrypoint's module-level selection table — the
+     * `const <selection> = { <sceneId>: <Component>, … }` binding the entrypoint
+     * renders at its swap slot.
+     *
+     * OMIT for an entrypoint that mounts ONE composition: the finder then answers
+     * with the single-scene degenerate table (the root's own composition, opened
+     * by mounting the region). Only legal alongside exactly one named region —
+     * a selection identifier is a fact about ONE entrypoint's source, so pairing
+     * it with the rule form is rejected by name rather than applied to whichever
+     * region happened to match.
+     */
+    readonly selection?: string;
+}
+/**
+ * `prefabsFromStories` — read the colocated portable-CSF story registrations.
+ * A prefab is an ordinary source component a designer independently places,
+ * declared by a story whose `meta.component` names it; the story registration
+ * is the load-bearing reference here (removing it removes the declaration).
+ * Zero parameters: the selection IS the whole configuration.
+ */
+export interface PrefabsFromStoriesParams {
+    readonly finder: 'prefabsFromStories';
+}
+/** Every finder this engine ships, as the adapter's concrete SELECTION. */
+export type FinderSelection = ScenesFromEntrypointSelectionParams | PrefabsFromStoriesParams;
+/** The finder names, as a value — what the loader's dispatcher switches on. */
+export declare const FINDER_NAMES: readonly ["scenesFromEntrypointSelection", "prefabsFromStories"];
+export type FinderName = (typeof FINDER_NAMES)[number];
+/**
+ * How the RUNNING game is navigated to an entry — the `reachable` honesty
+ * clause, stated rather than assumed. An entry whose reach is `none` is a
+ * declared-but-unreachable scene: a red cell carrying its own reason.
+ */
+export type SceneReach = 
+/** Mounting the region IS opening it — the single-composition degenerate case. */
+{
+    readonly kind: 'root-mount';
+}
+/** The entrypoint's own selection table reaches it under `key`. */
+ | {
+    readonly kind: 'entrypoint-selection';
+    readonly selection: string;
+    readonly key: string;
+}
+/** A portable story mounts it in isolation. */
+ | {
+    readonly kind: 'story';
+    readonly storyId: string;
+}
+/** Declared, with no code path that opens it. */
+ | {
+    readonly kind: 'none';
+    readonly reason: string;
+};
+/** Where an entry's composition lives in the game's own source. */
+export interface SceneSource {
+    /** Project-relative path. */
+    readonly path: string;
+    /** Named export; omit when the module default-exports it. */
+    readonly export?: string;
+}
+/**
+ * One entry of the scene table. Scenes and prefabs are SIBLINGS here — both
+ * are registered compositions the editor opens in isolation through the same
+ * verb, differing only in instance site (ARCHITECTURE-CORE §Roots: "A scene is
+ * a ROLE, not a kind … the same kind of thing as a prefab").
+ */
+export interface SceneEntry {
+    readonly id: string;
+    readonly label: string;
+    /** `scene` (swaps at the entrypoint's slot) or `prefab` (placed by a designer). */
+    readonly kind: 'scene' | 'prefab';
+    /** Owning region id; `null` for a project-scoped entry bound to no one root. */
+    readonly region: string | null;
+    /**
+     * `true` = a composition a designer authors (it earns a matrix column).
+     * `false` = TRAVERSAL: boot/loading choreography, which gets no column.
+     */
+    readonly authorable: boolean;
+    readonly reach: SceneReach;
+    readonly source?: SceneSource;
+    /** Which finder produced it; absent = the adapter stated it outright. */
+    readonly finder?: FinderName;
+}
+/**
+ * The adapter's scene table: entries stated outright, finder selections the
+ * host runs to produce the rest, and the entry open by default.
+ */
+export interface AdapterSceneTable {
+    readonly entries?: readonly SceneEntry[];
+    readonly find?: readonly FinderSelection[];
+    /**
+     * Id of the entry open by default. Omit to let the finder's own answer
+     * stand — the host never picks one on its own, so "no default" stays a fact
+     * rather than becoming whichever entry sorted first.
+     */
+    readonly default?: string;
+}
+/**
+ * One statically declared observation slot. Declaring a slot and ANSWERING it
+ * live are separate facts (the two-state rule): a slot declared here whose
+ * `answer` throws or whose game never booted reads as broken, never as
+ * "the game has none".
+ */
+export interface ObservationDeclaration {
+    readonly id: string;
+    readonly kind: 'system' | 'command' | 'state';
+    /**
+     * Lazily evaluated against the mounted game. The field may be a closure; the
+     * TABLE around it stays statically readable, which is the whole discipline.
+     */
+    readonly answer?: (game: unknown) => unknown;
+}
+/** The adapter module's default export, after {@link defineAdapter}. */
+export interface AdapterDefinition {
+    readonly regions: RegionBinding;
+    readonly scenes: AdapterSceneTable;
+    readonly observation: readonly ObservationDeclaration[];
+}
+/** What a game writes. Every field optional — the near-empty adapter is the
+ *  first-party case, and an adapter's SIZE measures the game's distance from
+ *  native. */
+export interface AdapterDefinitionInput {
+    readonly regions?: RegionBinding;
+    readonly scenes?: AdapterSceneTable;
+    readonly observation?: readonly ObservationDeclaration[];
+}
+export declare const AdapterDefinitionSchema: z.ZodObject<{
+    regions: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"manifest-roots">, z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        surface: z.ZodEnum<{
+            canvas: "canvas";
+            three: "three";
+            dom: "dom";
+        }>;
+        dev: z.ZodBoolean;
+        projector: z.ZodEnum<{
+            three: "three";
+            dom: "dom";
+            pixi: "pixi";
+        }>;
+        dialect: z.ZodNullable<z.ZodString>;
+        anchors: z.ZodArray<z.ZodEnum<{
+            "source-prop": "source-prop";
+            "construction-literal": "construction-literal";
+            "physics-binding": "physics-binding";
+            "data-record": "data-record";
+            "live-only": "live-only";
+        }>>;
+        basis: z.ZodOptional<z.ZodObject<{
+            up: z.ZodEnum<{
+                y: "y";
+                z: "z";
+            }>;
+            groundHeight: z.ZodNumber;
+        }, z.core.$strict>>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>]>>;
+    scenes: z.ZodOptional<z.ZodObject<{
+        entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                scene: "scene";
+                prefab: "prefab";
+            }>;
+            region: z.ZodNullable<z.ZodString>;
+            authorable: z.ZodBoolean;
+            reach: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"root-mount">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"entrypoint-selection">;
+                selection: z.ZodString;
+                key: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"story">;
+                storyId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"none">;
+                reason: z.ZodString;
+            }, z.core.$strict>]>;
+            source: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+                export: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            finder: z.ZodOptional<z.ZodEnum<{
+                scenesFromEntrypointSelection: "scenesFromEntrypointSelection";
+                prefabsFromStories: "prefabsFromStories";
+            }>>;
+        }, z.core.$strict>>>;
+        find: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            finder: z.ZodLiteral<"scenesFromEntrypointSelection">;
+            regions: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"exported-composition-regions">]>;
+            selection: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            finder: z.ZodLiteral<"prefabsFromStories">;
+        }, z.core.$strict>]>>>;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    observation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            command: "command";
+            state: "state";
+            system: "system";
+        }>;
+        answer: z.ZodOptional<z.ZodCustom<(game: unknown) => unknown, (game: unknown) => unknown>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+/**
+ * Validate and freeze a game's binding table.
+ *
+ * Called TWICE by design and with one schema: once here, in the game's own
+ * module, so a malformed table fails at the author's own file with the key
+ * named; and once in the host's loader, because the loaded default export is
+ * untrusted input crossing a module boundary. Two call sites, one rule — not
+ * two ways to say the same thing.
+ */
+export declare function defineAdapter(input?: AdapterDefinitionInput): AdapterDefinition;
+/** Extra bindings a near-native game adds without restating the native ones. */
+export interface NativeAdapterOptions {
+    /** Scene-table entries this game states outright, beside what the finders find. */
+    readonly scenes?: readonly SceneEntry[];
+    /** Observation slots this game declares. */
+    readonly observation?: readonly ObservationDeclaration[];
+}
+/**
+ * THE NATIVE DEFAULT — regions derived mechanically from the manifest's
+ * `roots[]`, and a scene table produced by the two shipped finders. This is
+ * what a first-party project ships (`export default nativeAdapter()`), and it
+ * is also what a project with NO `vgai.adapter.ts` gets: that absence is the
+ * declared native default, not a silent fallback.
+ */
+export declare function nativeAdapter(options?: NativeAdapterOptions): AdapterDefinition;
+/**
+ * Parse an untrusted default export (the loaded `vgai.adapter.ts`) into a
+ * definition. Rejects loudly — an unknown key, a bad finder name, a
+ * `selection` paired with the rule form all fail by name.
+ */
+export declare function parseAdapterDefinition(value: unknown): AdapterDefinition;
+//# sourceMappingURL=adapter-module.d.ts.map

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

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