@waica/cli 0.7.0 → 0.9.0

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

@@ -0,0 +1,18 @@
+import { type ProjectedPoint } from '@waica/engine';
+/** The eight screen-relative facings a directional contract can declare. */
+export type ScreenFacing = 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw';
+export declare const SCREEN_FACINGS: readonly ScreenFacing[];
+/**
+ * The eight-way facing a screen-relative input reads as — signs only, so a
+ * tiny diagonal component still counts. Undefined for no input, which lets
+ * the caller keep whatever it was facing.
+ */
+export declare function facingForInput(inputX: number, inputY: number): ScreenFacing | undefined;
+/** The screen sign pair behind a facing; undefined for a name the table lacks. */
+export declare function facingVector(facing: string): ProjectedPoint | undefined;
+/**
+ * The unit vector a facing points along in the scene's logical space: the
+ * screen vector itself without a projection, or its image on the logical
+ * diamond under the isometric one — the same mapping the motors move along.
+ */
+export declare function logicalDirection(facing: string, projection: 'isometric' | null): ProjectedPoint | undefined;

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

@@ -0,0 +1,56 @@
+import { screenInputToLogical } from '@waica/engine';
+export const SCREEN_FACINGS = ['n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw'];
+/** Facing → screen sign pair (x right, y up), the inverse of facingForInput. */
+const FACING_VECTORS = {
+    n: { x: 0, y: 1 },
+    ne: { x: 1, y: 1 },
+    e: { x: 1, y: 0 },
+    se: { x: 1, y: -1 },
+    s: { x: 0, y: -1 },
+    sw: { x: -1, y: -1 },
+    w: { x: -1, y: 0 },
+    nw: { x: -1, y: 1 },
+};
+/**
+ * The eight-way facing a screen-relative input reads as — signs only, so a
+ * tiny diagonal component still counts. Undefined for no input, which lets
+ * the caller keep whatever it was facing.
+ */
+export 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';
+}
+/** The screen sign pair behind a facing; undefined for a name the table lacks. */
+export function facingVector(facing) {
+    const vector = FACING_VECTORS[facing];
+    return vector ? { ...vector } : undefined;
+}
+/**
+ * The unit vector a facing points along in the scene's logical space: the
+ * screen vector itself without a projection, or its image on the logical
+ * diamond under the isometric one — the same mapping the motors move along.
+ */
+export function logicalDirection(facing, projection) {
+    const vector = facingVector(facing);
+    if (!vector)
+        return undefined;
+    if (projection === 'isometric')
+        return screenInputToLogical(vector.x, vector.y);
+    const length = Math.hypot(vector.x, vector.y);
+    return { x: vector.x / length, y: vector.y / length };
+}

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

