@mythxengine/types 0.1.0

package/dist/rules/abilities.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Ability Configuration
+ *
+ * Allows world packs to define custom abilities or override base abilities.
+ */
+/**
+ * How an ability is used in the system
+ */
+export interface AbilityUsage {
+    /** Can be used for melee attacks */
+    meleeAttack?: boolean;
+    /** Can be used for ranged attacks */
+    rangedAttack?: boolean;
+    /** Used in defense calculation */
+    defense?: boolean;
+    /** Added to damage rolls */
+    damage?: boolean;
+    /** Contributes to HP calculation */
+    hp?: boolean;
+    /** Used for initiative */
+    initiative?: boolean;
+}
+/**
+ * Definition of a single ability
+ */
+export interface AbilityDefinition {
+    /** Unique identifier (e.g., "STR", "STRESS", "SANITY") */
+    id: string;
+    /** Display name (e.g., "Strength", "Stress", "Sanity") */
+    name: string;
+    /** Description of what this ability represents */
+    description: string;
+    /** Minimum allowed value */
+    minValue: number;
+    /** Maximum allowed value */
+    maxValue: number;
+    /** Default starting value for new characters */
+    defaultValue: number;
+    /** How this ability is used in the system */
+    usage?: AbilityUsage;
+}
+/**
+ * Configuration for abilities in a world pack
+ */
+export interface AbilitiesConfig {
+    /**
+     * Replace all base abilities with these.
+     * Use this for systems with completely different abilities
+     * (e.g., Mothership's STR/SPD/INT/CMB instead of STR/AGI/WIT/CON)
+     */
+    replace?: AbilityDefinition[];
+    /**
+     * Add these abilities to the base set.
+     * Use this to add tracking abilities like STRESS, SANITY, CORRUPTION
+     * while keeping the base 4.
+     */
+    add?: AbilityDefinition[];
+    /**
+     * Override specific properties of base abilities.
+     * Use this to change ranges or descriptions without full replacement.
+     */
+    override?: {
+        [abilityId: string]: Partial<Omit<AbilityDefinition, "id">>;
+    };
+}
+/**
+ * Base ability definitions (the defaults)
+ */
+export declare const BASE_ABILITIES: AbilityDefinition[];
+/**
+ * Get the effective abilities after applying configuration
+ */
+export declare function resolveAbilities(config?: AbilitiesConfig): AbilityDefinition[];
+/**
+ * Create an abilities record with default values
+ */
+export declare function createDefaultAbilitiesRecord(definitions: AbilityDefinition[]): Record<string, number>;
+/**
+ * Validate an ability value against its definition
+ */
+export declare function isValidAbilityValueForDefinition(value: number, definition: AbilityDefinition): boolean;
+//# sourceMappingURL=abilities.d.ts.map

package/dist/rules/abilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abilities.d.ts","sourceRoot":"","sources":["../../src/rules/abilities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,qCAAqC;IACrC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,kCAAkC;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,0BAA0B;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,EAAE,EAAE,MAAM,CAAC;IACX,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,OAAO,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAE9B;;;;OAIG;IACH,GAAG,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAE1B;;;OAGG;IACH,QAAQ,CAAC,EAAE;QACT,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC,CAAC;KAC7D,CAAC;CACH;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,iBAAiB,EAqC7C,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,iBAAiB,EAAE,CA8B9E;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,iBAAiB,EAAE,GAC/B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxB;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,iBAAiB,GAC5B,OAAO,CAMT"}

package/dist/rules/abilities.js

