@sharpee/lang-en-us 0.9.61-beta

package/dist-npm/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AAGxB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAG3B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAG7B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAG5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAG3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAG1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAG1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAG1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAG5B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAG5B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AAyDxB;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0ElC,CAAC"}

package/dist-npm/actions/index.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * English language content for all standard actions
+ *
+ * Each action has its own file with patterns, messages, and help text
+ */
+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 });
+exports.standardActionLanguage = void 0;
+// Core actions
+__exportStar(require("./taking"), exports);
+__exportStar(require("./dropping"), exports);
+__exportStar(require("./looking"), exports);
+__exportStar(require("./inventory"), exports);
+__exportStar(require("./examining"), exports);
+__exportStar(require("./going"), exports);
+// Container actions
+__exportStar(require("./opening"), exports);
+__exportStar(require("./closing"), exports);
+__exportStar(require("./putting"), exports);
+__exportStar(require("./inserting"), exports);
+__exportStar(require("./removing"), exports);
+// Wearable actions
+__exportStar(require("./wearing"), exports);
+__exportStar(require("./taking-off"), exports);
+// Lock actions
+__exportStar(require("./locking"), exports);
+__exportStar(require("./unlocking"), exports);
+// Movement actions
+__exportStar(require("./entering"), exports);
+__exportStar(require("./exiting"), exports);
+__exportStar(require("./climbing"), exports);
+// Sensory actions
+__exportStar(require("./searching"), exports);
+__exportStar(require("./listening"), exports);
+__exportStar(require("./smelling"), exports);
+__exportStar(require("./touching"), exports);
+__exportStar(require("./reading"), exports);
+// Device actions
+__exportStar(require("./switching-on"), exports);
+__exportStar(require("./switching-off"), exports);
+__exportStar(require("./pushing"), exports);
+__exportStar(require("./pulling"), exports);
+__exportStar(require("./turning"), exports);
+// Capability-dispatch actions (ADR-090)
+__exportStar(require("./lowering"), exports);
+__exportStar(require("./raising"), exports);
+// Social actions
+__exportStar(require("./giving"), exports);
+__exportStar(require("./showing"), exports);
+__exportStar(require("./talking"), exports);
+__exportStar(require("./asking"), exports);
+__exportStar(require("./telling"), exports);
+__exportStar(require("./answering"), exports);
+// Interaction actions
+__exportStar(require("./throwing"), exports);
+__exportStar(require("./using"), exports);
+__exportStar(require("./eating"), exports);
+__exportStar(require("./drinking"), exports);
+__exportStar(require("./attacking"), exports);
+// Meta actions
+__exportStar(require("./waiting"), exports);
+__exportStar(require("./sleeping"), exports);
+__exportStar(require("./scoring"), exports);
+__exportStar(require("./help"), exports);
+__exportStar(require("./about"), exports);
+__exportStar(require("./version"), exports);
+__exportStar(require("./saving"), exports);
+__exportStar(require("./restoring"), exports);
+__exportStar(require("./quitting"), exports);
+__exportStar(require("./undoing"), exports);
+__exportStar(require("./again"), exports);
+// Import all action language definitions
+const taking_1 = require("./taking");
+const dropping_1 = require("./dropping");
+const looking_1 = require("./looking");
+const inventory_1 = require("./inventory");
+const examining_1 = require("./examining");
+const going_1 = require("./going");
+const opening_1 = require("./opening");
+const closing_1 = require("./closing");
+const putting_1 = require("./putting");
+const inserting_1 = require("./inserting");
+const removing_1 = require("./removing");
+const wearing_1 = require("./wearing");
+const taking_off_1 = require("./taking-off");
+const locking_1 = require("./locking");
+const unlocking_1 = require("./unlocking");
+const entering_1 = require("./entering");
+const exiting_1 = require("./exiting");
+const climbing_1 = require("./climbing");
+const searching_1 = require("./searching");
+const listening_1 = require("./listening");
+const smelling_1 = require("./smelling");
+const touching_1 = require("./touching");
+const reading_1 = require("./reading");
+const switching_on_1 = require("./switching-on");
+const switching_off_1 = require("./switching-off");
+const pushing_1 = require("./pushing");
+const pulling_1 = require("./pulling");
+const turning_1 = require("./turning");
+// Capability-dispatch actions (ADR-090)
+const lowering_1 = require("./lowering");
+const raising_1 = require("./raising");
+const giving_1 = require("./giving");
+const showing_1 = require("./showing");
+const talking_1 = require("./talking");
+const asking_1 = require("./asking");
+const telling_1 = require("./telling");
+const answering_1 = require("./answering");
+const throwing_1 = require("./throwing");
+const using_1 = require("./using");
+const eating_1 = require("./eating");
+const drinking_1 = require("./drinking");
+const attacking_1 = require("./attacking");
+const waiting_1 = require("./waiting");
+const sleeping_1 = require("./sleeping");
+const scoring_1 = require("./scoring");
+const help_1 = require("./help");
+const about_1 = require("./about");
+const version_1 = require("./version");
+const saving_1 = require("./saving");
+const restoring_1 = require("./restoring");
+const quitting_1 = require("./quitting");
+const undoing_1 = require("./undoing");
+const again_1 = require("./again");
+/**
+ * All standard action language definitions
+ */
+exports.standardActionLanguage = [
+    // Core actions
+    taking_1.takingLanguage,
+    dropping_1.droppingLanguage,
+    looking_1.lookingLanguage,
+    inventory_1.inventoryLanguage,
+    examining_1.examiningLanguage,
+    going_1.goingLanguage,
+    // Container actions
+    opening_1.openingLanguage,
+    closing_1.closingLanguage,
+    putting_1.puttingLanguage,
+    inserting_1.insertingLanguage,
+    removing_1.removingLanguage,
+    // Wearable actions
+    wearing_1.wearingLanguage,
+    taking_off_1.takingOffLanguage,
+    // Lock actions
+    locking_1.lockingLanguage,
+    unlocking_1.unlockingLanguage,
+    // Movement actions
+    entering_1.enteringLanguage,
+    exiting_1.exitingLanguage,
+    climbing_1.climbingLanguage,
+    // Sensory actions
+    searching_1.searchingLanguage,
+    listening_1.listeningLanguage,
+    smelling_1.smellingLanguage,
+    touching_1.touchingLanguage,
+    reading_1.readingLanguage,
+    // Device actions
+    switching_on_1.switchingOnLanguage,
+    switching_off_1.switchingOffLanguage,
+    pushing_1.pushingLanguage,
+    pulling_1.pullingLanguage,
+    turning_1.turningLanguage,
+    // Capability-dispatch actions (ADR-090)
+    lowering_1.loweringLanguage,
+    raising_1.raisingLanguage,
+    // Social actions
+    giving_1.givingLanguage,
+    showing_1.showingLanguage,
+    talking_1.talkingLanguage,
+    asking_1.askingLanguage,
+    telling_1.tellingLanguage,
+    answering_1.answeringLanguage,
+    // Interaction actions
+    throwing_1.throwingLanguage,
+    using_1.usingLanguage,
+    eating_1.eatingLanguage,
+    drinking_1.drinkingLanguage,
+    attacking_1.attackingLanguage,
+    // Meta actions
+    waiting_1.waitingLanguage,
+    sleeping_1.sleepingLanguage,
+    scoring_1.scoringLanguage,
+    help_1.helpLanguage,
+    about_1.aboutLanguage,
+    version_1.versionLanguage,
+    saving_1.savingLanguage,
+    restoring_1.restoringLanguage,
+    quitting_1.quittingLanguage,
+    undoing_1.undoingLanguage,
+    again_1.againLanguage
+];
+//# sourceMappingURL=index.js.map

