@archivist-gg/dnd5e 0.3.19 → 0.3.24

package/dist/dnd/amount-text.d.ts

@@ -1,41 +1,14 @@
-/**
- * D2b-A · an AMOUNT that names a modifier prints the number (design §1.2 A, user rulings 2026-09-27).
- *
- * An effect amount, a rider amount or a save DC formula is written in the book's words ("1d8 plus your Wisdom
- * modifier", "your spell save DC") or with a `{token}` ("2d4 + {spell_mod}"). Nothing rendered it as a number: the
- * resource DSL (`resource-formula.ts`) has no dice production and no spellcasting idents. This module reads both at
- * READ time, so existing notes and homebrew need no re-import:
- *   1. `normalizeAmountPhrases` turns the closed phrase table below into tokens;
- *   2. `resolveAmountText` substitutes each `{ident}` with its number and folds: a pure numeric result is evaluated by
- *      the resource DSL (so `floor`, `max`, `ceil` keep working) and a trailing "(minimum of N)" is applied;
- *      `<dice> +/- <numbers>` folds to one roll ("1d8+3"); anything else keeps its words with the numbers in place
- *      ("one roll of your Martial Arts die + 3").
- * The phrase table is the ONE place the book's English is read; an unmapped phrase stays as written.
- */
 import { type FormulaBindings } from "./resource-formula.js";
-/** The DSL bindings plus the owner's spellcasting modifier and save DC (absent when the owner casts no spells). */
 export interface AmountBindings extends FormulaBindings {
     spell_mod?: number;
     spell_dc?: number;
+    class_name?: string;
+    class_names?: readonly string[];
 }
-/** The book phrases of `text` as tokens, "plus" as "+"; text with no mapped phrase comes back unchanged. */
-export declare function normalizeAmountPhrases(text: string): string;
-/**
- * The amount as the sheet prints it: the phrases and tokens of `text` resolved against `b`. A pure number is
- * evaluated ("13"); a roll plus numbers folds ("1d8+3"); other words keep their place with the numbers in ("the roll + 2
- * (minimum of 1)"). An UNBOUND token prints its short label when the note wrote the token, and a book phrase whose
- * token is unbound keeps the note's own words. Text with no phrase and no token comes back unchanged.
- */
+export declare function normalizeAmountPhrases(text: string, ownClass?: string, classNames?: readonly string[]): string;
 export declare function resolveAmountText(text: string, b: AmountBindings): string;
-/** `roll` with each RESOLVED amount added (a spell's damage riders, already resolved against their owners): dice plus
- *  numbers fold to one roll ("2d4+5" and "2" read "2d4+7", "1d10" and "-1" read "1d10-1"); anything that does not fold
- *  keeps its words, joined by " + ". No amount returns `roll` unchanged. */
 export declare function addToRoll(roll: string, amounts: readonly string[]): string;
-/** The leading dice roll of a resolved amount ("1d8+3" of "1d8+3 (minimum of 1)"), which the sheet makes rollable; null
- *  when the amount does not open with a roll. */
 export declare function diceRollOf(resolved: string): string | null;
