@sharpee/world-model 3.0.0 → 3.1.0

package/traits/deadly-room/deadlyRoomBehavior.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Behavior for the deadly-room trigger shape (ADR-224).
+ *
+ * Computes the lethal/safe verdict for a parsed verb against a {@link DeadlyRoomTrait}.
+ * Consumers (the deadly-room command transformer) call `checkVerb` rather than
+ * reading the trait directly, so the model survives `loadJSON()`.
+ *
+ * Public interface: `checkVerb`, `isSafeVerb`.
+ * Owner context: `@sharpee/world-model` — the deadly-room trigger shape (ADR-224).
+ */
+import { SeededRandom } from '@sharpee/core';
+import { Behavior } from '../../behaviors/behavior';
+import { DeadlyRoomTrait } from './deadlyRoomTrait';
+/** Verdict returned by {@link DeadlyRoomBehavior.checkVerb}. */
+export interface DeadlyRoomVerdict {
+    /** Whether this verb kills the player in this room. */
+    lethal: boolean;
+    /** Cause to record on the death (from the trait). */
+    cause: string;
+    /** Optional death-text message id (from the trait). */
+    messageId?: string;
+}
+export declare class DeadlyRoomBehavior extends Behavior {
+    static requiredTraits: "deadlyRoom"[];
+    /**
+     * Whether `verb` is in the room's safe allowlist. Matches the resolved action id
+     * exactly (case-insensitive) or by its final dotted segment, so both an action id
+     * (`'if.action.looking'`) and the bare participle (`'looking'`) count as safe.
+     * @param t the deadly-room trait
+     * @param verb the command's resolved action id
+     */
+    static isSafeVerb(t: DeadlyRoomTrait, verb: string): boolean;
+    /**
+     * The lethal/safe verdict for a verb in this room.
+     *
+     * A safe verb is never lethal. Otherwise the verb is lethal outright when the
+     * trait has no `chance`, or lethal with probability `chance` (rolled against the
+     * seeded `rng`) when it does. If `chance` is set but no `rng` is supplied, the
+     * verb is treated as lethal (fail-deadly) — production always supplies the
+     * engine's seeded RNG; a missing RNG is a wiring error, not a survival chance.
+     *
+     * @param t the deadly-room trait
+     * @param verb the command's resolved action id
+     * @param rng the engine's seeded RNG (required only for the `chance` variant)
+     */
+    static checkVerb(t: DeadlyRoomTrait, verb: string, rng?: SeededRandom): DeadlyRoomVerdict;
+}
+//# sourceMappingURL=deadlyRoomBehavior.d.ts.map

package/traits/deadly-room/deadlyRoomBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadlyRoomBehavior.d.ts","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/deadly-room/deadlyRoomBehavior.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,uDAAuD;IACvD,MAAM,EAAE,OAAO,CAAC;IAChB,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,kBAAmB,SAAQ,QAAQ;IAC9C,MAAM,CAAC,cAAc,iBAA2B;IAEhD;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAS5D;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,YAAY,GAAG,iBAAiB;CAY1F"}