@@ -0,0 +1,94 @@
+/**
+ * Ability Configuration
+ *
+ * Allows world packs to define custom abilities or override base abilities.
+ */
+/**
+ * Base ability definitions (the defaults)
+ */
+export const BASE_ABILITIES = [
+    {
+        id: "STR",
+        name: "Strength",
+        description: "Physical power, melee damage, carrying capacity",
+        minValue: -3,
+        maxValue: 3,
+        defaultValue: 0,
+        usage: { meleeAttack: true, damage: true },
+    },
+    {
+        id: "AGI",
+        name: "Agility",
+        description: "Speed, reflexes, ranged attacks, defense",
+        minValue: -3,
+        maxValue: 3,
+        defaultValue: 0,
+        usage: { rangedAttack: true, defense: true, initiative: true },
+    },
+    {
+        id: "WIT",
+        name: "Wit",
+        description: "Intelligence, perception, social skills, magic",
+        minValue: -3,
+        maxValue: 3,
+        defaultValue: 0,
+        usage: {},
+    },
+    {
+        id: "CON",
+        name: "Constitution",
+        description: "Toughness, HP, endurance, resistance",
+        minValue: -3,
+        maxValue: 3,
+        defaultValue: 0,
+        usage: { hp: true },
+    },
+];
+/**
+ * Get the effective abilities after applying configuration
+ */
+export function resolveAbilities(config) {
+    if (!config) {
+        return BASE_ABILITIES;
+    }
+    // If replacing, start with replacement set
+    if (config.replace) {
+        return config.replace;
+    }
+    // Start with base abilities
+    let abilities = [...BASE_ABILITIES];
+    // Apply overrides
+    if (config.override) {
+        abilities = abilities.map((ability) => {
+            const override = config.override?.[ability.id];
+            if (override) {
+                return { ...ability, ...override };
+            }
+            return ability;
+        });
+    }
+    // Add new abilities
+    if (config.add) {
+        abilities = [...abilities, ...config.add];
+    }
+    return abilities;
+}
+/**
+ * Create an abilities record with default values
+ */
+export function createDefaultAbilitiesRecord(definitions) {
+    const record = {};
+    for (const def of definitions) {
+        record[def.id] = def.defaultValue;
+    }
+    return record;
+}
+/**
+ * Validate an ability value against its definition
+ */
+export function isValidAbilityValueForDefinition(value, definition) {
+    return (Number.isInteger(value) &&
+        value >= definition.minValue &&
+        value <= definition.maxValue);
+}
+//# sourceMappingURL=abilities.js.map

package/dist/rules/abilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abilities.js","sourceRoot":"","sources":["../../src/rules/abilities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAmEH;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAwB;IACjD;QACE,EAAE,EAAE,KAAK;QACT,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,iDAAiD;QAC9D,QAAQ,EAAE,CAAC,CAAC;QACZ,QAAQ,EAAE,CAAC;QACX,YAAY,EAAE,CAAC;QACf,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;KAC3C;IACD;QACE,EAAE,EAAE,KAAK;QACT,IAAI,EAAE,SAAS;QACf,WAAW,EAAE,0CAA0C;QACvD,QAAQ,EAAE,CAAC,CAAC;QACZ,QAAQ,EAAE,CAAC;QACX,YAAY,EAAE,CAAC;QACf,KAAK,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE;KAC/D;IACD;QACE,EAAE,EAAE,KAAK;QACT,IAAI,EAAE,KAAK;QACX,WAAW,EAAE,gDAAgD;QAC7D,QAAQ,EAAE,CAAC,CAAC;QACZ,QAAQ,EAAE,CAAC;QACX,YAAY,EAAE,CAAC;QACf,KAAK,EAAE,EAAE;KACV;IACD;QACE,EAAE,EAAE,KAAK;QACT,IAAI,EAAE,cAAc;QACpB,WAAW,EAAE,sCAAsC;QACnD,QAAQ,EAAE,CAAC,CAAC;QACZ,QAAQ,EAAE,CAAC;QACX,YAAY,EAAE,CAAC;QACf,KAAK,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE;KACpB;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAwB;IACvD,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,2CAA2C;IAC3C,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,MAAM,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,4BAA4B;IAC5B,IAAI,SAAS,GAAG,CAAC,GAAG,cAAc,CAAC,CAAC;IAEpC,kBAAkB;IAClB,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;QACpB,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;YACpC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YAC/C,IAAI,QAAQ,EAAE,CAAC;gBACb,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,QAAQ,EAAE,CAAC;YACrC,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,oBAAoB;IACpB,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;QACf,SAAS,GAAG,CAAC,GAAG,SAAS,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAC1C,WAAgC;IAEhC,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;QAC9B,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,YAAY,CAAC;IACpC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gCAAgC,CAC9C,KAAa,EACb,UAA6B;IAE7B,OAAO,CACL,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC;QACvB,KAAK,IAAI,UAAU,CAAC,QAAQ;QAC5B,KAAK,IAAI,UAAU,CAAC,QAAQ,CAC7B,CAAC;AACJ,CAAC"}