package/dist-npm/actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"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"}

package/dist-npm/actions/inserting.d.ts

@@ -0,0 +1,25 @@
+/**
+ * English language content for the inserting action
+ * Note: This is often combined with putting, but can be separate for specific use cases
+ */
+export declare const insertingLanguage: {
+    actionId: string;
+    patterns: string[];
+    messages: {
+        no_target: string;
+        no_destination: string;
+        not_held: string;
+        not_insertable: string;
+        not_container: string;
+        already_there: string;
+        inserted: string;
+        wont_fit: string;
+        container_closed: string;
+    };
+    help: {
+        description: string;
+        examples: string;
+        summary: string;
+    };
+};
+//# sourceMappingURL=inserting.d.ts.map

package/dist-npm/actions/inserting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inserting.d.ts","sourceRoot":"","sources":["../../src/actions/inserting.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;CA2B7B,CAAC"}

package/dist-npm/actions/inserting.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * English language content for the inserting action
+ * Note: This is often combined with putting, but can be separate for specific use cases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertingLanguage = void 0;
+exports.insertingLanguage = {
+    actionId: 'if.action.inserting',
+    patterns: [
+        'insert [something] in [something]',
+        'insert [something] into [something]',
+        'stick [something] in [something]',
+        'push [something] in [something]'
+    ],
+    messages: {
+        'no_target': "Insert what?",
+        'no_destination': "Insert {item} into what?",
+        'not_held': "{You} {need} to be holding {item} first.",
+        'not_insertable': "{item} can't be inserted into things.",
+        'not_container': "{You} {can't} insert things into {destination}.",
+        'already_there': "{item} is already in {destination}.",
+        'inserted': "{You} {insert} {item} into {container}.",
+        'wont_fit': "{item} won't fit in {container}.",
+        'container_closed': "{container} is closed."
+    },
+    help: {
+        description: 'Insert objects into containers.',
+        examples: 'insert coin in slot, insert key into lock',
+        summary: 'INSERT/PUT IN - Put objects inside containers. Example: PUT COIN IN SLOT'
+    }
+};
+//# sourceMappingURL=inserting.js.map