package/traits/deadly-room/deadlyRoomBehavior.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Behavior for the deadly-room trigger shape (ADR-224).
+ *
+ * Computes the lethal/safe verdict for a parsed verb against a {@link DeadlyRoomTrait}.
+ * Consumers (the deadly-room command transformer) call `checkVerb` rather than
+ * reading the trait directly, so the model survives `loadJSON()`.
+ *
+ * Public interface: `checkVerb`, `isSafeVerb`.
+ * Owner context: `@sharpee/world-model` — the deadly-room trigger shape (ADR-224).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeadlyRoomBehavior = void 0;
+const behavior_1 = require("../../behaviors/behavior");
+const trait_types_1 = require("../trait-types");
+class DeadlyRoomBehavior extends behavior_1.Behavior {
+    static requiredTraits = [trait_types_1.TraitType.DEADLY_ROOM];
+    /**
+     * Whether `verb` is in the room's safe allowlist. Matches the resolved action id
+     * exactly (case-insensitive) or by its final dotted segment, so both an action id
+     * (`'if.action.looking'`) and the bare participle (`'looking'`) count as safe.
+     * @param t the deadly-room trait
+     * @param verb the command's resolved action id
+     */
+    static isSafeVerb(t, verb) {
+        const v = (verb ?? '').toLowerCase();
+        const seg = v.split('.').pop() ?? v;
+        return t.safeVerbs.some((s) => {
+            const safe = s.toLowerCase();
+            return v === safe || seg === safe;
+        });
+    }
+    /**
+     * The lethal/safe verdict for a verb in this room.
+     *
+     * A safe verb is never lethal. Otherwise the verb is lethal outright when the
+     * trait has no `chance`, or lethal with probability `chance` (rolled against the
+     * seeded `rng`) when it does. If `chance` is set but no `rng` is supplied, the
+     * verb is treated as lethal (fail-deadly) — production always supplies the
+     * engine's seeded RNG; a missing RNG is a wiring error, not a survival chance.
+     *
+     * @param t the deadly-room trait
+     * @param verb the command's resolved action id
+     * @param rng the engine's seeded RNG (required only for the `chance` variant)
+     */
+    static checkVerb(t, verb, rng) {
+        const base = { cause: t.cause, messageId: t.messageId };
+        if (DeadlyRoomBehavior.isSafeVerb(t, verb)) {
+            return { lethal: false, ...base };
+        }
+        if (t.chance === undefined) {
+            return { lethal: true, ...base };
+        }
+        const lethal = rng ? rng.chance(t.chance) : true;
+        return { lethal, ...base };
+    }
+}
+exports.DeadlyRoomBehavior = DeadlyRoomBehavior;
+//# sourceMappingURL=deadlyRoomBehavior.js.map

package/traits/deadly-room/deadlyRoomBehavior.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadlyRoomBehavior.js","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/deadly-room/deadlyRoomBehavior.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAGH,uDAAoD;AACpD,gDAA2C;AAa3C,MAAa,kBAAmB,SAAQ,mBAAQ;IAC9C,MAAM,CAAC,cAAc,GAAG,CAAC,uBAAS,CAAC,WAAW,CAAC,CAAC;IAEhD;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,CAAkB,EAAE,IAAY;QAChD,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QACrC,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACpC,OAAO,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;YAC5B,MAAM,IAAI,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;YAC7B,OAAO,CAAC,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,CAAC;QACpC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,SAAS,CAAC,CAAkB,EAAE,IAAY,EAAE,GAAkB;QACnE,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;QAExD,IAAI,kBAAkB,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;YAC3C,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,CAAC;QACpC,CAAC;QACD,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAAC;QACnC,CAAC;QACD,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACjD,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC;IAC7B,CAAC;;AA3CH,gDA4CC"}

