@waica/cli 0.3.0

package/dist/mcp/node_modules/@waica/engine/dist/components/sprite.js

@@ -0,0 +1,112 @@
+import * as THREE from 'three';
+import { Component } from '../component.js';
+const loader = new THREE.TextureLoader();
+/**
+ * Textured or flat-color quad. In the unified pipeline, a 2D sprite is a
+ * plane in front of the orthographic camera (see DESIGN.md §6, decision 2).
+ */
+export class Sprite extends Component {
+    static componentName = 'Sprite';
+    static params = {
+        offsetX: { label: 'x offset' },
+        offsetY: { label: 'y offset' },
+        layer: { label: 'layer', min: -5, max: 5, step: 1 },
+    };
+    // Size, color and offset are reactive so inspector edits update the live quad.
+    // Texture still needs a rebuild. TODO(H1): fully reactive props.
+    _width = 1;
+    _height = 1;
+    get width() {
+        return this._width;
+    }
+    set width(value) {
+        this._width = value;
+        this.mesh?.scale.set(this._width, this._height, 1);
+    }
+    get height() {
+        return this._height;
+    }
+    set height(value) {
+        this._height = value;
+        this.mesh?.scale.set(this._width, this._height, 1);
+    }
+    _color = 0xffffff;
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+        this.mesh?.material.color.setHex(value);
+    }
+    _offsetX = 0;
+    _offsetY = 0;
+    get offsetX() {
+        return this._offsetX;
+    }
+    set offsetX(value) {
+        this._offsetX = value;
+        if (this.mesh)
+            this.mesh.position.x = value;
+    }
+    get offsetY() {
+        return this._offsetY;
+    }
+    set offsetY(value) {
+        this._offsetY = value;
+        if (this.mesh)
+            this.mesh.position.y = value;
+    }
+    /** Optional texture URL; with pixelArt on it filters in nearest. */
+    texture;
+    pixelArt = false;
+    // Draw order among sprites: higher layers render in front. Same-layer
+    // sprites fall back to spawn order, so give overlap an explicit layer.
+    _layer = 0;
+    get layer() {
+        return this._layer;
+    }
+    set layer(value) {
+        this._layer = value;
+        if (this.mesh)
+            this.mesh.position.z = value * 0.01;
+    }
+    _shape = 'rectangle';
+    get shape() {
+        return this._shape;
+    }
+    set shape(value) {
+        this._shape = value === 'circle' ? 'circle' : 'rectangle';
+        if (!this.mesh)
+            return;
+        this.mesh.geometry.dispose();
+        this.mesh.geometry = this.createGeometry();
+    }
+    mesh;
+    onReady() {
+        const material = new THREE.MeshBasicMaterial({ color: this.color, transparent: true });
+        if (this.texture) {
+            const tex = loader.load(this.texture);
+            if (this.pixelArt) {
+                tex.magFilter = THREE.NearestFilter;
+                tex.minFilter = THREE.NearestFilter;
+            }
+            tex.colorSpace = THREE.SRGBColorSpace;
+            material.map = tex;
+            material.color.set(0xffffff);
+        }
+        this.mesh = new THREE.Mesh(this.createGeometry(), material);
+        this.mesh.scale.set(this._width, this._height, 1);
+        this.mesh.position.set(this._offsetX, this._offsetY, this.layer * 0.01);
+        this.entity.node.add(this.mesh);
+    }
+    onDestroy() {
+        this.mesh?.removeFromParent();
+        this.mesh?.geometry.dispose();
+        this.mesh?.material.dispose();
+    }
+    createGeometry() {
+        return this._shape === 'circle'
+            ? new THREE.CircleGeometry(0.5, 32)
+            : new THREE.PlaneGeometry(1, 1);
+    }
+}