package/dist-npm/actions/inserting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inserting.js","sourceRoot":"","sources":["../../src/actions/inserting.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEU,QAAA,iBAAiB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB;IAE/B,QAAQ,EAAE;QACR,mCAAmC;QACnC,qCAAqC;QACrC,kCAAkC;QAClC,iCAAiC;KAClC;IAED,QAAQ,EAAE;QACR,WAAW,EAAE,cAAc;QAC3B,gBAAgB,EAAE,0BAA0B;QAC5C,UAAU,EAAE,0CAA0C;QACtD,gBAAgB,EAAE,uCAAuC;QACzD,eAAe,EAAE,iDAAiD;QAClE,eAAe,EAAE,qCAAqC;QACtD,UAAU,EAAE,yCAAyC;QACrD,UAAU,EAAE,kCAAkC;QAC9C,kBAAkB,EAAE,wBAAwB;KAC7C;IAED,IAAI,EAAE;QACJ,WAAW,EAAE,iCAAiC;QAC9C,QAAQ,EAAE,2CAA2C;QACrD,OAAO,EAAE,0EAA0E;KACpF;CACF,CAAC"}

package/dist-npm/actions/inventory.d.ts

@@ -0,0 +1,32 @@
+/**
+ * English language content for the inventory action
+ */
+export declare const inventoryLanguage: {
+    actionId: string;
+    patterns: string[];
+    messages: {
+        empty: string;
+        inventory_empty: string;
+        nothing_at_all: string;
+        hands_empty: string;
+        pockets_empty: string;
+        carrying: string;
+        wearing: string;
+        carrying_and_wearing: string;
+        item_list: string;
+        holding_list: string;
+        worn_list: string;
+        inventory_header: string;
+        carrying_count: string;
+        wearing_count: string;
+        burden_light: string;
+        burden_heavy: string;
+        burden_overloaded: string;
+    };
+    help: {
+        description: string;
+        examples: string;
+        summary: string;
+    };
+};
+//# sourceMappingURL=inventory.d.ts.map

