@vgai/engine 0.5.11 → 0.5.13

package/dist/manifest/schema.js

@@ -9,8 +9,8 @@
 //
 // Naming: this file follows the repo's `XxxSchema` (Zod schema) / `Xxx`
 // (inferred type) convention used throughout `scene/schema/` — the design
-// doc's §3 sketch names the bare consts (`Tier`, `IngestStrategy`,
-// `AdapterRoot`) without the `Schema` suffix; that sketch is explicitly a
+// doc's §3 sketch names the bare consts (`AdapterRoot`) without the
+// `Schema` suffix; that sketch is explicitly a
 // "Zod sketch" the doc tells implementers to adapt to real code style
 // ("mirror the style in scene/schema/scene-file.ts" per CLAUDE.md), so the
 // schema consts here are suffixed and the bare names are reserved for the
@@ -26,26 +26,6 @@ import { z } from 'zod';
  */
 export const GAME_MANIFEST_VERSION = 2;
 // ---------------------------------------------------------------------------
-// Ingest capture strategy (the general vocabulary D6/§4 names)
-// ---------------------------------------------------------------------------
-export const IngestStrategySchema = z.enum([
-    'shared', // game imports host-served ESM three — full in-realm capture
-    'deduped', // game source built by OUR pipeline, bundler dedupe — full capture
-    'iframe-reachable', // prebuilt bundle in iframe, three reachable — cross-realm capture
-    'opaque-embed', // prebuilt bundle, nothing reachable — host lifecycle only
-]);
-// ---------------------------------------------------------------------------
-// Capability tier — one ordered enum, declared per delivery context (§4)
-// ---------------------------------------------------------------------------
-export const TierSchema = z.enum([
-    'first-party', // vgai-native root: full editor, full loop control
-    'shared', // = IngestStrategy 'shared' rung
-    'deduped', // = IngestStrategy 'deduped' rung
-    'iframe-reachable', // = IngestStrategy 'iframe-reachable' rung
-    'opaque-embed', // = IngestStrategy 'opaque-embed' rung
-    'unsupported', // this root does not function in this delivery context
-]);
-// ---------------------------------------------------------------------------
 // Root adapter identity. The adapter is the sole discriminator: a root never
 // repeats its rendering substrate in a sibling `kind` field. Module and ingest
 // adapters carry the surface their adapter contract exposes because the host
