ttrpg-engine-dnd 0.1.0-alpha.0

package/dist/content/pack.d.ts.map

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

package/dist/content/packs/starter.d.ts

@@ -0,0 +1,4 @@
+import { type ContentPack } from '../pack.js';
+export declare const STARTER_PACK_RAW: unknown;
+export declare const loadStarterPack: () => ContentPack;
+//# sourceMappingURL=starter.d.ts.map

package/dist/content/packs/starter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starter.d.ts","sourceRoot":"","sources":["../../../src/content/packs/starter.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,gBAAgB,EAAE,OAAyB,CAAC;AAEzD,eAAO,MAAM,eAAe,QAAO,WAA+C,CAAC"}

package/dist/content/validate.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedContent } from './pack.js';
+export interface ContentValidationIssue {
+    readonly path: string;
+    readonly message: string;
+    readonly suggestion?: string;
+}
+export declare const validateCrossReferences: (content: ResolvedContent) => ReadonlyArray<ContentValidationIssue>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/content/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/content/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AA6CD,eAAO,MAAM,uBAAuB,GAClC,SAAS,eAAe,KACvB,aAAa,CAAC,sBAAsB,CA8BtC,CAAC"}

package/dist/derive/ability-check.d.ts

@@ -0,0 +1,26 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { PendingChoice } from '../schemas/runtime/pending-choice.js';
+import type { ResolvedContent } from '../content/pack.js';
+import type { AbilityScore, Skill } from '../schemas/primitives.js';
+export interface AbilityCheckBreakdownEntry {
+    readonly source: string;
+    readonly value: number;
+}
+export interface AbilityCheckResult {
+    readonly total: number;
+    readonly breakdown: ReadonlyArray<AbilityCheckBreakdownEntry>;
+    readonly hasAdvantage: boolean;
+    readonly hasDisadvantage: boolean;
+}
+export interface ComputeAbilityCheckInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+    readonly ability: AbilityScore;
+    readonly skill?: Skill;
+    readonly pendingChoices?: Readonly<Record<string, PendingChoice>>;
+}
+export declare const computeAbilityCheck: (input: ComputeAbilityCheckInput) => AbilityCheckResult;
+export declare const computePassiveScore: (input: ComputeAbilityCheckInput) => number;
+//# sourceMappingURL=ability-check.d.ts.map

package/dist/derive/ability-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ability-check.d.ts","sourceRoot":"","sources":["../../src/derive/ability-check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAOpE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAAC;IAC9D,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;CACnE;AAKD,eAAO,MAAM,mBAAmB,GAAI,OAAO,wBAAwB,KAAG,kBA8CrE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,wBAAwB,KAAG,MAKrE,CAAC"}

package/dist/derive/ability.d.ts

@@ -0,0 +1,9 @@
+import type { CharacterLevel } from '../schemas/primitives.js';
+export declare const ABILITY_SCORE_MIN = 1;
+export declare const ABILITY_SCORE_MAX = 30;
+export declare const PROFICIENCY_BONUS_LEVEL_MIN = 1;
+export declare const PROFICIENCY_BONUS_LEVEL_MAX = 20;
+export declare const abilityModifier: (score: number) => number;
+export declare const proficiencyBonus: (level: number) => number;
+export declare const proficiencyBonusForCharacterLevel: (level: CharacterLevel) => number;
+//# sourceMappingURL=ability.d.ts.map

package/dist/derive/ability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ability.d.ts","sourceRoot":"","sources":["../../src/derive/ability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAC7C,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,MAU/C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MAUhD,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAAI,OAAO,cAAc,KAAG,MACjD,CAAC"}

package/dist/derive/ac.d.ts

@@ -0,0 +1,19 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { ResolvedContent } from '../content/pack.js';
+export interface ACBreakdownEntry {
+    readonly source: string;
+    readonly value: number;
+}
+export interface ACResult {
+    readonly total: number;
+    readonly breakdown: ReadonlyArray<ACBreakdownEntry>;
+}
+export interface ComputeACInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+    readonly pendingChoices?: Readonly<Record<string, import('../schemas/runtime/pending-choice.js').PendingChoice>>;
+}
+export declare const computeAC: (input: ComputeACInput) => ACResult;
+//# sourceMappingURL=ac.d.ts.map