package/dist-npm/actions/inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inventory.d.ts","sourceRoot":"","sources":["../../src/actions/inventory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC7B,CAAC"}

package/dist-npm/actions/inventory.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * English language content for the inventory action
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inventoryLanguage = void 0;
+exports.inventoryLanguage = {
+    actionId: 'if.action.inventory',
+    patterns: [
+        'inventory',
+        'i',
+        'inv',
+        'take inventory',
+        'check inventory'
+    ],
+    messages: {
+        'empty': "{You} aren't carrying anything.",
+        'inventory_empty': "{You} aren't carrying anything.",
+        'nothing_at_all': "{You} aren't carrying anything at all.",
+        'hands_empty': "{Your} hands are empty.",
+        'pockets_empty': "{Your} pockets are empty.",
+        'carrying': "{You} {be} carrying:",
+        'wearing': "{You} {be} wearing:",
+        'carrying_and_wearing': "{You} {be} carrying and wearing:",
+        'item_list': "  {item}",
+        'holding_list': "  {items}",
+        'worn_list': "  {items} (worn)",
+        'inventory_header': "{You} {be} carrying:",
+        'carrying_count': "{You} {be} carrying {holdingCount} item(s).",
+        'wearing_count': "{You} {be} wearing {wearingCount} item(s).",
+        'burden_light': "{You're} traveling light.",
+        'burden_heavy': "{You're} carrying quite a load.",
+        'burden_overloaded': "{You're} weighed down with everything {you're} carrying."
+    },
+    help: {
+        description: 'Check what you are carrying and wearing.',
+        examples: 'inventory, i, inv',
+        summary: 'INVENTORY/I - Check what you are carrying and wearing. Example: I'
+    }
+};
+//# sourceMappingURL=inventory.js.map

package/dist-npm/actions/inventory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inventory.js","sourceRoot":"","sources":["../../src/actions/inventory.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEU,QAAA,iBAAiB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB;IAE/B,QAAQ,EAAE;QACR,WAAW;QACX,GAAG;QACH,KAAK;QACL,gBAAgB;QAChB,iBAAiB;KAClB;IAED,QAAQ,EAAE;QACR,OAAO,EAAE,iCAAiC;QAC1C,iBAAiB,EAAE,iCAAiC;QACpD,gBAAgB,EAAE,wCAAwC;QAC1D,aAAa,EAAE,yBAAyB;QACxC,eAAe,EAAE,2BAA2B;QAC5C,UAAU,EAAE,sBAAsB;QAClC,SAAS,EAAE,qBAAqB;QAChC,sBAAsB,EAAE,kCAAkC;QAC1D,WAAW,EAAE,UAAU;QACvB,cAAc,EAAE,WAAW;QAC3B,WAAW,EAAE,kBAAkB;QAC/B,kBAAkB,EAAE,sBAAsB;QAC1C,gBAAgB,EAAE,6CAA6C;QAC/D,eAAe,EAAE,4CAA4C;QAC7D,cAAc,EAAE,2BAA2B;QAC3C,cAAc,EAAE,iCAAiC;QACjD,mBAAmB,EAAE,0DAA0D;KAChF;IAED,IAAI,EAAE;QACJ,WAAW,EAAE,0CAA0C;QACvD,QAAQ,EAAE,mBAAmB;QAC7B,OAAO,EAAE,mEAAmE;KAC7E;CACF,CAAC"}

package/dist-npm/actions/listening.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Language content for listening action
+ */
+export declare const listeningLanguage: {
+    actionId: string;
+    patterns: string[];
+    messages: {
+        not_visible: string;
+        silence: string;
+        ambient_sounds: string;
+        active_devices: string;
+        no_sound: string;
+        device_running: string;
+        device_off: string;
+        container_sounds: string;
+        liquid_sounds: string;
+        listened_to: string;
+        listened_environment: string;
+    };
+    help: {
+        description: string;
+        examples: string;
+        summary: string;
+    };
+};
+//# sourceMappingURL=listening.d.ts.map