-/** The leading roll of `text` as the RAW characters it spans (`raw`, which the caller cuts the text by) and as a notation
- *  with no spaces (`notation`, which the roller reads): "2d4 + 2 more" is { raw: "2d4 + 2", notation: "2d4+2" }. */
 export declare function diceRollPrefix(text: string): {
     raw: string;
     notation: string;

package/dist/dnd/amount-text.js

@@ -1,15 +1 @@
-import {
-  addToRoll,
-  diceRollOf,
-  diceRollPrefix,
-  normalizeAmountPhrases,
-  resolveAmountText
-} from "../chunk-WOHX7YTH.js";
-import "../chunk-EVMUJYUD.js";
-export {
-  addToRoll,
-  diceRollOf,
-  diceRollPrefix,
-  normalizeAmountPhrases,
-  resolveAmountText
-};
+import{addToRoll,diceRollOf,diceRollPrefix,normalizeAmountPhrases,resolveAmountText}from"../chunk-VIP3FH2O.js";import"../chunk-EAARMPCW.js";export{addToRoll,diceRollOf,diceRollPrefix,normalizeAmountPhrases,resolveAmountText};

package/dist/dnd/constants.d.ts

@@ -12,27 +12,9 @@ export declare const DAMAGE_TYPES: string[];
 export declare const DAMAGE_NONMAGICAL_VARIANTS: string[];
 export declare const CONDITIONS: string[];
 export declare const STANDARD_SENSES: string[];
-/** R4-G7 T8 RIDER-22 (F-STDACT) · the standard combat actions any character can take, per rules edition, in the book's
- *  alphabetical order. The plugin's Actions tab reads the character's edition, so this is rendering data, never a
- *  renderer constant (it printed ONE union of both editions). 2014 is the PHB chapter 9 list; 2024 is the 2024 action
- *  list, which drops Cast a Spell (now Magic) and Use an Object (now Utilize) and adds Influence and Study. No rules
- *  glossary ships in the SRD 2024 bundle; its prose names ten of the twelve as "the <X> action" and none of the 2014-only
- *  names (measured 2026-09-15 over the plugin repo's `.compendium-bundle/SRD 2024`). */
 export declare const STANDARD_ACTIONS: Record<Edition, readonly string[]>;
 export declare const ALIGNMENT_ETHICAL: string[];
 export declare const ALIGNMENT_MORAL: string[];
 export declare const ALL_SECTIONS: string[];
-/**
- * Full ability NAME (lower-case) → canonical three-letter key. Distinct from `ABILITY_NAMES`
- * above, which is the OTHER direction and yields the display casing ("str" → "STR").
- *
- * Moved here from `pc/pc.feature-effects.ts` in R4-G3a §6.2.3, where it was private: the scope
- * normaliser (`pc/roll-scope.ts`) needs exactly the same vocabulary, and a second copy is the
- * defect class this phase exists to remove. `src/dnd/*` imports nothing from `src/pc/*`, so the
- * move introduces no cycle; the type is spelled `(typeof ABILITY_KEYS)[number]` rather than the
- * `Ability` alias so this module keeps its zero imports.
- */
 export declare const ABILITY_NAME_TO_KEY: Record<string, (typeof ABILITY_KEYS)[number]>;
-/** Accepts a canonical key ("dex") or a full ability name ("Dexterity"), any casing / padding;
- *  returns the canonical key, or null when the value is neither. */
 export declare function normalizeAbility(value: string): (typeof ABILITY_KEYS)[number] | null;

package/dist/dnd/constants.js

@@ -1,42 +1 @@
-import {
-  ABILITY_KEYS,
-  ABILITY_NAMES,
-  ABILITY_NAME_TO_KEY,
-  ALIGNMENT_ETHICAL,
-  ALIGNMENT_MORAL,
-  ALL_CR_VALUES,
-  ALL_SECTIONS,
-  ALL_SIZES,
-  ALL_SKILLS,
-  CONDITIONS,
-  CR_PROFICIENCY,
-  CR_XP,
-  DAMAGE_NONMAGICAL_VARIANTS,
-  DAMAGE_TYPES,
-  SIZE_HIT_DICE,
-  SKILL_ABILITY,
-  STANDARD_ACTIONS,
-  STANDARD_SENSES,
-  normalizeAbility
-} from "../chunk-WELIKLZF.js";
-export {
-  ABILITY_KEYS,
-  ABILITY_NAMES,
-  ABILITY_NAME_TO_KEY,
-  ALIGNMENT_ETHICAL,
-  ALIGNMENT_MORAL,
-  ALL_CR_VALUES,
-  ALL_SECTIONS,
-  ALL_SIZES,
-  ALL_SKILLS,
-  CONDITIONS,
-  CR_PROFICIENCY,
-  CR_XP,
-  DAMAGE_NONMAGICAL_VARIANTS,
-  DAMAGE_TYPES,
-  SIZE_HIT_DICE,
-  SKILL_ABILITY,
-  STANDARD_ACTIONS,
-  STANDARD_SENSES,
-  normalizeAbility
-};
+import{ABILITY_KEYS,ABILITY_NAMES,ABILITY_NAME_TO_KEY,ALIGNMENT_ETHICAL,ALIGNMENT_MORAL,ALL_CR_VALUES,ALL_SECTIONS,ALL_SIZES,ALL_SKILLS,CONDITIONS,CR_PROFICIENCY,CR_XP,DAMAGE_NONMAGICAL_VARIANTS,DAMAGE_TYPES,SIZE_HIT_DICE,SKILL_ABILITY,STANDARD_ACTIONS,STANDARD_SENSES,normalizeAbility}from"../chunk-EVT7MGAC.js";export{ABILITY_KEYS,ABILITY_NAMES,ABILITY_NAME_TO_KEY,ALIGNMENT_ETHICAL,ALIGNMENT_MORAL,ALL_CR_VALUES,ALL_SECTIONS,ALL_SIZES,ALL_SKILLS,CONDITIONS,CR_PROFICIENCY,CR_XP,DAMAGE_NONMAGICAL_VARIANTS,DAMAGE_TYPES,SIZE_HIT_DICE,SKILL_ABILITY,STANDARD_ACTIONS,STANDARD_SENSES,normalizeAbility};

package/dist/dnd/formula-tags.d.ts

@@ -10,7 +10,5 @@ export interface ResolvedTag {
     rollable: boolean;
 }
 export declare function resolveTag(tagType: string, content: string, ctx: FormulaContext): ResolvedTag;
-/** @deprecated use parseTagTerms directly */
 export declare function detectFormula(tagType: string, content: string): FormulaRef | null;
-/** @deprecated use resolveTag */
 export declare function resolveFormulaTag(tagType: string, content: string, abilities: Abilities, profBonus: number): string;

package/dist/dnd/formula-tags.js

@@ -1,119 +1 @@
-import {
-  normalizeTagType,
-  parseTagTerms
-} from "../chunk-QYZV2MQA.js";
-import {
-  abilityModifier,
-  formatModifier
-} from "../chunk-PDJSUH24.js";
-import {
-  ABILITY_KEYS
-} from "../chunk-WELIKLZF.js";
-
-// src/dnd/formula-tags.ts
-function resolveSlugForTag(slug, tagType, registry) {
-  var _a, _b, _c, _d;
-  if (!registry) return { value: 0, missing: true };
-  const found = registry.getBySlug(slug);
-  if (!found) return { value: 0, missing: true };
-  const data = found.data;
-  const b = data.bonuses;
-  switch (tagType) {
-    case "atk":
-      return { value: (_b = (_a = b == null ? void 0 : b.weapon_attack) != null ? _a : b == null ? void 0 : b.spell_attack) != null ? _b : 0, missing: false };
-    case "dmg":
-      return { value: (_c = b == null ? void 0 : b.weapon_damage) != null ? _c : 0, missing: false };
-    case "dc":
-      return { value: (_d = b == null ? void 0 : b.spell_save_dc) != null ? _d : 0, missing: false };
-    case "dice":
-      return { value: 0, missing: false };
-  }
-}
-function resolveTag(tagType, content, ctx) {
-  const canonical = normalizeTagType(tagType);
-  if (!canonical) return { display: content, rollable: false };
-  const parsed = parseTagTerms(content);
-  if ("error" in parsed) {
-    if (typeof console !== "undefined") {
-      console.warn(`tag parse error for ${canonical}:${content} \u2014 ${parsed.error}`);
-    }
-    return { display: content, rollable: false };
-  }
-  if (canonical === "dc" && parsed.pbTerm) {
-    if (typeof console !== "undefined") {
-      console.warn(`dc:${content} \u2014 explicit +PB is redundant; dc tags always include PB`);
-    }
-    return { display: content, rollable: false };
-  }
-  if (canonical === "dmg" && parsed.pbTerm) {
-    if (typeof console !== "undefined") {
-      console.warn(`dmg:${content} \u2014 PB not applicable to damage`);
-    }
-    return { display: content, rollable: false };
-  }
-  if (canonical === "dice" && (parsed.abilityTerm || parsed.pbTerm)) {
-    if (typeof console !== "undefined") {
-      console.warn(`dice:${content} \u2014 abilities/PB not allowed in dice tags`);
-    }
-    return { display: content, rollable: false };
-  }
-  const abilityMod = parsed.abilityTerm ? abilityModifier(ctx.abilities[parsed.abilityTerm]) : 0;
-  const literalSum = parsed.literalTerms.reduce((a, b) => a + b, 0);
-  let slugSum = 0;
-  let anySlugMissing = false;
-  for (const slug of parsed.slugTerms) {
-    const r = resolveSlugForTag(slug, canonical, ctx.compendium);
-    if (r.missing) anySlugMissing = true;
-    else slugSum += r.value;
-  }
-  switch (canonical) {
-    case "atk": {
-      const value = abilityMod + (parsed.pbTerm ? ctx.proficiencyBonus : 0) + literalSum + slugSum;
-      const display = anySlugMissing ? `${formatModifier(value)}?` : formatModifier(value);
-      return { display, value, rollable: true };
-    }
-    case "dc": {
-      if (!parsed.abilityTerm && parsed.literalTerms.length === 1 && parsed.literalTerms[0] >= 0 && parsed.slugTerms.length === 0) {
-        return { display: `DC ${parsed.literalTerms[0]}`, value: parsed.literalTerms[0], rollable: false };
-      }
-      const value = 8 + ctx.proficiencyBonus + abilityMod + literalSum + slugSum;
-      const display = anySlugMissing ? `DC ${value}?` : `DC ${value}`;
-      return { display, value, rollable: false };
-    }
-    case "dmg": {
-      const dicePart = parsed.diceTerms.map((d) => `${d.count}d${d.sides}`).join("+");
-      const modPart = abilityMod + literalSum + slugSum;
-      let display = dicePart;
-      if (modPart !== 0) display += modPart >= 0 ? `+${modPart}` : `${modPart}`;
-      if (display === "") display = String(modPart);
-      if (anySlugMissing) display += "?";
-      return { display, rollable: true };
-    }
-    case "dice": {
-      const dicePart = parsed.diceTerms.map((d) => `${d.count}d${d.sides}`).join("+");
-      return { display: dicePart || content, rollable: true };
-    }
-  }
-}
-var ABILITY_PATTERN = /\b(str|dex|con|int|wis|cha)\b/i;
-function detectFormula(tagType, content) {
-  const canonical = normalizeTagType(tagType);
-  if (!canonical || canonical === "dice") return null;
-  const match = content.match(ABILITY_PATTERN);
-  if (!match) return null;
-  const ability = match[1].toLowerCase();
-  if (!ABILITY_KEYS.includes(ability)) return null;
-  const kind = canonical === "atk" ? "attack" : canonical === "dc" ? "dc" : "damage";
-  return { ability, kind };
-}
-function resolveFormulaTag(tagType, content, abilities, profBonus) {
-  const r = resolveTag(tagType, content, { abilities, proficiencyBonus: profBonus });
-  return r.display;
-}
-export {
-  detectFormula,
-  normalizeTagType,
-  parseTagTerms,
-  resolveFormulaTag,
-  resolveTag
-};
+import{normalizeTagType,parseTagTerms}from"../chunk-2HRRH3WL.js";import{abilityModifier,formatModifier}from"../chunk-7FPQJDFD.js";import{ABILITY_KEYS}from"../chunk-EVT7MGAC.js";function resolveSlugForTag(slug,tagType,registry){var _a,_b,_c,_d;if(!registry)return{value:0,missing:true};const found=registry.getBySlug(slug);if(!found)return{value:0,missing:true};const data=found.data;const b=data.bonuses;switch(tagType){case"atk":return{value:(_b=(_a=b==null?void 0:b.weapon_attack)!=null?_a:b==null?void 0:b.spell_attack)!=null?_b:0,missing:false};case"dmg":return{value:(_c=b==null?void 0:b.weapon_damage)!=null?_c:0,missing:false};case"dc":return{value:(_d=b==null?void 0:b.spell_save_dc)!=null?_d:0,missing:false};case"dice":return{value:0,missing:false}}}function resolveTag(tagType,content,ctx){const canonical=normalizeTagType(tagType);if(!canonical)return{display:content,rollable:false};const parsed=parseTagTerms(content);if("error"in parsed){if(typeof console!=="undefined"){console.warn(`tag parse error for ${canonical}:${content} \u2014 ${parsed.error}`)}return{display:content,rollable:false}}if(canonical==="dc"&&parsed.pbTerm){if(typeof console!=="undefined"){console.warn(`dc:${content} \u2014 explicit +PB is redundant; dc tags always include PB`)}return{display:content,rollable:false}}if(canonical==="dmg"&&parsed.pbTerm){if(typeof console!=="undefined"){console.warn(`dmg:${content} \u2014 PB not applicable to damage`)}return{display:content,rollable:false}}if(canonical==="dice"&&(parsed.abilityTerm||parsed.pbTerm)){if(typeof console!=="undefined"){console.warn(`dice:${content} \u2014 abilities/PB not allowed in dice tags`)}return{display:content,rollable:false}}const abilityMod=parsed.abilityTerm?abilityModifier(ctx.abilities[parsed.abilityTerm]):0;const literalSum=parsed.literalTerms.reduce((a,b)=>a+b,0);let slugSum=0;let anySlugMissing=false;for(const slug of parsed.slugTerms){const r=resolveSlugForTag(slug,canonical,ctx.compendium);if(r.missing)anySlugMissing=true;else slugSum+=r.value}switch(canonical){case"atk":{const value=abilityMod+(parsed.pbTerm?ctx.proficiencyBonus:0)+literalSum+slugSum;const display=anySlugMissing?`${formatModifier(value)}?`:formatModifier(value);return{display,value,rollable:true}}case"dc":{if(!parsed.abilityTerm&&parsed.literalTerms.length===1&&parsed.literalTerms[0]>=0&&parsed.slugTerms.length===0){return{display:`DC ${parsed.literalTerms[0]}`,value:parsed.literalTerms[0],rollable:false}}const value=8+ctx.proficiencyBonus+abilityMod+literalSum+slugSum;const display=anySlugMissing?`DC ${value}?`:`DC ${value}`;return{display,value,rollable:false}}case"dmg":{const dicePart=parsed.diceTerms.map(d=>`${d.count}d${d.sides}`).join("+");const modPart=abilityMod+literalSum+slugSum;let display=dicePart;if(modPart!==0)display+=modPart>=0?`+${modPart}`:`${modPart}`;if(display==="")display=String(modPart);if(anySlugMissing)display+="?";return{display,rollable:true}}case"dice":{const dicePart=parsed.diceTerms.map(d=>`${d.count}d${d.sides}`).join("+");return{display:dicePart||content,rollable:true}}}}var ABILITY_PATTERN=/\b(str|dex|con|int|wis|cha)\b/i;function detectFormula(tagType,content){const canonical=normalizeTagType(tagType);if(!canonical||canonical==="dice")return null;const match=content.match(ABILITY_PATTERN);if(!match)return null;const ability=match[1].toLowerCase();if(!ABILITY_KEYS.includes(ability))return null;const kind=canonical==="atk"?"attack":canonical==="dc"?"dc":"damage";return{ability,kind}}function resolveFormulaTag(tagType,content,abilities,profBonus){const r=resolveTag(tagType,content,{abilities,proficiencyBonus:profBonus});return r.display}export{detectFormula,normalizeTagType,parseTagTerms,resolveFormulaTag,resolveTag};

package/dist/dnd/math.d.ts

@@ -2,7 +2,6 @@ import { ABILITY_KEYS } from "./constants.js";
 export declare function abilityModifier(score: number): number;
 export declare function formatModifier(mod: number): string;
 export declare function proficiencyBonusFromCR(cr: string): number;
-/** Proficiency bonus by total character level (1-20) */
 export declare function proficiencyFromLevel(level: number): number;
 export declare function crToXP(cr: string): number;
 export declare function hitDiceSizeFromCreatureSize(size: string): number;
@@ -13,38 +12,13 @@ export declare function parseHitDiceFormula(formula: string): {
 } | null;
 export declare function savingThrow(abilityScore: number, isProficient: boolean, profBonus: number): number;
 export declare function skillBonus(abilityScore: number, proficiency: "none" | "proficient" | "expertise", profBonus: number): number;
-/**
- * Passive score for any skill: 10 + skill bonus. Generalizes `passivePerception`.
- * Use this for Passive Investigation (INT) and Passive Insight (WIS).
- */
 export declare function passive(abilityScore: number, proficiency: "none" | "proficient" | "expertise", profBonus: number): number;
 export declare function passivePerception(wisScore: number, perceptionProf: "none" | "proficient" | "expertise", profBonus: number): number;
 export declare function attackBonus(abilityScore: number, profBonus: number): number;
 export declare function saveDC(abilityScore: number, profBonus: number): number;
 export declare function abilityNameToKey(name: string): (typeof ABILITY_KEYS)[number] | null;
-/** Is `type` one of the canonical damage types, whatever its casing? A rider whose declared type is
- *  anything else, a sentinel (`weapon`) or prose ("same as the weapon's type"), INHERITS the weapon row's
- *  own damage type; `pc.recalc.ts` resolves that where the rider is merged onto the row, never in a
- *  renderer, and never from a list of prose spellings. The ONE exception is the schema's own sentinel
- *  {@link CHOSEN_DAMAGE_TYPE}, which means the player's choice, not the row's type (R4-G7 T8 RIDER-13). */
 export declare function isCanonicalDamageType(type: string): boolean;
-/** The schema's own damage-type sentinel for a rider whose type the PLAYER picks when the damage is dealt
- *  (`feature-effect-schema.ts`, the `damage-bonus` arm: "player-selected damage type at action time"). It is a
- *  declared schema value, not a prose spelling, so it never inherits the weapon row's type: the rider keeps it,
- *  and the sheet prints the amount with no type and {@link CHOSEN_DAMAGE_TYPE_NOTE} in the row's caption
- *  (R4-G7 T8 RIDER-13). */
 export declare const CHOSEN_DAMAGE_TYPE = "chosen";
-/** The caption words a renderer prints for a {@link CHOSEN_DAMAGE_TYPE} rider in place of a damage type. One
- *  constant, so no renderer spells the phrase itself. */
 export declare const CHOSEN_DAMAGE_TYPE_NOTE = "damage type of your choice";
-/** Is `type` the {@link CHOSEN_DAMAGE_TYPE} sentinel, whatever its casing or surrounding space? */
 export declare function isChosenDamageType(type: string | undefined): boolean;
-/** Can a damage rider be printed INSIDE the damage text, as a dice chip? Only when it reads as a dice
- *  expression or a (signed) number, optionally followed by ONE canonical damage type: `1d6`, `+2`,
- *  `1d6 fire`. Anything else is prose ("your Wisdom modifier necrotic", "half your fighter level
- *  slashing") and belongs in the row's caption instead (R4-G7 T6a E-4 (c)).
- *
- *  `text` is the rider's PRINTED form, its amount plus its resolved damage type, because a shipped
- *  rider may carry the type inside the amount itself (`{amount: "1d6 fire"}` with no `damage_type`, the
- *  migrated manual override of `pc.equipment.ts`). */
 export declare function isRenderableDamageText(text: string): boolean;

package/dist/dnd/math.js

@@ -1,45 +1 @@
-import {
-  CHOSEN_DAMAGE_TYPE,
-  CHOSEN_DAMAGE_TYPE_NOTE,
-  abilityModifier,
-  abilityNameToKey,
-  attackBonus,
-  crToXP,
-  formatModifier,
-  hitDiceSizeFromCreatureSize,
-  hpFromHitDice,
-  isCanonicalDamageType,
-  isChosenDamageType,
-  isRenderableDamageText,
-  parseHitDiceFormula,
-  passive,
-  passivePerception,
-  proficiencyBonusFromCR,
-  proficiencyFromLevel,
-  saveDC,
-  savingThrow,
-  skillBonus
-} from "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  CHOSEN_DAMAGE_TYPE,
-  CHOSEN_DAMAGE_TYPE_NOTE,
-  abilityModifier,
-  abilityNameToKey,
-  attackBonus,
-  crToXP,
-  formatModifier,
-  hitDiceSizeFromCreatureSize,
-  hpFromHitDice,
-  isCanonicalDamageType,
-  isChosenDamageType,
-  isRenderableDamageText,
-  parseHitDiceFormula,
-  passive,
-  passivePerception,
-  proficiencyBonusFromCR,
-  proficiencyFromLevel,
-  saveDC,
-  savingThrow,
-  skillBonus
-};
+import{CHOSEN_DAMAGE_TYPE,CHOSEN_DAMAGE_TYPE_NOTE,abilityModifier,abilityNameToKey,attackBonus,crToXP,formatModifier,hitDiceSizeFromCreatureSize,hpFromHitDice,isCanonicalDamageType,isChosenDamageType,isRenderableDamageText,parseHitDiceFormula,passive,passivePerception,proficiencyBonusFromCR,proficiencyFromLevel,saveDC,savingThrow,skillBonus}from"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";export{CHOSEN_DAMAGE_TYPE,CHOSEN_DAMAGE_TYPE_NOTE,abilityModifier,abilityNameToKey,attackBonus,crToXP,formatModifier,hitDiceSizeFromCreatureSize,hpFromHitDice,isCanonicalDamageType,isChosenDamageType,isRenderableDamageText,parseHitDiceFormula,passive,passivePerception,proficiencyBonusFromCR,proficiencyFromLevel,saveDC,savingThrow,skillBonus};