package/dist/derive/ac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ac.d.ts","sourceRoot":"","sources":["../../src/derive/ac.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAO1D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;CACrD;AA2ED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,sCAAsC,EAAE,aAAa,CAAC,CAAC,CAAC;CAClH;AAED,eAAO,MAAM,SAAS,GAAI,OAAO,cAAc,KAAG,QAmBjD,CAAC"}

package/dist/derive/action-economy.d.ts

@@ -0,0 +1,17 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { PendingChoice } from '../schemas/runtime/pending-choice.js';
+import type { ResolvedContent } from '../content/pack.js';
+export interface ComputeActionEconomyInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+    readonly pendingChoices?: Readonly<Record<string, PendingChoice>>;
+}
+export interface ActionEconomyBudget {
+    readonly maxAttacksPerAction: number;
+    readonly extraActionsPerTurn: number;
+    readonly extraBonusActionsPerTurn: number;
+}
+export declare const computeActionEconomyBudget: (input: ComputeActionEconomyInput) => ActionEconomyBudget;
+//# sourceMappingURL=action-economy.d.ts.map

package/dist/derive/action-economy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-economy.d.ts","sourceRoot":"","sources":["../../src/derive/action-economy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAK1D,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;CACnE;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;CAC3C;AAED,eAAO,MAAM,0BAA0B,GACrC,OAAO,yBAAyB,KAC/B,mBAOF,CAAC"}

package/dist/derive/attack.d.ts

@@ -0,0 +1,20 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { ResolvedContent } from '../content/pack.js';
+export interface AttackBreakdownEntry {
+    readonly source: string;
+    readonly value: number;
+}
+export interface AttackResult {
+    readonly total: number;
+    readonly breakdown: ReadonlyArray<AttackBreakdownEntry>;
+}
+export interface ComputeAttackInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+    readonly weaponInstanceId: string;
+    readonly pendingChoices?: Readonly<Record<string, import('../schemas/runtime/pending-choice.js').PendingChoice>>;
+}
+export declare const computeAttackBonus: (input: ComputeAttackInput) => AttackResult;
+//# sourceMappingURL=attack.d.ts.map

package/dist/derive/attack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attack.d.ts","sourceRoot":"","sources":["../../src/derive/attack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAM1D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,sCAAsC,EAAE,aAAa,CAAC,CAAC,CAAC;CAClH;AA8BD,eAAO,MAAM,kBAAkB,GAAI,OAAO,kBAAkB,KAAG,YA+B9D,CAAC"}

package/dist/derive/character-view.d.ts

@@ -0,0 +1,29 @@
+import type { Character, HP } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { PendingChoice } from '../schemas/runtime/pending-choice.js';
+import type { ResolvedContent } from '../content/pack.js';
+import type { AbilityScore } from '../schemas/primitives.js';
+import { type ACResult } from './ac.js';
+import { type SaveResult } from './save.js';
+import { type SpellSlotsResult } from './spell-slots.js';
+export interface DerivedCharacter {
+    readonly id: string;
+    readonly name: string;
+    readonly totalLevel: number;
+    readonly proficiencyBonus: number;
+    readonly abilityModifiers: Readonly<Record<AbilityScore, number>>;
+    readonly hp: HP;
+    readonly ac: ACResult;
+    readonly savingThrows: Readonly<Record<AbilityScore, SaveResult>>;
+    readonly spellSlots: SpellSlotsResult;
+    readonly hasPendingChoices: boolean;
+    readonly pendingChoiceIds: ReadonlyArray<string>;
+}
+export interface ComputeDerivedCharacterInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+    readonly pendingChoices?: Readonly<Record<string, PendingChoice>>;
+}
+export declare const computeDerivedCharacter: (input: ComputeDerivedCharacterInput) => DerivedCharacter;
+//# sourceMappingURL=character-view.d.ts.map