@@ -141,34 +121,48 @@ export const RootAdapterSchema = z
             .describe('Native surface captured from the unmodified game'),
         ingest: z
             .object({
-            strategy: IngestStrategySchema.describe('Capture mechanics rung this ingested root uses (§4) — also the root`s natural local capability tier'),
-            entryHtml: z
-                .string()
-                .optional()
-                .describe('Entry HTML path, project-relative. WIRED for opaque-embed (D-W2): ' +
-                'the file`s bytes are read verbatim through ' +
-                'the project-static route and hosted in a sandboxed iframe (embed-only, no scene ' +
-                'introspection), for both canvas and three roots. Legal but NOT wired to a ' +
-                'mount for iframe-reachable (a named error at resolve names this — use `bundleUrl` ' +
-                'instead, the wired reachable route).'),
             contractShim: z
                 .string()
                 .optional()
                 .describe("Project-relative path to a HOST-ADDED ES module that declares this game's " +
                 '`window.vgaiGame` contract (adapter/ingest/game-contract.ts) WITHOUT editing a ' +
-                'vendored byte — the pristine-copy door. The host injects it as a ' +
-                '`<script type="module">` into the assembled iframe document AFTER the game`s own ' +
-                'importmap (moving a module load ahead of an import map invalidates the map) and ' +
-                'BEFORE the game`s entry module, so deferred module scripts run it first. ' +
+                'vendored byte — the pristine-copy door. The host imports it immediately BEFORE ' +
+                "the game's own entry module, in the editor's realm. " +
                 'TIMING CONTRACT, which a shim author must obey: because it runs before the ' +
-                'game`s entry, it MUST assign `window.vgaiGame` SYNCHRONOUSLY at top level — the ' +
-                'host waits for that assignment and fails the mount by name if it never arrives. ' +
+                'game`s entry, it MUST assign `window.vgaiGame` SYNCHRONOUSLY at top level. ' +
                 'Anything that needs the game`s own modules must be LAZY: a dynamic `import()` ' +
                 'INSIDE each verb/provider closure, resolved at call time. Importing a game module ' +
                 'eagerly from the shim would evaluate it ahead of the game`s own entry and reorder ' +
-                'its module side effects. Read by the vendored/self-hosted three route only ' +
-                '(strategy `iframe-reachable` with `entryHtml`); declaring it elsewhere is a ' +
-                'schema error rather than a silently dead field.'),
+                'its module side effects. ' +
+                'Every such `import()` MUST take a STRING LITERAL, never a variable/table lookup. ' +
+                'A variable specifier is not statically analyzable, so the dev server leaves it ' +
+                'alone and it resolves at runtime against the shim`s own `/@fs/` url — while the ' +
+                'game`s entry has had ITS relative imports rewritten to whatever url the server ' +
+                'considers canonical for those files. Module identity is per-url, so the shim ' +
+                'silently binds a SECOND, freshly-evaluated copy of the whole game and every ' +
+                'provider reports a game that never started. Measured on three-descent: 285 ' +
+                'segments through the game`s graph, 0 through the shim`s, and no error anywhere.'),
+            dataWriter: z
+                .string()
+                .optional()
+                .describe("Project-relative path to a HOST-ADDED ES module that writes this game's own " +
+                'DATA file back — the sibling of a source write for a game whose authorable ' +
+                'truth is not source. Descent places its robots, powerups and hostages in ' +
+                'binary records inside `descent.hog`, reaching no source literal, so an ' +
+                'authored move of one is an edit to that file and nothing else can write it. ' +
+                'The module declares two exports and the host knows nothing else about it: ' +
+                '`dataFile` (a project-relative string — the ONE file this writer edits) and ' +
+                '`planDataEdit(bytes, {record, property, baseline, next})`, which returns ' +
+                '`{changed: true, bytes}` or `{changed: false, reason}` and may be async. ' +
+                'It is loaded in the editor realm beside the game, so it may `import()` the ' +
+                "game's own modules to resolve what only a running game knows (Descent's " +
+                'writer asks the game`s own `find_point_seg` which segment a moved object ' +
+                'landed in, and refuses "outside the mine" rather than writing data the game ' +
+                'would read back wrong). It NEVER fabricates: a record it cannot address, or ' +
+                'a property it does not model, is a named refusal. ' +
+                'An object is anchored to a record by carrying `userData.vgaiRecordIndex` — ' +
+                'the game declares that identity itself (a recorded patch or a shim); the ' +
+                'host never infers one.'),
             assets: z
                 .record(z.string(), z.string())
                 .optional()
@@ -180,137 +174,13 @@ export const RootAdapterSchema = z
             captureTimeoutMs: z
                 .number()
                 .optional()
-                .describe('How long to wait for capture before REPORTING the degrade loudly — not how ' +
-                'long to keep listening. On the self-hosted-three route the devtools ' +
-                'subscription is permanent, so a renderer appearing later still upgrades a ' +
-                'reported-embed-only mount in place; the host clamps this value so a long ' +
-                'one cannot block the editor on a question the upgrade path answers anyway.'),
-            // The six iframe-reachable-multi mount fields
-            // (`ingest-iframe-2d.ts`'s `IframeReachableMultiOpts`), legal
-            // ONLY when `strategy` is 'iframe-reachable' (enforced by the
-            // `.superRefine` below).
-            bundleUrl: z
-                .string()
-                .optional()
-                .describe('Absolute URL of the externalized built game bundle — the WIRED iframe-reachable ' +
-                'mount route (iframe-reachable only), for BOTH canvas (Track P, ' +
-                "ingest-iframe-2d.ts's mountIngestGame2DIframeReachableMulti) and three (D-W1, " +
-                "ingest-iframe-reachable-adapter.ts's mountIngestGameIframeReachableBundle). " +
-                'PRECONDITION: the bundle must externalize its root`s own runtime as a bare, ' +
-                'un-rewritten import (`pixi.js` for canvas, `three` for three — `vgai bundle` ' +
-                'does this for you) so it resolves through the iframe importmap to the HOST ' +
-                'instance the capture trap is installed on; a bundle with an inlined runtime is ' +
-                'unreachable and degrades to the embed-only floor. Exactly one of bundleUrl/' +
-                'entryHtml is required when strategy is iframe-reachable.'),
-            baseHref: z
-                .string()
-                .optional()
-                .describe("Iframe <base href> so the game's relative asset URLs resolve (iframe-reachable only)."),
-            assetBaseUrl: z
-                .string()
-                .optional()
-                .describe("Host-side basePath forced onto the trapped runtime's own asset resolution — " +
-                "pixi's `Assets.init` for a canvas root, three's " +
-                '`DefaultLoadingManager.setURLModifier` for a three root (D-W1) — absolute, or ' +
-                "root-relative (resolved against the editor page's own origin at mount time, " +
-                'ingest-mode.ts, so a static manifest never has to know the dev-server port) ' +
-                '(iframe-reachable only — a document.write iframe keeps the parent window.location).'),
-            extraDeps: z
-                .array(z.string())
-                .optional()
-                .describe("Bare specifiers of this root's externalized deps beyond its own runtime " +
-                "(pixi.js/three — e.g. '@pixi/sound', 'gsap'). Resolved by the editor's " +
-                'host-namespace registry into module namespaces when known (D-P1 — the manifest ' +
-                'carries data, not code); an unregistered specifier falls back to the open ' +
-                "project's own node_modules (D-Z3), served " +
-                'as a verbatim iframe importmap URL. Throws a named error if neither resolves it ' +
-                '(iframe-reachable only).'),
-            pixiModuleUrl: z
-                .string()
-                .optional()
-                .describe('PIXI-ONLY: standalone matching-major pixi ESM URL to trap instead of the host ' +
-                "pixi, for version-skewed games (e.g. a v6 game on a v8 host); this field's " +
-                'PRESENCE is how the skew is expressed (D-P2 — no separate strategy/tier for ' +
-                'version skew) (iframe-reachable only). Declaring this on a `kind: "three"` ' +
-                'root is schema-legal (this field is kind-agnostic here) but throws a NAMED ' +
-                'not-supported error at resolve — three has no version-skew mount this wave ' +
-                '(D-W7: a hypothetical `threeModuleUrl` is explicitly parked, no consumer ' +
-                'exists).'),
-            bodyHtml: z
-                .string()
-                .optional()
-                .describe('HTML injected into the iframe body before the game script boots (e.g. a ' +
-                '`<div id="game-root">` the game expects to find) (iframe-reachable only).'),
+                .describe("How long the host waits for this game's first captured frame before the mount " +
+                'FAILS by name. A game that needs a long boot (streamed world assets, a menu ' +
+                'the player must clear) raises it; the default is 10s.'),
         })
