@waica/cli 0.3.0

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/registry-data.js

@@ -0,0 +1,45 @@
+import { AnimatedSprite, DynamicBody, Hitbox, Solid, Sprite, StateMachine, } from '@waica/engine';
+import { Chaser, Collectible, Hazard, Lifetime, Patrol, PlatformerMotor, Respawnable, } from '@waica/behaviors';
+import { PLATFORMER_ART } from './art.js';
+import { PLATFORMER_PREFABS } from './prefabs.js';
+import { PLATFORMER_UI } from './ui.js';
+const PACKAGE_ASSETS = Object.fromEntries(PLATFORMER_ART.map((art) => [art.uri, `assets/${art.file}`]));
+/** Asset-import-free registry. Browser URL resolution is layered on separately. */
+export const PLATFORMER_REGISTRY_DATA = {
+    components: {
+        Sprite,
+        AnimatedSprite,
+        Solid,
+        Hitbox,
+        DynamicBody,
+        StateMachine,
+        PlatformerMotor,
+        Collectible,
+        Patrol,
+        Chaser,
+        Hazard,
+        Respawnable,
+        Lifetime,
+    },
+    resolveAsset: (uri) => PACKAGE_ASSETS[uri] ?? uri,
+    prefabs: PLATFORMER_PREFABS,
+    ui: PLATFORMER_UI,
+};
+const PALETTE_ICONS = {
+    player: '🐕',
+    slime: '👾',
+    coin: '🪙',
+    platform: '▬',
+    block: '■',
+    decor: '▢',
+};
+/** The editor palette: pieces you can drag into the viewport, one per prefab. */
+export const PLATFORMER_PALETTE = Object.entries(PLATFORMER_PREFABS).map(([key, prefab]) => {
+    const base = key.slice(key.indexOf('/') + 1);
+    return {
+        label: base,
+        icon: PALETTE_ICONS[base] ?? '▣',
+        category: prefab.type,
+        make: () => ({ name: base.charAt(0).toUpperCase() + base.slice(1), prefab: key }),
+    };
+});

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/registry.d.ts

@@ -0,0 +1,6 @@
+import type { SceneRegistry } from '@waica/engine';
+export { PLATFORMER_PALETTE } from './registry-data.js';
+/** Browser URL per stock-art file; Node resolves these to packed file URLs. */
+export declare const PLATFORMER_ART_URLS: Record<string, string>;
+/** Browser registry with bundled asset resolution layered over the shared registry. */
+export declare const PLATFORMER_REGISTRY: SceneRegistry;

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/registry.js

@@ -0,0 +1,15 @@
+import { PLATFORMER_ART } from './art.js';
+import { PLATFORMER_REGISTRY_DATA } from './registry-data.js';
+export { PLATFORMER_PALETTE } from './registry-data.js';
+/** Browser URL per stock-art file; Node resolves these to packed file URLs. */
+export const PLATFORMER_ART_URLS = {
+    'waica-dog.png': new URL('../assets/waica-dog.png', import.meta.url).href,
+    'waica-coin.png': new URL('../assets/waica-coin.png', import.meta.url).href,
+    'waica-slime.png': new URL('../assets/waica-slime.png', import.meta.url).href,
+};
+const BUILTIN_ASSETS = Object.fromEntries(PLATFORMER_ART.map((art) => [art.uri, PLATFORMER_ART_URLS[art.file] ?? art.uri]));
+/** Browser registry with bundled asset resolution layered over the shared registry. */
+export const PLATFORMER_REGISTRY = {
+    ...PLATFORMER_REGISTRY_DATA,
+    resolveAsset: (uri) => BUILTIN_ASSETS[uri] ?? uri,
+};

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/scene-default.d.ts

