@waica/cli 0.4.2 → 0.5.0

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

@@ -8,7 +8,13 @@ export type HazardTouch = 'stomp' | 'hurt';
 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.
+ * bounces the player. Requires Hitbox on both entities.
+ *
+ * "Hurts on touch" is all this means — being able to take a hit is Health's
+ * job, so a spike is a Hazard alone and an enemy is Hazard + Health. Either
+ * side of the interaction falls back to its pre-Health behavior (destroy
+ * itself on a stomp, respawn the player on contact) when there is no Health
+ * to route the damage through.
  */
 export declare class Hazard extends Component {
     static componentName: string;
@@ -22,8 +28,43 @@ export declare class Hazard extends Component {
             max: number;
             step: number;
         };
+        stompDamage: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        contactDamage: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
     };
+    static transient: string[];
     stompable: boolean;
     bounce: number;
+    /**
+     * Dealt to this entity when the player stomps it. Only read on the
+     * Health path — with no Health on this entity, a stomp always destroys
+     * it outright (the legacy behavior), whatever this is set to. Setting it
+     * to 0 does not make a Health-less hazard survive a stomp.
+     */
+    stompDamage: number;
+    /**
+     * Dealt to whoever touches it any other way. Only read on the Health
+     * path — with no Health on the other entity, contact always respawns it
+     * (the legacy behavior), whatever this is set to. Setting it to 0 does
+     * not make contact harmless for a Health-less target.
+     */
+    contactDamage: number;
+    /**
+     * Set once a stomp bounces the player, until it stops rising. The bounce
+     * (motor.vy = this.bounce) can leave the hitboxes still overlapping on
+     * the very next check, and with vy no longer < 0 resolveHazardTouch reads
+     * that as 'hurt' — a survivor would otherwise hurt the player it is still
+     * bouncing away from.
+     */
+    private bouncing;
     onCollide(other: Entity): void;
 }

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

@@ -1,4 +1,5 @@
 import { Component } from '@waica/engine';
+import { Health } from './health.js';
 import { PlatformerMotor } from './platformer-motor.js';
 import { isPlayer } from './player-identity.js';
 import { Respawnable } from './respawnable.js';
@@ -14,16 +15,47 @@ export function resolveHazardTouch(playerVy, playerBottom, hazardY, stompable) {
 }
 /**
  * Hurts the player on contact. If stompable (Mario-style), stomping it
- * destroys it and bounces the player. Requires Hitbox on both entities.
+ * bounces the player. Requires Hitbox on both entities.
+ *
+ * "Hurts on touch" is all this means — being able to take a hit is Health's
+ * job, so a spike is a Hazard alone and an enemy is Hazard + Health. Either
+ * side of the interaction falls back to its pre-Health behavior (destroy
+ * itself on a stomp, respawn the player on contact) when there is no Health
+ * to route the damage through.
  */
 export class Hazard extends Component {
     static componentName = 'Hazard';
     static params = {
         stompable: { label: 'Stompable' },
         bounce: { label: 'Stomp bounce', min: 0, max: 30, step: 0.5 },
+        stompDamage: { label: 'Stomp damage', min: 0, max: 20, step: 1 },
+        contactDamage: { label: 'Contact damage', min: 0, max: 20, step: 1 },
     };
+    static transient = ['bouncing'];
     stompable = true;
     bounce = 10;
+    /**
+     * Dealt to this entity when the player stomps it. Only read on the
+     * Health path — with no Health on this entity, a stomp always destroys
+     * it outright (the legacy behavior), whatever this is set to. Setting it
+     * to 0 does not make a Health-less hazard survive a stomp.
+     */
+    stompDamage = 1;
+    /**
+     * Dealt to whoever touches it any other way. Only read on the Health
+     * path — with no Health on the other entity, contact always respawns it
+     * (the legacy behavior), whatever this is set to. Setting it to 0 does
+     * not make contact harmless for a Health-less target.
+     */
+    contactDamage = 1;
+    /**
+     * Set once a stomp bounces the player, until it stops rising. The bounce
+     * (motor.vy = this.bounce) can leave the hitboxes still overlapping on
+     * the very next check, and with vy no longer < 0 resolveHazardTouch reads
+     * that as 'hurt' — a survivor would otherwise hurt the player it is still
+     * bouncing away from.
+     */
+    bouncing = false;
     onCollide(other) {
         if (!isPlayer(other))
             return;
@@ -32,11 +64,25 @@ export class Hazard extends Component {
             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();
+                const health = this.entity.get(Health);
+                if (health)
+                    health.damage(this.stompDamage, other);
+                else
+                    this.entity.destroy();
                 motor.vy = this.bounce;
+                this.bouncing = true;
                 return;
             }
+            if (this.bouncing) {
+                if (motor.vy > 0)
+                    return;
+                this.bouncing = false;
+            }
         }
-        other.get(Respawnable)?.respawn();
+        const health = other.get(Health);
+        if (health)
+            health.damage(this.contactDamage, this.entity);
+        else
+            other.get(Respawnable)?.respawn();
     }
 }

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