+            .strict()
             .describe('Ingest adapter configuration for an unmodified game (a repo-vendored game or your ' +
-            'own external folder)')
-            // `contractShim` is injected into the assembled ENTRY DOCUMENT, so
-            // the ONLY route that can read it is the self-hosted one
-            // (`iframe-reachable` + `entryHtml`,
-            // ingest-self-hosted-three-adapter.ts). An `opaque-embed` entry
-            // document is hosted sandboxed with no host wiring, and a `bundleUrl`
-            // mount has no game document at all — under either, a declared shim
-            // would be a silently dead declaration, the exact failure the
-            // dead-field-under-wrong-variant checks below exist to prevent. Its
-            // own `.superRefine` rather than a branch inside the next one: they
-            // check unrelated invariants, and folding them together only made
-            // one function harder to read.
-            .superRefine((ingest, ctx) => {
-            if (ingest.contractShim === undefined ||
-                (ingest.strategy === 'iframe-reachable' && ingest.entryHtml !== undefined)) {
-                return;
-            }
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: '`contractShim` is read ONLY by the self-hosted entry-document route, so it ' +
-                    "requires strategy 'iframe-reachable' together with `entryHtml` (got strategy " +
-                    `"${ingest.strategy}"${ingest.entryHtml === undefined ? ' and no `entryHtml`' : ''}) — ` +
-                    "the host injects the shim module into the GAME'S OWN entry HTML " +
-                    '(ingest-self-hosted-three-adapter.ts), and no other mount has such a document.',
-                path: ['contractShim'],
-            });
-        })
-            .superRefine((ingest, ctx) => {
-            // The six iframe-reachable-multi fields only make sense for the
-            // iframe-reachable-multi mount — reject them under any other
-            // strategy (mirrors ui.ts's dead-field-under-wrong-variant pattern).
-            const iframeOnlyFields = [
-                ['bundleUrl', ingest.bundleUrl !== undefined],
-                ['baseHref', ingest.baseHref !== undefined],
-                ['assetBaseUrl', ingest.assetBaseUrl !== undefined],
-                ['extraDeps', ingest.extraDeps !== undefined],
-                ['pixiModuleUrl', ingest.pixiModuleUrl !== undefined],
-                ['bodyHtml', ingest.bodyHtml !== undefined],
-            ];
-            if (ingest.strategy !== 'iframe-reachable') {
-                for (const [key, present] of iframeOnlyFields) {
-                    if (present) {
-                        ctx.addIssue({
-                            code: z.ZodIssueCode.custom,
-                            message: `\`${key}\` is only legal when strategy is 'iframe-reachable' (got ` +
-                                `"${ingest.strategy}") — bundleUrl/baseHref/assetBaseUrl/extraDeps/` +
-                                "pixiModuleUrl/bodyHtml are the iframe-reachable-multi mount's options " +
-                                '(canvas: ingest-iframe-2d.ts IframeReachableMultiOpts; three, D-W1: ' +
-                                'ingest-iframe-reachable-adapter.ts IframeReachableBundleOpts) and have no ' +
-                                'meaning under any other strategy.',
-                            path: [key],
-                        });
-                    }
-                }
-                return;
-            }
-            const hasBundleUrl = ingest.bundleUrl !== undefined;
-            const hasEntryHtml = ingest.entryHtml !== undefined;
-            if (hasBundleUrl === hasEntryHtml) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: "strategy 'iframe-reachable' requires EXACTLY ONE of `bundleUrl` (externalized " +
-                        'multi-file bundle, the iframe-reachable-multi mount) or `entryHtml` (single-' +
-                        `file/legacy iframe entry) — ${hasBundleUrl ? 'both are present' : 'neither is present'}.`,
-                    path: hasBundleUrl ? ['bundleUrl'] : ['entryHtml'],
-                });
-            }
-        }),
+            'own external folder)'),
     })
         .strict(),
 ]))