@@ -0,0 +1,40 @@
+import type { SceneJson } from '@waica/engine';
+/** Clips matching the platformer state graph, applied to the placeholder dog. */
+export declare const DOG_SPRITE: {
+    texture: string;
+    cols: number;
+    rows: number;
+    width: number;
+    height: number;
+    clips: {
+        idle: {
+            frames: number[];
+            fps: number;
+        };
+        run: {
+            frames: number[];
+            fps: number;
+        };
+        jump: {
+            frames: number[];
+            fps: number;
+            loop: boolean;
+        };
+        fall: {
+            frames: number[];
+            fps: number;
+        };
+    };
+    initialClip: string;
+};
+/**
+ * The platformer archetype's starting scene, as data: prefab refs plus the
+ * per-entity overrides that differ from the prefab. This is what the wizard
+ * copies into `src/scenes/main.scene.json` and what the editor edits.
+ */
+export declare const PLATFORMER_SCENE: SceneJson;
+/**
+ * The blank-start variant: same camera framing, zero entities. No `follow`
+ * because there is no Player yet — the editor's palette places the first one.
+ */
+export declare const PLATFORMER_BLANK_SCENE: SceneJson;

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/scene-default.js

@@ -0,0 +1,93 @@
+/** Clips matching the platformer state graph, applied to the placeholder dog. */
+export const DOG_SPRITE = {
+    texture: 'waica:dog',
+    cols: 4,
+    rows: 4,
+    width: 1.4,
+    height: 1.4,
+    clips: {
+        idle: { frames: [0, 1, 2, 3], fps: 5 },
+        run: { frames: [4, 5, 6, 7], fps: 10 },
+        jump: { frames: [8, 9], fps: 8, loop: false },
+        fall: { frames: [12, 13], fps: 8 },
+    },
+    initialClip: 'idle',
+};
+/**
+ * The platformer archetype's starting scene, as data: prefab refs plus the
+ * per-entity overrides that differ from the prefab. This is what the wizard
+ * copies into `src/scenes/main.scene.json` and what the editor edits.
+ */
+export const PLATFORMER_SCENE = {
+    waicaScene: 3,
+    camera: { position: [0, -1], zoom: 12, follow: 'Player' },
+    entities: [
+        { name: 'Player', prefab: 'characters/player', position: [0, -1] },
+        {
+            name: 'Ground-A',
+            prefab: 'tiles/platform',
+            position: [-6, -5],
+            overrides: { Sprite: { width: 16, height: 2 }, Solid: { width: 16, height: 2 } },
+        },
+        {
+            name: 'Ground-B',
+            prefab: 'tiles/platform',
+            position: [16, -5],
+            overrides: { Sprite: { width: 16, height: 2 }, Solid: { width: 16, height: 2 } },
+        },
+        {
+            name: 'Platform-1',
+            prefab: 'tiles/platform',
+            position: [5, -2.5],
+            overrides: { Sprite: { width: 4 }, Solid: { width: 4 } },
+        },
+        { name: 'Platform-2', prefab: 'tiles/platform', position: [9.5, -0.5] },
+        { name: 'Platform-3', prefab: 'tiles/platform', position: [-5.5, -1.5] },
+        {
+            name: 'Platform-4',
+            prefab: 'tiles/block',
+            position: [14, 1.5],
+            overrides: { Sprite: { width: 3, height: 0.5 }, Solid: { width: 3, height: 0.5 } },
+        },
+        {
+            name: 'Wall-Left',
+            prefab: 'tiles/block',
+            position: [-15.5, 0],
+            overrides: { Sprite: { height: 12 }, Solid: { height: 12 } },
+        },
+        {
+            name: 'Wall-Right',
+            prefab: 'tiles/block',
+            position: [25.5, 0],
+            overrides: { Sprite: { height: 12 }, Solid: { height: 12 } },
+        },
+        { name: 'Coin-1', prefab: 'objects/coin', position: [-5.5, -0.5] },
+        { name: 'Coin-2', prefab: 'objects/coin', position: [-2, -3.2] },
+        { name: 'Coin-3', prefab: 'objects/coin', position: [5, -1.7] },
+        { name: 'Coin-4', prefab: 'objects/coin', position: [9.5, 0.3] },
+        { name: 'Coin-5', prefab: 'objects/coin', position: [14, 2.3] },
+        { name: 'Coin-6', prefab: 'objects/coin', position: [19, -3.2] },
+        {
+            name: 'Slime-1',
+            prefab: 'characters/slime',
+            position: [-9, -3.55],
+            overrides: { Patrol: { speed: 1.5 } },
+        },
+        {
+            name: 'Slime-2',
+            prefab: 'characters/slime',
+            position: [17, -3.55],
+            overrides: { Patrol: { distance: 2.5, speed: 2.5 } },
+        },
+    ],
+    ui: ['coin-counter'],
+};
+/**
+ * The blank-start variant: same camera framing, zero entities. No `follow`
+ * because there is no Player yet — the editor's palette places the first one.
+ */
+export const PLATFORMER_BLANK_SCENE = {
+    waicaScene: 3,
+    camera: { position: [0, -1], zoom: 12 },
+    entities: [],
+};

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/ui.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The archetype's default UI pieces: self-contained HTML fragments
+ * (markup + <style>, {{stat}} bindings) keyed by piece name. Projects
+ * override them with src/ui/<name>.html files; scenes list the pieces
+ * they start with in their "ui" field.
+ *
+ * TS template literals (not .html files) because this package builds
+ * with plain tsc — no bundler to inline raw imports.
+ */
+export declare const PLATFORMER_UI: Record<string, string>;

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/ui.js