package/traits/deadly-room/deadlyRoomTrait.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Deadly Room Trait (ADR-224 — the reusable deadly-room trigger shape).
+ *
+ * Marks a room where verbs outside a safe allowlist kill the player: MDL's
+ * Aragain Falls ("every verb but LOOK is fatal here"). An optional `chance` turns
+ * the same shape into a probabilistic hazard (the grue: a non-safe verb dies only
+ * `chance` of the time), rolled against the engine's seeded RNG.
+ *
+ * Data only — no methods. The lethal/safe verdict lives in {@link DeadlyRoomBehavior}
+ * (a getter would not survive `loadJSON()`). The trait carries no logic and no RNG;
+ * the deadly-room command transformer supplies the seeded RNG at check time.
+ *
+ * Public interface: read the verdict via `DeadlyRoomBehavior.checkVerb`.
+ * Owner context: `@sharpee/world-model` — the deadly-room trigger shape (ADR-224).
+ */
+import { ITrait } from '../trait';
+/**
+ * Constructor/serialization data for {@link DeadlyRoomTrait}.
+ */
+export interface IDeadlyRoomData {
+    /** Cause recorded on the death (e.g. 'fall', 'grue'). Defaults to `'hazard'`. */
+    cause?: string;
+    /** Optional death-text message id (rendered by the language layer). */
+    messageId?: string;
+    /**
+     * Verbs that are safe in this room — matched against a command's resolved
+     * action id, tolerant of the bare participle (`'looking'` matches
+     * `'if.action.looking'`). Defaults to `['looking', 'examining']` (LOOK/EXAMINE),
+     * the MDL falls allowlist.
+     */
+    safeVerbs?: string[];
+    /**
+     * Probability (0–1) that a non-safe verb is lethal. When omitted, every non-safe
+     * verb is lethal (the falls). When set, the hazard is probabilistic (the grue)
+     * and rolled against the engine's seeded RNG — never `Math.random()`.
+     */
+    chance?: number;
+}
+/**
+ * The deadly-room trigger trait. Data-only; see file header.
+ */
+export declare class DeadlyRoomTrait implements ITrait, IDeadlyRoomData {
+    static readonly type: "deadlyRoom";
+    readonly type: "deadlyRoom";
+    cause: string;
+    messageId?: string;
+    safeVerbs: string[];
+    chance?: number;
+    constructor(data?: IDeadlyRoomData);
+}
+//# sourceMappingURL=deadlyRoomTrait.d.ts.map

package/traits/deadly-room/deadlyRoomTrait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadlyRoomTrait.d.ts","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/deadly-room/deadlyRoomTrait.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IAErB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,eAAgB,YAAW,MAAM,EAAE,eAAe;IAC7D,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,YAAY,CAAU;IAC7C,QAAQ,CAAC,IAAI,EAAG,YAAY,CAAU;IAEtC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,IAAI,GAAE,eAAoB;CAMvC"}

package/traits/deadly-room/deadlyRoomTrait.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Deadly Room Trait (ADR-224 — the reusable deadly-room trigger shape).
+ *
+ * Marks a room where verbs outside a safe allowlist kill the player: MDL's
+ * Aragain Falls ("every verb but LOOK is fatal here"). An optional `chance` turns
+ * the same shape into a probabilistic hazard (the grue: a non-safe verb dies only
+ * `chance` of the time), rolled against the engine's seeded RNG.
+ *
+ * Data only — no methods. The lethal/safe verdict lives in {@link DeadlyRoomBehavior}
+ * (a getter would not survive `loadJSON()`). The trait carries no logic and no RNG;
+ * the deadly-room command transformer supplies the seeded RNG at check time.
+ *
+ * Public interface: read the verdict via `DeadlyRoomBehavior.checkVerb`.
+ * Owner context: `@sharpee/world-model` — the deadly-room trigger shape (ADR-224).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeadlyRoomTrait = void 0;
+/**
+ * The deadly-room trigger trait. Data-only; see file header.
+ */
+class DeadlyRoomTrait {
+    static type = 'deadlyRoom';
+    type = 'deadlyRoom';
+    cause;
+    messageId;
+    safeVerbs;
+    chance;
+    constructor(data = {}) {
+        this.cause = data.cause ?? 'hazard';
+        this.messageId = data.messageId;
+        this.safeVerbs = data.safeVerbs ?? ['looking', 'examining'];
+        this.chance = data.chance;
+    }
+}
+exports.DeadlyRoomTrait = DeadlyRoomTrait;
+//# sourceMappingURL=deadlyRoomTrait.js.map

package/traits/deadly-room/deadlyRoomTrait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadlyRoomTrait.js","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/deadly-room/deadlyRoomTrait.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AA8BH;;GAEG;AACH,MAAa,eAAe;IAC1B,MAAM,CAAU,IAAI,GAAG,YAAqB,CAAC;IACpC,IAAI,GAAG,YAAqB,CAAC;IAEtC,KAAK,CAAS;IACd,SAAS,CAAU;IACnB,SAAS,CAAW;IACpB,MAAM,CAAU;IAEhB,YAAY,OAAwB,EAAE;QACpC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,QAAQ,CAAC;QACpC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC5B,CAAC;;AAdH,0CAeC"}