package/dist/derive/character-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-view.d.ts","sourceRoot":"","sources":["../../src/derive/character-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAI5E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IAClE,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC;IAClE,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;CACnE;AAED,eAAO,MAAM,uBAAuB,GAClC,OAAO,4BAA4B,KAClC,gBA0BF,CAAC"}

package/dist/derive/damage-mitigation.d.ts

@@ -0,0 +1,18 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { PendingChoice } from '../schemas/runtime/pending-choice.js';
+import type { ResolvedContent } from '../content/pack.js';
+import type { DamageComponent } from '../schemas/events/combat.js';
+import type { DamageType } from '../schemas/primitives.js';
+export interface MitigateDamageInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+    readonly pendingChoices?: Readonly<Record<string, PendingChoice>>;
+    readonly rawComponents: ReadonlyArray<{
+        readonly amount: number;
+        readonly type: DamageType;
+    }>;
+}
+export declare const mitigateDamage: (input: MitigateDamageInput) => DamageComponent[];
+//# sourceMappingURL=damage-mitigation.d.ts.map

package/dist/derive/damage-mitigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"damage-mitigation.d.ts","sourceRoot":"","sources":["../../src/derive/damage-mitigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAM3D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IAClE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC;CAC/F;AAID,eAAO,MAAM,cAAc,GAAI,OAAO,mBAAmB,KAAG,eAAe,EAoC1E,CAAC"}

package/dist/derive/effect-stack.d.ts

@@ -0,0 +1,15 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { PendingChoice } from '../schemas/runtime/pending-choice.js';
+import type { Effect } from '../schemas/effects.js';
+import type { ResolvedContent } from '../content/pack.js';
+import { EffectAccumulator } from '../effects/builder.js';
+export interface BuildEffectStackInput {
+    readonly character: Character;
+    readonly content: ResolvedContent;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly pendingChoices?: Readonly<Record<string, PendingChoice>>;
+}
+export declare const collectEffectsFromCharacter: (input: BuildEffectStackInput) => Effect[];
+export declare const buildEffectStack: (input: BuildEffectStackInput) => EffectAccumulator;
+//# sourceMappingURL=effect-stack.d.ts.map

package/dist/derive/effect-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-stack.d.ts","sourceRoot":"","sources":["../../src/derive/effect-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAwB,MAAM,uBAAuB,CAAC;AAgFhF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;CACnE;AAED,eAAO,MAAM,2BAA2B,GAAI,OAAO,qBAAqB,KAAG,MAAM,EAehF,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,qBAAqB,KAAG,iBAqC/D,CAAC"}

package/dist/derive/encumbrance.d.ts

@@ -0,0 +1,17 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { ResolvedContent } from '../content/pack.js';
+export type EncumbranceLevel = 'unencumbered' | 'encumbered' | 'heavily-encumbered';
+export interface EncumbranceResult {
+    readonly carriedWeight: number;
+    readonly maxCarryingCapacity: number;
+    readonly level: EncumbranceLevel;
+}
+export interface ComputeEncumbranceInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+}
+export declare const computeCarryingCapacity: (character: Character) => number;
+export declare const computeEncumbrance: (input: ComputeEncumbranceInput) => EncumbranceResult;
+//# sourceMappingURL=encumbrance.d.ts.map

package/dist/derive/encumbrance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encumbrance.d.ts","sourceRoot":"","sources":["../../src/derive/encumbrance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAM1D,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAEpF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;CAClC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;CACnC;AAED,eAAO,MAAM,uBAAuB,GAAI,WAAW,SAAS,KAAG,MACN,CAAC;AAE1D,eAAO,MAAM,kBAAkB,GAAI,OAAO,uBAAuB,KAAG,iBAmBnE,CAAC"}

package/dist/derive/index.d.ts