package/dist/rules/custom-tests.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Custom Test Configuration
+ *
+ * Allows world packs to define genre-specific test types like
+ * panic rolls, sanity checks, corruption tests, etc.
+ */
+import type { Effect } from "../game/conditions.js";
+/**
+ * Roll configuration for a custom test
+ */
+export interface CustomTestRoll {
+    /** Dice expression to roll (e.g., "d20", "2d10", "d100") */
+    dice: string;
+    /** Ability modifier to add to the roll (roll-over systems) */
+    ability?: string;
+    /** For roll-under systems: ability to roll under */
+    underAbility?: string;
+    /** Fixed difficulty target (for roll-over) */
+    difficulty?: number;
+    /**
+     * Formula for dynamic difficulty.
+     * Variables: any ability ID in braces (e.g., "{STRESS}", "{SAN}")
+     * Operators: +, -, *, /
+     * Example: "{STRESS} * 2" or "20 - {WIT}"
+     */
+    difficultyFormula?: string;
+    /** Skill to add bonus from (if applicable) */
+    skill?: string;
+}
+/**
+ * A single entry in an outcome table
+ */
+export interface TableEntry {
+    /** Roll range that triggers this entry [min, max] inclusive */
+    range: [number, number];
+    /** Description of what happens */
+    description: string;
+    /** Effects to apply */
+    effects?: Effect[];
+}
+/**
+ * A table of outcomes rolled on after the test
+ */
+export interface OutcomeTable {
+    /** Dice to roll on the table */
+    dice: string;
+    /** Ability to add to table roll (optional) */
+    addAbility?: string;
+    /** Table entries */
+    entries: TableEntry[];
+}
+/**
+ * Outcome definition for a test result
+ */
+export interface CustomTestOutcome {
+    /** Description of what happens */
+    description: string;
+    /** Effects to apply immediately */
+    effects?: Effect[];
+    /** Table to roll on (for complex outcomes like panic tables) */
+    table?: OutcomeTable;
+}
+/**
+ * When this custom test should be triggered
+ */
+export type CustomTestTrigger = "manual" | "combat_start" | "combat_end" | "take_damage" | "critical_failure" | "witness_death" | "witness_horror" | "ability_threshold" | "rest" | "scene_start" | string;
+/**
+ * Threshold trigger configuration
+ */
+export interface ThresholdTrigger {
+    /** Ability to monitor */
+    ability: string;
+    /** Threshold value */
+    threshold: number;
+    /** Trigger when going above or below */
+    direction: "above" | "below" | "equals";
+}
+/**
+ * Full definition of a custom test type
+ */
+export interface CustomTestDefinition {
+    /** Unique identifier (e.g., "panic", "sanity_check") */
+    id: string;
+    /** Display name (e.g., "Panic Check") */
+    name: string;
+    /** Description of when and why this test is used */
+    description: string;
+    /** What triggers this test (can be multiple) */
+    triggers: CustomTestTrigger[];
+    /** Threshold trigger configuration (if using ability_threshold trigger) */
+    thresholdTrigger?: ThresholdTrigger;
+    /** The roll mechanics */
+    roll: CustomTestRoll;
+    /** Results by outcome type */
+    outcomes: {
+        /** What happens on critical success (optional) */
+        criticalSuccess?: CustomTestOutcome;
+        /** What happens on success */
+        success?: CustomTestOutcome;
+        /** What happens on failure */
+        failure?: CustomTestOutcome;
+        /** What happens on critical failure (optional) */
+        criticalFailure?: CustomTestOutcome;
+    };
+    /** Whether this test can be retried (default: false) */
+    retryable?: boolean;
+    /** Cooldown in game minutes before this test can trigger again */
+    cooldownMinutes?: number;
+}
+/**
+ * Configuration for custom tests in a world pack
+ */
+export interface CustomTestsConfig {
+    /** Custom test definitions */
+    tests: CustomTestDefinition[];
+}
+/**
+ * Result of resolving a custom test
+ */
+export interface CustomTestResult {
+    /** The test definition that was used */
+    testId: string;
+    /** The roll result */
+    roll: {
+        dice: string;
+        natural: number;
+        modifier: number;
+        total: number;
+    };
+    /** Target to beat (for roll-over) or stay under (for roll-under) */
+    target: number;
+    /** Whether the test succeeded */
+    success: boolean;
+    /** Whether this was a critical */
+    critical: boolean;
+    /** The outcome that applies */
+    outcome: CustomTestOutcome;
+    /** If a table was rolled, the table result */
+    tableRoll?: {
+        dice: string;
+        roll: number;
+        entry: TableEntry;
+    };
+    /** Effects to apply */
+    effects: Effect[];
+}
+/**
+ * Find a custom test by ID
+ */
+export declare function findCustomTest(tests: CustomTestDefinition[], id: string): CustomTestDefinition | undefined;
+/**
+ * Find custom tests that match a trigger
+ */
+export declare function findTestsByTrigger(tests: CustomTestDefinition[], trigger: CustomTestTrigger): CustomTestDefinition[];
+/**
+ * Parse a simple formula with ability substitutions
+ * Returns a function that takes ability values and returns the result
+ *
+ * Supported: addition, subtraction, multiplication, division, parentheses
+ * Variables: {ABILITY_ID} format
+ */
+export declare function parseFormula(formula: string): (abilities: Record<string, number>) => number;
+//# sourceMappingURL=custom-tests.d.ts.map