package/traits/deadly-room/index.d.ts

@@ -0,0 +1,3 @@
+export { DeadlyRoomTrait, IDeadlyRoomData } from './deadlyRoomTrait';
+export { DeadlyRoomBehavior, DeadlyRoomVerdict } from './deadlyRoomBehavior';
+//# sourceMappingURL=index.d.ts.map

package/traits/deadly-room/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/deadly-room/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}

package/traits/deadly-room/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeadlyRoomBehavior = exports.DeadlyRoomTrait = void 0;
+var deadlyRoomTrait_1 = require("./deadlyRoomTrait");
+Object.defineProperty(exports, "DeadlyRoomTrait", { enumerable: true, get: function () { return deadlyRoomTrait_1.DeadlyRoomTrait; } });
+var deadlyRoomBehavior_1 = require("./deadlyRoomBehavior");
+Object.defineProperty(exports, "DeadlyRoomBehavior", { enumerable: true, get: function () { return deadlyRoomBehavior_1.DeadlyRoomBehavior; } });
+//# sourceMappingURL=index.js.map

package/traits/deadly-room/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/deadly-room/index.ts"],"names":[],"mappings":";;;AAAA,qDAAqE;AAA5D,kHAAA,eAAe,OAAA;AACxB,2DAA6E;AAApE,wHAAA,kBAAkB,OAAA"}

package/traits/diggable/diggableBehavior.d.ts

@@ -0,0 +1,23 @@
+import { EntityId } from '@sharpee/core';
+import { Behavior } from '../../behaviors/behavior';
+import { IFEntity } from '../../entities/if-entity';
+/**
+ * Behavior for diggable entities (ADR-230 Phase 6 (sketch ruling 6)).
+ *
+ * Pure predicates only — the digging action's validate() consults these;
+ * the cut mutation itself belongs to the entity's registered
+ * implementation, never here.
+ */
+export declare class DiggableBehavior extends Behavior {
+    static requiredTraits: "diggable"[];
+    /**
+     * Check if this entity requires a tool to cut (mirrors
+     * LockableBehavior.requiresKey / OpenableBehavior.requiresTool)
+     */
+    static requiresTool(entity: IFEntity): boolean;
+    /**
+     * Check if a tool can cut this entity (mirrors LockableBehavior.canUnlockWith)
+     */
+    static canDigWith(entity: IFEntity, toolId: EntityId): boolean;
+}
+//# sourceMappingURL=diggableBehavior.d.ts.map

package/traits/diggable/diggableBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diggableBehavior.d.ts","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/diggable/diggableBehavior.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIpD;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,MAAM,CAAC,cAAc,eAAwB;IAE7C;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO;IAK9C;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO;CAa/D"}

package/traits/diggable/diggableBehavior.js