@@ -361,15 +231,7 @@ export const AdapterRootSchema = z
         .enum(['gated', 'self-driven'])
         .default('gated')
         .describe('gated: host-driven loop (default). self-driven: this root drives its own loop ' +
-        '(the "composited, unsynchronized" tier) — an axis independent of capability tier'),
-    capabilities: z
-        .object({
-        local: TierSchema.optional().describe('Declared capability tier when served via the local CLI (Vite pipeline); omitted -> derived (§4)'),
-        hosted: TierSchema.optional().describe('Declared capability tier when served hosted (no bundler: esbuild-wasm + externals only); omitted -> derived (§4)'),
-    })
-        .optional()
-        .describe("Per-delivery-context capability tier declarations (§4). Declaring above the adapter's " +
-        'ceiling for that context is an error; declaring at or below it (including `unsupported`) is legal.'),
+        '(composited, unsynchronized)'),
 })
     .strict();
 /**
@@ -580,6 +442,24 @@ export const GameManifestSchema = z
     })
         .optional()
         .describe('Canvas resolution'),
+    rendering: z
+        .object({
+        antialias: z
+            .boolean()
+            .describe('Whether every three root is built with a multisampled drawing buffer. This is the ' +
+            'ONE render property a world cannot declare for itself (world3d-react/' +
+            'renderer-config.ts): a WebGL context fixes its sample count at CREATION from this ' +
+            'boolean, long before a world mounts, so it belongs to the PROJECT. The runtime ' +
+            'reader is mount-manifest.ts, which threads it into createHostRenderer for each ' +
+            'three root. WebGL exposes no sample COUNT — the implementation picks one (4x on ' +
+            'every desktop browser measured), so a source engine that authored 8x/16x gets ' +
+            'multisampling but not its exact count.'),
+    })
+        .strict()
+        .optional()
+        .describe('Construction-time renderer properties, which no world can declare after the fact. ' +
+        'Everything a world CAN declare (tone mapping, output colour space, clear colour, ' +
+        "shadow filter) lives on the world's own renderer config instead."),
     debug: z
         .object({
         allowInProduction: z

package/dist/pixi/index.d.ts

@@ -4,12 +4,11 @@
  * PixiJS is opt-in: the engine core never imports it, so a three-only bundle
  * never pays for it. What lives here is what the host needs to mount and
  * inspect a PixiJS game it did not write — the render-call capture trap, the
- * in-realm and iframe mounts, the live display-tree authoring adapter, and the
+ * in-realm mount, the live display-tree authoring adapter, and the
  * Rapier-2D handle registry the editor's transform coordination reads.
  */
 export { AuthoringAdapter2D, type EditorNode2D, type Overlay2D, type Override2D, type Property2D, type Transform2DValue, } from './authoring';
-export { type ExtraDepsResolution2D, type IngestGame2D, type IngestMount2D, mountIngestGame2D, } from './ingest';
-export { type EmbedMount2D, type IframeReachableMount2D, type IframeReachableMultiOpts, mountIngestGame2DEmbed, mountIngestGame2DIframeReachable, mountIngestGame2DIframeReachableMulti, } from './ingest-iframe';
+export { type IngestGame2D, type IngestMount2D, mountIngestGame2D } from './ingest';
 export { createPhysics2DRegistry, type Physics2DRefs, type Physics2DRegistry, } from './physics-registry';
 export { type CapturedRuntime2D, installSceneCapture2D, type SceneCapture2DHandle, } from './scene-capture';
 export { createPhysicsAdapter2D, type PhysicsAdapter2D } from './system-adapters';