package/dist/mcp/node_modules/@waica/engine/dist/entity.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+import type { Component, ComponentClass } from './component.js';
+import type { Game } from './game.js';
+/**
+ * A live scene node: a transform (three Group) + components.
+ * Created with `game.spawn(name)`.
+ */
+export declare class Entity {
+    readonly game: Game;
+    readonly name: string;
+    readonly node: THREE.Group<THREE.Object3DEventMap>;
+    readonly components: Component[];
+    private destroyed;
+    get alive(): boolean;
+    constructor(game: Game, name: string);
+    get position(): THREE.Vector3;
+    get scale(): THREE.Vector3;
+    add<T extends Component>(Class: ComponentClass<T>, props?: Partial<T>): T;
+    get<T extends Component>(Class: ComponentClass<T>): T | undefined;
+    has<T extends Component>(Class: ComponentClass<T>): boolean;
+    destroy(): void;
+}

package/dist/mcp/node_modules/@waica/engine/dist/entity.js

@@ -0,0 +1,52 @@
+import * as THREE from 'three';
+/**
+ * A live scene node: a transform (three Group) + components.
+ * Created with `game.spawn(name)`.
+ */
+export class Entity {
+    game;
+    name;
+    node = new THREE.Group();
+    components = [];
+    destroyed = false;
+    get alive() {
+        return !this.destroyed;
+    }
+    constructor(game, name) {
+        this.game = game;
+        this.name = name;
+    }
+    get position() {
+        return this.node.position;
+    }
+    get scale() {
+        return this.node.scale;
+    }
+    add(Class, props) {
+        const component = new Class();
+        component.entity = this;
+        component.game = this.game;
+        if (props)
+            Object.assign(component, props);
+        this.game.applyParamOverrides(this, component);
+        this.components.push(component);
+        component.onReady?.();
+        return component;
+    }
+    get(Class) {
+        return this.components.find((c) => c instanceof Class);
+    }
+    has(Class) {
+        return this.components.some((c) => c instanceof Class);
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        for (const c of [...this.components])
+            c.onDestroy?.();
+        this.components.length = 0;
+        this.node.removeFromParent();
+        this.game.removeEntity(this);
+    }
+}

package/dist/mcp/node_modules/@waica/engine/dist/events.d.ts

@@ -0,0 +1,8 @@
+type Handler = (...args: unknown[]) => void;
+/** The game's minimal event bus (e.g. 'collect' when picking up a coin). */
+export declare class Emitter {
+    private readonly handlers;
+    on(event: string, handler: Handler): () => void;
+    emit(event: string, ...args: unknown[]): void;
+}
+export {};

package/dist/mcp/node_modules/@waica/engine/dist/events.js

@@ -0,0 +1,20 @@
+/** The game's minimal event bus (e.g. 'collect' when picking up a coin). */
+export class Emitter {
+    handlers = new Map();
+    on(event, handler) {
+        let set = this.handlers.get(event);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(event, set);
+        }
+        set.add(handler);
+        return () => set.delete(handler);
+    }
+    emit(event, ...args) {
+        const set = this.handlers.get(event);
+        if (!set)
+            return;
+        for (const handler of [...set])
+            handler(...args);
+    }
+}

package/dist/mcp/node_modules/@waica/engine/dist/game.d.ts

