@vgai/engine 0.5.11 → 0.5.13

package/dist/adapter/ingest/scene-capture.js

@@ -69,6 +69,8 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
     const REAL = Symbol('vgai.realRender');
     let captured = null;
     let drawCount = 0;
+    /** Set post-capture by the host; see {@link SceneCaptureHandle.setRenderPassHooks}. */
+    let renderPassHooks = null;
     const waiters = [];
     // Preserve any descriptor already on the prototype so uninstall can restore it.
     const priorDescriptor = Object.getOwnPropertyDescriptor(proto, 'render');
@@ -101,6 +103,26 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
             };
         },
     });
+    /**
+     * Call the renderer's own real `render`, bracketed by the render-pass hooks
+     * when this IS the captured game's renderer (see `setRenderPassHooks`).
+     * `after` runs in a `finally`, so a throwing game frame still restores
+     * whatever the hook armed.
+     */
+    function forwardRender(self, args) {
+        const real = self[REAL];
+        const hooks = renderPassHooks;
+        if (hooks === null || !captured || self !== captured.renderer) {
+            return real.apply(self, args);
+        }
+        hooks.before();
+        try {
+            return real.apply(self, args);
+        }
+        finally {
+            hooks.after();
+        }
+    }
     Object.defineProperty(proto, 'render', {
         configurable: true,
         set(fn) {
@@ -123,13 +145,11 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
                     drawCount++;
                 // Never capture a scene the HOST owns. The trap sits on the shared
                 // `WebGLRenderer.prototype`, so the editor's own viewport renders
-                // arrive here too — and when a game bundles its own MISMATCHED three
-                // (the case this whole degrade-to-embed-only path exists for), the
-                // editor's scene is then the only thing that ever reaches the trap.
+                // arrive here too — and when a game bundles its own MISMATCHED three,
+                // the editor's scene is then the only thing that ever reaches the trap.
                 // It was duly "captured" as the game: the editor got a hierarchy of
                 // its own GridHelper, BatchedRenderer and viewport lights presented as
-                // the ingested game's content, and `captureFailed` — the signal the
-                // whole graceful-degradation contract is built on — never fired.
+                // the ingested game's content, and the mount reported success.
                 // Whether that happened at all came down to whether the editor
                 // rendered a frame inside the game's capture window, so the same
                 // session could pass or fail on timing alone.
@@ -143,8 +163,7 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
                     for (const resolve of waiters.splice(0))
                         resolve(captured);
                 }
-                // Forward to the renderer's real render with the original args.
-                return self[REAL].apply(self, args);
+                return forwardRender(self, args);
             };
         },
     });
@@ -189,6 +208,9 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
         getDrawCount() {
             return drawCount;
         },
+        setRenderPassHooks(hooks) {
+            renderPassHooks = hooks;
+        },
         getAnimationLoop(renderer) {
             return loopCallbacks.get(renderer) ?? null;
         },

package/dist/adapter/ingest/structural-ids.d.ts