package/dist/dnd/prose-tags.d.ts

@@ -1,16 +1,2 @@
-/**
- * Convert 5etools-style {@...} tags to the plugin's backtick inline-tag format.
- * Called before backtick regex processing so AI-generated 5etools markup renders correctly.
- */
-export declare function convert5eToolsTags(text: string): string;
-/**
- * Wrap bare dice notation (e.g. `1d6`, `2d6+3`, `37d8 + 259`) in synthetic
- * `dice:…` backtick tags so the existing stat-block pill renderer picks them up.
- *
- * Skips dice notation that is already inside a backtick tag (the first
- * alternation branch consumes backtick-delimited spans and returns them
- * untouched) or embedded inside an identifier (word-character boundary).
- *
- * Pure. No state. No side effects.
- */
+export declare function convertBraceTags(text: string): string;
 export declare function decorateProseDice(text: string): string;

package/dist/dnd/prose-tags.js

@@ -1,18 +1 @@
-// src/dnd/prose-tags.ts
-function convert5eToolsTags(text) {
-  const rewritten = text.replace(/\{@atk\s+mw,rw\}/gi, "Melee or Ranged Weapon Attack:").replace(/\{@atk\s+mws\}/gi, "Melee or Ranged Weapon Attack:").replace(/\{@atk\s+msw\}/gi, "Melee or Ranged Spell Attack:").replace(/\{@atk\s+mw\}/gi, "Melee Weapon Attack:").replace(/\{@atk\s+rw\}/gi, "Ranged Weapon Attack:").replace(/\{@atk\s+ms\}/gi, "Melee Spell Attack:").replace(/\{@atk\s+rs\}/gi, "Ranged Spell Attack:").replace(/\{@hit\s+(\d+)\}/gi, "`atk:+$1`").replace(/\{@h\}\s*/gi, "Hit: ").replace(/\{@damage\s+([^}]+)\}/gi, "`damage:$1`").replace(/\{@dice\s+([^}]+)\}/gi, "`roll:$1`").replace(/\{@d20\s+([^}]+)\}/gi, "`roll:d20$1`").replace(/\{@dc\s+(\d+)\}/gi, "`dc:$1`").replace(/\{@recharge\s+(\d)\}/gi, "(Recharge $1-6)").replace(/\{@recharge\}/gi, "(Recharge)").replace(/\{@chance\s+(\d+)\}/gi, "$1% chance").replace(/\{@b(?:old)?\s+([^}]+)\}/gi, "**$1**").replace(/\{@i(?:talic)?\s+([^}]+)\}/gi, "_$1_").replace(/\{@s(?:trike)?\s+([^}]+)\}/gi, "~~$1~~").replace(/\{@note\s+([^}]+)\}/gi, "($1)").replace(/\{@spell\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@item\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@creature\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@condition\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@skill\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@sense\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@action\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@status\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@ability\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@class\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@feat\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@background\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@race\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@disease\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@hazard\s+([^|}]+)[^}]*\}/gi, "**$1**").replace(/\{@plane\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@language\s+([^|}]+)[^}]*\}/gi, "$1").replace(/\{@book\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@adventure\s+([^|}]+)[^}]*\}/gi, "_$1_").replace(/\{@\w+\s+([^}]+)\}/g, "$1");
-  return decorateProseDice(rewritten);
-}
-function decorateProseDice(text) {
-  return text.replace(
-    /`[^`]*`|(?<!\w)(\d+d\d+(?:\s*[+-]\s*\d+)?)(?!\w)/g,
-    (match, dice) => {
-      if (dice) return `\`dice:${dice.replace(/\s+/g, "")}\``;
-      return match;
-    }
-  );
-}
-export {
-  convert5eToolsTags,
-  decorateProseDice
-};
+function convertBraceTags(text){const rewritten=text.replace(/\{@atk\s+mw,rw\}/gi,"Melee or Ranged Weapon Attack:").replace(/\{@atk\s+mws\}/gi,"Melee or Ranged Weapon Attack:").replace(/\{@atk\s+msw\}/gi,"Melee or Ranged Spell Attack:").replace(/\{@atk\s+mw\}/gi,"Melee Weapon Attack:").replace(/\{@atk\s+rw\}/gi,"Ranged Weapon Attack:").replace(/\{@atk\s+ms\}/gi,"Melee Spell Attack:").replace(/\{@atk\s+rs\}/gi,"Ranged Spell Attack:").replace(/\{@hit\s+(\d+)\}/gi,"`atk:+$1`").replace(/\{@h\}\s*/gi,"Hit: ").replace(/\{@damage\s+([^}]+)\}/gi,"`damage:$1`").replace(/\{@dice\s+([^}]+)\}/gi,"`roll:$1`").replace(/\{@d20\s+([^}]+)\}/gi,"`roll:d20$1`").replace(/\{@dc\s+(\d+)\}/gi,"`dc:$1`").replace(/\{@recharge\s+(\d)\}/gi,"(Recharge $1-6)").replace(/\{@recharge\}/gi,"(Recharge)").replace(/\{@chance\s+(\d+)\}/gi,"$1% chance").replace(/\{@b(?:old)?\s+([^}]+)\}/gi,"**$1**").replace(/\{@i(?:talic)?\s+([^}]+)\}/gi,"_$1_").replace(/\{@s(?:trike)?\s+([^}]+)\}/gi,"~~$1~~").replace(/\{@note\s+([^}]+)\}/gi,"($1)").replace(/\{@spell\s+([^|}]+)[^}]*\}/gi,"_$1_").replace(/\{@item\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@creature\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@condition\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@skill\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@sense\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@action\s+([^|}]+)[^}]*\}/gi,"**$1**").replace(/\{@status\s+([^|}]+)[^}]*\}/gi,"**$1**").replace(/\{@ability\s+([^|}]+)[^}]*\}/gi,"**$1**").replace(/\{@class\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@feat\s+([^|}]+)[^}]*\}/gi,"**$1**").replace(/\{@background\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@race\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@disease\s+([^|}]+)[^}]*\}/gi,"**$1**").replace(/\{@hazard\s+([^|}]+)[^}]*\}/gi,"**$1**").replace(/\{@plane\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@language\s+([^|}]+)[^}]*\}/gi,"$1").replace(/\{@book\s+([^|}]+)[^}]*\}/gi,"_$1_").replace(/\{@adventure\s+([^|}]+)[^}]*\}/gi,"_$1_").replace(/\{@\w+\s+([^}]+)\}/g,"$1");return decorateProseDice(rewritten)}function decorateProseDice(text){return text.replace(/`[^`]*`|(?<!\w)(\d+d\d+(?:\s*[+-]\s*\d+)?)(?!\w)/g,(match,dice)=>{if(dice)return`\`dice:${dice.replace(/\s+/g,"")}\``;return match})}export{convertBraceTags,decorateProseDice};