@@ -0,0 +1,95 @@
+import * as THREE from 'three';
+import { type SceneCameraJson } from './camera.js';
+import type { Component } from './component.js';
+import { Entity } from './entity.js';
+import { Emitter } from './events.js';
+import { Input, type InputBindings } from './input.js';
+import { type SceneRegistry } from './scene.js';
+import { Stats, type StatValue } from './stats.js';
+import { GameUi } from './ui.js';
+/** Fixed game resolution: the view keeps this aspect, letterboxed. */
+export interface GameResolution {
+    width: number;
+    height: number;
+}
+export interface GameOptions {
+    /** Canvas the game draws into. */
+    canvas: HTMLCanvasElement;
+    /** Scene background color. */
+    background?: THREE.ColorRepresentation;
+    /** Visible world height in units; the 2D camera frames this. */
+    viewHeight?: number;
+    /** Fixed resolution (from the project's game.json); absent = fill the canvas. */
+    resolution?: GameResolution;
+    /** Control overrides (action → key codes) on top of the defaults. */
+    bindings?: InputBindings;
+    /** Initial stat values (points, lives…) from the project's stats.json. */
+    stats?: Record<string, StatValue>;
+}
+export type UpdateFn = (dt: number) => void;
+export interface SpawnPrefabOptions {
+    name?: string;
+    position?: [number, number];
+}
+/** Persisted overrides: entity → componentName → prop → value. */
+export type ParamOverrides = Record<string, Record<string, Record<string, number | boolean | string>>>;
+/**
+ * Engine core: loop, unified 2D/3D three scene, orthographic camera,
+ * entities with components, and input. See DESIGN.md.
+ */
+export declare class Game {
+    readonly scene: THREE.Scene<THREE.Object3DEventMap>;
+    readonly camera: THREE.OrthographicCamera;
+    readonly input: Input;
+    readonly entities: Entity[];
+    readonly events: Emitter;
+    readonly stats: Stats;
+    /** The HTML UI layer: presentation-only pieces toggled from code. */
+    readonly ui: GameUi;
+    /** Registry retained by loadScene for runtime prefab spawning. */
+    registry: SceneRegistry | null;
+    paramOverrides: ParamOverrides;
+    /**
+     * With false, the loop keeps rendering but runs no component updates
+     * or collisions — the editor's edit mode.
+     */
+    simulate: boolean;
+    private readonly renderer;
+    private readonly resizeObserver;
+    private readonly updateFns;
+    private readonly resolution;
+    private viewHeight;
+    private sceneCamera;
+    private lastTime;
+    constructor(options: GameOptions);
+    /** Creates a live entity in the scene. */
+    spawn(name: string): Entity;
+    /** Instantiates a registered prefab after a scene has supplied the registry. */
+    spawnPrefab(prefab: string, options?: SpawnPrefabOptions): Entity | null;
+    /** Finds an entity by name. */
+    find(name: string): Entity | undefined;
+    /** Loads persisted parameter overrides (waica.params.json). */
+    loadParams(url: string): Promise<void>;
+    /** Applies persisted overrides to a freshly added component. */
+    applyParamOverrides(entity: Entity, component: Component): void;
+    /** Registers a function that runs once per frame. Returns the unsubscribe. */
+    onUpdate(fn: UpdateFn): () => void;
+    /**
+     * Adopts a scene's camera block: jumps to its framing and, while
+     * simulating, follows/clamps per its settings. Called by loadScene.
+     */
+    setSceneCamera(json?: SceneCameraJson): void;
+    start(): void;
+    stop(): void;
+    /** Internal: called by Entity.destroy(). */
+    removeEntity(entity: Entity): void;
+    /** Visible world height (2D camera zoom). */
+    get view(): number;
+    setViewHeight(value: number): void;
+    /** Shuts the game down completely (loop, input, GPU). */
+    dispose(): void;
+    private tick;
+    private updateSceneCamera;
+    private dispatchCollisions;
+    private resize;
+}

package/dist/mcp/node_modules/@waica/engine/dist/game.js