@@ -45,7 +45,7 @@ export interface StructuralIdWalk {
  * tree re-binds the same ids to the same objects.
  *
  * EDITOR FURNITURE IS EXCLUDED, and that exclusion is load-bearing rather than
- * cosmetic. In ingest mode the editor adds its grid, lights, particle
+ * cosmetic. On an ingest root the editor adds its grid, lights, particle
  * BatchedRenderer and TransformControls gizmo to the GAME'S OWN scene, and
  * they arrive asynchronously — some before the walk, some after. Indexing them
  * made a game object's path depend on how much editor furniture happened to be

package/dist/adapter/ingest/structural-ids.js

@@ -25,7 +25,7 @@ export const CAMERA_ID = 'ingest:camera';
  * The editor parks its OWN objects — grid, its two lights, the particle
  * BatchedRenderer, every TransformControls/gizmo helper — on layer 31
  * (`packages/editor/src/editor-layers.ts`'s `EDITOR_LAYER`) so the game camera
- * never sees them. In ingest mode those objects are added to the GAME'S OWN
+ * never sees them. On an ingest root those objects are added to the GAME'S OWN
  * scene, which is the same tree this walk indexes.
  */
 const EDITOR_ONLY_LAYER_MASK = 1 << 31;
@@ -60,7 +60,7 @@ export function colorMaterialOf(o) {
  * tree re-binds the same ids to the same objects.
  *
  * EDITOR FURNITURE IS EXCLUDED, and that exclusion is load-bearing rather than
- * cosmetic. In ingest mode the editor adds its grid, lights, particle
+ * cosmetic. On an ingest root the editor adds its grid, lights, particle
  * BatchedRenderer and TransformControls gizmo to the GAME'S OWN scene, and
  * they arrive asynchronously — some before the walk, some after. Indexing them
  * made a game object's path depend on how much editor furniture happened to be

package/dist/adapter/reflection-probe.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Format-neutral live reflection-probe mark.
+ *
+ * A project-owned scene component writes this mark onto the Object3D it
+ * returns. The renderer capability owns capture and material integration; the
+ * editor only reads the mark to draw ordinary probe gizmos and expose the
+ * capture command/status. Authored truth remains the component's JSX props —
+ * this is a live adapter seam, not another document format.
+ */
+import type * as THREE from 'three';
+export type ReflectionProbeShape = 'box' | 'sphere';
+export type ReflectionProbeCaptureMode = 'on-change' | 'manual' | 'realtime';
+export type ReflectionProbeCaptureStatus = 'idle' | 'queued' | 'capturing' | 'ready' | 'error';
+export interface ReflectionProbeConfig {
+    readonly shape: ReflectionProbeShape;
+    /** Full local-space box dimensions. */
+    readonly size: readonly [number, number, number];
+    /** Local-space sphere radius when `shape === 'sphere'`. */
+    readonly radius: number;
+    /** Local-space distance over which this probe fades at its boundary. */
+    readonly blendDistance: number;
+    /** Larger values win before equal-priority probes blend. */
+    readonly priority: number;
+    readonly intensity: number;
+    readonly parallaxProjection: boolean;
+    /** Full local-space projection-box dimensions. */
+    readonly parallaxSize: readonly [number, number, number];
+    readonly parallaxOffset: readonly [number, number, number];
+    readonly captureOffset: readonly [number, number, number];
+    readonly captureMode: ReflectionProbeCaptureMode;
+    readonly resolution: number;
+    readonly near: number;
+    readonly far: number;
+    readonly cullMask: number;
+    readonly captureShadows: boolean;
+}
+export interface ReflectionProbeSnapshot {
+    readonly status: ReflectionProbeCaptureStatus;
+    /** Monotonic browser time from `performance.now()`, or null before capture. */
+    readonly lastCapturedAt: number | null;
+    readonly message?: string;
+}
+export interface ReflectionProbeMark {
+    readonly config: ReflectionProbeConfig;
+    readonly revision: number;
+    recapture(): void;
+    getSnapshot(): ReflectionProbeSnapshot;
+    subscribe(listener: () => void): () => void;
+}
+export declare function reflectionProbeOf(object: THREE.Object3D | null | undefined): ReflectionProbeMark | null;
+export declare function setReflectionProbeMark(object: THREE.Object3D, mark: ReflectionProbeMark): void;
+export declare function clearReflectionProbeMark(object: THREE.Object3D): void;
+//# sourceMappingURL=reflection-probe.d.ts.map

package/dist/adapter/reflection-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflection-probe.d.ts","sourceRoot":"","sources":["../../src/adapter/reflection-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAGpC,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,QAAQ,CAAC;AACpD,MAAM,MAAM,0BAA0B,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;AAC7E,MAAM,MAAM,4BAA4B,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,OAAO,GAAG,OAAO,CAAC;AAE/F,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC;IACrC,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACjD,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,kDAAkD;IAClD,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD,QAAQ,CAAC,cAAc,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3D,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1D,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAAC;IACjD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,EAAE,4BAA4B,CAAC;IAC9C,+EAA+E;IAC/E,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,SAAS,IAAI,IAAI,CAAC;IAClB,WAAW,IAAI,uBAAuB,CAAC;IACvC,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,GACxC,mBAAmB,GAAG,IAAI,CAS5B;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAE9F;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAErE"}

package/dist/adapter/reflection-probe.js

@@ -0,0 +1,18 @@
+import { deleteUserData, getUserData, setUserData } from '../ecs/user-data';
+export function reflectionProbeOf(object) {
+    const candidate = getUserData(object, 'reflectionProbe');
+    if (!candidate || typeof candidate !== 'object')
+        return null;
+    const mark = candidate;
+    return mark.config &&
+        typeof mark.recapture === 'function' &&
+        typeof mark.getSnapshot === 'function'
+        ? candidate
+        : null;
+}
+export function setReflectionProbeMark(object, mark) {
+    setUserData(object, 'reflectionProbe', mark);
+}
+export function clearReflectionProbeMark(object) {
+    deleteUserData(object, 'reflectionProbe');
+}

package/dist/asset-formats/index.d.ts

@@ -1,14 +1,11 @@
 /**
- * The engine's remaining authored asset formats and descriptor schemas.
+ * The engine's runtime descriptor schemas.
  *
  * WO-8 deleted the `.vscn.json` scene format and everything under
  * `engine/src/scene/`. What survived is here, and each module is here because a
  * real runtime reader still consumes it:
  *
- * - `material.ts`   — the `.mat.json` shared-material format (`parseMaterialFile`)
- *                     plus the inline material descriptor `render/material-factory.ts` reads
- * - `instances.ts`   — the `.instances.json` transform format (`parseInstancesFile`),
- *                     read by `render/instance-mesh.ts`
+ * - `material.ts`   — the inline material descriptor `render/material-factory.ts` reads
  * - `mesh.ts`        — the geometry descriptor `render/material-factory.ts`'s `createGeometry` reads
  * - `light.ts` / `camera.ts` — the descriptors `render/light-camera-factory.ts` reads
  * - `collider.ts`    — the descriptor `physics/collider-dimensions.ts` and the editor's
@@ -28,15 +25,12 @@ export type { CameraDescriptor } from './camera';
 export { CameraDescriptorSchema } from './camera';
 export type { ColliderDescriptor } from './collider';
 export { ColliderDescriptorSchema } from './collider';
-export type { InstancesFile } from './instances';
-export { InstancesFileSchema } from './instances';
 export type { LightDescriptor } from './light';
 export { LightDescriptorSchema } from './light';
-export type { MaterialDescriptor, MaterialFile } from './material';
-export { MaterialDescriptorSchema, MaterialFileSchema } from './material';
+export type { MaterialDescriptor } from './material';
+export { MaterialDescriptorSchema } from './material';
 export type { MeshDescriptor } from './mesh';
 export { MeshDescriptorSchema } from './mesh';
-export { parseInstancesFile, parseMaterialFile } from './parse';
 export type { ParticlesDescriptor } from './particles';
 export { ParticlesDescriptorSchema } from './particles';
 export type { PostProcessingDescriptor, RenderEnvironment, ToneMappingDescriptor, } from './render-env';

package/dist/asset-formats/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/asset-formats/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAClD,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC1E,YAAY,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAChE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EACV,wBAAwB,EACxB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/asset-formats/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAClD,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAC9C,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EACV,wBAAwB,EACxB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC"}

package/dist/asset-formats/index.js

@@ -1,14 +1,11 @@
 /**
- * The engine's remaining authored asset formats and descriptor schemas.
+ * The engine's runtime descriptor schemas.
  *
  * WO-8 deleted the `.vscn.json` scene format and everything under
  * `engine/src/scene/`. What survived is here, and each module is here because a
  * real runtime reader still consumes it:
  *
- * - `material.ts`   — the `.mat.json` shared-material format (`parseMaterialFile`)
- *                     plus the inline material descriptor `render/material-factory.ts` reads
- * - `instances.ts`   — the `.instances.json` transform format (`parseInstancesFile`),
- *                     read by `render/instance-mesh.ts`
+ * - `material.ts`   — the inline material descriptor `render/material-factory.ts` reads
  * - `mesh.ts`        — the geometry descriptor `render/material-factory.ts`'s `createGeometry` reads
  * - `light.ts` / `camera.ts` — the descriptors `render/light-camera-factory.ts` reads
  * - `collider.ts`    — the descriptor `physics/collider-dimensions.ts` and the editor's
@@ -26,11 +23,9 @@
  */
 export { CameraDescriptorSchema } from './camera';
 export { ColliderDescriptorSchema } from './collider';
-export { InstancesFileSchema } from './instances';
 export { LightDescriptorSchema } from './light';
-export { MaterialDescriptorSchema, MaterialFileSchema } from './material';
+export { MaterialDescriptorSchema } from './material';
 export { MeshDescriptorSchema } from './mesh';
-export { parseInstancesFile, parseMaterialFile } from './parse';
 export { ParticlesDescriptorSchema } from './particles';
 export { PostProcessingDescriptorSchema, RenderEnvironmentSchema, ToneMappingDescriptorSchema, } from './render-env';
 export { QuatSchema, TransformSchema, Vec3Schema } from './tuples';

package/dist/asset-formats/material.d.ts

@@ -60,70 +60,4 @@ export declare const MaterialDescriptorSchema: z.ZodObject<{
     displacementBias: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type MaterialDescriptor = z.infer<typeof MaterialDescriptorSchema>;
-/** .mat.json file format for shared/reusable material assets. */
-export declare const MaterialFileSchema: z.ZodObject<{
-    version: z.ZodNumber;
-    name: z.ZodString;
-    material: z.ZodObject<{
-        type: z.ZodEnum<{
-            standard: "standard";
-            physical: "physical";
-            basic: "basic";
-            toon: "toon";
-        }>;
-        color: z.ZodOptional<z.ZodString>;
-        metalness: z.ZodOptional<z.ZodNumber>;
-        roughness: z.ZodOptional<z.ZodNumber>;
-        map: z.ZodOptional<z.ZodString>;
-        normalMap: z.ZodOptional<z.ZodString>;
-        emissive: z.ZodOptional<z.ZodString>;
-        emissiveIntensity: z.ZodOptional<z.ZodNumber>;
-        emissiveMap: z.ZodOptional<z.ZodString>;
-        aoMap: z.ZodOptional<z.ZodString>;
-        lightMap: z.ZodOptional<z.ZodString>;
-        lightMapIntensity: z.ZodOptional<z.ZodNumber>;
-        roughnessMap: z.ZodOptional<z.ZodString>;
-        metalnessMap: z.ZodOptional<z.ZodString>;
-        opacity: z.ZodOptional<z.ZodNumber>;
-        transparent: z.ZodOptional<z.ZodBoolean>;
-        side: z.ZodOptional<z.ZodEnum<{
-            front: "front";
-            back: "back";
-            double: "double";
-        }>>;
-        flatShading: z.ZodOptional<z.ZodBoolean>;
-        clearcoat: z.ZodOptional<z.ZodObject<{
-            clearcoat: z.ZodNumber;
-            clearcoatRoughness: z.ZodOptional<z.ZodNumber>;
-            clearcoatMap: z.ZodOptional<z.ZodString>;
-            clearcoatRoughnessMap: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        transmission: z.ZodOptional<z.ZodObject<{
-            transmission: z.ZodNumber;
-            ior: z.ZodOptional<z.ZodNumber>;
-            thickness: z.ZodOptional<z.ZodNumber>;
-            attenuationColor: z.ZodOptional<z.ZodString>;
-            attenuationDistance: z.ZodOptional<z.ZodNumber>;
-            transmissionMap: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        sheen: z.ZodOptional<z.ZodObject<{
-            sheen: z.ZodNumber;
-            sheenColor: z.ZodOptional<z.ZodString>;
-            sheenRoughness: z.ZodOptional<z.ZodNumber>;
-            sheenColorMap: z.ZodOptional<z.ZodString>;
-            sheenRoughnessMap: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        iridescence: z.ZodOptional<z.ZodObject<{
-            iridescence: z.ZodNumber;
-            iridescenceIOR: z.ZodOptional<z.ZodNumber>;
-            iridescenceThicknessRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
-            iridescenceMap: z.ZodOptional<z.ZodString>;
-            iridescenceThicknessMap: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        displacementMap: z.ZodOptional<z.ZodString>;
-        displacementScale: z.ZodOptional<z.ZodNumber>;
-        displacementBias: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>;
-}, z.core.$strip>;
-export type MaterialFile = z.infer<typeof MaterialFileSchema>;
 //# sourceMappingURL=material.d.ts.map

package/dist/asset-formats/material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../src/asset-formats/material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwFxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,iEAAiE;AACjE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMsB,CAAC;AAEtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../src/asset-formats/material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwFxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/asset-formats/material.js

@@ -78,11 +78,3 @@ const MaterialDescriptorObjectSchema = z
 })
     .strict();
 export const MaterialDescriptorSchema = MaterialDescriptorObjectSchema.describe('Material appearance properties');
-/** .mat.json file format for shared/reusable material assets. */
-export const MaterialFileSchema = z
-    .object({
-    version: z.number().describe('File format version'),
-    name: z.string().describe('Human-readable material name'),
-    material: MaterialDescriptorSchema.describe('Material definition'),
-})
-    .describe('Shared material asset file (.mat.json)');

package/dist/asset-formats/mesh.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare const MeshDescriptorSchema: z.ZodObject<{
     type: z.ZodEnum<{
         box: "box";
-        capsule: "capsule";
         sphere: "sphere";
+        capsule: "capsule";
         plane: "plane";
         cylinder: "cylinder";
         gltf: "gltf";
@@ -12,7 +12,6 @@ export declare const MeshDescriptorSchema: z.ZodObject<{
     args: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     src: z.ZodOptional<z.ZodString>;
     node: z.ZodOptional<z.ZodString>;
-    instances: z.ZodOptional<z.ZodString>;
     lod: z.ZodOptional<z.ZodArray<z.ZodObject<{
         distance: z.ZodNumber;
         node: z.ZodString;

package/dist/asset-formats/mesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/asset-formats/mesh.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoExB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;kBAoBM,CAAC;AAExC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/asset-formats/mesh.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2DxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;kBAgBM,CAAC;AAExC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/asset-formats/mesh.js

@@ -21,13 +21,6 @@ const MeshDescriptorBase = z
         'Only meaningful with type: "gltf". CONSTRAINT: a skinned/animated node cannot be ' +
         'lifted out of its armature — if the named node is a SkinnedMesh (or contains one), ' +
         'resolving it throws (degrade loudly, not silently).'),
-    instances: z
-        .string()
-        .optional()
-        .describe('Path to an instance-transform asset (.instances.json: an array of ' +
-        '[posX,posY,posZ, quatX,quatY,quatZ,quatW, scaleX,scaleY,scaleZ] tuples). Renders one ' +
-        'THREE.InstancedMesh (one draw call). Bulk transform data is referenced as an asset, ' +
-        'never inlined — keeps the document thin.'),
     lod: z
         .array(z.object({
         distance: z
@@ -43,7 +36,7 @@ const MeshDescriptorBase = z
         .optional()
         .describe('Per-entity Level-of-Detail: distance-keyed glTF sub-nodes swapped by camera distance ' +
         '(THREE.LOD). gltf-only. Gated by the environment.rendering.lod master toggle — when ' +
-        'off, only the closest level renders. Cannot combine with node/instances.'),
+        'off, only the closest level renders. Cannot combine with node.'),
 })
     .strict();
 export const MeshDescriptorSchema = MeshDescriptorBase.refine((m) => (m.type !== 'gltf' && m.type !== 'splat') || m.src != null, {
@@ -55,10 +48,7 @@ export const MeshDescriptorSchema = MeshDescriptorBase.refine((m) => (m.type !==
     .refine((m) => m.lod == null || m.type === 'gltf', {
     message: "Mesh 'lod' is only meaningful with type: 'gltf'",
 })
-    .refine((m) => m.instances == null || m.type !== 'splat', {
-    message: "Mesh 'instances' is not supported with type: 'splat'",
-})
-    .refine((m) => !(m.lod && (m.node || m.instances)), {
-    message: "Mesh 'lod' cannot combine with 'node'/'instances' — LOD is the multi-level form of a node ref",
+    .refine((m) => !(m.lod && m.node), {
+    message: "Mesh 'lod' cannot combine with 'node' — LOD is the multi-level form of a node ref",
 })
     .describe('Mesh geometry definition');

package/dist/asset-formats/render-env.d.ts

@@ -12,9 +12,9 @@
 import { z } from 'zod';
 export declare const ToneMappingDescriptorSchema: z.ZodObject<{
     mode: z.ZodOptional<z.ZodEnum<{
-        aces: "aces";
         none: "none";
         linear: "linear";
+        aces: "aces";
         reinhard: "reinhard";
         cineon: "cineon";
         agx: "agx";
@@ -199,9 +199,9 @@ export type PostProcessingDescriptor = z.infer<typeof PostProcessingDescriptorSc
 export declare const RenderEnvironmentSchema: z.ZodObject<{
     toneMapping: z.ZodOptional<z.ZodObject<{
         mode: z.ZodOptional<z.ZodEnum<{
-            aces: "aces";
             none: "none";
             linear: "linear";
+            aces: "aces";
             reinhard: "reinhard";
             cineon: "cineon";
             agx: "agx";

package/dist/asset-parse-error.d.ts

@@ -4,14 +4,13 @@
  * Every authored asset format the engine validates at fetch time throws this
  * when Zod rejects the payload, naming the offending file (T4.6). It lives
  * here — beside `loader.ts`/`assets.ts` — rather than inside a format module so
- * every caller (the `.mat.json` parser, the input-map loader in
- * `input/input-manager.ts`) does not have to reach into the format half for
- * it.
+ * every caller (currently the input-map loader in `input/input-manager.ts`)
+ * does not have to reach into an unrelated subsystem for it.
  *
  * It was called `SceneParseError` until WO-9 task #6. The extraction that gave
  * this file its name deliberately deferred the class rename ("extraction, not
- * redesign"); with `.vscn` gone the old name described nothing — a `.mat.json`
- * or `.inputmap.json` failure is not a scene failure — so the class and its
+ * redesign"); with `.vscn` gone the old name described nothing — an
+ * `.inputmap.json` failure is not a scene failure — so the class and its
  * message header now say `asset`.
  */
 import type { ZodIssue } from 'zod';

package/dist/asset-parse-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-parse-error.d.ts","sourceRoot":"","sources":["../src/asset-parse-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC;IAC5B,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE3B,MAAM,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM;CAQlD"}
+{"version":3,"file":"asset-parse-error.d.ts","sourceRoot":"","sources":["../src/asset-parse-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC;IAC5B,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE3B,MAAM,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM;CAQlD"}

package/dist/asset-parse-error.js

@@ -4,14 +4,13 @@
  * Every authored asset format the engine validates at fetch time throws this
  * when Zod rejects the payload, naming the offending file (T4.6). It lives
  * here — beside `loader.ts`/`assets.ts` — rather than inside a format module so
- * every caller (the `.mat.json` parser, the input-map loader in
- * `input/input-manager.ts`) does not have to reach into the format half for
- * it.
+ * every caller (currently the input-map loader in `input/input-manager.ts`)
+ * does not have to reach into an unrelated subsystem for it.
  *
  * It was called `SceneParseError` until WO-9 task #6. The extraction that gave
  * this file its name deliberately deferred the class rename ("extraction, not
- * redesign"); with `.vscn` gone the old name described nothing — a `.mat.json`
- * or `.inputmap.json` failure is not a scene failure — so the class and its
+ * redesign"); with `.vscn` gone the old name described nothing — an
+ * `.inputmap.json` failure is not a scene failure — so the class and its
  * message header now say `asset`.
  */
 export class AssetParseError extends Error {

package/dist/config.d.ts

@@ -3,7 +3,14 @@
  * evaluated. The package build emits this entry as ordinary JavaScript, so
  * project config remains package-native without asking Node to execute raw
  * TypeScript or reach into an adjacent checkout.
+ *
+ * A project's `*.schema.ts` is reached from `vite.config.ts` itself (through
+ * `./src/data/assets`, so the dangling-ref gate can run the real Zod), which
+ * is why every schema-time field factory belongs here: `dataRef` and `curve`
+ * are both authored in a schema, and a schema module must stay loadable by
+ * plain Node.
  */
+export { type CurveAxes, type CurvePoint, type CurveValue, curve, sampleCurve, } from './data/curve';
 export { type DataRef, dataRef, getRef } from './data/data-ref';
 export { type VgaiDataCheckOptions, vgaiDataCheck } from './data/vite-plugin-data';
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,KAAK,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,KAAK,oBAAoB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EACL,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,EACL,WAAW,GACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,KAAK,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,KAAK,oBAAoB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/config.js

@@ -3,6 +3,13 @@
  * evaluated. The package build emits this entry as ordinary JavaScript, so
  * project config remains package-native without asking Node to execute raw
  * TypeScript or reach into an adjacent checkout.
+ *
+ * A project's `*.schema.ts` is reached from `vite.config.ts` itself (through
+ * `./src/data/assets`, so the dangling-ref gate can run the real Zod), which
+ * is why every schema-time field factory belongs here: `dataRef` and `curve`
+ * are both authored in a schema, and a schema module must stay loadable by
+ * plain Node.
  */
+export { curve, sampleCurve, } from './data/curve';
 export { dataRef, getRef } from './data/data-ref';
 export { vgaiDataCheck } from './data/vite-plugin-data';

package/dist/data/curve.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Curve FIELDS in data assets — a response curve a designer shapes, living
+ * inside an ordinary `.data.json` like any other tunable value.
+ *
+ * A curve is a FIELD TYPE, never a file type: there is no `.curve.json`, no
+ * curve asset class, no baked LUT, and no document. `curve(axes)` is a real
+ * Zod schema you drop into a `*.schema.ts` beside `z.number()`, so the value
+ * lives in the same data file, hot-swaps through the same `defineData` handle,
+ * and is edited by the same Data panel that edits everything else.
+ *
+ * The JSON a designer (or an agent) reads and writes:
+ *
+ * ```json
+ * { "interpolation": "smooth",
+ *   "points": [{ "x": 0, "y": 1 }, { "x": 12, "y": 0.85 }, { "x": 30, "y": 0.2 }] }
+ * ```
+ *
+ * TWO MODES, NO TANGENTS. `linear` and `smooth`, and nothing else. Per-key
+ * tangent handles would double the JSON, make it unreadable to an agent, and
+ * hand every author a way to make a curve overshoot its own points. Smoothness
+ * is DERIVED instead — Fritsch–Carlson monotone cubic tangents, computed from
+ * the points themselves — so the interpolant is guaranteed to stay inside each
+ * segment's `[yLeft, yRight]` band. "Shape it by moving points" is the whole
+ * authoring model.
+ *
+ * RUNG AUDIT (recorded decision, 2026-08-14): no npm dependency. The candidate
+ * packages (`monotone-cubic-spline` and its siblings) are unmaintained
+ * micro-packages, and d3's `curveMonotoneX` is an SVG PATH GENERATOR — it
+ * draws, it does not sample `y` at an `x`. What we need is ~40 lines of
+ * well-known numerics with no API surface, so it is written here.
+ *
+ * `sampleCurve` is the entire runtime: a pure function, no class, no cache
+ * object, no "curve system". Game code calls it every frame from its own
+ * update, the same way it reads any other tuning value.
+ */
+import { z } from 'zod';
+/** One authored key: a `y` value at an `x` position. No tangents — see above. */
+export interface CurvePoint {
+    x: number;
+    y: number;
+}
+/** A curve field's value, exactly as it sits in the `.data.json`. */
+export interface CurveValue {
+    interpolation: 'linear' | 'smooth';
+    points: CurvePoint[];
+}
+/**
+ * The curve's DOMAIN, declared by the engineer in the schema (never by the
+ * data): what the axes mean and how far they run. The editor draws its rails
+ * from this and clamps every drag to it; the schema rejects a point outside
+ * it.
+ */
+export interface CurveAxes {
+    x: {
+        min: number;
+        max: number;
+        label?: string;
+    };
+    y: {
+        min: number;
+        max: number;
+        label?: string;
+    };
+}
+/**
+ * A Zod schema for a data-asset FIELD holding a response curve. Use it in a
+ * `.schema.ts` exactly like any other field:
+ *
+ * ```ts
+ * export const TuningSchema = z.object({
+ *   spawnRate: z.number().min(0).max(10).default(1),
+ *   difficultyRamp: curve({
+ *     x: { min: 0, max: 300, label: 'Sim time (s)' },
+ *     y: { min: 0, max: 2, label: 'Spawn multiplier' },
+ *   }).describe('How hard the game leans on the player as the round runs.'),
+ * });
+ * ```
+ *
+ * The schema is STRICT (an unrecognized key is an error, never a silent
+ * strip), demands at least two points, and enforces strictly-increasing `x`
+ * with every point inside the declared axes — each with a message that names
+ * the fix rather than the rule.
+ *
+ * The emitted JSON Schema (`toDataJsonSchema`) carries
+ * `"x-vgai-curve": axes` — a Zod `.meta()`, which survives `z.toJSONSchema`
+ * including inside a table's `additionalProperties` row schema, exactly the
+ * way `dataRef`'s `"x-vgai-ref"` does. That marker is what makes the editor's
+ * Data panel render a curve EDITOR instead of a raw-JSON cell, with no emitter
+ * changes anywhere.
+ */
+export declare function curve(axes: CurveAxes): z.ZodType<CurveValue>;
+/**
+ * Read a curve field's declared axes back off a LIVE Zod schema (as opposed to
+ * the emitted JSON Schema, which the editor's Data panel reads instead).
+ *
+ * This is the dev-menu capability's detection door: it derives its rows by
+ * walking the game's own `TuningSchema` object, so it needs the axes from the
+ * schema in hand. Wrappers (`.optional()`, `.default(…)`, `.describe(…)` chains
+ * that re-wrap) hide the metadata behind an inner type, so a bounded unwrap
+ * walks down to it.
+ */
+export declare function curveAxesOf(schema: z.ZodType): CurveAxes | undefined;
+/**
+ * The curve's value at `x` — the whole runtime API.
+ *
+ * Read it every frame from the game's own update, the way every other data
+ * value is read (`tuning.get()` then sample); never precompute a table, and
+ * never hold the result across frames — an edit to the `.data.json` hot-swaps
+ * underneath you and that is the point.
+ *
+ * Outside `[first.x, last.x]` the value CLAMPS to the nearest endpoint: a
+ * curve declares what it knows about, and extrapolating past it would invent
+ * numbers nobody authored.
+ */
+export declare function sampleCurve(value: CurveValue, x: number): number;
+//# sourceMappingURL=curve.d.ts.map

package/dist/data/curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve.d.ts","sourceRoot":"","sources":["../../src/data/curve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,iFAAiF;AACjF,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,qEAAqE;AACrE,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACnC,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACjD;AA0CD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAwB5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,SAAS,GAAG,SAAS,CASpE;AAoDD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA0BhE"}