package/dist/dnd/resource-die.d.ts

@@ -1,6 +1,2 @@
 import type { ResourceDie } from "../types/resource.js";
-/** The die face in effect at `level`: the value of the highest `scaling` key
- *  ≤ level, else `die.base`. Keys are level thresholds as strings (JSON/YAML
- *  object keys are strings). Extracted from the resource badge so feature-attack
- *  damage can scale identically. Non-numeric scaling keys coerce to NaN and are skipped. */
 export declare function resolveScalingDie(die: ResourceDie, level: number): string;

package/dist/dnd/resource-die.js

@@ -1,17 +1 @@
-// src/dnd/resource-die.ts
-function resolveScalingDie(die, level) {
-  var _a;
-  let face = die.base;
-  let best = 0;
-  for (const [lvl, f] of Object.entries((_a = die.scaling) != null ? _a : {})) {
-    const n = Number(lvl);
-    if (n <= level && n > best) {
-      best = n;
-      face = f;
-    }
-  }
-  return face;
-}
-export {
-  resolveScalingDie
-};
+function resolveScalingDie(die,level){var _a;let face=die.base;let best=0;for(const[lvl,f]of Object.entries((_a=die.scaling)!=null?_a:{})){const n=Number(lvl);if(n<=level&&n>best){best=n;face=f}}return face}export{resolveScalingDie};