@@ -0,0 +1,12 @@
+export { abilityModifier, proficiencyBonus, proficiencyBonusForCharacterLevel, ABILITY_SCORE_MIN, ABILITY_SCORE_MAX, PROFICIENCY_BONUS_LEVEL_MIN, PROFICIENCY_BONUS_LEVEL_MAX, } from './ability.js';
+export { computeAC, type ACResult, type ACBreakdownEntry, type ComputeACInput, } from './ac.js';
+export { computeAttackBonus, type AttackResult, type AttackBreakdownEntry, type ComputeAttackInput, } from './attack.js';
+export { computeSavingThrow, type SaveResult, type SaveBreakdownEntry, type ComputeSaveInput, } from './save.js';
+export { computeSpellSaveDC, computeSpellAttackBonus, type SpellDCResult, type SpellDCBreakdownEntry, type ComputeSpellDCInput, } from './spell-dc.js';
+export { computeSpellSlots, spellSlotsForLevel, type SpellSlotsResult, } from './spell-slots.js';
+export { buildEffectStack, type BuildEffectStackInput } from './effect-stack.js';
+export { computeDerivedCharacter, type DerivedCharacter, type ComputeDerivedCharacterInput, } from './character-view.js';
+export { computeAbilityCheck, computePassiveScore, type AbilityCheckResult, type AbilityCheckBreakdownEntry, type ComputeAbilityCheckInput, } from './ability-check.js';
+export { computeActionEconomyBudget, type ActionEconomyBudget, type ComputeActionEconomyInput, } from './action-economy.js';
+export { terrainAt, movementCostFor, movementCostAt, chebyshevDistanceFeet, isInRangeFeet, hasLineOfSight, hasLineOfEffect, } from './terrain.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/derive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,iCAAiC,EACjC,iBAAiB,EACjB,iBAAiB,EACjB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,SAAS,EACT,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,cAAc,GACpB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,kBAAkB,EAClB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,GACtB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EACL,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,GAClC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,GAC9B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,GAC/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,SAAS,EACT,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,aAAa,EACb,cAAc,EACd,eAAe,GAChB,MAAM,cAAc,CAAC"}

package/dist/derive/save.d.ts

@@ -0,0 +1,23 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { ResolvedContent } from '../content/pack.js';
+import type { AbilityScore } from '../schemas/primitives.js';
+export interface SaveBreakdownEntry {
+    readonly source: string;
+    readonly value: number;
+}
+export interface SaveResult {
+    readonly total: number;
+    readonly breakdown: ReadonlyArray<SaveBreakdownEntry>;
+    readonly hasAdvantage: boolean;
+    readonly hasDisadvantage: boolean;
+}
+export interface ComputeSaveInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+    readonly ability: AbilityScore;
+    readonly pendingChoices?: Readonly<Record<string, import('../schemas/runtime/pending-choice.js').PendingChoice>>;
+}
+export declare const computeSavingThrow: (input: ComputeSaveInput) => SaveResult;
+//# sourceMappingURL=save.d.ts.map

package/dist/derive/save.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../../src/derive/save.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAM7D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,sCAAsC,EAAE,aAAa,CAAC,CAAC,CAAC;CAClH;AAUD,eAAO,MAAM,kBAAkB,GAAI,OAAO,gBAAgB,KAAG,UA8B5D,CAAC"}

package/dist/derive/spell-dc.d.ts

@@ -0,0 +1,21 @@
+import type { Character } from '../schemas/runtime/character.js';
+import type { ItemInstance } from '../schemas/runtime/item-instance.js';
+import type { ResolvedContent } from '../content/pack.js';
+export interface SpellDCBreakdownEntry {
+    readonly source: string;
+    readonly value: number;
+}
+export interface SpellDCResult {
+    readonly total: number;
+    readonly breakdown: ReadonlyArray<SpellDCBreakdownEntry>;
+}
+export interface ComputeSpellDCInput {
+    readonly character: Character;
+    readonly itemInstances: Readonly<Record<string, ItemInstance>>;
+    readonly content: ResolvedContent;
+    readonly classId: string;
+    readonly pendingChoices?: Readonly<Record<string, import('../schemas/runtime/pending-choice.js').PendingChoice>>;
+}
+export declare const computeSpellSaveDC: (input: ComputeSpellDCInput) => SpellDCResult;
+export declare const computeSpellAttackBonus: (input: ComputeSpellDCInput) => SpellDCResult;
+//# sourceMappingURL=spell-dc.d.ts.map