@@ -0,0 +1,81 @@
+import { Component, type Entity, type StateJson } from '@waica/engine';
+/**
+ * Where a 'signal:death' from `current` could land: the targets of every
+ * death edge on the current state or on '*'. Mirrors the merge
+ * nextTransition performs.
+ */
+export declare function deathTargets(states: Record<string, StateJson>, current: string): string[];
+/**
+ * Whether a state graph reacts to death on its own: a 'signal:death' edge
+ * on the current state or on '*'. Mirrors the merge nextTransition performs,
+ * because StateMachine.signal is fire-and-forget — it cannot report whether
+ * anybody handled the signal, so the graph is asked statically instead.
+ *
+ * Declaring an edge is not the same as taking it: nextTransition returns the
+ * FIRST firing edge, so a death edge listed after another edge that also
+ * fires loses the race and the signal is dropped. That is why signalling is
+ * followed by the deferred check in Health.onUpdate rather than trusted.
+ */
+export declare function declaresDeathHandling(states: Record<string, StateJson>, current: string): boolean;
+/**
+ * How much punishment an entity takes before it dies. Deliberately separate
+ * from Hazard's "hurts on touch": an enemy is both, a spike is only the
+ * hazard, and a projectile targets only what can be hurt.
+ *
+ * There is no kill(): lethality is arithmetic, so damage(Infinity) is the
+ * only death path and every death goes through the same policy.
+ */
+export declare class Health extends Component {
+    static componentName: string;
+    static params: {
+        max: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        invulnerability: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    static transient: string[];
+    max: number;
+    /** Seconds of immunity granted by taking a hit. 0 disables i-frames. */
+    invulnerability: number;
+    /** Health left; 0 is dead. Filled in from max on ready. */
+    current: number;
+    /** Seconds left in the invulnerability window. */
+    private invulnerable;
+    /** Frames left before the signalled death is checked; 0 when not waiting. */
+    private deathGrace;
+    /** States the death signal was supposed to reach. */
+    private expectedStates;
+    onReady(): void;
+    onUpdate(dt: number): void;
+    /**
+     * Makes good on a death the graph said it would handle. Signalling is
+     * fire-and-forget, so "it declared an edge" is a promise, not a receipt:
+     * if the machine is not in one of the states that edge led to and the
+     * entity is still dead, nobody took it and the destroy fallback applies
+     * after all. Being healed back up counts as handled — a project that
+     * revives on death did resolve it, just not by changing state.
+     */
+    private settleDeath;
+    /**
+     * Takes `amount` off unless already dead or still invulnerable, then opens
+     * the invulnerability window. `source` is whatever dealt the damage, for
+     * listeners that care who hit them.
+     */
+    damage(amount: number, source?: Entity): void;
+    /** Gives health back, capped at max. heal(Infinity) is a full restore. */
+    heal(amount: number): void;
+    /**
+     * 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
+     * destroying is the fallback rather than the exception.
+     */
+    private die;
+}

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

@@ -0,0 +1,150 @@
+import { Component, StateMachine } from '@waica/engine';
+/**
+ * Below this, current is treated as exactly zero. Repeated fractional
+ * damage (e.g. ten hits of 0.1 against max: 1) can leave a floating-point
+ * residual — Math.max(0, current - amount) only clamps values that land
+ * at or below zero, not tiny positive ones — that current === 0 would
+ * otherwise miss forever, leaving the entity undead at 0 HP.
+ */
+const DEATH_EPSILON = 1e-9;
+/**
+ * Where a 'signal:death' from `current` could land: the targets of every
+ * death edge on the current state or on '*'. Mirrors the merge
+ * nextTransition performs.
+ */
+export function deathTargets(states, current) {
+    const edges = [...(states[current]?.transitions ?? []), ...(states['*']?.transitions ?? [])];
+    return edges.filter((transition) => transition.on === 'signal:death').map((t) => t.to);
+}
+/**
+ * Whether a state graph reacts to death on its own: a 'signal:death' edge
+ * on the current state or on '*'. Mirrors the merge nextTransition performs,
+ * because StateMachine.signal is fire-and-forget — it cannot report whether
+ * anybody handled the signal, so the graph is asked statically instead.
+ *
+ * Declaring an edge is not the same as taking it: nextTransition returns the
+ * FIRST firing edge, so a death edge listed after another edge that also
+ * fires loses the race and the signal is dropped. That is why signalling is
+ * followed by the deferred check in Health.onUpdate rather than trusted.
+ */
+export function declaresDeathHandling(states, current) {
+    return deathTargets(states, current).length > 0;
+}
+/**
+ * Frames to wait before deciding the graph ignored the death signal. Two,
+ * not one, because component update order is prefab-authored: with Health
+ * listed before its StateMachine, one frame would check before the machine
+ * ever ran. Two guarantees the machine got a full tick either way.
+ */
+const DEATH_GRACE_FRAMES = 2;
+/**
+ * How much punishment an entity takes before it dies. Deliberately separate
+ * from Hazard's "hurts on touch": an enemy is both, a spike is only the
+ * hazard, and a projectile targets only what can be hurt.
+ *
+ * There is no kill(): lethality is arithmetic, so damage(Infinity) is the
+ * only death path and every death goes through the same policy.
+ */
+export class Health extends Component {
+    static componentName = 'Health';
+    static params = {
+        max: { label: 'Max health', min: 1, max: 20, step: 1 },
+        invulnerability: { label: 'Invulnerability', min: 0, max: 5, step: 0.1 },
+    };
+    static transient = ['current', 'invulnerable', 'deathGrace', 'expectedStates'];
+    max = 3;
+    /** Seconds of immunity granted by taking a hit. 0 disables i-frames. */
+    invulnerability = 0;
+    /** Health left; 0 is dead. Filled in from max on ready. */
+    current = 0;
+    /** Seconds left in the invulnerability window. */
+    invulnerable = 0;
+    /** Frames left before the signalled death is checked; 0 when not waiting. */
+    deathGrace = 0;
+    /** States the death signal was supposed to reach. */
+    expectedStates = [];
+    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
+        // and stays there forever: damage() early-returns while current <= 0,
+        // so die() is never reached — permanently invulnerable instead of
+        // already dead.
+        this.current = Math.max(0, this.max);
+        if (this.current === 0)
+            this.die();
+    }
+    onUpdate(dt) {
+        if (this.invulnerable > 0)
+            this.invulnerable = Math.max(0, this.invulnerable - dt);
+        if (this.deathGrace > 0 && --this.deathGrace === 0)
+            this.settleDeath();
+    }
+    /**
+     * Makes good on a death the graph said it would handle. Signalling is
+     * fire-and-forget, so "it declared an edge" is a promise, not a receipt:
+     * if the machine is not in one of the states that edge led to and the
+     * entity is still dead, nobody took it and the destroy fallback applies
+     * after all. Being healed back up counts as handled — a project that
+     * revives on death did resolve it, just not by changing state.
+     */
+    settleDeath() {
+        const expected = this.expectedStates;
+        this.expectedStates = [];
+        if (!this.entity.alive || this.current > 0)
+            return;
+        const machine = this.entity.get(StateMachine);
+        if (machine && expected.includes(machine.current))
+            return;
+        this.entity.destroy();
+    }
+    /**
+     * Takes `amount` off unless already dead or still invulnerable, then opens
+     * the invulnerability window. `source` is whatever dealt the damage, for
+     * listeners that care who hit them.
+     */
+    damage(amount, source) {
+        // Written as !(amount > 0) rather than amount <= 0 so NaN is rejected
+        // too — every NaN comparison is false, so amount <= 0 lets it through
+        // and poisons current (NaN - anything is NaN, and every guard against
+        // it is false forever after).
+        if (!(amount > 0) || this.current <= 0 || this.invulnerable > 0)
+            return;
+        this.current = Math.max(0, this.current - amount);
+        if (this.current < DEATH_EPSILON)
+            this.current = 0;
+        this.game.events.emit('damage', {
+            entity: this.entity,
+            amount,
+            current: this.current,
+            source,
+        });
+        this.invulnerable = this.invulnerability;
+        if (this.current === 0)
+            this.die();
+    }
+    /** 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);
+    }
+    /**
+     * 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
+     * destroying is the fallback rather than the exception.
+     */
+    die() {
+        this.game.events.emit('death', { entity: this.entity });
+        const machine = this.entity.get(StateMachine);
+        const targets = machine ? deathTargets(machine.states, machine.current) : [];
+        if (machine && targets.length > 0) {
+            machine.signal('death');
+            // Trust, then verify: settleDeath falls back to destroying if the
+            // signal never actually moved the machine anywhere it said it would.
+            this.expectedStates = targets;
+            this.deathGrace = DEATH_GRACE_FRAMES;
+            return;
+        }
+        this.entity.destroy();
+    }
+}

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