package/dist-npm/actions/listening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listening.d.ts","sourceRoot":"","sources":["../../src/actions/listening.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;CAmC7B,CAAC"}

package/dist-npm/actions/listening.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Language content for listening action
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listeningLanguage = void 0;
+exports.listeningLanguage = {
+    actionId: 'if.action.listening',
+    patterns: [
+        'listen',
+        'listen to [something]',
+        'hear [something]'
+    ],
+    messages: {
+        // Error messages
+        'not_visible': "{You} {can't} see {target} well enough to focus on its sounds.",
+        // Success messages - environment
+        'silence': "{You} {hear} nothing out of the ordinary.",
+        'ambient_sounds': "{You} {hear} the usual ambient sounds.",
+        'active_devices': "{You} can {hear} {devices} operating nearby.",
+        // Success messages - specific targets
+        'no_sound': "{target} isn't making any sound.",
+        'device_running': "{target} is making a soft humming sound.",
+        'device_off': "{target} is silent.",
+        'container_sounds': "{You} {hear} faint sounds from inside {target}.",
+        'liquid_sounds': "{You} {hear} liquid sloshing in {target}.",
+        // Generic listening
+        'listened_to': "{You} {listen} carefully to {target}.",
+        'listened_environment': "{You} {listen} carefully."
+    },
+    help: {
+        description: 'Listen for sounds in the environment or from specific objects.',
+        examples: 'listen, listen to radio, hear',
+        summary: 'LISTEN - Listen for sounds in the environment or from specific objects. Example: LISTEN TO RADIO'
+    }
+};
+//# sourceMappingURL=listening.js.map

package/dist-npm/actions/listening.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listening.js","sourceRoot":"","sources":["../../src/actions/listening.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEU,QAAA,iBAAiB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB;IAE/B,QAAQ,EAAE;QACR,QAAQ;QACR,uBAAuB;QACvB,kBAAkB;KACnB;IAED,QAAQ,EAAE;QACR,iBAAiB;QACjB,aAAa,EAAE,gEAAgE;QAE/E,iCAAiC;QACjC,SAAS,EAAE,2CAA2C;QACtD,gBAAgB,EAAE,wCAAwC;QAC1D,gBAAgB,EAAE,8CAA8C;QAEhE,sCAAsC;QACtC,UAAU,EAAE,kCAAkC;QAC9C,gBAAgB,EAAE,0CAA0C;QAC5D,YAAY,EAAE,qBAAqB;QACnC,kBAAkB,EAAE,iDAAiD;QACrE,eAAe,EAAE,2CAA2C;QAE5D,oBAAoB;QACpB,aAAa,EAAE,uCAAuC;QACtD,sBAAsB,EAAE,2BAA2B;KACpD;IAED,IAAI,EAAE;QACJ,WAAW,EAAE,gEAAgE;QAC7E,QAAQ,EAAE,+BAA+B;QACzC,OAAO,EAAE,kGAAkG;KAC5G;CACF,CAAC"}

package/dist-npm/actions/locking.d.ts

@@ -0,0 +1,25 @@
+/**
+ * English language content for the locking action
+ */
+export declare const lockingLanguage: {
+    actionId: string;
+    patterns: string[];
+    messages: {
+        no_target: string;
+        not_lockable: string;
+        no_key: string;
+        wrong_key: string;
+        already_locked: string;
+        not_closed: string;
+        locked: string;
+        locked_with: string;
+        cant_reach: string;
+        key_not_held: string;
+    };
+    help: {
+        description: string;
+        examples: string;
+        summary: string;
+    };
+};
+//# sourceMappingURL=locking.d.ts.map

package/dist-npm/actions/locking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locking.d.ts","sourceRoot":"","sources":["../../src/actions/locking.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;CA4B3B,CAAC"}