package/dist/derive/spell-dc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spell-dc.d.ts","sourceRoot":"","sources":["../../src/derive/spell-dc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAK1D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;CAC1D;AAID,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,sCAAsC,EAAE,aAAa,CAAC,CAAC,CAAC;CAClH;AAUD,eAAO,MAAM,kBAAkB,GAAI,OAAO,mBAAmB,KAAG,aAe/D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,OAAO,mBAAmB,KAAG,aAcpE,CAAC"}

package/dist/derive/spell-slots.d.ts

@@ -0,0 +1,21 @@
+import type { Class } from '../schemas/content/class.js';
+import type { Character } from '../schemas/runtime/character.js';
+import type { SpellLevel } from '../schemas/primitives.js';
+export interface SpellSlotsResult {
+    readonly slotsByLevel: ReadonlyArray<number>;
+    readonly pactSlots?: {
+        readonly level: number;
+        readonly count: number;
+    };
+}
+export declare const computeSpellSlots: (character: Character, classesById: ReadonlyMap<string, Class>) => SpellSlotsResult;
+export declare const spellSlotsForLevel: (result: SpellSlotsResult, spellLevel: SpellLevel) => number;
+export interface AvailableSlots {
+    readonly standardByLevel: ReadonlyArray<number>;
+    readonly pact: {
+        readonly level: number;
+        readonly count: number;
+    } | undefined;
+}
+export declare const computeAvailableSpellSlots: (character: Character, classesById: ReadonlyMap<string, Class>) => AvailableSlots;
+//# sourceMappingURL=spell-slots.d.ts.map

package/dist/derive/spell-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spell-slots.d.ts","sourceRoot":"","sources":["../../src/derive/spell-slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAA2B,MAAM,6BAA6B,CAAC;AAClF,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,iCAAiC,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAiE3D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACzE;AAED,eAAO,MAAM,iBAAiB,GAC5B,WAAW,SAAS,EACpB,aAAa,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,KACtC,gBAuDF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,gBAAgB,EACxB,YAAY,UAAU,KACrB,MAGF,CAAC;AAEF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;CAC/E;AAED,eAAO,MAAM,0BAA0B,GACrC,WAAW,SAAS,EACpB,aAAa,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,KACtC,cAcF,CAAC"}

package/dist/derive/terrain.d.ts

@@ -0,0 +1,10 @@
+import type { Door, LocationMap, TerrainKind } from '../schemas/runtime/location.js';
+import type { Position } from '../schemas/runtime/encounter.js';
+export declare const terrainAt: (map: LocationMap, x: number, y: number) => TerrainKind | undefined;
+export declare const movementCostFor: (terrain: TerrainKind) => number;
+export declare const movementCostAt: (map: LocationMap, x: number, y: number) => number;
+export declare const chebyshevDistanceFeet: (a: Position, b: Position, cellSizeFeet?: number) => number;
+export declare const isInRangeFeet: (from: Position, to: Position, rangeFeet: number, cellSizeFeet?: number) => boolean;
+export declare const hasLineOfSight: (map: LocationMap, doorsAtLocation: ReadonlyArray<Door>, from: Position, to: Position) => boolean;
+export declare const hasLineOfEffect: (map: LocationMap, doorsAtLocation: ReadonlyArray<Door>, from: Position, to: Position) => boolean;
+//# sourceMappingURL=terrain.d.ts.map

package/dist/derive/terrain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.d.ts","sourceRoot":"","sources":["../../src/derive/terrain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,WAAW,EACX,WAAW,EACZ,MAAM,gCAAgC,CAAC;AAMxC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEhE,eAAO,MAAM,SAAS,GAAI,KAAK,WAAW,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,WAAW,GAAG,SAIhF,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,SAAS,WAAW,KAAG,MAUtD,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,KAAK,WAAW,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAIvE,CAAC;AAKF,eAAO,MAAM,qBAAqB,GAChC,GAAG,QAAQ,EACX,GAAG,QAAQ,EACX,eAAc,MAA+B,KAC5C,MAA6C,CAAC;AAEjD,eAAO,MAAM,aAAa,GACxB,MAAM,QAAQ,EACd,IAAI,QAAQ,EACZ,WAAW,MAAM,EACjB,eAAc,MAA+B,KAC5C,OAAqE,CAAC;AAqCzE,eAAO,MAAM,cAAc,GACzB,KAAK,WAAW,EAChB,iBAAiB,aAAa,CAAC,IAAI,CAAC,EACpC,MAAM,QAAQ,EACd,IAAI,QAAQ,KACX,OAYF,CAAC;AAEF,eAAO,MAAM,eAAe,QAlBrB,WAAW,mBACC,aAAa,CAAC,IAAI,CAAC,QAC9B,QAAQ,MACV,QAAQ,KACX,OAc0C,CAAC"}