@@ -5,5 +5,7 @@ export { Patrol, PATROLLER_ROLE, PATROLLER_STATE_GRAPH, type PatrolAxis } from '
 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 { Health, declaresDeathHandling, deathTargets } from './health.js';
 export { Respawnable } from './respawnable.js';
+export { OutOfBounds } from './out-of-bounds.js';
 export { Lifetime } from './lifetime.js';

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

@@ -5,5 +5,7 @@ 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 { Health, declaresDeathHandling, deathTargets } from './health.js';
 export { Respawnable } from './respawnable.js';
+export { OutOfBounds } from './out-of-bounds.js';
 export { Lifetime } from './lifetime.js';

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

@@ -10,6 +10,7 @@ export declare class Lifetime extends Component {
             step: number;
         };
     };
+    static transient: string[];
     seconds: number;
     private elapsed;
     onUpdate(dt: number): void;

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

@@ -5,6 +5,7 @@ export class Lifetime extends Component {
     static params = {
         seconds: { label: 'Seconds', min: 0.05, max: 60, step: 0.05 },
     };
+    static transient = ['elapsed'];
     seconds = 1;
     elapsed = 0;
     onUpdate(dt) {

package/dist/mcp/node_modules/@waica/behaviors/dist/out-of-bounds.d.ts

@@ -0,0 +1,29 @@
+import { Component } from '@waica/engine';
+/**
+ * Kills whatever falls out of the world. The damage is not configurable
+ * because leaving the level is lethal by nature — being hurt by a hard
+ * landing is a different mechanic, measured on ground contact, and project
+ * code can write it with Health.damage and the motor's readable velocity.
+ *
+ * "Lethal" still goes through Health.damage, which means invulnerability
+ * frames delay it: an entity that falls right after taking a hit keeps
+ * falling until its i-frames lapse. That is deliberate — damage() has no
+ * bypass, by design — and it resolves itself because this check re-runs
+ * every frame. An entity with no Health is destroyed outright instead;
+ * unlike Hazard, this does NOT fall back to Respawnable.
+ */
+export declare class OutOfBounds extends Component {
+    static componentName: string;
+    static displayName: string;
+    static params: {
+        minY: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    /** Falling below this height is fatal. */
+    minY: number;
+    onUpdate(): void;
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/out-of-bounds.js

@@ -0,0 +1,37 @@
+import { Component } from '@waica/engine';
+import { Health } from './health.js';
+/**
+ * Kills whatever falls out of the world. The damage is not configurable
+ * because leaving the level is lethal by nature — being hurt by a hard
+ * landing is a different mechanic, measured on ground contact, and project
+ * code can write it with Health.damage and the motor's readable velocity.
+ *
+ * "Lethal" still goes through Health.damage, which means invulnerability
+ * frames delay it: an entity that falls right after taking a hit keeps
+ * falling until its i-frames lapse. That is deliberate — damage() has no
+ * bypass, by design — and it resolves itself because this check re-runs
+ * every frame. An entity with no Health is destroyed outright instead;
+ * unlike Hazard, this does NOT fall back to Respawnable.
+ */
+export class OutOfBounds extends Component {
+    static componentName = 'OutOfBounds';
+    static displayName = 'Out of bounds';
+    static params = {
+        minY: { label: 'Floor height', min: -50, max: 0, step: 1 },
+    };
+    /** Falling below this height is fatal. */
+    minY = -12;
+    onUpdate() {
+        // The frame that destroys the entity still iterates a copy of its
+        // components: stop checking instead of destroying twice.
+        if (!this.entity.alive)
+            return;
+        if (this.entity.position.y >= this.minY)
+            return;
+        const health = this.entity.get(Health);
+        if (health)
+            health.damage(Infinity, this.entity);
+        else
+            this.entity.destroy();
+    }
+}

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

@@ -28,6 +28,7 @@ export declare class Patrol extends Component {
             step: number;
         };
     };
+    static transient: string[];
     axis: PatrolAxis;
     distance: number;
     speed: number;

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

@@ -14,6 +14,7 @@ export class Patrol extends Component {
         distance: { label: 'Distance', min: 0.5, max: 20, step: 0.5 },
         speed: { label: 'Speed', min: 0.5, max: 15, step: 0.5 },
     };
+    static transient = ['originX', 'originY', 'dir'];
     axis = 'horizontal';
     distance = 3;
     speed = 2;

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

@@ -77,6 +77,7 @@ export declare class PlatformerMotor extends Component {
             label: string;
         };
     };
+    static transient: string[];
     moveSpeed: number;
     acceleration: number;
     deceleration: number;

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

@@ -25,6 +25,16 @@ export class PlatformerMotor extends Component {
         runThreshold: { label: 'Run threshold', min: 0, max: 5, step: 0.1 },
         squashStretch: { label: 'Squash & stretch' },
     };
+    static transient = [
+        'vx',
+        'vy',
+        'grounded',
+        'facing',
+        'coyoteTimer',
+        'bufferTimer',
+        'squashX',
+        'squashY',
+    ];
     moveSpeed = 9;
     acceleration = 60;
     deceleration = 80;

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

@@ -1,5 +1,7 @@
 import {} from '@waica/engine';
+import { Health } from './health.js';
 import { PlatformerMotor } from './platformer-motor.js';
+import { Respawnable } from './respawnable.js';
 /**
  * The 'player' role: the character you control. All four default states
  * share one body update; they differ only in the edges their prefab data
@@ -38,6 +40,17 @@ export const PLAYER_STATE_GRAPH = {
                 { on: 'signal:land', to: 'idle' },
             ],
         },
+        dead: {
+            // The stock dog sheet has no death animation; freeze on idle rather
+            // than name a clip that does not exist and warn every frame.
+            clip: 'idle',
+            // A beat before control comes back, so death reads as an event.
+            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' }] },
     },
 };
 /**
@@ -91,5 +104,18 @@ export const PLAYER_ROLE = {
         run: { onUpdate: playerUpdate },
         jump: { onUpdate: playerUpdate },
         fall: { onUpdate: playerUpdate },
+        // 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 — the shape every custom state relies on — so without
+            // this no-op the player kept running, jumping and falling for the
+            // whole death beat instead of the graph taking control away.
+            onUpdate() { },
+            onExit({ entity }) {
+                entity.get(Respawnable)?.respawn();
+                entity.get(Health)?.heal(Infinity);
+            },
+        },
     },
 };

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

@@ -1,23 +1,15 @@
 import { Component } from '@waica/engine';
 /**
- * Remembers the spawn point and puts the entity back there on death
- * (falling off the world or touching a Hazard).
+ * Remembers where the entity started and puts it back there on demand.
+ * That is all: what counts as death, and whether death leads to a respawn
+ * at all, belongs to Health and to the role's state graph. The `killY`
+ * lower bound this used to author moved to OutOfBounds (docs/adr/0003).
  */
 export declare class Respawnable extends Component {
     static componentName: string;
     static displayName: string;
-    static params: {
-        killY: {
-            label: string;
-            min: number;
-            max: number;
-            step: number;
-        };
-    };
-    /** Falling below this height respawns. */
-    killY: number;
+    static transient: string[];
     private spawn;
     onReady(): void;
     respawn(): void;
-    onUpdate(): void;
 }

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

@@ -1,17 +1,15 @@
 import { Component, THREE } from '@waica/engine';
 import { PlatformerMotor } from './platformer-motor.js';
 /**
- * Remembers the spawn point and puts the entity back there on death
- * (falling off the world or touching a Hazard).
+ * Remembers where the entity started and puts it back there on demand.
+ * That is all: what counts as death, and whether death leads to a respawn
+ * at all, belongs to Health and to the role's state graph. The `killY`
+ * lower bound this used to author moved to OutOfBounds (docs/adr/0003).
  */
 export class Respawnable extends Component {
     static componentName = 'Respawnable';
     static displayName = 'Respawn';
-    static params = {
-        killY: { label: 'Kill height', min: -50, max: 0, step: 1 },
-    };
-    /** Falling below this height respawns. */
-    killY = -12;
+    static transient = ['spawn'];
     spawn = new THREE.Vector3();
     onReady() {
         this.spawn.copy(this.entity.position);
@@ -20,8 +18,4 @@ export class Respawnable extends Component {
         this.entity.position.copy(this.spawn);
         this.entity.get(PlatformerMotor)?.halt();
     }
-    onUpdate() {
-        if (this.entity.position.y < this.killY)
-            this.respawn();
-    }
 }

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

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

package/dist/mcp/node_modules/@waica/engine/dist/authoring-defaults.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentClass } from './component.js';
+/**
+ * The public authoring surface of a component class: own enumerable fields
+ * plus setter-backed accessors (walking the whole prototype chain, so a
+ * getter/setter pair inherited from a base class counts), read through the
+ * getter so the value is the public one. Excludes `_`-prefixed keys, the
+ * base Component wiring (`entity`, `game`), anything the class (or an
+ * ancestor) declares `transient`, and values that are `undefined` or not
+ * JSON-serializable (`Map`, `Set`, functions, class instances).
+ */
+export declare function authoringDefaults(Class: ComponentClass, onError?: (error: unknown) => void): Record<string, unknown>;