package/dist/dnd/resource-formula.d.ts

@@ -1,24 +1,3 @@
-/**
- * Tiny DSL for Resource.max_formula and Resource.recovery[].amount (SP4d; R4-G4 §6 added max / min). Grammar:
- *   expr   := term (('+' | '-') term)*
- *   term   := factor (('*' | '/') factor)*
- *   factor := number | string-arg-only | ident | '{' ident '}' | fn1 '(' expr ')' | fnN '(' expr (',' expr)+ ')'
- *           | "column" '(' string ')' | '(' expr ')'
- *   fn1    := 'ceil' | 'floor'          (exactly one argument)
- *   fnN    := 'max' | 'min'             (two or more comma-separated arguments)
- *   ident  := level | class_level | prof | <abil>_mod
- * The single-quoted string literal (e.g. 'Seals') is valid ONLY as the argument to column(...).
- * '*' and '/' bind tighter than '+'/'-'. '/' is real division; wrap in ceil()/floor() for integer
- * results (e.g. "ceil({class_level}/2)"). "max(1, {cha_mod})" is how the data says "a minimum of once".
- * `AT_WILL_MAX` (999) is the at-will sentinel: it evaluates as the literal 999; R4-G4 T3 (§5) taught
- * the plugin's charge boxes to render "at will" for it instead of 999 boxes (the `opts.atWill` branch
- * at the head of `renderChargeBoxes`, fed by the `atWill: fu.max === AT_WILL_MAX` opt its callers
- * pass). Measured 2026-09-05 on the plugin tree that carries T7b with
- * `grep -rn "atWill:" packages/obsidian/src`: FOUR lines, the two T3 feature trackers
- * `renderCardResource` and `renderFirstResourceTracker`, T5's pool-tab dice head `renderPoolHead`,
- * and T7b's `renderPickTracker`, which draws a pool pick's own `uses` on the pool row, the granted
- * row and the boon row.
- */
 export interface FormulaBindings {
     level: number;
     class_level: number;
@@ -29,9 +8,6 @@ export interface FormulaBindings {
     int_mod: number;
     wis_mod: number;
     cha_mod: number;
-    /** Numeric values of the owning (sub)class table row at the current class
-     *  level, keyed by column name (e.g. "Seals"). Empty when no table/row.
-     *  Read by the `column('Name')` accessor; missing name → 0. */
     columns: Record<string, number>;
 }
 export declare const AT_WILL_MAX = 999;
@@ -44,24 +20,5 @@ export interface ScalableResource {
         max: string;
     }[];
 }