@@ -0,0 +1,263 @@
+import * as THREE from 'three';
+import { collisionOverlap } from './collision-shape.js';
+import { resolveSceneCamera, stepSceneCamera } from './camera.js';
+import { Hitbox } from './components/hitbox.js';
+import { Entity } from './entity.js';
+import { Emitter } from './events.js';
+import { Input } from './input.js';
+import { registryEntry, spawnFromJson } from './scene.js';
+import { Stats } from './stats.js';
+import { GameUi } from './ui.js';
+/**
+ * Engine core: loop, unified 2D/3D three scene, orthographic camera,
+ * entities with components, and input. See DESIGN.md.
+ */
+export class Game {
+    scene = new THREE.Scene();
+    camera;
+    input;
+    entities = [];
+    events = new Emitter();
+    stats;
+    /** The HTML UI layer: presentation-only pieces toggled from code. */
+    ui;
+    /** Registry retained by loadScene for runtime prefab spawning. */
+    registry = null;
+    paramOverrides = {};
+    /**
+     * With false, the loop keeps rendering but runs no component updates
+     * or collisions — the editor's edit mode.
+     */
+    simulate = true;
+    // TODO(H1): migrate to WebGPURenderer (three/webgpu) with automatic WebGL2 fallback.
+    renderer;
+    resizeObserver;
+    updateFns = new Set();
+    resolution;
+    viewHeight;
+    sceneCamera = null;
+    lastTime = 0;
+    constructor(options) {
+        const { canvas, background = 0x1a1a2e, viewHeight = 10 } = options;
+        this.viewHeight = viewHeight;
+        this.resolution = options.resolution ?? null;
+        this.input = new Input(options.bindings);
+        this.stats = new Stats(options.stats);
+        this.ui = new GameUi(this.stats, () => canvas.parentElement ?? document.body);
+        this.renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
+        this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+        this.scene.background = new THREE.Color(background);
+        this.camera = new THREE.OrthographicCamera();
+        this.camera.position.z = 10;
+        this.resize();
+        this.resizeObserver = new ResizeObserver(() => this.resize());
+        this.resizeObserver.observe(canvas);
+    }
+    /** Creates a live entity in the scene. */
+    spawn(name) {
+        const entity = new Entity(this, name);
+        this.entities.push(entity);
+        this.scene.add(entity.node);
+        return entity;
+    }
+    /** Instantiates a registered prefab after a scene has supplied the registry. */
+    spawnPrefab(prefab, options = {}) {
+        const registry = this.registry;
+        if (!registry) {
+            console.warn(`[waica] cannot spawn prefab before loadScene: "${prefab}"`);
+            return null;
+        }
+        if (!registryEntry(registry.prefabs, prefab)) {
+            console.warn(`[waica] unknown runtime prefab: "${prefab}"`);
+            return null;
+        }
+        const base = prefab.slice(prefab.lastIndexOf('/') + 1) || 'Entity';
+        const name = options.name ?? base.charAt(0).toUpperCase() + base.slice(1);
+        return spawnFromJson(this, { name, prefab, ...(options.position ? { position: options.position } : {}) }, registry);
+    }
+    /** Finds an entity by name. */
+    find(name) {
+        return this.entities.find((e) => e.name === name);
+    }
+    /** Loads persisted parameter overrides (waica.params.json). */
+    async loadParams(url) {
+        try {
+            const res = await fetch(url);
+            if (res.ok)
+                this.paramOverrides = (await res.json());
+        }
+        catch {
+            // no params file: the archetype defaults apply
+        }
+    }
+    /** Applies persisted overrides to a freshly added component. */
+    applyParamOverrides(entity, component) {
+        const Class = component.constructor;
+        const override = this.paramOverrides[entity.name]?.[Class.componentName];
+        if (override)
+            Object.assign(component, override);
+    }
+    /** Registers a function that runs once per frame. Returns the unsubscribe. */
+    onUpdate(fn) {
+        this.updateFns.add(fn);
+        return () => this.updateFns.delete(fn);
+    }
+    /**
+     * Adopts a scene's camera block: jumps to its framing and, while
+     * simulating, follows/clamps per its settings. Called by loadScene.
+     */
+    setSceneCamera(json) {
+        // No camera block: leave the camera to the host (constructor viewHeight).
+        if (!json) {
+            this.sceneCamera = null;
+            return;
+        }
+        this.sceneCamera = resolveSceneCamera(json);
+        // With a follow target the declared position is moot: start centered on
+        // the target so play begins framed like the editor shows it.
+        const followed = this.sceneCamera.follow ? this.find(this.sceneCamera.follow) : undefined;
+        const [x, y] = followed
+            ? [followed.position.x, followed.position.y]
+            : this.sceneCamera.position;
+        this.camera.position.x = x;
+        this.camera.position.y = y;
+        this.setViewHeight(this.sceneCamera.zoom);
+    }
+    start() {
+        this.renderer.setAnimationLoop((time) => this.tick(time));
+    }
+    stop() {
+        this.renderer.setAnimationLoop(null);
+    }
+    /** Internal: called by Entity.destroy(). */
+    removeEntity(entity) {
+        const i = this.entities.indexOf(entity);
+        if (i !== -1)
+            this.entities.splice(i, 1);
+    }
+    /** Visible world height (2D camera zoom). */
+    get view() {
+        return this.viewHeight;
+    }
+    setViewHeight(value) {
+        this.viewHeight = Math.min(Math.max(value, 2), 80);
+        this.resize();
+    }
+    /** Shuts the game down completely (loop, input, GPU). */
+    dispose() {
+        this.stop();
+        this.input.dispose();
+        this.resizeObserver.disconnect();
+        this.ui.dispose();
+        for (const entity of [...this.entities])
+            entity.destroy();
+        this.renderer.dispose();
+    }
+    tick(time) {
+        // Clamp dt: switching tabs or pausing doesn't fast-forward the simulation.
+        const dt = Math.min((time - this.lastTime) / 1000, 0.1);
+        this.lastTime = time;
+        if (this.simulate) {
+            for (const entity of [...this.entities]) {
+                for (const component of [...entity.components])
+                    component.onUpdate?.(dt);
+            }
+            this.dispatchCollisions();
+            this.updateSceneCamera(dt);
+        }
+        // The UI must react to the pause itself (hide until resumed).
+        this.ui.setActive(this.simulate);
+        for (const fn of this.updateFns)
+            fn(dt);
+        this.input.endFrame();
+        if (this.resolution) {
+            // Letterbox bars: clear the whole canvas, then render inside the scissor.
+            this.renderer.setScissorTest(false);
+            this.renderer.setClearColor(0x000000, 1);
+            this.renderer.clear(true, false, false);
+            this.renderer.setScissorTest(true);
+        }
+        this.renderer.render(this.scene, this.camera);
+    }
+    updateSceneCamera(dt) {
+        const cam = this.sceneCamera;
+        if (!cam)
+            return;
+        const followed = cam.follow ? this.find(cam.follow) : undefined;
+        const mover = followed?.components.find((c) => typeof c.vx === 'number');
+        const next = stepSceneCamera(cam, {
+            x: this.camera.position.x,
+            y: this.camera.position.y,
+            halfW: (this.camera.right - this.camera.left) / 2,
+            halfH: this.viewHeight / 2,
+            target: followed ? { x: followed.position.x, y: followed.position.y } : null,
+            vx: mover?.vx ?? 0,
+            dt,
+        });
+        this.camera.position.x = next.x;
+        this.camera.position.y = next.y;
+    }
+    dispatchCollisions() {
+        const boxed = this.entities.filter((e) => e.has(Hitbox));
+        for (let i = 0; i < boxed.length; i++) {
+            for (let j = i + 1; j < boxed.length; j++) {
+                const a = boxed[i];
+                const b = boxed[j];
+                if (!a?.alive || !b?.alive)
+                    continue;
+                const ha = a.get(Hitbox);
+                const hb = b.get(Hitbox);
+                if (!ha || !hb)
+                    continue;
+                const hit = collisionOverlap({
+                    x: a.position.x + ha.offsetX,
+                    y: a.position.y + ha.offsetY,
+                    width: ha.width,
+                    height: ha.height,
+                    shape: ha.shape,
+                    points: ha.points,
+                }, {
+                    x: b.position.x + hb.offsetX,
+                    y: b.position.y + hb.offsetY,
+                    width: hb.width,
+                    height: hb.height,
+                    shape: hb.shape,
+                    points: hb.points,
+                });
+                if (!hit)
+                    continue;
+                for (const c of [...a.components])
+                    c.onCollide?.(b);
+                if (!a.alive || !b.alive)
+                    continue;
+                for (const c of [...b.components])
+                    c.onCollide?.(a);
+            }
+        }
+    }
+    resize() {
+        const canvas = this.renderer.domElement;
+        const { clientWidth: w, clientHeight: h } = canvas;
+        if (w === 0 || h === 0)
+            return;
+        this.renderer.setSize(w, h, false);
+        let aspect = w / h;
+        if (this.resolution) {
+            // Fixed resolution: the largest rect with its aspect, centered (letterbox).
+            aspect = this.resolution.width / this.resolution.height;
+            const vw = Math.min(w, h * aspect);
+            const vh = vw / aspect;
+            const vx = (w - vw) / 2;
+            const vy = (h - vh) / 2;
+            this.renderer.setViewport(vx, vy, vw, vh);
+            this.renderer.setScissor(vx, vy, vw, vh);
+        }
+        const halfH = this.viewHeight / 2;
+        const halfW = halfH * aspect;
+        this.camera.left = -halfW;
+        this.camera.right = halfW;
+        this.camera.top = halfH;
+        this.camera.bottom = -halfH;
+        this.camera.updateProjectionMatrix();
+    }
+}

