@waica/cli 0.6.1 → 0.8.0

package/dist/mcp/node_modules/@waica/archetype-topdown/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@waica/archetype-topdown",
+  "version": "0.8.0",
+  "description": "Waica top-down archetype — opinionated setup for Zelda-like overhead adventures",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chichex/waica",
+    "directory": "packages/archetype-topdown"
+  },
+  "files": [
+    "dist",
+    "assets"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "default": "./dist/manifest.js"
+    }
+  },
+  "dependencies": {
+    "@waica/behaviors": "^0.8.0",
+    "@waica/engine": "^0.8.0"
+  }
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/grid-motor.d.ts

@@ -0,0 +1,56 @@
+import { Component, type AnimationFacingProvider, type CameraVelocity, type CameraVelocityProvider } from '@waica/engine';
+/** Shared velocity, collision and provider behavior for square-grid motors. */
+export declare abstract class GridMotor<Facing extends string> extends Component implements CameraVelocityProvider, AnimationFacingProvider {
+    static displayName: string;
+    static params: {
+        moveSpeed: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        acceleration: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        deceleration: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        walkThreshold: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    static transient: string[];
+    moveSpeed: number;
+    acceleration: number;
+    deceleration: number;
+    /** Speed above this reads as walking (the idle ↔ walk edge). */
+    walkThreshold: number;
+    /** The character's AABB hitbox — a footprint, shorter than the sprite. */
+    hitboxWidth: number;
+    hitboxHeight: number;
+    vx: number;
+    vy: number;
+    abstract facing: Facing;
+    /** The scene camera reads follow velocity through this explicit seam. */
+    getCameraVelocity(): CameraVelocity;
+    /** The StateMachine resolves directional clips through this explicit seam. */
+    getAnimationFacing(): string;
+    /** Accelerates each axis toward an already-normalized logical direction. */
+    protected accelerateToward(x: number, y: number, dt: number): void;
+    /** Live speed, for the idle ↔ walk edge. */
+    speed(): number;
+    /** Integrates velocity and resolves each logical axis against Solids. */
+    step(dt: number): void;
+    halt(): void;
+    private resolveAxis;
+    private collisionBody;
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/grid-motor.js

@@ -0,0 +1,74 @@
+import { Component, resolveSolidAxis, THREE, } from '@waica/engine';
+/** Shared velocity, collision and provider behavior for square-grid motors. */
+export class GridMotor extends Component {
+    static displayName = 'Motor';
+    static params = {
+        moveSpeed: { label: 'Speed', min: 1, max: 30, step: 0.5 },
+        acceleration: { label: 'Acceleration', min: 5, max: 200, step: 5 },
+        deceleration: { label: 'Deceleration', min: 5, max: 200, step: 5 },
+        walkThreshold: { label: 'Walk threshold', min: 0, max: 5, step: 0.1 },
+    };
+    static transient = ['vx', 'vy', 'facing'];
+    moveSpeed = 6;
+    acceleration = 60;
+    deceleration = 80;
+    /** Speed above this reads as walking (the idle ↔ walk edge). */
+    walkThreshold = 0.5;
+    /** The character's AABB hitbox — a footprint, shorter than the sprite. */
+    hitboxWidth = 0.9;
+    hitboxHeight = 0.6;
+    vx = 0;
+    vy = 0;
+    /** The scene camera reads follow velocity through this explicit seam. */
+    getCameraVelocity() {
+        return { vx: this.vx, vy: this.vy };
+    }
+    /** The StateMachine resolves directional clips through this explicit seam. */
+    getAnimationFacing() {
+        return this.facing;
+    }
+    /** Accelerates each axis toward an already-normalized logical direction. */
+    accelerateToward(x, y, dt) {
+        const rateX = x !== 0 ? this.acceleration : this.deceleration;
+        const rateY = y !== 0 ? this.acceleration : this.deceleration;
+        this.vx = THREE.MathUtils.damp(this.vx, x * this.moveSpeed, rateX / this.moveSpeed, dt);
+        this.vy = THREE.MathUtils.damp(this.vy, y * this.moveSpeed, rateY / this.moveSpeed, dt);
+    }
+    /** Live speed, for the idle ↔ walk edge. */
+    speed() {
+        return Math.hypot(this.vx, this.vy);
+    }
+    /** Integrates velocity and resolves each logical axis against Solids. */
+    step(dt) {
+        const position = this.entity.position;
+        const previousX = position.x;
+        position.x += this.vx * dt;
+        if (this.resolveAxis('x', previousX))
+            this.vx = 0;
+        const previousY = position.y;
+        position.y += this.vy * dt;
+        if (this.resolveAxis('y', previousY))
+            this.vy = 0;
+    }
+    halt() {
+        this.vx = 0;
+        this.vy = 0;
+    }
+    resolveAxis(axis, previous) {
+        return resolveSolidAxis({
+            entity: this.entity,
+            axis,
+            previous,
+            body: () => this.collisionBody(),
+        });
+    }
+    collisionBody() {
+        return {
+            x: this.entity.position.x,
+            y: this.entity.position.y,
+            width: this.hitboxWidth,
+            height: this.hitboxHeight,
+            shape: 'rectangle',
+        };
+    }
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/grid-player-role.d.ts

@@ -0,0 +1,15 @@
+import { type Component, type ComponentClass, type RoleDefinition, type RoleGraph, type StateContext } from '@waica/engine';
+interface PlayerMotor extends Component {
+    walkThreshold: number;
+    run(inputX: number, inputY: number, dt: number): void;
+    step(dt: number): void;
+    speed(): number;
+}
+interface GridPlayerRoleParts {
+    graph: RoleGraph;
+    update(ctx: StateContext, dt: number): void;
+    role: RoleDefinition;
+}
+/** Builds the common player graph and role around one genre-specific grid motor. */
+export declare function createGridPlayerRole<T extends PlayerMotor>(Motor: ComponentClass<T>, description: string): GridPlayerRoleParts;
+export {};

package/dist/mcp/node_modules/@waica/behaviors/dist/grid-player-role.js

@@ -0,0 +1,71 @@
+import {} from '@waica/engine';
+import { Health } from './health.js';
+import { interactUpdate } from './interactable.js';
+import { Respawnable } from './respawnable.js';
+/** Builds the common player graph and role around one genre-specific grid motor. */
+export function createGridPlayerRole(Motor, description) {
+    const graph = {
+        initial: 'idle',
+        states: {
+            idle: {
+                transitions: [{ on: 'signal:move', to: 'walk' }],
+            },
+            walk: {
+                transitions: [{ on: 'signal:stop', to: 'idle' }],
+            },
+            dead: {
+                // Freeze on idle (resolved directionally) rather than name a death
+                // clip the stock sheets do not have and warn every frame.
+                clip: 'idle',
+                transitions: [{ on: 'timer:0.8', to: 'idle' }],
+            },
+            // Dying is the same from every state, so the edge lives on '*'. Its
+            // presence is also the contract Health checks before signalling: a graph
+            // without it gets its entity destroyed instead.
+            '*': { transitions: [{ on: 'signal:death', to: 'dead' }] },
+        },
+    };
+    const update = ({ entity, game, fsm }, dt) => {
+        const motor = entity.get(Motor);
+        if (!motor)
+            return;
+        motor.run(game.input.axis('left', 'right'), game.input.axis('down', 'up'), dt);
+        motor.step(dt);
+        fsm.signal(motor.speed() > motor.walkThreshold ? 'move' : 'stop');
+    };
+    const role = {
+        description,
+        driver: Motor.componentName,
+        graph,
+        signals: {
+            move: 'moving',
+            stop: 'standing still',
+        },
+        states: {
+            // Always-hook: the interact lookup must survive custom states like an
+            // attack, so it runs in every state.
+            '*': {
+                onUpdate(ctx) {
+                    interactUpdate(ctx);
+                },
+            },
+            // Fallback: a custom state without its own onUpdate keeps the full body
+            // update — its file only has to say what makes it special.
+            default: { onUpdate: update },
+            idle: { onUpdate: update },
+            walk: { onUpdate: update },
+            // Coming back is what leaving death means, so it hangs off onExit: any
+            // other way out of this state (a project's own edge) revives too.
+            dead: {
+                // A state without its own onUpdate falls back to the role's default
+                // body update, so this no-op keeps the player still for the death beat.
+                onUpdate() { },
+                onExit({ entity }) {
+                    entity.get(Respawnable)?.respawn();
+                    entity.get(Health)?.heal(Infinity);
+                },
+            },
+        },
+    };
+    return { graph, update, role };
+}

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

@@ -1,5 +1,10 @@
 export { PlatformerMotor } from './platformer-motor.js';
 export { PLAYER_ROLE, PLAYER_STATE_GRAPH, playerUpdate } from './player-states.js';
+export { TopDownMotor, type TopDownFacing } from './topdown-motor.js';
+export { IsoMotor, type IsoFacing } from './iso-motor.js';
+export { TOPDOWN_PLAYER_ROLE, TOPDOWN_PLAYER_STATE_GRAPH, topdownPlayerUpdate, } from './topdown-player-states.js';
+export { ISO_PLAYER_ROLE, ISO_PLAYER_STATE_GRAPH, isoPlayerUpdate, } from './iso-player-states.js';
+export { INTERACTABLE_UI, INTERACTABLE_UI_PIECE, Interactable, interactUpdate, } from './interactable.js';
 export { Collectible } from './collectible.js';
 export { Patrol, PATROLLER_ROLE, PATROLLER_STATE_GRAPH, type PatrolAxis } from './patrol.js';
 export { Chaser, CHASER_ROLE, CHASER_STATE_GRAPH, type ChaserMode } from './chaser.js';

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

@@ -1,5 +1,10 @@
 export { PlatformerMotor } from './platformer-motor.js';
 export { PLAYER_ROLE, PLAYER_STATE_GRAPH, playerUpdate } from './player-states.js';
+export { TopDownMotor } from './topdown-motor.js';
+export { IsoMotor } from './iso-motor.js';
+export { TOPDOWN_PLAYER_ROLE, TOPDOWN_PLAYER_STATE_GRAPH, topdownPlayerUpdate, } from './topdown-player-states.js';
+export { ISO_PLAYER_ROLE, ISO_PLAYER_STATE_GRAPH, isoPlayerUpdate, } from './iso-player-states.js';
+export { INTERACTABLE_UI, INTERACTABLE_UI_PIECE, Interactable, interactUpdate, } from './interactable.js';
 export { Collectible } from './collectible.js';
 export { Patrol, PATROLLER_ROLE, PATROLLER_STATE_GRAPH } from './patrol.js';
 export { Chaser, CHASER_ROLE, CHASER_STATE_GRAPH } from './chaser.js';

package/dist/mcp/node_modules/@waica/behaviors/dist/interactable.d.ts

@@ -0,0 +1,34 @@
+import { Component, type StateContext } from '@waica/engine';
+/**
+ * Something the player can talk to or examine: a dialogue line and the
+ * radius it can be triggered from. The component is pure data — the
+ * player role's always-hook does the lookup (see interactUpdate), so an
+ * NPC stays code-free: Interactable + the npc role is a whole villager.
+ */
+export declare class Interactable extends Component {
+    static componentName: string;
+    static params: {
+        line: {
+            label: string;
+        };
+        radius: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    /** What pressing interact within the radius says. */
+    line: string;
+    radius: number;
+}
+export declare const INTERACTABLE_UI_PIECE = "npc-line";
+/** The UI fragment every archetype using Interactable must register. */
+export declare const INTERACTABLE_UI: Readonly<Record<string, string>>;
+/**
+ * The player role's interact lookup, run by its '*' hook in every state:
+ * pressing interact near an Interactable publishes its line through the
+ * npcLine stat and shows the npc-line UI piece; walking out of every
+ * radius hides it again. Nearest one wins when several are in range.
+ */
+export declare function interactUpdate({ entity, game }: StateContext): void;

package/dist/mcp/node_modules/@waica/behaviors/dist/interactable.js

@@ -0,0 +1,72 @@
+import { Component } from '@waica/engine';
+/**
+ * Something the player can talk to or examine: a dialogue line and the
+ * radius it can be triggered from. The component is pure data — the
+ * player role's always-hook does the lookup (see interactUpdate), so an
+ * NPC stays code-free: Interactable + the npc role is a whole villager.
+ */
+export class Interactable extends Component {
+    static componentName = 'Interactable';
+    static params = {
+        line: { label: 'Line' },
+        radius: { label: 'Radius', min: 0.5, max: 10, step: 0.25 },
+    };
+    /** What pressing interact within the radius says. */
+    line = 'Hello, traveler!';
+    radius = 1.5;
+}
+export const INTERACTABLE_UI_PIECE = 'npc-line';
+/** The UI fragment every archetype using Interactable must register. */
+export const INTERACTABLE_UI = {
+    [INTERACTABLE_UI_PIECE]: `<style>
+  .npc-line {
+    position: absolute;
+    left: 50%;
+    bottom: 24px;
+    transform: translateX(-50%);
+    max-width: 70%;
+    padding: 10px 18px;
+    border-radius: 8px;
+    background: #1a1a2ecc;
+    border: 1px solid #ffffff2e;
+    font: 500 18px system-ui, sans-serif;
+    color: #f5f5f5;
+    text-shadow: 0 1px 2px #000a;
+    user-select: none;
+  }
+</style>
+<div class="npc-line">{{npcLine}}</div>
+`,
+};
+/**
+ * The player role's interact lookup, run by its '*' hook in every state:
+ * pressing interact near an Interactable publishes its line through the
+ * npcLine stat and shows the npc-line UI piece; walking out of every
+ * radius hides it again. Nearest one wins when several are in range.
+ */
+export function interactUpdate({ entity, game }) {
+    let nearest = null;
+    let nearestDistance = Infinity;
+    for (const other of game.entities) {
+        if (other === entity)
+            continue;
+        const interactable = other.get(Interactable);
+        if (!interactable)
+            continue;
+        const distance = Math.hypot(other.position.x - entity.position.x, other.position.y - entity.position.y);
+        if (distance <= interactable.radius && distance < nearestDistance) {
+            nearest = interactable;
+            nearestDistance = distance;
+        }
+    }
+    if (!nearest) {
+        game.ui.hide(INTERACTABLE_UI_PIECE);
+        return;
+    }
+    if (game.input.justPressed('interact') && !game.input.consumed('interact')) {
+        // The press is spent: an input:interact edge needs a NEW press.
+        game.input.consume('interact');
+        game.stats.set('npcLine', nearest.line);
+        game.ui.show(INTERACTABLE_UI_PIECE);
+    }
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/iso-motor.d.ts

@@ -0,0 +1,14 @@
+import { GridMotor } from './grid-motor.js';
+/** The eight screen-relative facings declared by the isometric archetype. */
+export type IsoFacing = 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw';
+/**
+ * Passive isometric motor. Input and facing are screen-relative while the
+ * shared GridMotor integrates and collides in logical square-grid space.
+ * State code owns the frame; this component has no onUpdate of its own.
+ */
+export declare class IsoMotor extends GridMotor<IsoFacing> {
+    static componentName: string;
+    facing: IsoFacing;
+    /** Accelerates screen-relative input toward a logical-space velocity. */
+    run(inputX: number, inputY: number, dt: number): void;
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/iso-motor.js

@@ -0,0 +1,36 @@
+import { screenInputToLogical } from '@waica/engine';
+import { GridMotor } from './grid-motor.js';
+function facingForInput(inputX, inputY) {
+    if (inputX === 0 && inputY === 0)
+        return undefined;
+    if (inputY > 0) {
+        if (inputX > 0)
+            return 'ne';
+        if (inputX < 0)
+            return 'nw';
+        return 'n';
+    }
+    if (inputY < 0) {
+        if (inputX > 0)
+            return 'se';
+        if (inputX < 0)
+            return 'sw';
+        return 's';
+    }
+    return inputX > 0 ? 'e' : 'w';
+}
+/**
+ * Passive isometric motor. Input and facing are screen-relative while the
+ * shared GridMotor integrates and collides in logical square-grid space.
+ * State code owns the frame; this component has no onUpdate of its own.
+ */
+export class IsoMotor extends GridMotor {
+    static componentName = 'IsoMotor';
+    facing = 's';
+    /** Accelerates screen-relative input toward a logical-space velocity. */
+    run(inputX, inputY, dt) {
+        const direction = screenInputToLogical(inputX, inputY);
+        this.accelerateToward(direction.x, direction.y, dt);
+        this.facing = facingForInput(inputX, inputY) ?? this.facing;
+    }
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/iso-player-states.d.ts

@@ -0,0 +1,5 @@
+/** The state graph new isometric player characters start with, as prefab data. */
+export declare const ISO_PLAYER_STATE_GRAPH: import("@waica/engine").RoleGraph;
+/** Drives IsoMotor from screen-relative actions and reports body state. */
+export declare const isoPlayerUpdate: (ctx: import("@waica/engine").StateContext, dt: number) => void;
+export declare const ISO_PLAYER_ROLE: import("@waica/engine").RoleDefinition;

package/dist/mcp/node_modules/@waica/behaviors/dist/iso-player-states.js

@@ -0,0 +1,9 @@
+import { createGridPlayerRole } from './grid-player-role.js';
+import { IsoMotor } from './iso-motor.js';
+const isoPlayer = createGridPlayerRole(IsoMotor, 'You control this character with screen-relative eight-direction movement ' +
+    'projected into an isometric logical world. Its states move the Motor.');
+/** The state graph new isometric player characters start with, as prefab data. */
+export const ISO_PLAYER_STATE_GRAPH = isoPlayer.graph;
+/** Drives IsoMotor from screen-relative actions and reports body state. */
+export const isoPlayerUpdate = isoPlayer.update;
+export const ISO_PLAYER_ROLE = isoPlayer.role;

package/dist/mcp/node_modules/@waica/behaviors/dist/platformer-motor.d.ts

@@ -1,4 +1,4 @@
-import { Component } from '@waica/engine';
+import { Component, type CameraVelocity, type CameraVelocityProvider } from '@waica/engine';
 /**
  * Passive platformer motor: tuning params, physical state and movement
  * methods for state code to call. It has no onUpdate of its own — the
@@ -9,7 +9,7 @@ import { Component } from '@waica/engine';
  * Per-axis collision against the scene's Solids — deterministic genre
  * movement (Celeste-style), not "realistic" physics.
  */
-export declare class PlatformerMotor extends Component {
+export declare class PlatformerMotor extends Component implements CameraVelocityProvider {
     static componentName: string;
     static displayName: string;
     static params: {
@@ -103,6 +103,8 @@ export declare class PlatformerMotor extends Component {
     private bufferTimer;
     private squashX;
     private squashY;
+    /** The scene camera reads follow velocity through this explicit seam. */
+    getCameraVelocity(): CameraVelocity;
     /**
      * Per-frame bookkeeping: forgiveness timers, squash decay and the
      * facing flip. The logic set's '*' hook runs it in every state, so

package/dist/mcp/node_modules/@waica/behaviors/dist/platformer-motor.js

@@ -1,4 +1,4 @@
-import { Component, resolveSolidAxis, THREE } from '@waica/engine';
+import { Component, resolveSolidAxis, THREE, } from '@waica/engine';
 /**
  * Passive platformer motor: tuning params, physical state and movement
  * methods for state code to call. It has no onUpdate of its own — the
@@ -60,6 +60,10 @@ export class PlatformerMotor extends Component {
     bufferTimer = 0;
     squashX = 1;
     squashY = 1;
+    /** The scene camera reads follow velocity through this explicit seam. */
+    getCameraVelocity() {
+        return { vx: this.vx, vy: this.vy };
+    }
     /**
      * Per-frame bookkeeping: forgiveness timers, squash decay and the
      * facing flip. The logic set's '*' hook runs it in every state, so

package/dist/mcp/node_modules/@waica/behaviors/dist/topdown-motor.d.ts

@@ -0,0 +1,18 @@
+import { GridMotor } from './grid-motor.js';
+/** The four facings the top-down animation contract declares. */
+export type TopDownFacing = 'n' | 's' | 'e' | 'w';
+/**
+ * Passive top-down motor: state code owns the frame and calls run() then
+ * step(). Eight-direction input is normalized so diagonals match cardinal
+ * speed; movement has no gravity and resolves each axis against Solids.
+ */
+export declare class TopDownMotor extends GridMotor<TopDownFacing> {
+    static componentName: string;
+    /** Four-direction facing; starts looking at the camera. */
+    facing: TopDownFacing;
+    /**
+     * Accelerates toward the input vector and lets the dominant raw input axis
+     * select facing. Perfect ties preserve the previous facing.
+     */
+    run(inputX: number, inputY: number, dt: number): void;
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/topdown-motor.js

@@ -0,0 +1,31 @@
+import { GridMotor } from './grid-motor.js';
+/**
+ * Passive top-down motor: state code owns the frame and calls run() then
+ * step(). Eight-direction input is normalized so diagonals match cardinal
+ * speed; movement has no gravity and resolves each axis against Solids.
+ */
+export class TopDownMotor extends GridMotor {
+    static componentName = 'TopDownMotor';
+    /** Four-direction facing; starts looking at the camera. */
+    facing = 's';
+    /**
+     * Accelerates toward the input vector and lets the dominant raw input axis
+     * select facing. Perfect ties preserve the previous facing.
+     */
+    run(inputX, inputY, dt) {
+        let x = inputX;
+        let y = inputY;
+        const length = Math.hypot(x, y);
+        if (length > 1) {
+            x /= length;
+            y /= length;
+        }
+        this.accelerateToward(x, y, dt);
+        const absX = Math.abs(inputX);
+        const absY = Math.abs(inputY);
+        if (absX > absY)
+            this.facing = inputX < 0 ? 'w' : 'e';
+        else if (absY > absX)
+            this.facing = inputY < 0 ? 's' : 'n';
+    }
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/topdown-player-states.d.ts

@@ -0,0 +1,5 @@
+/** The state graph new top-down player characters start with, as prefab data. */
+export declare const TOPDOWN_PLAYER_STATE_GRAPH: import("@waica/engine").RoleGraph;
+/** Drives TopDownMotor from project actions and reports body state. */
+export declare const topdownPlayerUpdate: (ctx: import("@waica/engine").StateContext, dt: number) => void;
+export declare const TOPDOWN_PLAYER_ROLE: import("@waica/engine").RoleDefinition;

package/dist/mcp/node_modules/@waica/behaviors/dist/topdown-player-states.js

@@ -0,0 +1,14 @@
+import { createGridPlayerRole } from './grid-player-role.js';
+import { TopDownMotor } from './topdown-motor.js';
+/**
+ * The top-down player role: eight-direction logical-grid movement with
+ * normalized diagonals and no gravity, driven by TopDownMotor.
+ */
+const topdownPlayer = createGridPlayerRole(TopDownMotor, 'You control this character with the project controls: eight-direction ' +
+    'top-down movement with normalized diagonals and no gravity. Its ' +
+    'states move the Motor.');
+/** The state graph new top-down player characters start with, as prefab data. */
+export const TOPDOWN_PLAYER_STATE_GRAPH = topdownPlayer.graph;
+/** Drives TopDownMotor from project actions and reports body state. */
+export const topdownPlayerUpdate = topdownPlayer.update;
+export const TOPDOWN_PLAYER_ROLE = topdownPlayer.role;

package/dist/mcp/node_modules/@waica/behaviors/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waica/behaviors",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Waica built-in behaviors — the curated game-feel library",
   "license": "MIT",
   "type": "module",
@@ -19,6 +19,6 @@
     }
   },
   "dependencies": {
-    "@waica/engine": "^0.6.1"
+    "@waica/engine": "^0.8.0"
   }
 }

package/dist/mcp/node_modules/@waica/engine/dist/animation/directional.d.ts

@@ -0,0 +1,48 @@
+import type { AnimationContract } from './contract.js';
+/**
+ * Directional animation contract: the archetype declares which facing
+ * directions exist, how clips are named per direction (`<state>-<dir>`),
+ * and how a missing direction degrades — including mirroring, so west can
+ * reuse east art flipped. Extends the base AnimationContract thesis to
+ * genres where characters face more than one way (top-down, isometric).
+ */
+export interface DirectionalFallback<Dir extends string = string> {
+    dir: Dir;
+    /** Mirror the resolved clip horizontally (e.g. west plays east flipped). */
+    flip?: boolean;
+}
+export interface DirectionalAnimation<Dir extends string = string> {
+    /** Declared facing directions, e.g. ['n', 's', 'e', 'w'] — 8 for isometric. */
+    directions: readonly Dir[];
+    /** Directional degradation: a missing facing resolves to another, optionally mirrored. */
+    fallbacks?: Partial<Record<Dir, DirectionalFallback<Dir>>>;
+    /** State-level degradation chain applied when no directional clip resolves. */
+    contract: AnimationContract;
+}
+export interface ResolvedDirectionalClip {
+    clip: string | undefined;
+    flip: boolean;
+}
+/**
+ * Resolves state × facing to a playable clip: the exact `<state>-<dir>`
+ * clip, else the declared directional fallback chain (accumulating flips).
+ * On a dead end, walks the base AnimationContract's state fallback chain
+ * (cycle-safe) and, for each candidate state in turn, retries the
+ * directional chain against it before trying its bare name. An invalid
+ * facing, or a chain that dead-ends everywhere, resolves to nothing rather
+ * than guessing — the caller's name-based fallback path handles that.
+ */
+export declare function resolveDirectionalClip(animation: DirectionalAnimation, available: Iterable<string>, state: string, facing: string): ResolvedDirectionalClip;
+/** Installs (or clears, with null) the active directional contract. */
+export declare function installDirectionalAnimation(animation: DirectionalAnimation | null): void;
+/** The active directional contract, if an archetype installed one. */
+export declare function installedDirectionalAnimation(): DirectionalAnimation | null;
+/**
+ * The explicit seam a driving component (a motor) opts into so StateMachine
+ * can resolve directional clips: it reports the entity's current facing as
+ * one of the contract's declared directions.
+ */
+export interface AnimationFacingProvider {
+    getAnimationFacing(): string;
+}
+export declare function isAnimationFacingProvider(value: unknown): value is AnimationFacingProvider;