package/dist/pixi/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pixi/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,gBAAgB,GACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,iBAAiB,GAClB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,sBAAsB,EACtB,gCAAgC,EAChC,qCAAqC,GACtC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,iBAAiB,GACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,iBAAiB,EACtB,qBAAqB,EACrB,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pixi/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,gBAAgB,GACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACpF,OAAO,EACL,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,iBAAiB,GACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,iBAAiB,EACtB,qBAAqB,EACrB,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/pixi/index.js

@@ -4,12 +4,11 @@
  * PixiJS is opt-in: the engine core never imports it, so a three-only bundle
  * never pays for it. What lives here is what the host needs to mount and
  * inspect a PixiJS game it did not write — the render-call capture trap, the
- * in-realm and iframe mounts, the live display-tree authoring adapter, and the
+ * in-realm mount, the live display-tree authoring adapter, and the
  * Rapier-2D handle registry the editor's transform coordination reads.
  */
 export { AuthoringAdapter2D, } from './authoring';
-export { mountIngestGame2D, } from './ingest';
-export { mountIngestGame2DEmbed, mountIngestGame2DIframeReachable, mountIngestGame2DIframeReachableMulti, } from './ingest-iframe';
+export { mountIngestGame2D } from './ingest';
 export { createPhysics2DRegistry, } from './physics-registry';
 export { installSceneCapture2D, } from './scene-capture';
 export { createPhysicsAdapter2D } from './system-adapters';

package/dist/pixi/ingest.d.ts

@@ -1,85 +1,18 @@
 import { type SceneCapture2DHandle } from './scene-capture';
-/**
- * A manifest's `extraDeps` resolve to TWO kinds of importmap entry:
- * `namespaces` are today's registry-known bare specifiers
- * (host-namespace-registry.ts), re-exported via a blob module
- * (`ingest-iframe-2d.ts`'s `makeHostNamespaceReexportUrl`); `urls` are the
- * D-Z3 fallback — a specifier that isn't registered but IS present in the
- * open project's own `node_modules`, mapped DIRECTLY to its
- * `/project-game-static/node_modules/<spec>/<esm entry>` URL (no host-side
- * import, no blob — the dep executes in the iframe realm and its own
- * transitive `import 'pixi.js'` resolves through the same importmap back to
- * the host pixi trap). All probing/decision logic (which kind a specifier
- * resolves to, exports-map parsing, anti-shim throws) lives editor-side
- * (`host-namespace-registry.ts`) — this engine module only carries the
- * ALREADY-DECIDED shape; `ingest-iframe-2d.ts` stays decision-free and just
- * merges both maps into the iframe importmap.
- */
-export interface ExtraDepsResolution2D {
-    namespaces: Record<string, Record<string, unknown>>;
-    urls: Record<string, string>;
-}
 /** A registered unmodified PixiJS game (the Pixi analog of `IngestGame`). */
 export interface IngestGame2D {
     id: string;
     name: string;
     description: string;
-    /** Shared-pixi path: import + run the unmodified game module. */
-    load?: () => Promise<unknown>;
-    /** Tier ceiling: how reachable the game's pixi instance is. */
-    tier?: 'shared' | 'iframe-reachable' | 'opaque-embed';
+    /** Import + run the unmodified game module in the host's own realm. */
+    load: () => Promise<unknown>;
+    /** How long to wait for the game's first captured frame before failing. */
     captureTimeoutMs?: number;
-    /**
-     * IFRAME-REACHABLE-MULTI fields (Track P): an externalized built bundle
-     * mounted via `mountIngestGame2DIframeReachableMulti`
-     * (`./ingest-iframe-2d.ts`) instead of `load()` — populated only when `tier`
-     * is `'iframe-reachable'` AND `load` is absent. Mirror
-     * `IframeReachableMultiOpts`'s fields, EXCEPT `extraDeps`/`pixiNamespace` are
-     * THUNKS here, not resolved values — the same "lazy, only invoked at mount
-     * time" shape `load` already uses, so building this descriptor
-     * (`resolveIngest2DDescriptor` / the canvas surface's
-     * `ingest/surface-canvas.ts`, editor-side — Wave 0.6 replaced the three
-     * per-surface `discovery*.ts` modules with one manifest-driven registry) never
-     * has to be async just to wire up which specifiers/ version-skew URL a game
-     * needs; only actually MOUNTING it (the ingest-mode mount bridge) pays for the
-     * dynamic import of `@pixi/sound`/`gsap`/spine/ a standalone pixi build.
-     */
-    bundleUrl?: string;
-    /** <base href> for the iframe (see `IframeReachableMultiOpts.baseHref`). */
-    baseHref?: string;
-    /** Host-side Assets.init basePath remap (see `IframeReachableMultiOpts.assetBaseUrl`). */
-    assetBaseUrl?: string;
-    /**
-     * Lazily resolve this game's bare-specifier -> extraDeps resolution via the
-     * editor's host-namespace registry. Absent (or omitted) means no extra deps
-     * beyond pixi.js.
-     */
-    extraDeps?: () => Promise<ExtraDepsResolution2D>;
-    /**
-     * Lazily resolve the trapped-pixi namespace for version-skewed games (a
-     * dynamic `import()` of the manifest's `pixiModuleUrl`) — absent means
-     * "mount against the host's own `pixi.js`" (no skew).
-     */
-    pixiNamespace?: () => Promise<unknown>;
-    /** DOM the game expects before boot (see `IframeReachableMultiOpts.bodyHtml`). */
-    bodyHtml?: string;
-    /**
-     * Lazily read an OPAQUE prebuilt bundle's self-contained HTML (D-W2) — the pixi
-     * twin of `IngestGame.embedHtml`. Always a lazy thunk here (no in-tree Pixi
-     * opaque-embed fixture exists yet to need a plain-string form, unlike the three
-     * side): `resolveIngest2DDescriptor` (adapter-resolver.ts) builds one that reads
-     * the declared `entryHtml` file's bytes through the `/project-game-static/`
-     * route, only when the game is actually mounted. The host runs the resolved HTML
-     * in a sandboxed iframe at the embed-only floor (Tier 0-1),
-     * `mountIngestGame2DEmbed` (`./ingest-iframe-2d.ts`).
-     */
-    embedHtml?: () => Promise<string>;
 }
 export interface IngestMount2D {
-    /** The captured live stage Container (null if capture failed/degraded). */
-    stage: unknown | null;
+    /** The captured live stage Container. */
+    stage: unknown;
     capture: SceneCapture2DHandle;
-    embedOnly: boolean;
     setPaused(paused: boolean): void;
     dispose(): void;
 }