package/dist/mcp/node_modules/@waica/engine/dist/index.d.ts

@@ -0,0 +1,39 @@
+export { Game } from './game.js';
+export type { GameOptions, GameResolution, SpawnPrefabOptions, UpdateFn, ParamOverrides, } from './game.js';
+export { CAMERA_DEFAULTS, resolveSceneCamera, stepSceneCamera } from './camera.js';
+export type { SceneCameraJson, CameraLimitsJson, ResolvedSceneCamera } from './camera.js';
+export { Entity } from './entity.js';
+export { Component } from './component.js';
+export type { ComponentClass, ContactNormal, ParamSpec, SolidContact, } from './component.js';
+export { collectModuleComponents, mergeRegistryComponents } from './component-registry.js';
+export type { ComponentModule } from './component-registry.js';
+export { Input, DEFAULT_BINDINGS } from './input.js';
+export type { ActionName, InputBindings } from './input.js';
+export type { ArchetypeArt, ArchetypeManifest, BrowserArchetypeManifest, EntityTemplate, } from './archetype.js';
+export { Stats } from './stats.js';
+export type { StatValue } from './stats.js';
+export { GameUi } from './ui.js';
+export { Sprite } from './components/sprite.js';
+export { Solid } from './components/solid.js';
+export { Hitbox } from './components/hitbox.js';
+export { DynamicBody } from './components/dynamic-body.js';
+export { AnimatedSprite } from './components/animated-sprite.js';
+export { aabbOverlap } from './aabb.js';
+export { resolveSolidAxis } from './solid-axis.js';
+export type { CollisionAxis, SolidAxisOptions } from './solid-axis.js';
+export { COLLISION_SHAPES, DEFAULT_COLLISION_POLYGON, collisionBounds, collisionOverlap, collisionVertices, resolveCollisionPoints, } from './collision-shape.js';
+export type { CollisionBody, CollisionBounds, CollisionPoint, CollisionShape, } from './collision-shape.js';
+export { Emitter } from './events.js';
+export { loadScene, spawnFromJson, resolveEntityComponents, resolveProps } from './scene.js';
+export type { SceneJson, SceneEntityJson, SceneComponentJson, SceneRegistry, PrefabJson } from './scene.js';
+export { ClipPlayer } from './animation/clip-player.js';
+export type { ClipDef } from './animation/clip-player.js';
+export { sheetCell, sheetFrameCount, locateFrame } from './animation/sheet.js';
+export type { SheetGridParams, SheetCell, SheetDef } from './animation/sheet.js';
+export { resolveClip, missingClips } from './animation/contract.js';
+export type { AnimationContract } from './animation/contract.js';
+export { StateMachine, evaluateTrigger, nextTransition } from './state/state-machine.js';
+export type { StateJson, StateTransitionJson, TriggerEnv } from './state/state-machine.js';
+export { defineRole, defineStates, installArchetype, logicSet, registeredLogicSets, registeredRoles, resetRegistries, roleDefinition, } from './state/hooks.js';
+export type { ArchetypeBundle, RoleDefinition, RoleGraph, StateContext, StateHooks, StateLogic, } from './state/hooks.js';
+export * as THREE from 'three';