@@ -0,0 +1,64 @@
+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;
+        };
+        knockbackSpeed: {
+            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;
+    /** How hard a hit shoves the body away from its source (the hurt state). */
+    knockbackSpeed: 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,77 @@
+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 },
+        knockbackSpeed: { label: 'Knockback speed', min: 0, max: 30, step: 0.5 },
+    };
+    static transient = ['vx', 'vy', 'facing'];
+    moveSpeed = 6;
+    acceleration = 60;
+    deceleration = 80;
+    /** Speed above this reads as walking (the idle ↔ walk edge). */
+    walkThreshold = 0.5;
+    /** How hard a hit shoves the body away from its source (the hurt state). */
+    knockbackSpeed = 8;
+    /** 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,20 @@
+import { type Component, type ComponentClass, type RoleDefinition, type RoleGraph, type StateContext } from '@waica/engine';
+interface PlayerMotor extends Component {
+    walkThreshold: number;
+    knockbackSpeed: number;
+    facing: string;
+    vx: number;
+    vy: number;
+    run(inputX: number, inputY: number, dt: number): void;
+    step(dt: number): void;
+    speed(): number;
+    halt(): void;
+}
+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,133 @@
+import {} from '@waica/engine';
+import { logicalDirection } from './facing.js';
+import { Health } from './health.js';
+import { interactUpdate } from './interactable.js';
+import { MeleeAttack } from './melee-attack.js';
+import { Respawnable } from './respawnable.js';
+/** Seconds the attack swing and the hurt stun each keep the body from the player. */
+const ATTACK_SECONDS = 0.3;
+const HURT_SECONDS = 0.3;
+/** 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: 'input:attack', to: 'attack' },
+                    { on: 'signal:move', to: 'walk' },
+                ],
+            },
+            walk: {
+                transitions: [
+                    { on: 'input:attack', to: 'attack' },
+                    { on: 'signal:stop', to: 'idle' },
+                ],
+            },
+            // One swing, body frozen; the strike itself lands on entry.
+            attack: {
+                transitions: [{ on: `timer:${ATTACK_SECONDS}`, to: 'idle' }],
+            },
+            // Knocked back and stunned for a beat; the '*' edge below gets it here.
+            hurt: {
+                transitions: [{ on: `timer:${HURT_SECONDS}`, to: 'idle' }],
+            },
+            dead: {
+                // The death pose, resolved directionally like every other clip.
+                clip: 'death',
+                transitions: [{ on: 'timer:0.8', to: 'idle' }],
+            },
+            // Dying and getting hurt are the same from every state, so both edges
+            // live on '*' — death first, so a lethal hit never lands in hurt. The
+            // death edge is also the contract Health checks before signalling: a
+            // graph without it gets its entity destroyed instead.
+            '*': {
+                transitions: [
+                    { on: 'signal:death', to: 'dead' },
+                    { on: 'signal:hurt', to: 'hurt' },
+                ],
+            },
+        },
+    };
+    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 },
+            attack: {
+                onEnter({ entity }) {
+                    const motor = entity.get(Motor);
+                    if (!motor)
+                        return;
+                    motor.halt();
+                    entity.get(MeleeAttack)?.strike(motor.facing);
+                },
+                // Explicit no-op: without it the state would inherit the default
+                // body update and keep walking through the swing.
+                onUpdate() { },
+            },
+            hurt: {
+                onEnter({ entity, game }) {
+                    const motor = entity.get(Motor);
+                    if (!motor)
+                        return;
+                    const source = entity.get(Health)?.lastDamageSource;
+                    const dx = source ? entity.position.x - source.position.x : 0;
+                    const dy = source ? entity.position.y - source.position.y : 0;
+                    const distance = Math.hypot(dx, dy);
+                    let away = distance > 0 ? { x: dx / distance, y: dy / distance } : undefined;
+                    if (!away) {
+                        // No source (or one standing on top of us): recoil from the facing.
+                        const forward = logicalDirection(motor.facing, game.projection);
+                        away = forward ? { x: -forward.x, y: -forward.y } : { x: 0, y: 0 };
+                    }
+                    motor.vx = away.x * motor.knockbackSpeed;
+                    motor.vy = away.y * motor.knockbackSpeed;
+                },
+                // The shove resolves against Solids like any movement; no input.
+                onUpdate({ entity }, dt) {
+                    entity.get(Motor)?.step(dt);
+                },
+                onExit({ entity }) {
+                    entity.get(Motor)?.halt();
+                },
+            },
+            // 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/health.d.ts

@@ -41,19 +41,40 @@ export declare class Health extends Component {
             max: number;
             step: number;
         };
+        stat: {
+            label: string;
+            ref: 'stat';
+        };
     };
     static transient: string[];
     max: number;
     /** Seconds of immunity granted by taking a hit. 0 disables i-frames. */
     invulnerability: number;
+    /**
+     * Stat that mirrors `current` (a HUD binds to it with `{{stat}}`). Empty
+     * publishes nothing: the stat is the project's to declare.
+     */
+    stat: string;
     /** Health left; 0 is dead. Filled in from max on ready. */
     current: number;
+    /** Whoever dealt the last accepted hit, for the state that reacts to it. */
+    lastDamageSource: Entity | undefined;
     /** Seconds left in the invulnerability window. */
     private invulnerable;
+    /** Seconds into the current blink, for the 10 Hz toggle. */
+    private blinkClock;
+    /** Whether the node is being flashed: exactly while a window is open. */
+    get blinking(): boolean;
     /** Whether the signalled death must be checked on this component's next update. */
     private deathPending;
     /** States the death signal was supposed to reach. */
     private expectedStates;