package/dist/rules/custom-tests.d.ts.map

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

package/dist/rules/custom-tests.js

@@ -0,0 +1,43 @@
+/**
+ * Custom Test Configuration
+ *
+ * Allows world packs to define genre-specific test types like
+ * panic rolls, sanity checks, corruption tests, etc.
+ */
+/**
+ * Find a custom test by ID
+ */
+export function findCustomTest(tests, id) {
+    return tests.find((t) => t.id === id);
+}
+/**
+ * Find custom tests that match a trigger
+ */
+export function findTestsByTrigger(tests, trigger) {
+    return tests.filter((t) => t.triggers.includes(trigger));
+}
+/**
+ * Parse a simple formula with ability substitutions
+ * Returns a function that takes ability values and returns the result
+ *
+ * Supported: addition, subtraction, multiplication, division, parentheses
+ * Variables: {ABILITY_ID} format
+ */
+export function parseFormula(formula) {
+    return (abilities) => {
+        // Replace ability references with values using split/join for safety
+        // (avoids RegExp construction from ability IDs which could cause ReDoS)
+        let expr = formula;
+        for (const [id, value] of Object.entries(abilities)) {
+            expr = expr.split(`{${id}}`).join(String(value));
+        }
+        // Basic safety check - only allow numbers, operators, parentheses, spaces
+        if (!/^[\d+\-*/().\s]+$/.test(expr)) {
+            throw new Error(`Invalid formula expression: ${expr}`);
+        }
+        // Evaluate (safe because we validated the expression)
+        // eslint-disable-next-line no-new-func
+        return Function(`"use strict"; return (${expr})`)();
+    };
+}
+//# sourceMappingURL=custom-tests.js.map

