@vgai/engine 0.2.0 → 0.3.0

package/dist/world2d/schema/sprite.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { Vec2Schema } from './tuples2d';
+/**
+ * `sprite` authored section — engine-owned 2D sprite data, NOT a `PIXI.Sprite`.
+ *
+ * Per ARCHITECTURE.md §Render Surfaces: authored data says `sprite`, and a runtime
+ * adapter instantiates it onto the appropriate backend (here, a `PIXI.Sprite` on
+ * the world2d surface). A 1x1 white texture is used when `texture` is omitted, so a
+ * tinted rectangle sprite needs no asset.
+ */
+export const SpriteSchema = z
+    .object({
+    texture: z
+        .string()
+        .optional()
+        .describe('Texture asset URL (loaded via PIXI.Assets). Omit for a tintable 1x1 white texture'),
+    frame: z
+        .string()
+        .optional()
+        .describe('Spritesheet frame/sub-texture name when `texture` is a spritesheet atlas'),
+    anchor: Vec2Schema.optional().describe('Normalized anchor [x, y] (0..1). Default [0.5, 0.5]'),
+    tint: z
+        .string()
+        .optional()
+        .describe("Tint color as hex string (e.g. '#ff8800'). Default white"),
+    alpha: z.number().min(0).max(1).optional().describe('Opacity 0..1. Default 1'),
+    width: z
+        .number()
+        .optional()
+        .describe('Explicit display width in pixels (overrides texture size)'),
+    height: z
+        .number()
+        .optional()
+        .describe('Explicit display height in pixels (overrides texture size)'),
+    blendMode: z
+        .enum(['normal', 'add', 'multiply', 'screen'])
+        .optional()
+        .describe('PixiJS blend mode. Default normal'),
+    interactive: z
+        .boolean()
+        .optional()
+        .describe('Enable federated pointer events (eventMode=static) so this sprite can be picked'),
+    filter: z
+        .enum(['none', 'blur', 'desaturate'])
+        .optional()
+        .describe('Apply a PixiJS filter (BlurFilter / ColorMatrix desaturate). Default none'),
+    animationFrames: z
+        .number()
+        .int()
+        .optional()
+        .describe('If set, build an AnimatedSprite cycling N generated tinted frames'),
+    fps: z.number().optional().describe('AnimatedSprite playback speed in frames/sec. Default 8'),
+})
+    .describe('2D sprite appearance (world2d). Instantiated as a PIXI.Sprite or AnimatedSprite');
+/** `text` authored section — a world-space PIXI.Text label (world-space UI). */
+export const Text2DSchema = z
+    .object({
+    text: z.string().describe('The string to display'),
+    fontSize: z.number().optional().describe('Font size in pixels. Default 24'),
+    fill: z.string().optional().describe("Text color as hex string. Default '#ffffff'"),
+    anchor: Vec2Schema.optional().describe('Normalized anchor [x, y] (0..1). Default [0.5, 0.5]'),
+})
+    .describe('2D world-space text label (world2d). Instantiated as a PIXI.Text');