package/dist/effects/builder.d.ts

@@ -0,0 +1,66 @@
+import type { Effect, ModifierTarget, RollTarget } from '../schemas/effects.js';
+import type { AbilityScore, DamageType } from '../schemas/primitives.js';
+export interface ModifierContribution {
+    readonly source: string;
+    readonly value: number;
+}
+export interface AdvantageState {
+    advantage: boolean;
+    disadvantage: boolean;
+    autoCrit: boolean;
+    autoFail: boolean;
+}
+export interface ACOverride {
+    readonly base: number | 'dex' | 'con' | 'wis';
+    readonly abilityModifiers: ReadonlyArray<AbilityScore>;
+    readonly dexCap: number | undefined;
+    readonly priority: number;
+    readonly source: string;
+}
+export interface ResourceGrant {
+    readonly resourceId: string;
+    readonly max: number;
+    readonly recharge: string;
+    readonly source: string;
+}
+export declare class EffectAccumulator {
+    private readonly modifiers;
+    private readonly advantages;
+    private readonly resistances;
+    private readonly immunities;
+    private readonly vulnerabilities;
+    private readonly conditionImmunities;
+    private readonly acOverrides;
+    private readonly resourceGrants;
+    private readonly proficiencies;
+    private readonly actionEconomyMods;
+    private readonly flatDamageReductions;
+    addModifier(target: ModifierTarget, value: number, source: string): void;
+    setAdvantage(target: RollTarget, mode: 'advantage' | 'disadvantage' | 'auto-crit' | 'auto-fail'): void;
+    addResistance(type: DamageType | 'all'): void;
+    addImmunity(type: DamageType | 'all'): void;
+    addVulnerability(type: DamageType): void;
+    addConditionImmunity(id: string): void;
+    addACOverride(override: ACOverride): void;
+    addResourceGrant(grant: ResourceGrant): void;
+    addProficiency(target: 'skill' | 'tool' | 'weapon' | 'armor' | 'save' | 'language', id: string, level: 'half' | 'proficient' | 'expertise'): void;
+    modifierSum(target: ModifierTarget): number;
+    modifierBreakdown(target: ModifierTarget): ReadonlyArray<ModifierContribution>;
+    advantageFor(target: RollTarget): AdvantageState;
+    hasResistance(type: DamageType): boolean;
+    hasImmunity(type: DamageType): boolean;
+    hasVulnerability(type: DamageType): boolean;
+    hasConditionImmunity(id: string): boolean;
+    effectiveACOverride(): ACOverride | undefined;
+    resources(): ReadonlyArray<ResourceGrant>;
+    proficiencyLevel(target: string, id: string): 'none' | 'half' | 'proficient' | 'expertise';
+    addActionEconomy(op: 'extraAttack' | 'extraAction' | 'extraBonusAction', count: number): void;
+    actionEconomyTotal(op: 'extraAttack' | 'extraAction' | 'extraBonusAction'): number;
+    addFlatDamageReduction(damageType: DamageType, amount: number): void;
+    flatDamageReductionFor(damageType: DamageType): number;
+}
+export interface BuilderContext {
+    readonly source: string;
+}
+export declare const applyEffectToBuilder: (effect: Effect, acc: EffectAccumulator, ctx: BuilderContext) => void;
+//# sourceMappingURL=builder.d.ts.map

package/dist/effects/builder.d.ts.map

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

package/dist/effects/formula.d.ts