package/dist-npm/actions/locking.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * English language content for the locking action
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockingLanguage = void 0;
+exports.lockingLanguage = {
+    actionId: 'if.action.locking',
+    patterns: [
+        'lock [something]',
+        'lock [something] with [something]',
+        'secure [something]',
+        'secure [something] with [something]'
+    ],
+    messages: {
+        'no_target': "Lock what?",
+        'not_lockable': "{item} can't be locked.",
+        'no_key': "What do {you} want to lock it with?",
+        'wrong_key': "{key} doesn't fit {item}.",
+        'already_locked': "{item} is already locked.",
+        'not_closed': "{You} {need} to close {item} first.",
+        'locked': "{You} {lock} {item}.",
+        'locked_with': "{You} {lock} {item} with {key}.",
+        'cant_reach': "{You} {can't} reach {item}.",
+        'key_not_held': "{You} {need} to be holding {key}."
+    },
+    help: {
+        description: 'Lock containers or doors.',
+        examples: 'lock door, lock chest with key',
+        summary: 'LOCK - Lock doors and containers with the appropriate key. Example: LOCK DOOR WITH KEY'
+    }
+};
+//# sourceMappingURL=locking.js.map

package/dist-npm/actions/locking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locking.js","sourceRoot":"","sources":["../../src/actions/locking.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEU,QAAA,eAAe,GAAG;IAC7B,QAAQ,EAAE,mBAAmB;IAE7B,QAAQ,EAAE;QACR,kBAAkB;QAClB,mCAAmC;QACnC,oBAAoB;QACpB,qCAAqC;KACtC;IAED,QAAQ,EAAE;QACR,WAAW,EAAE,YAAY;QACzB,cAAc,EAAE,yBAAyB;QACzC,QAAQ,EAAE,qCAAqC;QAC/C,WAAW,EAAE,2BAA2B;QACxC,gBAAgB,EAAE,2BAA2B;QAC7C,YAAY,EAAE,qCAAqC;QACnD,QAAQ,EAAE,sBAAsB;QAChC,aAAa,EAAE,iCAAiC;QAChD,YAAY,EAAE,6BAA6B;QAC3C,cAAc,EAAE,mCAAmC;KACpD;IAED,IAAI,EAAE;QACJ,WAAW,EAAE,2BAA2B;QACxC,QAAQ,EAAE,gCAAgC;QAC1C,OAAO,EAAE,wFAAwF;KAClG;CACF,CAAC"}

package/dist-npm/actions/looking.d.ts

@@ -0,0 +1,23 @@
+/**
+ * English language content for the looking action
+ */
+export declare const lookingLanguage: {
+    actionId: string;
+    patterns: string[];
+    messages: {
+        room_description: string;
+        room_dark: string;
+        exits: string;
+        you_see: string;
+        contents_list: string;
+        nothing_special: string;
+        container_contents: string;
+        surface_contents: string;
+    };
+    help: {
+        description: string;
+        examples: string;
+        summary: string;
+    };
+};
+//# sourceMappingURL=looking.d.ts.map

package/dist-npm/actions/looking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"looking.d.ts","sourceRoot":"","sources":["../../src/actions/looking.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;CA6B3B,CAAC"}

package/dist-npm/actions/looking.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * English language content for the looking action
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookingLanguage = void 0;
+exports.lookingLanguage = {
+    actionId: 'if.action.looking',
+    patterns: [
+        'look',
+        'l',
+        'look around',
+        'look at [something]',
+        'examine [something]',
+        'x [something]'
+    ],
+    messages: {
+        // Room description - rendered via action.success (if.event.room.description is suppressed)
+        'room_description': "{name}\n{description}",
+        'room_dark': "It's pitch dark, and {you} {can't} see a thing.",
+        'exits': "Exits: {exits}",
+        'you_see': "{You} can {see} {items} here.",
+        'contents_list': "{You} can {see} {items} here.",
+        'nothing_special': "{You} {see} nothing special.",
+        'container_contents': "In {container} {you} {see} {items}.",
+        'surface_contents': "On {surface} {you} {see} {items}."
+    },
+    help: {
+        description: 'Look around the current location to see what is there.',
+        examples: 'look, l, look around',
+        summary: 'LOOK/L - Look around the current location to see what is there. Example: LOOK'
+    }
+};
+//# sourceMappingURL=looking.js.map