+    /**
+     * What a Runtime Snapshot shows: the authored values, the live ones, and
+     * the last source by name — projecting the whole Entity would drag its
+     * scene node along and bury the numbers that matter.
+     */
+    inspectState(): Record<string, unknown>;
     onReady(): void;
     onUpdate(dt: number): void;
     /**
@@ -73,6 +94,14 @@ export declare class Health extends Component {
     damage(amount: number, source?: Entity): void;
     /** Gives health back, capped at max. heal(Infinity) is a full restore. */
     heal(amount: number): void;
+    /** Mirrors current into the named stat, when one is named. */
+    private publish;
+    /**
+     * Flashes the node at 10 Hz for as long as the window stays open, and
+     * leaves it visible the frame the window closes — the flash is feedback,
+     * never a state a hit can leave the entity stuck in.
+     */
+    private blink;
     /**
      * Announces the death, then lets the role decide — but only if it says it
      * can: a graph with no death edge would swallow the signal silently, so

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

@@ -7,6 +7,8 @@ import { Component, StateMachine } from '@waica/engine';
  * otherwise miss forever, leaving the entity undead at 0 HP.
  */
 const DEATH_EPSILON = 1e-9;
+/** Seconds each blink phase lasts while invulnerable: 10 Hz on/off. */
+const BLINK_PERIOD = 0.1;
 /**
  * Where a 'signal:death' from `current` could land: the targets of every
  * death edge on the current state or on '*'. Mirrors the merge
@@ -44,19 +46,56 @@ export class Health extends Component {
     static params = {
         max: { label: 'Max health', min: 1, max: 20, step: 1 },
         invulnerability: { label: 'Invulnerability', min: 0, max: 5, step: 0.1 },
+        stat: { label: 'Stat', ref: 'stat' },
     };
-    static transient = ['current', 'invulnerable', 'deathPending', 'expectedStates'];
+    static transient = [
+        'current',
+        'invulnerable',
+        'deathPending',
+        'expectedStates',
+        'lastDamageSource',
+        'blinkClock',
+    ];
     max = 3;
     /** Seconds of immunity granted by taking a hit. 0 disables i-frames. */
     invulnerability = 0;
+    /**
+     * Stat that mirrors `current` (a HUD binds to it with `{{stat}}`). Empty
+     * publishes nothing: the stat is the project's to declare.
+     */
+    stat = '';
     /** Health left; 0 is dead. Filled in from max on ready. */
     current = 0;
+    /** Whoever dealt the last accepted hit, for the state that reacts to it. */
+    lastDamageSource;
     /** Seconds left in the invulnerability window. */
     invulnerable = 0;
+    /** Seconds into the current blink, for the 10 Hz toggle. */
+    blinkClock = 0;
+    /** Whether the node is being flashed: exactly while a window is open. */
+    get blinking() {
+        return this.invulnerable > 0;
+    }
     /** Whether the signalled death must be checked on this component's next update. */
     deathPending = false;
     /** States the death signal was supposed to reach. */
     expectedStates = [];