@@ -0,0 +1,12 @@
+import type { AbilityScore } from '../schemas/primitives.js';
+import type { Formula } from '../schemas/formula.js';
+export interface FormulaContext {
+    readonly abilityScores: Readonly<Record<AbilityScore, number>>;
+    readonly proficiencyBonus: number;
+    readonly classLevels: ReadonlyMap<string, number>;
+    readonly classColumns?: ReadonlyMap<string, ReadonlyMap<string, number>>;
+    readonly totalLevel: number;
+}
+export declare const abilityModifier: (score: number) => number;
+export declare const evaluateFormula: (formula: Formula, ctx: FormulaContext) => number;
+//# sourceMappingURL=formula.d.ts.map

package/dist/effects/formula.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula.d.ts","sourceRoot":"","sources":["../../src/effects/formula.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,MAAsC,CAAC;AAQvF,eAAO,MAAM,eAAe,GAAI,SAAS,OAAO,EAAE,KAAK,cAAc,KAAG,MAqCvE,CAAC"}

package/dist/effects/index.d.ts

@@ -0,0 +1,4 @@
+export { evaluateFormula, abilityModifier as evaluateAbilityModifier, type FormulaContext, } from './formula.js';
+export { evaluatePredicate, type PredicateContext } from './predicate.js';
+export { EffectAccumulator, applyEffectToBuilder, type ModifierContribution, type AdvantageState, type ACOverride, type ResourceGrant, type BuilderContext, } from './builder.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/effects/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,eAAe,IAAI,uBAAuB,EAC1C,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC"}

package/dist/effects/predicate.d.ts

@@ -0,0 +1,12 @@
+import type { Predicate } from '../schemas/predicate.js';
+import type { ConditionId } from '../ids.js';
+import type { WeaponProperty, DamageType } from '../schemas/primitives.js';
+export interface PredicateContext {
+    readonly self?: boolean;
+    readonly weaponProperties?: ReadonlySet<WeaponProperty>;
+    readonly activeConditions?: ReadonlySet<ConditionId>;
+    readonly damageType?: DamageType;
+    readonly facts?: ReadonlyMap<string, unknown>;
+}
+export declare const evaluatePredicate: (predicate: Predicate, ctx: PredicateContext) => boolean;
+//# sourceMappingURL=predicate.d.ts.map

package/dist/effects/predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../../src/effects/predicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IACxD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IACrD,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/C;AAKD,eAAO,MAAM,iBAAiB,GAAI,WAAW,SAAS,EAAE,KAAK,gBAAgB,KAAG,OAuB/E,CAAC"}

package/dist/engine/apply.d.ts

@@ -0,0 +1,5 @@
+import type { CampaignState } from '../schemas/runtime/campaign.js';
+import type { Event } from '../schemas/events/index.js';
+export declare const apply: (state: CampaignState, event: Event) => CampaignState;
+export declare const applyAll: (state: CampaignState, events: ReadonlyArray<Event>) => CampaignState;
+//# sourceMappingURL=apply.d.ts.map

package/dist/engine/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../src/engine/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAgJxD,eAAO,MAAM,KAAK,GAAI,OAAO,aAAa,EAAE,OAAO,KAAK,KAAG,aA2TvD,CAAC;AAEL,eAAO,MAAM,QAAQ,GAAI,OAAO,aAAa,EAAE,QAAQ,aAAa,CAAC,KAAK,CAAC,KAAG,aAClC,CAAC"}

package/dist/engine/commit.d.ts

@@ -0,0 +1,12 @@
+import type { CampaignState } from '../schemas/runtime/campaign.js';
+import type { Event } from '../schemas/events/index.js';
+export interface Campaign {
+    readonly id: string;
+    readonly name: string;
+    readonly state: CampaignState;
+    readonly events: ReadonlyArray<Event>;
+    readonly cursor: number;
+    readonly schemaVersion: number;
+}
+export declare const commit: (campaign: Campaign, events: ReadonlyArray<Event>) => Campaign;
+//# sourceMappingURL=commit.d.ts.map

package/dist/engine/commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/engine/commit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAGxD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,eAAO,MAAM,MAAM,GAAI,UAAU,QAAQ,EAAE,QAAQ,aAAa,CAAC,KAAK,CAAC,KAAG,QAazE,CAAC"}