package/dist/mcp/node_modules/@waica/engine/dist/index.js

@@ -0,0 +1,26 @@
+export { Game } from './game.js';
+export { CAMERA_DEFAULTS, resolveSceneCamera, stepSceneCamera } from './camera.js';
+export { Entity } from './entity.js';
+export { Component } from './component.js';
+export { collectModuleComponents, mergeRegistryComponents } from './component-registry.js';
+export { Input, DEFAULT_BINDINGS } from './input.js';
+export { Stats } from './stats.js';
+export { GameUi } from './ui.js';
+export { Sprite } from './components/sprite.js';
+export { Solid } from './components/solid.js';
+export { Hitbox } from './components/hitbox.js';
+export { DynamicBody } from './components/dynamic-body.js';
+export { AnimatedSprite } from './components/animated-sprite.js';
+export { aabbOverlap } from './aabb.js';
+export { resolveSolidAxis } from './solid-axis.js';
+export { COLLISION_SHAPES, DEFAULT_COLLISION_POLYGON, collisionBounds, collisionOverlap, collisionVertices, resolveCollisionPoints, } from './collision-shape.js';
+export { Emitter } from './events.js';
+export { loadScene, spawnFromJson, resolveEntityComponents, resolveProps } from './scene.js';
+export { ClipPlayer } from './animation/clip-player.js';
+export { sheetCell, sheetFrameCount, locateFrame } from './animation/sheet.js';
+export { resolveClip, missingClips } from './animation/contract.js';
+export { StateMachine, evaluateTrigger, nextTransition } from './state/state-machine.js';
+export { defineRole, defineStates, installArchetype, logicSet, registeredLogicSets, registeredRoles, resetRegistries, roleDefinition, } from './state/hooks.js';
+// Explicit escape hatch while our own API grows: a single source of three
+// for the whole workspace. The thesis is that three stays an implementation detail.
+export * as THREE from 'three';