@@ -0,0 +1,24 @@
+/**
+ * The archetype's default UI pieces: self-contained HTML fragments
+ * (markup + <style>, {{stat}} bindings) keyed by piece name. Projects
+ * override them with src/ui/<name>.html files; scenes list the pieces
+ * they start with in their "ui" field.
+ *
+ * TS template literals (not .html files) because this package builds
+ * with plain tsc — no bundler to inline raw imports.
+ */
+export const PLATFORMER_UI = {
+    'coin-counter': `<style>
+  .coin-counter {
+    position: absolute;
+    top: 12px;
+    left: 12px;
+    font: 600 20px system-ui, sans-serif;
+    color: #ffd166;
+    text-shadow: 0 1px 3px #000a;
+    user-select: none;
+  }
+</style>
+<div class="coin-counter">🪙 {{points}}</div>
+`,
+};

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

@@ -0,0 +1,30 @@
+{
+  "name": "@waica/archetype-platformer",
+  "version": "0.3.0",
+  "description": "Waica platformer archetype — opinionated setup for side-scrolling platformers",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chichex/waica",
+    "directory": "packages/archetype-platformer"
+  },
+  "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.3.0",
+    "@waica/engine": "^0.3.0"
+  }
+}

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

@@ -0,0 +1,59 @@
+import { Component, type RoleDefinition, type RoleGraph } from '@waica/engine';
+export type ChaserMode = 'walker' | 'ghost' | 'flyer';
+/**
+ * Pursuit toward the player while they are within sight range, in one of
+ * three modes: a walker paces the ground (X only, gravity, blocked by
+ * Solids), a ghost floats straight at them through everything, a flyer
+ * floats straight at them but walls and ceilings stop it.
+ * Passive like a motor: no onUpdate of its own — the 'chaser' logic set's
+ * chase state calls step(dt), so the StateMachine stays the single owner
+ * of the frame.
+ */
+export declare class Chaser extends Component {
+    static componentName: string;
+    static params: {
+        mode: {
+            label: string;
+            options: string[];
+        };
+        range: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        speed: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        gravity: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    mode: ChaserMode;
+    range: number;
+    speed: number;
+    gravity: number;
+    private vy;
+    private target;
+    /** The player is the live entity whose StateMachine declares that role. */
+    private findTarget;
+    /** One chase step in the current mode, flipping the sprite toward prey. */
+    step(dt: number): void;
+    /** Ground pursuit: chase on X when in sight; gravity and Solids always rule. */
+    private stepWalker;
+    /** Straight-line pursuit; the flyer sweeps against Solids, the ghost doesn't. */
+    private stepAirborne;
+    /** Resolves this mode's body through the engine's shared Solid solver. */
+    private resolveAxis;
+    /** AABB sized by the sibling Hitbox (chassis default if none). */
+    private collisionBody;
+}
+/** The state graph new chasing characters start with, as prefab data. */
+export declare const CHASER_STATE_GRAPH: RoleGraph;
+export declare const CHASER_ROLE: RoleDefinition;

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

@@ -0,0 +1,127 @@
+import { Component, Hitbox, resolveSolidAxis, } from '@waica/engine';
+import { isPlayer } from './player-identity.js';
+/**
+ * Pursuit toward the player while they are within sight range, in one of
+ * three modes: a walker paces the ground (X only, gravity, blocked by
+ * Solids), a ghost floats straight at them through everything, a flyer
+ * floats straight at them but walls and ceilings stop it.
+ * Passive like a motor: no onUpdate of its own — the 'chaser' logic set's
+ * chase state calls step(dt), so the StateMachine stays the single owner
+ * of the frame.
+ */
+export class Chaser extends Component {
+    static componentName = 'Chaser';
+    static params = {
+        mode: { label: 'Mode', options: ['walker', 'ghost', 'flyer'] },
+        range: { label: 'Sight range', min: 1, max: 30, step: 0.5 },
+        speed: { label: 'Speed', min: 0.5, max: 15, step: 0.5 },
+        gravity: { label: 'Gravity (walker)', min: 5, max: 120, step: 1 },
+    };
+    mode = 'walker';
+    range = 6;
+    speed = 3;
+    gravity = 42;
+    vy = 0;
+    target;
+    /** The player is the live entity whose StateMachine declares that role. */
+    findTarget() {
+        if (!this.target?.alive || !isPlayer(this.target)) {
+            this.target = this.entity.game.entities.find(isPlayer);
+        }
+        return this.target;
+    }
+    /** One chase step in the current mode, flipping the sprite toward prey. */
+    step(dt) {
+        if (this.mode === 'walker')
+            this.stepWalker(dt);
+        else
+            this.stepAirborne(dt);
+    }
+    /** Ground pursuit: chase on X when in sight; gravity and Solids always rule. */
+    stepWalker(dt) {
+        const pos = this.entity.position;
+        const target = this.findTarget();
+        const dx = target ? target.position.x - pos.x : 0;
+        if (target && Math.abs(dx) <= this.range && Math.abs(dx) > 0.05) {
+            const dir = dx > 0 ? 1 : -1;
+            const previous = pos.x;
+            pos.x += dir * Math.min(this.speed * dt, Math.abs(dx));
+            this.resolveAxis('x', previous);
+            this.entity.scale.x = dir;
+        }
+        // Gravity applies in and out of sight — a walker spawned midair lands.
+        this.vy = Math.max(this.vy - this.gravity * dt, -22);
+        const previous = pos.y;
+        pos.y += this.vy * dt;
+        this.resolveAxis('y', previous);
+    }
+    /** Straight-line pursuit; the flyer sweeps against Solids, the ghost doesn't. */
+    stepAirborne(dt) {
+        const pos = this.entity.position;
+        const target = this.findTarget();
+        if (!target)
+            return;
+        const dx = target.position.x - pos.x;
+        const dy = target.position.y - pos.y;
+        const dist = Math.hypot(dx, dy);
+        // The inner deadband keeps it from jittering on top of the player.
+        if (dist > this.range || dist < 0.1)
+            return;
+        const move = Math.min(this.speed * dt, dist);
+        const solid = this.mode === 'flyer';
+        const previousX = pos.x;
+        pos.x += (dx / dist) * move;
+        if (solid)
+            this.resolveAxis('x', previousX);
+        const previousY = pos.y;
+        pos.y += (dy / dist) * move;
+        if (solid)
+            this.resolveAxis('y', previousY);
+        if (Math.abs(dx) > 0.05)
+            this.entity.scale.x = dx > 0 ? 1 : -1;
+    }
+    /** Resolves this mode's body through the engine's shared Solid solver. */
+    resolveAxis(axis, previous) {
+        const collided = resolveSolidAxis({
+            entity: this.entity,
+            axis,
+            previous,
+            body: () => this.collisionBody(),
+        });
+        if (collided && axis === 'y')
+            this.vy = 0;
+    }
+    /** AABB sized by the sibling Hitbox (chassis default if none). */
+    collisionBody() {
+        const box = this.entity.get(Hitbox);
+        return {
+            x: this.entity.position.x + (box?.offsetX ?? 0),
+            y: this.entity.position.y + (box?.offsetY ?? 0),
+            width: box?.width ?? 0.9,
+            height: box?.height ?? 0.95,
+            shape: 'rectangle',
+        };
+    }
+}
+/** The state graph new chasing characters start with, as prefab data. */
+export const CHASER_STATE_GRAPH = {
+    initial: 'chase',
+    states: { chase: {} },
+};
+// The pursuer role. One state out of the box; give chasing characters more
+// states by registering on top (defineStates('chaser', { flee: {...} }))
+// plus prefab data.
+export const CHASER_ROLE = {
+    description: 'Hunts the player when they come within sight range. Its Mode picks ' +
+        'the body: a walker paces the ground with gravity, a ghost floats ' +
+        'through walls, a flyer floats but walls stop it. Its states move Chaser.',
+    driver: 'Chaser',
+    graph: CHASER_STATE_GRAPH,
+    states: {
+        chase: {
+            onUpdate({ entity }, dt) {
+                entity.get(Chaser)?.step(dt);
+            },
+        },
+    },
+};

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

@@ -0,0 +1,25 @@
+import { Component, type Entity } from '@waica/engine';
+/**
+ * Collected when the entity with the player role touches
+ * it: adds its value to a stat, fires onCollect and destroys itself.
+ * Requires Hitbox on both entities.
+ */
+export declare class Collectible extends Component {
+    static componentName: string;
+    static params: {
+        value: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        stat: {
+            label: string;
+        };
+    };
+    value: number;
+    /** Stat receiving the value ('' collects without counting anywhere). */
+    stat: string;
+    onCollect?: (value: number) => void;
+    onCollide(other: Entity): void;
+}

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

@@ -0,0 +1,27 @@
+import { Component } from '@waica/engine';
+import { isPlayer } from './player-identity.js';
+/**
+ * Collected when the entity with the player role touches
+ * it: adds its value to a stat, fires onCollect and destroys itself.
+ * Requires Hitbox on both entities.
+ */
+export class Collectible extends Component {
+    static componentName = 'Collectible';
+    static params = {
+        value: { label: 'Value', min: 1, max: 100, step: 1 },
+        stat: { label: 'Adds to stat' },
+    };
+    value = 1;
+    /** Stat receiving the value ('' collects without counting anywhere). */
+    stat = 'points';
+    onCollect;
+    onCollide(other) {
+        if (!isPlayer(other))
+            return;
+        this.onCollect?.(this.value);
+        if (this.stat)
+            this.game.stats.add(this.stat, this.value);
+        this.game.events.emit('collect', this.value);
+        this.entity.destroy();
+    }
+}

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

@@ -0,0 +1,29 @@
+import { Component, type Entity } from '@waica/engine';
+export type HazardTouch = 'stomp' | 'hurt';
+/**
+ * Touching a hazard by stomping it from above (falling, with the feet
+ * above its center) squashes it; any other contact hurts.
+ * Pure, so the decision is testable without the engine.
+ */
+export declare function resolveHazardTouch(playerVy: number, playerBottom: number, hazardY: number, stompable: boolean): HazardTouch;
+/**
+ * Hurts the player on contact. If stompable (Mario-style), stomping it
+ * destroys it and bounces the player. Requires Hitbox on both entities.
+ */
+export declare class Hazard extends Component {
+    static componentName: string;
+    static params: {
+        stompable: {
+            label: string;
+        };
+        bounce: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    stompable: boolean;
+    bounce: number;
+    onCollide(other: Entity): void;
+}

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

@@ -0,0 +1,42 @@
+import { Component } from '@waica/engine';
+import { PlatformerMotor } from './platformer-motor.js';
+import { isPlayer } from './player-identity.js';
+import { Respawnable } from './respawnable.js';
+/**
+ * Touching a hazard by stomping it from above (falling, with the feet
+ * above its center) squashes it; any other contact hurts.
+ * Pure, so the decision is testable without the engine.
+ */
+export function resolveHazardTouch(playerVy, playerBottom, hazardY, stompable) {
+    if (stompable && playerVy < 0 && playerBottom > hazardY)
+        return 'stomp';
+    return 'hurt';
+}
+/**
+ * Hurts the player on contact. If stompable (Mario-style), stomping it
+ * destroys it and bounces the player. Requires Hitbox on both entities.
+ */
+export class Hazard extends Component {
+    static componentName = 'Hazard';
+    static params = {
+        stompable: { label: 'Stompable' },
+        bounce: { label: 'Stomp bounce', min: 0, max: 30, step: 0.5 },
+    };
+    stompable = true;
+    bounce = 10;
+    onCollide(other) {
+        if (!isPlayer(other))
+            return;
+        const motor = other.get(PlatformerMotor);
+        if (motor) {
+            const playerBottom = other.position.y - motor.hitboxHeight / 2;
+            const touch = resolveHazardTouch(motor.vy, playerBottom, this.entity.position.y, this.stompable);
+            if (touch === 'stomp') {
+                this.entity.destroy();
+                motor.vy = this.bounce;
+                return;
+            }
+        }
+        other.get(Respawnable)?.respawn();
+    }
+}

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

@@ -0,0 +1,9 @@
+export { PlatformerMotor } from './platformer-motor.js';
+export { PLAYER_ROLE, PLAYER_STATE_GRAPH, playerUpdate } from './player-states.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 { Respawnable } from './respawnable.js';
+export { Lifetime } from './lifetime.js';

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

@@ -0,0 +1,9 @@
+export { PlatformerMotor } from './platformer-motor.js';
+export { PLAYER_ROLE, PLAYER_STATE_GRAPH, playerUpdate } from './player-states.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 { Respawnable } from './respawnable.js';
+export { Lifetime } from './lifetime.js';

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

@@ -0,0 +1,16 @@
+import { Component } from '@waica/engine';
+/** Destroys its entity after a configurable amount of simulated time. */
+export declare class Lifetime extends Component {
+    static componentName: string;
+    static params: {
+        seconds: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    seconds: number;
+    private elapsed;
+    onUpdate(dt: number): void;
+}

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

@@ -0,0 +1,19 @@
+import { Component } from '@waica/engine';
+/** Destroys its entity after a configurable amount of simulated time. */
+export class Lifetime extends Component {
+    static componentName = 'Lifetime';
+    static params = {
+        seconds: { label: 'Seconds', min: 0.05, max: 60, step: 0.05 },
+    };
+    seconds = 1;
+    elapsed = 0;
+    onUpdate(dt) {
+        // The frame that destroys the entity still iterates a copy of its
+        // components: stop counting instead of destroying twice.
+        if (!this.entity.alive)
+            return;
+        this.elapsed += dt;
+        if (this.elapsed >= this.seconds)
+            this.entity.destroy();
+    }
+}

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

@@ -0,0 +1,4 @@
+import { type RoleDefinition, type RoleGraph } from '@waica/engine';
+/** The state graph new NPCs start with, as prefab data. */
+export declare const NPC_STATE_GRAPH: RoleGraph;
+export declare const NPC_ROLE: RoleDefinition;

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

@@ -0,0 +1,14 @@
+import {} from '@waica/engine';
+/** The state graph new NPCs start with, as prefab data. */
+export const NPC_STATE_GRAPH = {
+    initial: 'idle',
+    states: { idle: {} },
+};
+// The bystander role: no driver and no code — the character stands where
+// you put it, playing its idle animation, and hurts no one. Bring it to
+// life by adding states (defineStates('npc', {...})) and behaviours.
+export const NPC_ROLE = {
+    description: 'Stands where you put it — no input, no movement, harmless. Good for ' +
+        'villagers and signposts. Give it states to bring it to life.',
+    graph: NPC_STATE_GRAPH,
+};