package/dist-npm/actions/looking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"looking.js","sourceRoot":"","sources":["../../src/actions/looking.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEU,QAAA,eAAe,GAAG;IAC7B,QAAQ,EAAE,mBAAmB;IAE7B,QAAQ,EAAE;QACR,MAAM;QACN,GAAG;QACH,aAAa;QACb,qBAAqB;QACrB,qBAAqB;QACrB,eAAe;KAChB;IAED,QAAQ,EAAE;QACR,2FAA2F;QAC3F,kBAAkB,EAAE,uBAAuB;QAC3C,WAAW,EAAE,iDAAiD;QAC9D,OAAO,EAAE,gBAAgB;QACzB,SAAS,EAAE,+BAA+B;QAC1C,eAAe,EAAE,+BAA+B;QAChD,iBAAiB,EAAE,8BAA8B;QACjD,oBAAoB,EAAE,qCAAqC;QAC3D,kBAAkB,EAAE,mCAAmC;KACxD;IAED,IAAI,EAAE;QACJ,WAAW,EAAE,wDAAwD;QACrE,QAAQ,EAAE,sBAAsB;QAChC,OAAO,EAAE,+EAA+E;KACzF;CACF,CAAC"}

package/dist-npm/actions/lowering.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Language content for lowering action (ADR-090 capability dispatch)
+ *
+ * This action dispatches to trait behaviors. Default messages are provided
+ * here, but specific behaviors may emit custom message IDs.
+ */
+export declare const loweringLanguage: {
+    actionId: string;
+    patterns: string[];
+    messages: {
+        'if.lower.no_target': string;
+        'if.lower.cant_lower_that': string;
+        'if.lower.already_down': string;
+        'if.lower.lowered': string;
+    };
+    help: {
+        description: string;
+        examples: string;
+        summary: string;
+    };
+};
+//# sourceMappingURL=lowering.d.ts.map

package/dist-npm/actions/lowering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowering.d.ts","sourceRoot":"","sources":["../../src/actions/lowering.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;CAsB5B,CAAC"}

package/dist-npm/actions/lowering.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Language content for lowering action (ADR-090 capability dispatch)
+ *
+ * This action dispatches to trait behaviors. Default messages are provided
+ * here, but specific behaviors may emit custom message IDs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loweringLanguage = void 0;
+exports.loweringLanguage = {
+    actionId: 'if.action.lowering',
+    patterns: [
+        'lower [something]'
+    ],
+    messages: {
+        // Error messages (used by capability dispatch)
+        'if.lower.no_target': "Lower what?",
+        'if.lower.cant_lower_that': "{You} {can't} lower {target}.",
+        'if.lower.already_down': "That's already lowered.",
+        // Generic success message (specific behaviors override)
+        'if.lower.lowered': "{You} {lower} {target}."
+    },
+    help: {
+        description: 'Lower something that can be lowered.',
+        examples: 'lower basket, lower drawbridge, lower blinds',
+        summary: 'LOWER - Lower objects like baskets, drawbridges, or blinds. Example: LOWER BASKET'
+    }
+};
+//# sourceMappingURL=lowering.js.map

package/dist-npm/actions/lowering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowering.js","sourceRoot":"","sources":["../../src/actions/lowering.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEU,QAAA,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,oBAAoB;IAE9B,QAAQ,EAAE;QACR,mBAAmB;KACpB;IAED,QAAQ,EAAE;QACR,+CAA+C;QAC/C,oBAAoB,EAAE,aAAa;QACnC,0BAA0B,EAAE,+BAA+B;QAC3D,uBAAuB,EAAE,yBAAyB;QAElD,wDAAwD;QACxD,kBAAkB,EAAE,yBAAyB;KAC9C;IAED,IAAI,EAAE;QACJ,WAAW,EAAE,sCAAsC;QACnD,QAAQ,EAAE,8CAA8C;QACxD,OAAO,EAAE,mFAAmF;KAC7F;CACF,CAAC"}