package/dist/rules/custom-tests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-tests.js","sourceRoot":"","sources":["../../src/rules/custom-tests.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA8KH;;GAEG;AACH,MAAM,UAAU,cAAc,CAC5B,KAA6B,EAC7B,EAAU;IAEV,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACxC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAA6B,EAC7B,OAA0B;IAE1B,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAe;IAEf,OAAO,CAAC,SAAiC,EAAU,EAAE;QACnD,qEAAqE;QACrE,wEAAwE;QACxE,IAAI,IAAI,GAAG,OAAO,CAAC;QACnB,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YACpD,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACnD,CAAC;QAED,0EAA0E;QAC1E,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,EAAE,CAAC,CAAC;QACzD,CAAC;QAED,sDAAsD;QACtD,uCAAuC;QACvC,OAAO,QAAQ,CAAC,yBAAyB,IAAI,GAAG,CAAC,EAAY,CAAC;IAChE,CAAC,CAAC;AACJ,CAAC"}

package/dist/rules/difficulties.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Difficulty Configuration
+ *
+ * Allows world packs to define custom difficulty levels.
+ */
+/**
+ * Definition of a difficulty level
+ */
+export interface DifficultyDefinition {
+    /** Unique identifier (e.g., "EASY", "STANDARD", "HARD") */
+    id: string;
+    /** Display name (e.g., "Easy", "Standard", "Hard") */
+    name: string;
+    /** Target number to meet or exceed */
+    target: number;
+    /** Description of when to use this difficulty */
+    description?: string;
+}
+/**
+ * Configuration for difficulties in a world pack
+ */
+export interface DifficultiesConfig {
+    /**
+     * Replace all base difficulties with these.
+     * Use for systems with different difficulty scales.
+     */
+    replace?: DifficultyDefinition[];
+    /**
+     * Add these difficulties to the base set.
+     * Use to add intermediate levels like "MODERATE" or "TRIVIAL".
+     */
+    add?: DifficultyDefinition[];
+}
+/**
+ * Base difficulty definitions (the defaults)
+ */
+export declare const BASE_DIFFICULTIES: DifficultyDefinition[];
+/**
+ * Get the effective difficulties after applying configuration
+ */
+export declare function resolveDifficulties(config?: DifficultiesConfig): DifficultyDefinition[];
+/**
+ * Find a difficulty by ID or target number
+ */
+export declare function findDifficulty(difficulties: DifficultyDefinition[], idOrTarget: string | number): DifficultyDefinition | undefined;
+/**
+ * Convert difficulty levels to a record for easy lookup
+ * @throws Error if duplicate IDs are found
+ */
+export declare function difficultiesToRecord(difficulties: DifficultyDefinition[]): Record<string, number>;
+//# sourceMappingURL=difficulties.d.ts.map

package/dist/rules/difficulties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"difficulties.d.ts","sourceRoot":"","sources":["../../src/rules/difficulties.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,2DAA2D;IAC3D,EAAE,EAAE,MAAM,CAAC;IACX,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAEjC;;;OAGG;IACH,GAAG,CAAC,EAAE,oBAAoB,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,oBAAoB,EAyBnD,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,CAAC,EAAE,kBAAkB,GAC1B,oBAAoB,EAAE,CAmBxB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,oBAAoB,EAAE,EACpC,UAAU,EAAE,MAAM,GAAG,MAAM,GAC1B,oBAAoB,GAAG,SAAS,CAOlC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,oBAAoB,EAAE,GACnC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxB"}

package/dist/rules/difficulties.js