@@ -87,9 +20,8 @@ export interface IngestMount2D {
  * Mount an UNMODIFIED PixiJS game via the shared-instance capture path — the 2D
  * analog of `mountIngestGame`. Installs the render trap on the host's pixi
  * instance, runs the game's `load()`, waits for the game to render its first
- * frame (capturing its live stage), and exposes loop gating + cleanup. If capture
- * times out (pixi unreachable / bundled / mismatched), degrades to embed-only —
- * never a silent failure.
+ * frame (capturing its live stage), and exposes loop gating + cleanup. A game
+ * whose pixi the trap cannot reach never captures, and the mount FAILS by name.
  */
 export declare function mountIngestGame2D(pixiNamespace: unknown, game: IngestGame2D, opts?: {
     captureTimeoutMs?: number;

package/dist/pixi/ingest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ingest.d.ts","sourceRoot":"","sources":["../../src/pixi/ingest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEnF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9B,+DAA+D;IAC/D,IAAI,CAAC,EAAE,QAAQ,GAAG,kBAAkB,GAAG,cAAc,CAAC;IACtD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACjD;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,aAAa,EAAE,OAAO,EACtB,IAAI,EAAE,YAAY,EAClB,IAAI,GAAE;IAAE,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAO,GACvC,OAAO,CAAC,aAAa,CAAC,CA6BxB"}
+{"version":3,"file":"ingest.d.ts","sourceRoot":"","sources":["../../src/pixi/ingest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEnF,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,oBAAoB,CAAC;IAC9B,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,aAAa,EAAE,OAAO,EACtB,IAAI,EAAE,YAAY,EAClB,IAAI,GAAE;IAAE,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAO,GACvC,OAAO,CAAC,aAAa,CAAC,CAwBxB"}

package/dist/pixi/ingest.js

@@ -3,14 +3,13 @@ import { installSceneCapture2D } from './scene-capture';
  * Mount an UNMODIFIED PixiJS game via the shared-instance capture path — the 2D
  * analog of `mountIngestGame`. Installs the render trap on the host's pixi
  * instance, runs the game's `load()`, waits for the game to render its first
- * frame (capturing its live stage), and exposes loop gating + cleanup. If capture
- * times out (pixi unreachable / bundled / mismatched), degrades to embed-only —
- * never a silent failure.
+ * frame (capturing its live stage), and exposes loop gating + cleanup. A game
+ * whose pixi the trap cannot reach never captures, and the mount FAILS by name.
  */
 export async function mountIngestGame2D(pixiNamespace, game, opts = {}) {
     const capture = installSceneCapture2D(pixiNamespace);
     try {
-        await game.load?.();
+        await game.load();
     }
     catch (err) {
         capture.uninstall();
@@ -22,19 +21,12 @@ export async function mountIngestGame2D(pixiNamespace, game, opts = {}) {
         return {
             stage: rt.stage,
             capture,
-            embedOnly: false,
             setPaused: (p) => capture.setPaused(p),
             dispose: () => capture.uninstall(),
         };
     }
-    catch {
-        // Capture failed → pixi unreachable/mismatched → degrade to embed-only.
-        return {
-            stage: null,
-            capture,
-            embedOnly: true,
-            setPaused: () => { },
-            dispose: () => capture.uninstall(),
-        };
+    catch (err) {
+        capture.uninstall();
+        throw new Error(`pixi ingest: game "${game.id}" rendered no capturable frame within ${timeout}ms: ${err}`);
     }
 }

package/dist/pixi/scene-capture.d.ts

@@ -14,8 +14,8 @@
  * CRITICAL (same module-identity gatekeeper as the 3D path): the trap must be
  * installed on the SAME `pixi.js` module instance the game uses. A bundler/dev-server
  * that dedupes `pixi.js` makes an ESM game's `import 'pixi.js'` resolve to the host
- * instance, so it is trapped; a game bundling its own pixi cannot be captured this
- * way (degrade to iframe-reachable or opaque-embed tiers — see the spec).
+ * instance, so it is trapped; a game bundling its own pixi cannot be captured at
+ * all, and its mount fails by name.
  */
 /** A live Pixi runtime captured from an external PixiJS game. */
 export interface CapturedRuntime2D {

package/dist/pixi/scene-capture.js

@@ -14,8 +14,8 @@
  * CRITICAL (same module-identity gatekeeper as the 3D path): the trap must be
  * installed on the SAME `pixi.js` module instance the game uses. A bundler/dev-server
  * that dedupes `pixi.js` makes an ESM game's `import 'pixi.js'` resolve to the host
- * instance, so it is trapped; a game bundling its own pixi cannot be captured this
- * way (degrade to iframe-reachable or opaque-embed tiers — see the spec).
+ * instance, so it is trapped; a game bundling its own pixi cannot be captured at
+ * all, and its mount fails by name.
  */
 /**
  * Install the render trap on `pixiNamespace.Application.prototype.render`. Pass the

package/dist/react/use-data.d.ts

@@ -50,11 +50,16 @@ export declare function useData<T>(handle: DataHandle<T>): T;
  * this rejects with a teaching error (a shipped game could never reach the
  * route anyway — builds strip `src/tools/` entirely, §4).
  *
- * Serialization matches the editor Data panel's diff-minimal contract:
- * `"$schema"` first, 2-space indent, trailing newline. When `value` carries
- * no `"$schema"` key (the common case — `DataHandle.get()` strips it), the
- * conventional sibling reference (`./<name>.schema.json`, §2.1) is restored
- * so a tool write never silently drops VS Code validation from the file.
+ * The body is PARSED VALUES, never serialized text: the dev server's fold
+ * (`packages/editor/server/data-file-serialize.ts`) owns key order and the
+ * `"$schema"`-first diff-minimal serialization, and it must — a parsed JS
+ * object has already reindexed integer-like keys ("1","2","10"), so only the
+ * server, which still has the file's raw text, can keep a one-field write a
+ * one-line diff. When `value` carries no `"$schema"` key (the common case —
+ * `DataHandle.get()` strips it), the conventional sibling reference
+ * (`./<name>.schema.json`, §2.1) is restored so a tool write never silently
+ * drops VS Code validation from the file. Undo for data writes is git;
+ * every accepted write is recorded server-side as a project revision.
  */
 export declare function writeData(projectRelativePath: string, value: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=use-data.d.ts.map

package/dist/react/use-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-data.d.ts","sourceRoot":"","sources":["../../src/react/use-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAKnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,SAAS,CAC7B,mBAAmB,EAAE,MAAM,EAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC,CAqDf"}
+{"version":3,"file":"use-data.d.ts","sourceRoot":"","sources":["../../src/react/use-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAKnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,SAAS,CAC7B,mBAAmB,EAAE,MAAM,EAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC,CA2Cf"}

package/dist/react/use-data.js

@@ -52,11 +52,16 @@ export function useData(handle) {
  * this rejects with a teaching error (a shipped game could never reach the
  * route anyway — builds strip `src/tools/` entirely, §4).
  *
- * Serialization matches the editor Data panel's diff-minimal contract:
- * `"$schema"` first, 2-space indent, trailing newline. When `value` carries
- * no `"$schema"` key (the common case — `DataHandle.get()` strips it), the
- * conventional sibling reference (`./<name>.schema.json`, §2.1) is restored
- * so a tool write never silently drops VS Code validation from the file.
+ * The body is PARSED VALUES, never serialized text: the dev server's fold
+ * (`packages/editor/server/data-file-serialize.ts`) owns key order and the
+ * `"$schema"`-first diff-minimal serialization, and it must — a parsed JS
+ * object has already reindexed integer-like keys ("1","2","10"), so only the
+ * server, which still has the file's raw text, can keep a one-field write a
+ * one-line diff. When `value` carries no `"$schema"` key (the common case —
+ * `DataHandle.get()` strips it), the conventional sibling reference
+ * (`./<name>.schema.json`, §2.1) is restored so a tool write never silently
+ * drops VS Code validation from the file. Undo for data writes is git;
+ * every accepted write is recorded server-side as a project revision.
  */
 export async function writeData(projectRelativePath, value) {
     if (!projectRelativePath.startsWith('src/data/') || !projectRelativePath.endsWith('.data.json')) {
@@ -64,27 +69,22 @@ export async function writeData(projectRelativePath, value) {
             'src/data/**/*.data.json, addressed project-relative, ' +
             "e.g. writeData('src/data/tuning.data.json', next).");
     }
-    // "$schema" first for minimal diffs; restore the conventional sibling
-    // reference when the caller's object (typically `{ ...handle.get() }`,
-    // which never carries it) omits the line.
+    // Restore the conventional sibling "$schema" reference when the caller's
+    // object (typically `{ ...handle.get() }`, which never carries it) omits
+    // it; the server fold serializes it first.
     const { $schema, ...rest } = value;
     const schemaRef = $schema ??
         `./${projectRelativePath
             .split('/')
             .pop()
             ?.replace(/\.data\.json$/, '')}.schema.json`;
-    const content = `${JSON.stringify({ $schema: schemaRef, ...rest }, null, 2)}\n`;
-    const transactionalWriter = globalThis.__vgaiHistoryWriteData;
-    if (transactionalWriter) {
-        await transactionalWriter(projectRelativePath, content);
-        return;
-    }
+    const values = { $schema: schemaRef, ...rest };
     let res;
     try {
         res = await fetch('/__editor/data-file', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ path: projectRelativePath, content }),
+            body: JSON.stringify({ path: projectRelativePath, values }),
         });
     }
     catch (err) {

package/dist/render/viewport-shading.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 /** Temporary developer-facing shading modes. These never become scene data. */
-export type ViewportShadingMode = 'solid' | 'unlit' | 'wireframe' | 'normals' | 'overdraw';
+export type ViewportShadingMode = 'solid' | 'clay' | 'unlit' | 'wireframe' | 'normals' | 'overdraw';
 /**
  * Applies a render-only material view and restores every native material in a
  * `finally` block. Gameplay and authoring therefore always observe the real

package/dist/render/viewport-shading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viewport-shading.d.ts","sourceRoot":"","sources":["../../src/render/viewport-shading.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC;AAoB3F;;;;GAIG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2C;IACpE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CASvB;IAEH,MAAM,CACJ,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,MAAM,IAAI,EAChB,OAAO,GAAE,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,KAAK,OAAoB,GAClD,IAAI;IA0BP,OAAO,IAAI,IAAI;IAUf,OAAO,CAAC,YAAY;CAgCrB"}
+{"version":3,"file":"viewport-shading.d.ts","sourceRoot":"","sources":["../../src/render/viewport-shading.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC;AAqBpG;;;;GAIG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2C;IACpE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CASvB;IAEH,MAAM,CACJ,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,MAAM,IAAI,EAChB,OAAO,GAAE,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,KAAK,OAAoB,GAClD,IAAI;IA0BP,OAAO,IAAI,IAAI;IAWf,OAAO,CAAC,YAAY;CA6CrB"}