+    /**
+     * What a Runtime Snapshot shows: the authored values, the live ones, and
+     * the last source by name — projecting the whole Entity would drag its
+     * scene node along and bury the numbers that matter.
+     */
+    inspectState() {
+        return {
+            max: this.max,
+            invulnerability: this.invulnerability,
+            stat: this.stat,
+            current: this.current,
+            invulnerable: this.invulnerable,
+            blinking: this.blinking,
+            lastDamageSource: this.lastDamageSource?.name ?? null,
+        };
+    }
     onReady() {
         // The inspector has no min clamp on max, so an authored 0 (or a
         // negative value) is reachable. Without this, current lands at <= 0
@@ -64,12 +103,15 @@ export class Health extends Component {
         // so die() is never reached — permanently invulnerable instead of
         // already dead.
         this.current = Math.max(0, this.max);
+        this.publish();
         if (this.current === 0)
             this.die();
     }
     onUpdate(dt) {
-        if (this.invulnerable > 0)
+        if (this.invulnerable > 0) {
             this.invulnerable = Math.max(0, this.invulnerable - dt);
+            this.blink(dt);
+        }
         if (this.deathPending) {
             this.deathPending = false;
             this.settleDeath();
@@ -108,6 +150,8 @@ export class Health extends Component {
         this.current = Math.max(0, this.current - amount);
         if (this.current < DEATH_EPSILON)
             this.current = 0;
+        this.lastDamageSource = source;
+        this.publish();
         this.game.events.emit('damage', {
             entity: this.entity,
             amount,
@@ -115,14 +159,39 @@ export class Health extends Component {
             source,
         });
         this.invulnerable = this.invulnerability;
-        if (this.current === 0)
+        this.blinkClock = 0;
+        if (this.current === 0) {
             this.die();
+            return;
+        }
+        // Fire-and-forget, like death: a graph with no 'signal:hurt' edge simply
+        // ignores it, so a stunned/knocked-back reaction is the role's to add.
+        this.entity.get(StateMachine)?.signal('hurt');
     }
     /** Gives health back, capped at max. heal(Infinity) is a full restore. */
     heal(amount) {
         if (amount <= 0)
             return;
         this.current = Math.min(this.max, this.current + amount);
+        this.publish();
+    }
+    /** Mirrors current into the named stat, when one is named. */
+    publish() {
+        if (this.stat)
+            this.game.stats.set(this.stat, this.current);
+    }
+    /**
+     * Flashes the node at 10 Hz for as long as the window stays open, and
+     * leaves it visible the frame the window closes — the flash is feedback,
+     * never a state a hit can leave the entity stuck in.
+     */
+    blink(dt) {
+        if (this.invulnerable > 0) {
+            this.blinkClock += dt;
+            this.entity.node.visible = Math.floor(this.blinkClock / BLINK_PERIOD) % 2 === 0;
+            return;
+        }
+        this.entity.node.visible = true;
     }
     /**
      * Announces the death, then lets the role decide — but only if it says it
@@ -130,6 +199,13 @@ export class Health extends Component {
      * destroying is the fallback rather than the exception.
      */
     die() {
+        // The killing blow opened a window like any other hit; close it. The
+        // death pose must hold steady, and a revived entity starts without
+        // leftover immunity. The node is visible here by construction: blink()
+        // restores it the frame a window closes, and a lethal hit only lands
+        // while no window is open.
+        this.invulnerable = 0;
+        this.blinkClock = 0;
         this.game.events.emit('death', { entity: this.entity });
         const machine = this.entity.get(StateMachine);
         const targets = machine ? deathTargets(machine.states, machine.current) : [];

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

@@ -1,13 +1,16 @@
 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 { Interactable, interactUpdate } from './interactable.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';
 export { NPC_ROLE, NPC_STATE_GRAPH } from './npc.js';
 export { Hazard, resolveHazardTouch, type HazardTouch } from './hazard.js';
+export { MeleeAttack } from './melee-attack.js';
 export { Health, declaresDeathHandling, deathTargets } from './health.js';
 export { Respawnable } from './respawnable.js';
 export { OutOfBounds } from './out-of-bounds.js';

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

@@ -1,13 +1,16 @@
 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 { Interactable, interactUpdate } from './interactable.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';
 export { NPC_ROLE, NPC_STATE_GRAPH } from './npc.js';
 export { Hazard, resolveHazardTouch } from './hazard.js';
+export { MeleeAttack } from './melee-attack.js';
 export { Health, declaresDeathHandling, deathTargets } from './health.js';
 export { Respawnable } from './respawnable.js';
 export { OutOfBounds } from './out-of-bounds.js';

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

@@ -22,6 +22,9 @@ export declare class Interactable extends Component {
     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

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

@@ -15,6 +15,29 @@ export class Interactable extends Component {
     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
@@ -37,13 +60,13 @@ export function interactUpdate({ entity, game }) {
         }
     }
     if (!nearest) {
-        game.ui.hide('npc-line');
+        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('npc-line');
+        game.ui.show(INTERACTABLE_UI_PIECE);
     }
 }