@@ -0,0 +1,77 @@
+/**
+ * Difficulty Configuration
+ *
+ * Allows world packs to define custom difficulty levels.
+ */
+/**
+ * Base difficulty definitions (the defaults)
+ */
+export const BASE_DIFFICULTIES = [
+    {
+        id: "EASY",
+        name: "Easy",
+        target: 8,
+        description: "Simple tasks that most could accomplish",
+    },
+    {
+        id: "STANDARD",
+        name: "Standard",
+        target: 12,
+        description: "Tasks requiring skill or focus",
+    },
+    {
+        id: "HARD",
+        name: "Hard",
+        target: 16,
+        description: "Challenging tasks requiring expertise",
+    },
+    {
+        id: "EXTREME",
+        name: "Extreme",
+        target: 20,
+        description: "Near-impossible feats requiring mastery and luck",
+    },
+];
+/**
+ * Get the effective difficulties after applying configuration
+ */
+export function resolveDifficulties(config) {
+    if (!config) {
+        return BASE_DIFFICULTIES;
+    }
+    // If replacing, use replacement set
+    if (config.replace) {
+        return config.replace;
+    }
+    // Start with base and add new ones
+    let difficulties = [...BASE_DIFFICULTIES];
+    if (config.add) {
+        difficulties = [...difficulties, ...config.add];
+    }
+    // Sort by target number
+    return difficulties.sort((a, b) => a.target - b.target);
+}
+/**
+ * Find a difficulty by ID or target number
+ */
+export function findDifficulty(difficulties, idOrTarget) {
+    if (typeof idOrTarget === "string") {
+        return difficulties.find((d) => d.id.toUpperCase() === idOrTarget.toUpperCase());
+    }
+    return difficulties.find((d) => d.target === idOrTarget);
+}
+/**
+ * Convert difficulty levels to a record for easy lookup
+ * @throws Error if duplicate IDs are found
+ */
+export function difficultiesToRecord(difficulties) {
+    const record = {};
+    for (const d of difficulties) {
+        if (record[d.id] !== undefined) {
+            throw new Error(`Duplicate difficulty ID "${d.id}" with targets ${record[d.id]} and ${d.target}`);
+        }
+        record[d.id] = d.target;
+    }
+    return record;
+}
+//# sourceMappingURL=difficulties.js.map