@@ -0,0 +1,39 @@
+"use strict";
+// packages/world-model/src/traits/diggable/diggableBehavior.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiggableBehavior = void 0;
+const behavior_1 = require("../../behaviors/behavior");
+const trait_types_1 = require("../trait-types");
+/**
+ * Behavior for diggable entities (ADR-230 Phase 6 (sketch ruling 6)).
+ *
+ * Pure predicates only — the digging action's validate() consults these;
+ * the cut mutation itself belongs to the entity's registered
+ * implementation, never here.
+ */
+class DiggableBehavior extends behavior_1.Behavior {
+    static requiredTraits = [trait_types_1.TraitType.DIGGABLE];
+    /**
+     * Check if this entity requires a tool to cut (mirrors
+     * LockableBehavior.requiresKey / OpenableBehavior.requiresTool)
+     */
+    static requiresTool(entity) {
+        const diggable = DiggableBehavior.require(entity, trait_types_1.TraitType.DIGGABLE);
+        return !!(diggable.toolId || diggable.toolIds?.length);
+    }
+    /**
+     * Check if a tool can cut this entity (mirrors LockableBehavior.canUnlockWith)
+     */
+    static canDigWith(entity, toolId) {
+        const diggable = DiggableBehavior.require(entity, trait_types_1.TraitType.DIGGABLE);
+        if (diggable.toolId === toolId) {
+            return true;
+        }
+        if (diggable.toolIds && diggable.toolIds.includes(toolId)) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.DiggableBehavior = DiggableBehavior;
+//# sourceMappingURL=diggableBehavior.js.map

package/traits/diggable/diggableBehavior.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diggableBehavior.js","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/diggable/diggableBehavior.ts"],"names":[],"mappings":";AAAA,+DAA+D;;;AAG/D,uDAAoD;AAEpD,gDAA2C;AAG3C;;;;;;GAMG;AACH,MAAa,gBAAiB,SAAQ,mBAAQ;IAC5C,MAAM,CAAC,cAAc,GAAG,CAAC,uBAAS,CAAC,QAAQ,CAAC,CAAC;IAE7C;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,MAAgB;QAClC,MAAM,QAAQ,GAAG,gBAAgB,CAAC,OAAO,CAAgB,MAAM,EAAE,uBAAS,CAAC,QAAQ,CAAC,CAAC;QACrF,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACzD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,MAAgB,EAAE,MAAgB;QAClD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,OAAO,CAAgB,MAAM,EAAE,uBAAS,CAAC,QAAQ,CAAC,CAAC;QAErF,IAAI,QAAQ,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,QAAQ,CAAC,OAAO,IAAI,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1D,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;;AA3BH,4CA4BC"}

package/traits/diggable/diggableTrait.d.ts

@@ -0,0 +1,37 @@
+import { EntityId } from '@sharpee/core';
+import { ITrait } from '../trait';
+/**
+ * Data for the diggable trait (ADR-230 Phase 6 (sketch ruling 6)).
+ *
+ * Tool fields mirror ILockableData's key config (PIN 2 shared shape with
+ * OpenableTrait's tool fields): a declared requirement makes the digging
+ * action refuse wrong/missing tools; no requirement means any explicit
+ * tool (or none) passes validation.
+ */
+export interface IDiggableData {
+    /** Single tool entity required to dig this (mirrors ILockableData.keyId) */
+    toolId?: EntityId;
+    /** Multiple tool entities that can dig this (mirrors ILockableData.keyIds) */
+    toolIds?: EntityId[];
+}
+/**
+ * Diggable trait — marks an entity the digging action may target.
+ *
+ * The trait gates eligibility only. The dig OUTCOME is the entity's own
+ * registered implementation (ADR-090 capability behavior from TS, or a
+ * Chord `on digging it` interceptor) — the standard digging action never
+ * mutates state itself. An entity with this trait and no registered
+ * implementation is an authoring error (load-time in Chord; runtime
+ * safety-net refusal otherwise).
+ *
+ * This trait contains only data - eligibility/tool logic is in
+ * DiggableBehavior.
+ */
+export declare class DiggableTrait implements ITrait, IDiggableData {
+    static readonly type: "diggable";
+    readonly type: "diggable";
+    toolId?: EntityId;
+    toolIds?: EntityId[];
+    constructor(data?: IDiggableData);
+}
+//# sourceMappingURL=diggableTrait.d.ts.map

package/traits/diggable/diggableTrait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diggableTrait.d.ts","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/diggable/diggableTrait.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,MAAM,CAAC,EAAE,QAAQ,CAAC;IAElB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,YAAW,MAAM,EAAE,aAAa;IACzD,MAAM,CAAC,QAAQ,CAAC,IAAI,aAAsB;IAC1C,QAAQ,CAAC,IAAI,aAAsB;IAEnC,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC;gBAET,IAAI,GAAE,aAAkB;CAIrC"}

package/traits/diggable/diggableTrait.js

@@ -0,0 +1,30 @@
+"use strict";
+// packages/world-model/src/traits/diggable/diggableTrait.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiggableTrait = void 0;
+const trait_types_1 = require("../trait-types");
+/**
+ * Diggable trait — marks an entity the digging action may target.
+ *
+ * The trait gates eligibility only. The dig OUTCOME is the entity's own
+ * registered implementation (ADR-090 capability behavior from TS, or a
+ * Chord `on digging it` interceptor) — the standard digging action never
+ * mutates state itself. An entity with this trait and no registered
+ * implementation is an authoring error (load-time in Chord; runtime
+ * safety-net refusal otherwise).
+ *
+ * This trait contains only data - eligibility/tool logic is in
+ * DiggableBehavior.
+ */
+class DiggableTrait {
+    static type = trait_types_1.TraitType.DIGGABLE;
+    type = trait_types_1.TraitType.DIGGABLE;
+    toolId;
+    toolIds;
+    constructor(data = {}) {
+        this.toolId = data.toolId;
+        this.toolIds = data.toolIds;
+    }
+}
+exports.DiggableTrait = DiggableTrait;
+//# sourceMappingURL=diggableTrait.js.map

package/traits/diggable/diggableTrait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diggableTrait.js","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/diggable/diggableTrait.ts"],"names":[],"mappings":";AAAA,4DAA4D;;;AAI5D,gDAA2C;AAkB3C;;;;;;;;;;;;GAYG;AACH,MAAa,aAAa;IACxB,MAAM,CAAU,IAAI,GAAG,uBAAS,CAAC,QAAQ,CAAC;IACjC,IAAI,GAAG,uBAAS,CAAC,QAAQ,CAAC;IAEnC,MAAM,CAAY;IAClB,OAAO,CAAc;IAErB,YAAY,OAAsB,EAAE;QAClC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC9B,CAAC;;AAVH,sCAWC"}

package/traits/diggable/index.d.ts

@@ -0,0 +1,3 @@
+export * from './diggableTrait';
+export * from './diggableBehavior';
+//# sourceMappingURL=index.d.ts.map

package/traits/diggable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/diggable/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}

package/traits/diggable/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// packages/world-model/src/traits/diggable/index.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./diggableTrait"), exports);
+__exportStar(require("./diggableBehavior"), exports);
+//# sourceMappingURL=index.js.map

package/traits/diggable/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/diggable/index.ts"],"names":[],"mappings":";AAAA,oDAAoD;;;;;;;;;;;;;;;;AAEpD,kDAAgC;AAChC,qDAAmC"}

package/traits/health/healthBehavior.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Behavior for the HEALTH layer (ADR-226).
+ *
+ * All derivation and mutation over {@link HealthTrait} data. Consumers call these
+ * static methods rather than reading the trait's fields through getters, so the
+ * model survives `loadJSON()` (the `npc-service` `canAct`-getter footgun this layer
+ * removes). Consciousness is purely derived from `health` — there is no stored
+ * knocked-out flag, no `knockOut`/`wakeUp`, and no recovery timer (ADR-226 §1 F1).
+ *
+ * Public interface: `isAlive` / `isConscious` / `canAct` (pure derivation) and
+ * `takeDamage` / `heal` / `kill` (mutation). All operate on a `HealthTrait` directly;
+ * callers first confirm the entity has one (an entity with no `HealthTrait` is alive
+ * and conscious by default — ADR-226 §3 opt-in rule — a check owned by the caller).
+ * Owner context: `@sharpee/world-model` — HEALTH layer (ADR-223 child A).
+ */
+import { Behavior } from '../../behaviors/behavior';
+import { HealthTrait } from './healthTrait';
+export declare class HealthBehavior extends Behavior {
+    static requiredTraits: "health"[];
+    /**
+     * Whether the entity is alive: not terminally dead and above zero health.
+     * @param t the entity's health trait
+     */
+    static isAlive(t: HealthTrait): boolean;
+    /**
+     * Whether the entity is conscious: alive, not asleep, and above the
+     * unconsciousness threshold. Consciousness is derived from `health` alone.
+     * @param t the entity's health trait
+     */
+    static isConscious(t: HealthTrait): boolean;
+    /**
+     * Whether the entity can take a turn / act. Alias of {@link isConscious} — the
+     * turn loop's eligibility predicate (replaces `NpcTrait.canAct`).
+     * @param t the entity's health trait
+     */
+    static canAct(t: HealthTrait): boolean;
+    /**
+     * Apply damage to health. Armor is the caller's concern (a `CombatantTrait` stat),
+     * so `amount` is already post-armor. On reaching zero health the entity dies with
+     * the given `cause`.
+     * @param t the entity's health trait
+     * @param amount post-armor damage; negatives are treated as zero
+     * @param cause cause recorded if this blow is lethal (default 'damage')
+     * @returns `true` iff the entity is now dead
+     */
+    static takeDamage(t: HealthTrait, amount: number, cause?: string): boolean;
+    /**
+     * Restore health, clamped to `maxHealth`. Healing back above the unconsciousness
+     * threshold *is* regaining consciousness (no separate wake step). The dead do not
+     * heal — resurrection is a deliberate separate act, not `heal`.
+     * @param t the entity's health trait
+     * @param amount healing; negatives are treated as zero
+     * @returns the actual amount healed
+     */
+    static heal(t: HealthTrait, amount: number): number;
+    /**
+     * Kill the entity: set the terminal `dead` flag and its `cause`, leaving `health`
+     * untouched. This is death's single writer — non-damage deaths (grue/fall/drown,
+     * ADR-224 `killPlayer`) call it directly; `takeDamage` calls it on a lethal blow.
+     * Death is distinct from `health === 0` (an entity can be dead at full health).
+     * @param t the entity's health trait
+     * @param cause the cause of death (e.g. 'grue', 'fall', 'combat')
+     */
+    static kill(t: HealthTrait, cause: string): void;
+}
+//# sourceMappingURL=healthBehavior.d.ts.map

package/traits/health/healthBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"healthBehavior.d.ts","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/health/healthBehavior.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,qBAAa,cAAe,SAAQ,QAAQ;IAC1C,MAAM,CAAC,cAAc,aAAsB;IAI3C;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAIvC;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAQ3C;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAMtC;;;;;;;;OAQG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,MAAiB,GAAG,OAAO;IAUpF;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAOnD;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAIjD"}