-/** The max-formula string in effect at `totalLevel`: the highest `scales_at` step whose level
- *  ≤ totalLevel (the FIRST declaration wins on a duplicate level; a `level: 0` step is skipped), else
- *  the base `max_formula`. Parse-free, so a die-string step comes back as the die string. Its one
- *  production caller, the plugin's `seedFeatureUses` (`pc.resource-seed.ts`), moved to
- *  `resolveMaxCountAt` in R4-G4 T3, so it is now TEST-ONLY: zero callers in this repo's `src/` and zero
- *  in the plugin's `packages/obsidian/src/`, pinned by this repo's `tests/resource-formula.test.ts`
- *  (its Bardic-Die-2024 and duplicate-level-tie cases) and by the plugin's cross-repo file of the same
- *  name (its `describe("resolveMaxAt")` block). */
 export declare function resolveMaxAt(totalLevel: number, resource: ScalableResource): string;
-/** The max COUNT in effect at `level`: the highest `scales_at` step at or below `level` whose `max`
- *  PARSES under the DSL, else the base `max_formula` if it parses, else null. Ties break exactly as
- *  `resolveMaxAt` breaks them (the FIRST declaration at a duplicate level wins, a `level: 0` step is
- *  skipped), so a duplicate-level pair of PARSING steps cannot make the count and the die label pick
- *  different steps; where one member of the pair is a die string they DO pick different steps
- *  (`[{level:3,max:"1d8"},{level:3,max:"3"}]` at 3 reads 3 here and "1d8" there), which is the same
- *  parse-vs-string divergence described next. A step that does not parse is a die size (Bardic Die
- *  2024: "1d8" at 5), not a count, and is skipped HERE while `resolveMaxAt` still returns it; a base
- *  that does not parse (Sneak Attack "1d6") is a damage die, correctly no tracker. `resolveMaxAt`
- *  keeps the parse-free string lookup; R4-G4 T3 handed its one production caller, the plugin seed, to
- *  this function (see its docblock), so a null here is what the seed warns on and leaves un-seeded. */
 export declare function resolveMaxCountAt(level: number, resource: ScalableResource, bindings: FormulaBindings): number | null;