package/dist/rules/difficulties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"difficulties.js","sourceRoot":"","sources":["../../src/rules/difficulties.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiCH;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA2B;IACvD;QACE,EAAE,EAAE,MAAM;QACV,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,CAAC;QACT,WAAW,EAAE,yCAAyC;KACvD;IACD;QACE,EAAE,EAAE,UAAU;QACd,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,EAAE;QACV,WAAW,EAAE,gCAAgC;KAC9C;IACD;QACE,EAAE,EAAE,MAAM;QACV,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,EAAE;QACV,WAAW,EAAE,uCAAuC;KACrD;IACD;QACE,EAAE,EAAE,SAAS;QACb,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,EAAE;QACV,WAAW,EAAE,kDAAkD;KAChE;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAA2B;IAE3B,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED,oCAAoC;IACpC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,MAAM,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,mCAAmC;IACnC,IAAI,YAAY,GAAG,CAAC,GAAG,iBAAiB,CAAC,CAAC;IAE1C,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;QACf,YAAY,GAAG,CAAC,GAAG,YAAY,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAClD,CAAC;IAED,wBAAwB;IACxB,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;AAC1D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAC5B,YAAoC,EACpC,UAA2B;IAE3B,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;QACnC,OAAO,YAAY,CAAC,IAAI,CACtB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,KAAK,UAAU,CAAC,WAAW,EAAE,CACvD,CAAC;IACJ,CAAC;IACD,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC;AAC3D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,YAAoC;IAEpC,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,KAAK,MAAM,CAAC,IAAI,YAAY,EAAE,CAAC;QAC7B,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CACb,4BAA4B,CAAC,CAAC,EAAE,kBAAkB,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,CACjF,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/rules/index.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Rules Configuration System
+ *
+ * Allows world packs to extend or override base game rules,
+ * enabling genre-specific mechanics while keeping a generic base.
+ *
+ * @example Basic usage - keep defaults
+ * ```ts
+ * // No rules config = use all defaults
+ * const worldPack = { meta: {...}, archetypes: {...} };
+ * ```
+ *
+ * @example Add stress tracking
+ * ```ts
+ * const worldPack = {
+ *   rules: {
+ *     abilities: {
+ *       add: [{ id: "STRESS", name: "Stress", minValue: 0, maxValue: 20, defaultValue: 2 }]
+ *     }
+ *   }
+ * };
+ * ```
+ *
+ * @example Full Mothership-style system
+ * ```ts
+ * const worldPack = {
+ *   rules: {
+ *     abilities: {
+ *       replace: [
+ *         { id: "STR", name: "Strength", minValue: 10, maxValue: 80, defaultValue: 30 },
+ *         { id: "SPD", name: "Speed", minValue: 10, maxValue: 80, defaultValue: 30 },
+ *         // ... etc
+ *       ]
+ *     },
+ *     mechanics: {
+ *       rollUnder: { enabled: true, dice: "d100" }
+ *     },
+ *     customTests: {
+ *       tests: [{ id: "panic", name: "Panic Check", ... }]
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export * from "./abilities.js";
+export * from "./difficulties.js";
+export * from "./mechanics.js";
+export * from "./custom-tests.js";
+import type { AbilitiesConfig, AbilityDefinition } from "./abilities.js";
+import type { DifficultiesConfig, DifficultyDefinition } from "./difficulties.js";
+import type { MechanicsConfig, ResolvedMechanics } from "./mechanics.js";
+import type { CustomTestsConfig, CustomTestDefinition } from "./custom-tests.js";
+/**
+ * Complete rules configuration for a world pack
+ */
+export interface WorldRulesConfig {
+    /**
+     * Override or extend ability definitions.
+     * Use to add stress/sanity tracking or replace the base 4 abilities entirely.
+     */
+    abilities?: AbilitiesConfig;
+    /**
+     * Override or extend difficulty levels.
+     * Use to add intermediate difficulties or change the scale.
+     */
+    difficulties?: DifficultiesConfig;
+    /**
+     * Override core mechanics like defense formula, criticals, etc.
+     * Use for d100 systems, different crit ranges, etc.
+     */
+    mechanics?: MechanicsConfig;
+    /**
+     * Define custom test types like panic checks, sanity rolls, etc.
+     * These can be triggered automatically or called manually.
+     */
+    customTests?: CustomTestsConfig;
+}
+/**
+ * Fully resolved rules with all defaults applied
+ */
+export interface ResolvedRules {
+    /** All ability definitions */
+    abilities: AbilityDefinition[];
+    /** Ability lookup by ID */
+    abilityMap: Map<string, AbilityDefinition>;
+    /** All difficulty definitions */
+    difficulties: DifficultyDefinition[];
+    /** Difficulty lookup by ID */
+    difficultyMap: Map<string, DifficultyDefinition>;
+    /** Resolved mechanics */
+    mechanics: ResolvedMechanics;
+    /** Custom test definitions */
+    customTests: CustomTestDefinition[];
+    /** Custom test lookup by ID */
+    customTestMap: Map<string, CustomTestDefinition>;
+}
+/**
+ * Resolve a world's rules configuration into fully resolved rules
+ *
+ * @param config - The world's rules configuration (or undefined for defaults)
+ * @returns Fully resolved rules with all defaults applied
+ */
+export declare function resolveRules(config?: WorldRulesConfig): ResolvedRules;
+/**
+ * Get the default rules (no configuration)
+ */
+export declare function getDefaultRules(): ResolvedRules;
+/**
+ * Validate that a rules configuration is valid
+ *
+ * @param config - The configuration to validate
+ * @returns Array of validation errors (empty if valid)
+ */
+export declare function validateRulesConfig(config: WorldRulesConfig): string[];
+/**
+ * Check if a rules config uses roll-under mechanics
+ */
+export declare function isRollUnderSystem(config?: WorldRulesConfig): boolean;
+/**
+ * Get ability IDs from a rules config
+ */
+export declare function getAbilityIds(config?: WorldRulesConfig): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAGH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAGlC,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAMjF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B;;;OAGG;IACH,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAElC;;;OAGG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B;;;OAGG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,8BAA8B;IAC9B,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,2BAA2B;IAC3B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC3C,iCAAiC;IACjC,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,8BAA8B;IAC9B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IACjD,yBAAyB;IACzB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,8BAA8B;IAC9B,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,+BAA+B;IAC/B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;CAClD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,aAAa,CAerE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,aAAa,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CA0FtE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAEpE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAGjE"}