package/traits/health/healthBehavior.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Behavior for the HEALTH layer (ADR-226).
+ *
+ * All derivation and mutation over {@link HealthTrait} data. Consumers call these
+ * static methods rather than reading the trait's fields through getters, so the
+ * model survives `loadJSON()` (the `npc-service` `canAct`-getter footgun this layer
+ * removes). Consciousness is purely derived from `health` — there is no stored
+ * knocked-out flag, no `knockOut`/`wakeUp`, and no recovery timer (ADR-226 §1 F1).
+ *
+ * Public interface: `isAlive` / `isConscious` / `canAct` (pure derivation) and
+ * `takeDamage` / `heal` / `kill` (mutation). All operate on a `HealthTrait` directly;
+ * callers first confirm the entity has one (an entity with no `HealthTrait` is alive
+ * and conscious by default — ADR-226 §3 opt-in rule — a check owned by the caller).
+ * Owner context: `@sharpee/world-model` — HEALTH layer (ADR-223 child A).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthBehavior = void 0;
+const behavior_1 = require("../../behaviors/behavior");
+const trait_types_1 = require("../trait-types");
+class HealthBehavior extends behavior_1.Behavior {
+    static requiredTraits = [trait_types_1.TraitType.HEALTH];
+    // ---- Derivation (pure — no mutation) ----
+    /**
+     * Whether the entity is alive: not terminally dead and above zero health.
+     * @param t the entity's health trait
+     */
+    static isAlive(t) {
+        return !t.dead && t.health > 0;
+    }
+    /**
+     * Whether the entity is conscious: alive, not asleep, and above the
+     * unconsciousness threshold. Consciousness is derived from `health` alone.
+     * @param t the entity's health trait
+     */
+    static isConscious(t) {
+        return (HealthBehavior.isAlive(t) &&
+            !t.asleep &&
+            t.health > t.maxHealth * t.unconsciousThreshold);
+    }
+    /**
+     * Whether the entity can take a turn / act. Alias of {@link isConscious} — the
+     * turn loop's eligibility predicate (replaces `NpcTrait.canAct`).
+     * @param t the entity's health trait
+     */
+    static canAct(t) {
+        return HealthBehavior.isConscious(t);
+    }
+    // ---- Mutation (behaviors own mutations) ----
+    /**
+     * Apply damage to health. Armor is the caller's concern (a `CombatantTrait` stat),
+     * so `amount` is already post-armor. On reaching zero health the entity dies with
+     * the given `cause`.
+     * @param t the entity's health trait
+     * @param amount post-armor damage; negatives are treated as zero
+     * @param cause cause recorded if this blow is lethal (default 'damage')
+     * @returns `true` iff the entity is now dead
+     */
+    static takeDamage(t, amount, cause = 'damage') {
+        if (t.dead)
+            return true; // a corpse takes no further damage (idempotent)
+        t.health = Math.max(0, t.health - Math.max(0, amount));
+        if (t.health <= 0) {
+            HealthBehavior.kill(t, cause);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Restore health, clamped to `maxHealth`. Healing back above the unconsciousness
+     * threshold *is* regaining consciousness (no separate wake step). The dead do not
+     * heal — resurrection is a deliberate separate act, not `heal`.
+     * @param t the entity's health trait
+     * @param amount healing; negatives are treated as zero
+     * @returns the actual amount healed
+     */
+    static heal(t, amount) {
+        if (t.dead)
+            return 0;
+        const before = t.health;
+        t.health = Math.min(t.maxHealth, t.health + Math.max(0, amount));
+        return t.health - before;
+    }
+    /**
+     * Kill the entity: set the terminal `dead` flag and its `cause`, leaving `health`
+     * untouched. This is death's single writer — non-damage deaths (grue/fall/drown,
+     * ADR-224 `killPlayer`) call it directly; `takeDamage` calls it on a lethal blow.
+     * Death is distinct from `health === 0` (an entity can be dead at full health).
+     * @param t the entity's health trait
+     * @param cause the cause of death (e.g. 'grue', 'fall', 'combat')
+     */
+    static kill(t, cause) {
+        t.dead = true;
+        t.causeOfDeath = cause;
+    }
+}
+exports.HealthBehavior = HealthBehavior;
+//# sourceMappingURL=healthBehavior.js.map

package/traits/health/healthBehavior.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"healthBehavior.js","sourceRoot":"","sources":["../../../../../../../../repos/sharpee_v2/packages/world-model/src/traits/health/healthBehavior.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,uDAAoD;AACpD,gDAA2C;AAG3C,MAAa,cAAe,SAAQ,mBAAQ;IAC1C,MAAM,CAAC,cAAc,GAAG,CAAC,uBAAS,CAAC,MAAM,CAAC,CAAC;IAE3C,4CAA4C;IAE5C;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,CAAc;QAC3B,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,CAAc;QAC/B,OAAO,CACL,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC,MAAM;YACT,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,oBAAoB,CAChD,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,CAAc;QAC1B,OAAO,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IACvC,CAAC;IAED,+CAA+C;IAE/C;;;;;;;;OAQG;IACH,MAAM,CAAC,UAAU,CAAC,CAAc,EAAE,MAAc,EAAE,QAAgB,QAAQ;QACxE,IAAI,CAAC,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC,CAAC,gDAAgD;QACzE,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;QACvD,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YAClB,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,CAAc,EAAE,MAAc;QACxC,IAAI,CAAC,CAAC,IAAI;YAAE,OAAO,CAAC,CAAC;QACrB,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;QACxB,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;QACjE,OAAO,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC;IAC3B,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,CAAc,EAAE,KAAa;QACvC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC;QACd,CAAC,CAAC,YAAY,GAAG,KAAK,CAAC;IACzB,CAAC;;AAlFH,wCAmFC"}