package/dist/dnd/resource-formula.js

@@ -1,14 +1 @@
-import {
-  AT_WILL_MAX,
-  evaluateMaxFormula,
-  isValidMaxFormula,
-  resolveMaxAt,
-  resolveMaxCountAt
-} from "../chunk-EVMUJYUD.js";
-export {
-  AT_WILL_MAX,
-  evaluateMaxFormula,
-  isValidMaxFormula,
-  resolveMaxAt,
-  resolveMaxCountAt
-};
+import{AT_WILL_MAX,evaluateMaxFormula,isValidMaxFormula,resolveMaxAt,resolveMaxCountAt}from"../chunk-EAARMPCW.js";export{AT_WILL_MAX,evaluateMaxFormula,isValidMaxFormula,resolveMaxAt,resolveMaxCountAt};

package/dist/dnd/resource-words.d.ts

@@ -1,4 +1,2 @@
-/** The resource's name worded for `amount`: the last word singular for one, plural otherwise, when it is a count noun. */
 export declare function resourceCountWord(name: string, amount: number): string;
-/** "<amount> <name worded for it>" ("1 Superiority Die"). */
 export declare function countedResource(amount: number, name: string): string;

package/dist/dnd/resource-words.js

@@ -1,30 +1 @@
-// src/dnd/resource-words.ts
-var COUNT_NOUNS = [
-  ["Die", "Dice"],
-  ["Point", "Points"],
-  ["Use", "Uses"],
-  ["Seal", "Seals"],
-  ["Rage", "Rages"],
-  ["Cast", "Casts"],
-  ["Casting", "Castings"],
-  ["Scroll", "Scrolls"],
-  ["Charge", "Charges"],
-  ["Token", "Tokens"],
-  ["Slot", "Slots"]
-];
-var BY_WORD = new Map(
-  COUNT_NOUNS.flatMap((pair) => [[pair[0], pair], [pair[1], pair]])
-);
-function resourceCountWord(name, amount) {
-  const at = name.lastIndexOf(" ") + 1;
-  const pair = BY_WORD.get(name.slice(at));
-  if (!pair) return name;
-  return name.slice(0, at) + (amount === 1 ? pair[0] : pair[1]);
-}
-function countedResource(amount, name) {
-  return `${amount} ${resourceCountWord(name, amount)}`;
-}
-export {
-  countedResource,
-  resourceCountWord
-};
+var COUNT_NOUNS=[["Die","Dice"],["Point","Points"],["Use","Uses"],["Seal","Seals"],["Rage","Rages"],["Cast","Casts"],["Casting","Castings"],["Scroll","Scrolls"],["Charge","Charges"],["Token","Tokens"],["Slot","Slots"]];var BY_WORD=new Map(COUNT_NOUNS.flatMap(pair=>[[pair[0],pair],[pair[1],pair]]));function resourceCountWord(name,amount){const at=name.lastIndexOf(" ")+1;const pair=BY_WORD.get(name.slice(at));if(!pair)return name;return name.slice(0,at)+(amount===1?pair[0]:pair[1])}function countedResource(amount,name){return`${amount} ${resourceCountWord(name,amount)}`}export{countedResource,resourceCountWord};