package/dist/mcp/node_modules/@waica/engine/dist/input.d.ts

@@ -0,0 +1,40 @@
+export type ActionName = string;
+/** Action → KeyboardEvent.code list. */
+export type InputBindings = Record<string, string[]>;
+/** Neutral engine baseline; archetypes own their action vocabulary. */
+export declare const DEFAULT_BINDINGS: Readonly<InputBindings>;
+/**
+ * Action-based input with archetype default bindings.
+ * v0: keyboard. TODO(H1): gamepad and touch.
+ */
+export declare class Input {
+    private readonly bindings;
+    private readonly down;
+    private readonly justDown;
+    private readonly used;
+    /** Installs exactly the action map supplied by the active archetype/project. */
+    constructor(bindings?: Readonly<InputBindings>);
+    /** Is the action held this frame? */
+    held(action: ActionName): boolean;
+    /** Was the action pressed exactly this frame? */
+    justPressed(action: ActionName): boolean;
+    /** -1..1 axis from two actions (left/right by default). */
+    axis(negative?: ActionName, positive?: ActionName): number;
+    /**
+     * Marks this frame's press of the action as spent, so consumers that
+     * honor consumption (state-machine 'input:' triggers) ignore it. One
+     * press does one thing: the press that launches a ground jump can't
+     * also fire a "key press jump" transition on the very same frame.
+     */
+    consume(action: ActionName): void;
+    /** Was this frame's press already spent by someone? */
+    consumed(action: ActionName): boolean;
+    /** Called by the Game at the end of each frame. */
+    endFrame(): void;
+    dispose(): void;
+    private isActive;
+    private releaseAll;
+    private onVisibilityChange;
+    private onKeyDown;
+    private onKeyUp;
+}