package/dist/world2d/schema/tilemap.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+/**
+ * `tilemap` authored section — engine-owned 2D tilemap data (NOT a CompositeTilemap),
+ * instantiated to a `@pixi/tilemap` CompositeTilemap by the 2D spawn path. Asset-light:
+ * a `palette` of hex colors generates one tile texture each, and `tiles` is a row-major
+ * grid of palette indices. A real tileset texture/Tiled `.tmj` import is the natural
+ * extension (per the spec's optional Tiled note).
+ */
+export declare const TilemapSchema: z.ZodObject<{
+    tileSize: z.ZodNumber;
+    palette: z.ZodArray<z.ZodString>;
+    tiles: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type SceneTilemap = z.infer<typeof TilemapSchema>;
+//# sourceMappingURL=tilemap.d.ts.map

package/dist/world2d/schema/tilemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tilemap.d.ts","sourceRoot":"","sources":["../../../src/world2d/schema/tilemap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;iBAU2D,CAAC;AAEtF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/world2d/schema/tilemap.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+/**
+ * `tilemap` authored section — engine-owned 2D tilemap data (NOT a CompositeTilemap),
+ * instantiated to a `@pixi/tilemap` CompositeTilemap by the 2D spawn path. Asset-light:
+ * a `palette` of hex colors generates one tile texture each, and `tiles` is a row-major
+ * grid of palette indices. A real tileset texture/Tiled `.tmj` import is the natural
+ * extension (per the spec's optional Tiled note).
+ */
+export const TilemapSchema = z
+    .object({
+    tileSize: z.number().describe('Tile width/height in pixels'),
+    palette: z
+        .array(z.string())
+        .describe('Hex colors; one generated tile texture per entry (index → color)'),
+    tiles: z
+        .array(z.array(z.number().int()))
+        .describe('Row-major grid of palette indices (each row is an array of tile indices)'),
+})
+    .describe('2D tilemap (world2d). Instantiated as a @pixi/tilemap CompositeTilemap');

package/dist/world2d/schema/tuples2d.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+/** 2D vector as [x, y]. The world2d analog of the 3D Vec3. */
+export declare const Vec2Schema: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+export type Vec2 = z.infer<typeof Vec2Schema>;
+/**
+ * 2D local transform — the world2d analog of the 3D TransformSchema.
+ *
+ * Orientation is a single scalar `rotation` (radians, about the screen Z axis),
+ * NOT a quaternion: PixiJS display objects rotate in the plane. The runtime/editor
+ * neutral `Transform` tuple (position[3]/quaternion[4]/scale[3]) maps onto this as
+ * z = 0 and rotation about Z (see PIXI-WORLD2D-MAXIMAL-SPEC model-transform2d-section).
+ */
+export declare const Transform2DSchema: z.ZodObject<{
+    position: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    pivot: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>;
+export type SceneTransform2D = z.infer<typeof Transform2DSchema>;
+//# sourceMappingURL=tuples2d.d.ts.map

package/dist/world2d/schema/tuples2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuples2d.d.ts","sourceRoot":"","sources":["../../../src/world2d/schema/tuples2d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,8DAA8D;AAC9D,eAAO,MAAM,UAAU,8CAAoE,CAAC;AAE5F,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;iBAOwC,CAAC;AAEvE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/world2d/schema/tuples2d.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+/** 2D vector as [x, y]. The world2d analog of the 3D Vec3. */
+export const Vec2Schema = z.tuple([z.number(), z.number()]).describe('2D vector as [x, y]');
+/**
+ * 2D local transform — the world2d analog of the 3D TransformSchema.
+ *
+ * Orientation is a single scalar `rotation` (radians, about the screen Z axis),
+ * NOT a quaternion: PixiJS display objects rotate in the plane. The runtime/editor
+ * neutral `Transform` tuple (position[3]/quaternion[4]/scale[3]) maps onto this as
+ * z = 0 and rotation about Z (see PIXI-WORLD2D-MAXIMAL-SPEC model-transform2d-section).
+ */
+export const Transform2DSchema = z
+    .object({
+    position: Vec2Schema.optional().describe('Local position [x, y] in world2d pixels'),
+    rotation: z.number().optional().describe('Rotation in radians about the Z axis. Default 0'),
+    scale: Vec2Schema.optional().describe('Scale per axis [x, y]. Default [1, 1]'),
+    pivot: Vec2Schema.optional().describe('Local pivot point [x, y] (center of rotation/scale)'),
+})
+    .describe('2D local transform relative to parent (world2d surface)');

package/dist/world2d/system-adapters-2d.d.ts

@@ -0,0 +1,16 @@
+import type { Container } from 'pixi.js';
+import type { Physics2DRegistry } from './physics2d-registry';
+/**
+ * PhysicsAdapter2D — the world2d analog of the 3D PhysicsAdapter (rapier-physics-adapter).
+ * Lets the editor coordinate editing of a Rapier-2D-driven entity WITHOUT owning the
+ * simulation: report transform ownership, then freeze → commit → unfreeze so a drag
+ * sticks instead of being stomped by the next physics step.
+ */
+export interface PhysicsAdapter2D {
+    ownerOf(display: Container): 'physics' | 'none';
+    freeze(display: Container): void;
+    commit(display: Container, position: [number, number], rotation: number): void;
+    unfreeze(display: Container): void;
+}
+export declare function createPhysicsAdapter2D(physics: Physics2DRegistry): PhysicsAdapter2D;
+//# sourceMappingURL=system-adapters-2d.d.ts.map

package/dist/world2d/system-adapters-2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-adapters-2d.d.ts","sourceRoot":"","sources":["../../src/world2d/system-adapters-2d.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;IAChD,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI,CAAC;IACjC,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/E,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI,CAAC;CACpC;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAgCnF"}

package/dist/world2d/system-adapters-2d.js

@@ -0,0 +1,37 @@
+export function createPhysicsAdapter2D(physics) {
+    // Remember each frozen body's prior type so unfreeze restores it.
+    const frozen = new WeakMap();
+    return {
+        ownerOf(display) {
+            const refs = physics.get(display);
+            if (!refs)
+                return 'none';
+            return refs.body.isDynamic() || refs.body.isKinematic() ? 'physics' : 'none';
+        },
+        freeze(display) {
+            const refs = physics.get(display);
+            if (!refs)
+                return;
+            frozen.set(display, refs.body.bodyType());
+            // Kinematic-position bodies hold a pose without being driven by forces.
+            refs.body.setBodyType(2 /* KinematicPositionBased */, true);
+        },
+        commit(display, position, rotation) {
+            const refs = physics.get(display);
+            if (!refs)
+                return;
+            refs.body.setTranslation({ x: position[0], y: position[1] }, true);
+            refs.body.setRotation(rotation, true);
+        },
+        unfreeze(display) {
+            const refs = physics.get(display);
+            if (!refs)
+                return;
+            const prior = frozen.get(display);
+            if (prior !== undefined) {
+                refs.body.setBodyType(prior, true);
+                frozen.delete(display);
+            }
+        },
+    };
+}

package/dist/world2d/transform-writer-2d.d.ts

@@ -0,0 +1,16 @@
+import type { Physics2DRegistry } from './physics2d-registry';
+/**
+ * Build the single postPhysics transform writer for world2d — the ~5-line 2D
+ * analog of `createTransformWriter`.
+ *
+ * Rapier 2D reports `translation()` as `{x, y}` and `rotation()` as a SCALAR angle
+ * (radians), so the writeback is simply `display.position.set(x, y)` +
+ * `display.rotation = angle`. Scale is left untouched (Rapier carries no scale).
+ *
+ * Bodies are simulated in world2d pixel space directly (the surface uses a
+ * y-down, pixel-unit world), so no unit conversion is needed; parented entities
+ * are kept flat under the world container by the loader, mirroring the 3D writer's
+ * scene-root fast path.
+ */
+export declare function createTransformWriter2D(physics: Physics2DRegistry): () => void;
+//# sourceMappingURL=transform-writer-2d.d.ts.map

package/dist/world2d/transform-writer-2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-writer-2d.d.ts","sourceRoot":"","sources":["../../src/world2d/transform-writer-2d.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,SAC3B,IAAI,CAO1C"}

package/dist/world2d/transform-writer-2d.js

@@ -0,0 +1,22 @@
+/**
+ * Build the single postPhysics transform writer for world2d — the ~5-line 2D
+ * analog of `createTransformWriter`.
+ *
+ * Rapier 2D reports `translation()` as `{x, y}` and `rotation()` as a SCALAR angle
+ * (radians), so the writeback is simply `display.position.set(x, y)` +
+ * `display.rotation = angle`. Scale is left untouched (Rapier carries no scale).
+ *
+ * Bodies are simulated in world2d pixel space directly (the surface uses a
+ * y-down, pixel-unit world), so no unit conversion is needed; parented entities
+ * are kept flat under the world container by the loader, mirroring the 3D writer's
+ * scene-root fast path.
+ */
+export function createTransformWriter2D(physics) {
+    return function writeTransforms2D() {
+        for (const [display, { body }] of physics.entries()) {
+            const t = body.translation();
+            display.position.set(t.x, t.y);
+            display.rotation = body.rotation();
+        }
+    };
+}

package/dist/world2d/types.d.ts

@@ -0,0 +1,53 @@
+import type RAPIER from '@dimforge/rapier2d-compat';
+import type { Application, Container } from 'pixi.js';
+import type { z } from 'zod';
+import type { createSystemRunner } from '../core/system-runner';
+import type { SystemPhaseName } from '../core/types';
+import type { ComponentManager } from '../ecs/component-manager';
+import type { GameComponent } from '../ecs/game-component';
+import type { Collision2DSystem } from './collision-2d';
+import type { Physics2DRegistry } from './physics2d-registry';
+/**
+ * All world2d subsystems, passed to every world2d `setup(ctx)` and to each
+ * `GameComponent<'pixijs'>` lifecycle method — the 2D analog of `GameContext`.
+ *
+ * Raw libraries (call directly, no wrappers): `app` / `stage` (PixiJS),
+ * `rapier2dWorld` / `rapier2d` (Rapier 2D). Engine handles bridge them into the
+ * SAME phase-ordered loop the 3D path uses (`systems` is the very same
+ * `createSystemRunner`, and `PHASE_ORDER` is shared).
+ */
+export interface World2DContext {
+    /** The PixiJS application. Its renderer draws `stage`; auto-ticker is disabled. */
+    app: Application;
+    /** The world2d scene-graph root (the camera/world container under app.stage). */
+    stage: Container;
+    /** The Rapier 2D physics `World`. One shared world per world2d scene. */
+    rapier2dWorld: RAPIER.World;
+    /** The Rapier 2D module namespace (RigidBodyDesc, ColliderDesc, Vector2, …). */
+    rapier2d: typeof RAPIER;
+    /** `Container ↔ Rapier2D body/collider` registry (+ collider→entity reverse index). */
+    physics2d: Physics2DRegistry;
+    /** Rapier 2D collision/trigger event dispatcher; drained each postPhysics. */
+    collisions2d: Collision2DSystem;
+    /** Manager for all live GameComponent instances in this pixi world — the
+     *  unified `ComponentManager` (`ecs/component-manager.ts`, constructed with
+     *  `{ kind: 'pixijs' }`). The world2d-silo-only manager this replaced
+     *  (T7.3) is deleted; every 2D component attaches here, exactly like a
+     *  threejs component attaches onto its world's manager. */
+    components: ComponentManager;
+    /** The phase-ordered system runner (shared with the 3D path). */
+    systems: ReturnType<typeof createSystemRunner>;
+    /** DOM overlay for screen-space React/HUD UI (pointer-events:none by default). */
+    uiContainer: HTMLDivElement;
+}
+/** Constructor type for `GameComponent<'pixijs'>` subclasses used in a world2d
+ *  registry (carries static phase/schema) — the 2D-registry analog of
+ *  `GameComponentClass` (`ecs/game-component.ts`), narrowed to the pixijs kind
+ *  so `new Cls()` returns a properly-typed `GameComponent<'pixijs'>` without a cast. */
+export type Pixi2DComponentClass = (new () => GameComponent<'pixijs'>) & {
+    phase?: SystemPhaseName;
+    schema?: z.ZodObject<z.ZodRawShape>;
+};
+/** Component registry for world2d — a plain name→class map (the 2D analog). */
+export type Component2DRegistry = Record<string, Pixi2DComponentClass>;
+//# sourceMappingURL=types.d.ts.map

package/dist/world2d/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/world2d/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,2BAA2B,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,GAAG,EAAE,WAAW,CAAC;IACjB,iFAAiF;IACjF,KAAK,EAAE,SAAS,CAAC;IACjB,yEAAyE;IACzE,aAAa,EAAE,MAAM,CAAC,KAAK,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,EAAE,OAAO,MAAM,CAAC;IACxB,uFAAuF;IACvF,SAAS,EAAE,iBAAiB,CAAC;IAC7B,8EAA8E;IAC9E,YAAY,EAAE,iBAAiB,CAAC;IAChC;;;;+DAI2D;IAC3D,UAAU,EAAE,gBAAgB,CAAC;IAC7B,iEAAiE;IACjE,OAAO,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC/C,kFAAkF;IAClF,WAAW,EAAE,cAAc,CAAC;CAC7B;AAED;;;wFAGwF;AACxF,MAAM,MAAM,oBAAoB,GAAG,CAAC,UAAU,aAAa,CAAC,QAAQ,CAAC,CAAC,GAAG;IACvE,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;CACrC,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC"}

package/dist/world2d/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vgai/engine",
   "author": "Volter AI, Inc.",
   "license": "Apache-2.0",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "The vgai game engine — core loop, GameComponent model, physics, scene loader, adapter seam.",
   "homepage": "https://github.com/volter-ai/vgai-engine#readme",
@@ -19,7 +19,13 @@
     "./package.json": "./package.json",
     "./*": "./src/*"
   },
-  "files": ["src", "dist"],
+  "files": [
+    "src",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.build.json"
   },
@@ -34,8 +40,12 @@
     "postprocessing": "^6.38.0",
     "realism-effects": "^1.1.2",
     "recast-navigation": "^0.43.0",
+    "@theatre/core": "0.7.2",
+    "gsap": "^3.12.0",
     "three": "^0.170.0",
     "three.quarks": "^0.16.0",
+    "tone": "^15.1.22",
+    "xstate": "^5.32.4",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
@@ -43,8 +53,12 @@
     "react-dom": ">=18"
   },
   "peerDependenciesMeta": {
-    "react": { "optional": true },
-    "react-dom": { "optional": true }
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/react": "^19.2.14",

package/src/adapter/authoring.ts

@@ -277,6 +277,16 @@ export interface ComponentsProvider {
   list(nodeId: string): { type: string }[];
   add(nodeId: string, type: string): void;
   remove(nodeId: string, type: string): void;
+  /**
+   * OPTIONAL read accessor (W3.1, docs/DATA-TOOLS-DESIGN.md §3.3): the raw
+   * authored config record for one attached component (`list()` names the
+   * types; this reads one type's per-entity data), or `null` when the entity
+   * or component doesn't exist. Returns a shallow copy — callers must write
+   * through `InspectorProvider.set('components.<Type>.<field>', v)`, never by
+   * mutating this. Absent ⇒ config is not readable through this provider
+   * (tools degrade to `config: null`).
+   */
+  config?(nodeId: string, type: string): Record<string, unknown> | null;
 }
 
 /** Asset drop (hierarchy + viewport). */

package/src/adapter/first-party-systems.ts

@@ -1,20 +1,22 @@
 /**
  * First-party implementations of the remaining `SystemAdapters` — input, assets,
- * animation, navigation — each a thin coordination/introspection boundary over the
- * real engine subsystem (the original vision named these as first-class System
+ * navigation — each a thin coordination/introspection boundary over the real
+ * engine subsystem (the original vision named these as first-class System
  * adapters; physics + networking shipped earlier). The editor speaks only the
- * interfaces; these wrap `InputManager`, the asset loader, `AnimGraph`, and
- * `NavMeshManager` so an external game could supply its own equivalents.
+ * interfaces; these wrap `InputManager`, the asset loader, and `NavMeshManager`
+ * so an external game could supply its own equivalents. (The former
+ * `AnimationAdapter`/`createAnimationAdapter` over the `AnimGraph` map was
+ * removed by E5 — AnimGraph no longer exists; see
+ * docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §3.3/§11 E5.)
  */
 
 import type * as THREE from 'three';
 import type { NavMeshManager } from '../ai/navigation';
-import type { AnimGraph } from '../animation/anim-graph';
 import type { InputManager } from '../input/input-manager';
 import { resolveUrl } from '../loader';
 import type { AudioContext as GameAudio } from '../setup/setup-audio';
 import type {
-  AnimationAdapter,
+  ActionValueSnapshot,
   AssetAdapter,
   AudioAdapter,
   InputAdapter,
@@ -22,13 +24,25 @@ import type {
   NavPoint,
 } from './system-adapter';
 
-/** First-party `InputAdapter` over the engine `InputManager`. */
+/** First-party `InputAdapter` over the engine `InputManager`. Reads each action through
+ *  `InputManager.readAction`, dispatched on that action's OWN declared `valueType`
+ *  (`getActionValueType`) — never a hardcoded getter — so a scalar/Vector2/pointer action
+ *  surfaces its real typed value instead of being coerced through `isPressed` (F1-followup;
+ *  `readAction` on the wrong type would throw, so dispatch must follow the declared type). */
 export function createInputManagerAdapter(input: InputManager): InputAdapter {
   return {
     poll: () => input.poll(),
     actions: () => {
-      const out: Record<string, number> = {};
-      for (const name of input.actionNames()) out[name] = input.isPressed(name) ? 1 : 0;
+      const out: Record<string, ActionValueSnapshot> = {};
+      for (const name of input.actionNames()) {
+        const type = input.getActionValueType(name);
+        // `readAction`'s return type is inferred from a literal `expectedType`; with `type`
+        // widened to `ActionValueType` here it collapses to `boolean | number | Vector2`, so
+        // digital's `boolean` is normalized to the adapter's 1/0 the same way the old digital-
+        // only adapter did — every other value type already reads as `number | Vector2`.
+        const raw = input.readAction(name, type);
+        out[name] = { type, value: typeof raw === 'boolean' ? (raw ? 1 : 0) : raw };
+      }
       return out;
     },
   };
@@ -41,31 +55,6 @@ export function createVgaiAssetAdapter(): AssetAdapter {
   return { resolve: (url) => resolveUrl(url) };
 }
 
-/** First-party `AnimationAdapter` over the runtime's `AnimGraph` map. */
-export function createAnimationAdapter(
-  animGraphs: Map<THREE.Object3D, AnimGraph>,
-): AnimationAdapter {
-  const paramsOf = (g: AnimGraph): Record<string, number | boolean> => {
-    const out: Record<string, number | boolean> = {};
-    for (const name of g.parameterNames()) {
-      const v = g.getParameter(name);
-      if (v !== undefined) out[name] = v;
-    }
-    return out;
-  };
-  return {
-    graphs: () =>
-      [...animGraphs.entries()].map(([object, g]) => ({
-        object,
-        state: g.getCurrentState(),
-        parameters: paramsOf(g),
-      })),
-    state: (o) => animGraphs.get(o)?.getCurrentState() ?? null,
-    getParameter: (o, name) => animGraphs.get(o)?.getParameter(name),
-    setParameter: (o, name, value) => animGraphs.get(o)?.setParameter(name, value),
-  };
-}
-
 /**
  * First-party `AudioAdapter` over the engine's master-gain bus
  * (`setup-audio.ts`'s `AudioContext.masterGain`) — the seam `Game.play.pause()`

package/src/adapter/index.ts

@@ -41,7 +41,6 @@ export {
   createColyseusNetworkingAdapter,
 } from './colyseus-networking-adapter';
 export {
-  createAnimationAdapter,
   createInputManagerAdapter,
   createNavigationAdapter,
   createVgaiAssetAdapter,
@@ -60,8 +59,7 @@ export type {
 export type { HostContext, HostSurface, LoopHandle, SystemRegistry } from './host-context';
 export { createRapierPhysicsAdapter } from './rapier-physics-adapter';
 export type {
-  AnimationAdapter,
-  AnimationGraphInfo,
+  ActionValueSnapshot,
   AssetAdapter,
   ConnectionState,
   InputAdapter,

package/src/adapter/system-adapter.ts

@@ -12,6 +12,7 @@
  */
 
 import type * as THREE from 'three';
+import type { ActionValueType, Vector2 } from '../input/input-types';
 import type { Transform, TransformOwner } from './transform';
 
 /**
@@ -75,10 +76,22 @@ export interface NetworkingAdapter {
   subscribe(cb: () => void): Unsubscribe;
 }
 
+/** One action's current value, tagged with its declared shape (F1 `ActionValueType`) so a
+ *  consumer (editor input inspector, conformance suite) can render/assert on the real typed
+ *  value instead of a lossy digital coercion. `value` is a `number` for `'digital'`
+ *  (1 = pressed, 0 = not) and `'scalar'`, or a `Vector2` for `'vector2'`/`'pointerDelta'`/
+ *  `'pointerPosition'` — narrow on `type` to know which. */
+export interface ActionValueSnapshot {
+  type: ActionValueType;
+  value: number | Vector2;
+}
+
 export interface InputAdapter {
   poll(): void;
-  /** Current value of every named action (1 = pressed, 0 = not), for inspection. */
-  actions(): Readonly<Record<string, number>>;
+  /** Every named action's current value, faithfully typed per its declared `ActionValueType`
+   *  (F1, spec §12) — digital reads as 1/0, scalar as its float, vector2/pointerDelta/
+   *  pointerPosition as `{x,y}`. Never coerces a non-digital action down to 0/1. */
+  actions(): Readonly<Record<string, ActionValueSnapshot>>;
 }
 
 /** URL remap so an ingested game's relative asset paths resolve under the host. */
@@ -86,25 +99,6 @@ export interface AssetAdapter {
   resolve(url: string): string;
 }
 
-/** A snapshot of one object's animation graph (state + parameter values). */
-export interface AnimationGraphInfo {
-  object: THREE.Object3D;
-  state: string;
-  parameters: Record<string, number | boolean>;
-}
-
-/**
- * Inspect + drive a game's animation graphs (state machines / blend params). The
- * editor uses this to list animated objects, read their current state, and scrub
- * parameters — without owning the animation system.
- */
-export interface AnimationAdapter {
-  graphs(): AnimationGraphInfo[];
-  state(o: THREE.Object3D): string | null;
-  getParameter(o: THREE.Object3D, name: string): number | boolean | undefined;
-  setParameter(o: THREE.Object3D, name: string, value: number | boolean): void;
-}
-
 export interface NavPoint {
   x: number;
   y: number;
@@ -148,7 +142,6 @@ export interface SystemAdapters {
   networking?: NetworkingAdapter;
   input?: InputAdapter;
   assets?: AssetAdapter;
-  animation?: AnimationAdapter;
   navigation?: NavigationAdapter;
   audio?: AudioAdapter;
 }

package/src/adapter/vgai-scene-game-adapter.ts

@@ -15,8 +15,6 @@
 import RAPIER from '@dimforge/rapier3d-compat';
 import type { EffectComposer } from 'postprocessing';
 import * as THREE from 'three';
-import type { AnimGraph } from '../animation/anim-graph';
-import { animationSystem } from '../animation/anim-system';
 import { createSystemRunner } from '../core/system-runner';
 import { createDebugDraw } from '../dev/debug-draw';
 import { createComponentManager } from '../ecs/component-manager';
@@ -57,7 +55,6 @@ import {
   createSceneView,
 } from '../setup/setup-renderer';
 import {
-  createAnimationAdapter,
   createAudioSystemAdapter,
   createInputManagerAdapter,
   createNavigationAdapter,
@@ -240,10 +237,9 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     // --- UI container (host-provided) ---
     const uiContainer = host.ui as HTMLDivElement;
 
-    // --- Debug draw / assets / anim graphs ---
+    // --- Debug draw / assets ---
     const debugDraw = createDebugDraw(scene);
     const assets = host.assets;
-    const animGraphs = new Map<THREE.Object3D, AnimGraph>();
 
     // --- System runner (engine-level systems) ---
     const systems = createSystemRunner();
@@ -253,7 +249,6 @@ export class VgaiSceneGameAdapter implements GameAdapter {
       collisions.drain();
       writeTransforms();
     });
-    systems.add('animation', (dt) => animationSystem(animGraphs, dt));
     systems.add('preRender', (dt) => {
       particles.batchedRenderer.update(dt);
       tickCustomMaterials(scene, dt);
@@ -309,7 +304,6 @@ export class VgaiSceneGameAdapter implements GameAdapter {
       audio,
       particles,
       debugDraw,
-      animGraphs,
       assets,
       systems,
       components: null!,
@@ -372,7 +366,6 @@ export class VgaiSceneGameAdapter implements GameAdapter {
     systemAdapters.physics = createRapierPhysicsAdapter(physicsRegistry, physics.debugMesh);
     systemAdapters.input = createInputManagerAdapter(input);
     systemAdapters.assets = createVgaiAssetAdapter();
-    systemAdapters.animation = createAnimationAdapter(animGraphs);
     // D10/T7.6: the audio seam `Game.play.pause()` silences on pause. Works
     // against the headless stand-in too (`headlessAudio()`'s plain
     // `masterGain.gain` object) — this world's `pause()` mutes it harmlessly.
@@ -510,7 +503,6 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         rapier: ctx.rapier,
         physics: ctx.physics,
         audioListener: ctx.audio.listener,
-        animGraphs: ctx.animGraphs,
         ...(componentRegistry ? { componentRegistry } : {}),
         componentManager: ctx.components,
         particleRenderer: ctx.particles.batchedRenderer,
@@ -532,7 +524,6 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         rapier: ctx.rapier,
         physics: ctx.physics,
         audioListener: ctx.audio.listener,
-        animGraphs: ctx.animGraphs,
         ...(componentRegistry ? { componentRegistry } : {}),
         componentManager: ctx.components,
         particleRenderer: ctx.particles.batchedRenderer,
@@ -663,7 +654,6 @@ export class VgaiSceneGameAdapter implements GameAdapter {
       });
       safeStep('clearAssetCaches', () => clearAssetCaches());
       safeStep('debugDraw.clear', () => debugDraw.clear());
-      safeStep('animGraphs.clear', () => animGraphs.clear());
       safeStep('sceneUIHandle.dispose', () => {
         sceneUIHandle?.dispose();
         sceneUIHandle = null;
@@ -764,7 +754,6 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         scene.environment = null;
       });
       safeStep('debugDraw.clear', () => debugDraw.clear());
-      safeStep('animGraphs.clear', () => animGraphs.clear());
       safeStep('sceneUIHandle.dispose', () => {
         sceneUIHandle?.dispose();
         sceneUIHandle = null;
@@ -813,8 +802,10 @@ export class VgaiSceneGameAdapter implements GameAdapter {
         postFrame();
       },
       resize: (w: number, h: number) => {
-        composer.setSize(w, h);
-        camera.aspect = w / h;
+        const safeWidth = Math.max(1, w);
+        const safeHeight = Math.max(1, h);
+        composer.setSize(safeWidth, safeHeight);
+        camera.aspect = safeWidth / safeHeight;
         camera.updateProjectionMatrix();
       },
       dispose: disposeGame,