package/dist/dnd/srd-tag-converter.d.ts

@@ -15,29 +15,8 @@ export interface ConversionContext {
     actionCategory: ActionCategory;
     spellAbility?: "int" | "wis" | "cha";
 }
-/**
- * Shared static-fallback context for callers that enrich creature-agnostic
- * content (spells, magic items) where no real ability mods / prof bonus exist.
- *
- * All ability mods = 0 and prof = 0, so no computed target matches any
- * reasonable value and every pattern falls to the static fallback path
- * (e.g. `dc:15`, `atk:+7`).
- */
 export declare const STATIC_FALLBACK_CONTEXT: ConversionContext;
-/**
- * Convert SRD plain-English descriptions (e.g. "Melee Weapon Attack: +14 to hit,
- * Hit: 21 (3d8 + 8) slashing damage") into backtick formula tags
- * (e.g. "Melee Weapon Attack: `atk:STR+PB`, Hit: `dmg:3d8+STR` slashing damage")
- * by reverse-inferring which ability mod + prof produced the static value.
- *
- * Pure. Deterministic. Never throws: wraps everything in try/catch and returns
- * the original desc on any failure.
- */
 export declare function convertDescToTags(desc: string, ctx: ConversionContext): string;
-/**
- * Scan a monster's trait list for a spellcasting ability declaration like
- * "Its spellcasting ability is Wisdom". Returns undefined for non-casters.
- */
 export declare function detectSpellcastingAbility(traits: {
     name: string;
     entries: string[];

package/dist/dnd/srd-tag-converter.js

@@ -1,12 +1 @@
-import {
-  STATIC_FALLBACK_CONTEXT,
-  convertDescToTags,
-  detectSpellcastingAbility
-} from "../chunk-DEEHHLAP.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  STATIC_FALLBACK_CONTEXT,
-  convertDescToTags,
-  detectSpellcastingAbility
-};
+import{STATIC_FALLBACK_CONTEXT,convertDescToTags,detectSpellcastingAbility}from"../chunk-MGGKZGLG.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";export{STATIC_FALLBACK_CONTEXT,convertDescToTags,detectSpellcastingAbility};

package/dist/dnd/tag-grammar.js

@@ -1,12 +1 @@
-import {
-  normalizeTagType,
-  parseTagTerms
-} from "../chunk-QYZV2MQA.js";
-import {
-  ABILITY_KEYS
-} from "../chunk-WELIKLZF.js";
-export {
-  ABILITY_KEYS as ABILITIES,
-  normalizeTagType,
-  parseTagTerms
-};
+import{normalizeTagType,parseTagTerms}from"../chunk-2HRRH3WL.js";import{ABILITY_KEYS}from"../chunk-EVT7MGAC.js";export{ABILITY_KEYS as ABILITIES,normalizeTagType,parseTagTerms};

package/dist/dnd/warn-once.js

@@ -1,8 +1 @@
-import {
-  __resetWarnOnceForTests,
-  warnOnce
-} from "../chunk-LVQLWRCU.js";
-export {
-  __resetWarnOnceForTests,
-  warnOnce
-};
+import{__resetWarnOnceForTests,warnOnce}from"../chunk-DZITM5AG.js";export{__resetWarnOnceForTests,warnOnce};

package/dist/encounter/encounter.ai-schema.js

@@ -1,8 +1 @@
-import {
-  encounterInputSchema,
-  encounterOutputSchema
-} from "../chunk-LSLSG67V.js";
-export {
-  encounterInputSchema,
-  encounterOutputSchema
-};
+import{encounterInputSchema,encounterOutputSchema}from"../chunk-M6RPOLKS.js";export{encounterInputSchema,encounterOutputSchema};