@archivist-gg/dnd5e 0.1.0

package/dist/dnd/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const CR_PROFICIENCY: Record<string, number>;
+export declare const CR_XP: Record<string, number>;
+export declare const ALL_CR_VALUES: string[];
+export declare const SIZE_HIT_DICE: Record<string, number>;
+export declare const ALL_SIZES: string[];
+export declare const SKILL_ABILITY: Record<string, string>;
+export declare const ALL_SKILLS: string[];
+export declare const ABILITY_KEYS: readonly ["str", "dex", "con", "int", "wis", "cha"];
+export declare const ABILITY_NAMES: Record<string, string>;
+export declare const DAMAGE_TYPES: string[];
+export declare const DAMAGE_NONMAGICAL_VARIANTS: string[];
+export declare const CONDITIONS: string[];
+export declare const STANDARD_SENSES: string[];
+export declare const ALIGNMENT_ETHICAL: string[];
+export declare const ALIGNMENT_MORAL: string[];
+export declare const ALL_SECTIONS: string[];

package/dist/dnd/constants.js

@@ -0,0 +1,36 @@
+import {
+  ABILITY_KEYS,
+  ABILITY_NAMES,
+  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_SENSES
+} from "../chunk-WP2CX2JO.js";
+export {
+  ABILITY_KEYS,
+  ABILITY_NAMES,
+  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_SENSES
+};

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

@@ -0,0 +1,16 @@
+import type { FormulaRef } from "../inline-tag-parser.js";
+import type { Abilities } from "../types/abilities.js";
+import type { FormulaContext } from "../types/formula-context.js";
+import { CanonicalTagType, normalizeTagType, parseTagTerms } from "./tag-grammar.js";
+export type { CanonicalTagType, FormulaContext };
+export { normalizeTagType, parseTagTerms };
+export interface ResolvedTag {
+    display: string;
+    value?: number;
+    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

@@ -0,0 +1,119 @@
+import {
+  normalizeTagType,
+  parseTagTerms
+} from "../chunk-QYZV2MQA.js";
+import {
+  abilityModifier,
+  formatModifier
+} from "../chunk-NAEPSZAM.js";
+import {
+  ABILITY_KEYS
+} from "../chunk-WP2CX2JO.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
+};

package/dist/dnd/math.d.ts

@@ -0,0 +1,24 @@
+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;
+export declare function hpFromHitDice(hitDiceCount: number, hitDiceSize: number, conMod: number): number;
+export declare function parseHitDiceFormula(formula: string): {
+    count: number;
+    size: number;
+} | 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;

package/dist/dnd/math.js

@@ -0,0 +1,35 @@
+import {
+  abilityModifier,
+  abilityNameToKey,
+  attackBonus,
+  crToXP,
+  formatModifier,
+  hitDiceSizeFromCreatureSize,
+  hpFromHitDice,
+  parseHitDiceFormula,
+  passive,
+  passivePerception,
+  proficiencyBonusFromCR,
+  proficiencyFromLevel,
+  saveDC,
+  savingThrow,
+  skillBonus
+} from "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  abilityModifier,
+  abilityNameToKey,
+  attackBonus,
+  crToXP,
+  formatModifier,
+  hitDiceSizeFromCreatureSize,
+  hpFromHitDice,
+  parseHitDiceFormula,
+  passive,
+  passivePerception,
+  proficiencyBonusFromCR,
+  proficiencyFromLevel,
+  saveDC,
+  savingThrow,
+  skillBonus
+};

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

@@ -0,0 +1,16 @@
+/**
+ * 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 decorateProseDice(text: string): string;

package/dist/dnd/prose-tags.js

@@ -0,0 +1,18 @@
+// 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\}/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
+};

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,17 @@
+// 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
+};

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

@@ -0,0 +1,41 @@
+/**
+ * Tiny DSL for Resource.max_formula and Resource.recovery[].amount (SP4d). Grammar:
+ *   expr   := term (('+' | '-') term)*
+ *   term   := factor (('*' | '/') factor)*
+ *   factor := number | string-arg-only | ident | '{' ident '}' | fn '(' expr ')'
+ *           | "column" '(' string ')' | '(' expr ')'
+ *   fn     := 'ceil' | 'floor'
+ *   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)").
+ * `999` is the at-will sentinel; it evaluates as the literal 999.
+ */
+export interface FormulaBindings {
+    level: number;
+    class_level: number;
+    prof: number;
+    str_mod: number;
+    dex_mod: number;
+    con_mod: number;
+    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 function isValidMaxFormula(formula: string): boolean;
+export declare function evaluateMaxFormula(formula: string, bindings: FormulaBindings): number;
+export interface ScalableResource {
+    max_formula: string;
+    scales_at?: {
+        level: number;
+        max: string;
+    }[];
+}
+/** The max-formula string in effect at `totalLevel`: the highest `scales_at`
+ *  step whose level ≤ totalLevel, else the base `max_formula`. */
+export declare function resolveMaxAt(totalLevel: number, resource: ScalableResource): string;

package/dist/dnd/resource-formula.js

@@ -0,0 +1,159 @@
+// src/dnd/resource-formula.ts
+var IDENTS = /* @__PURE__ */ new Set([
+  "level",
+  "class_level",
+  "prof",
+  "str_mod",
+  "dex_mod",
+  "con_mod",
+  "int_mod",
+  "wis_mod",
+  "cha_mod"
+]);
+var FUNCS = /* @__PURE__ */ new Set(["ceil", "floor"]);
+function tokenize(input) {
+  input = input.trim();
+  const tokens = [];
+  const re = /\s*('[^']*'|\{[a-z_]+\}|[a-z_]+|\d+|[+\-*/()])/y;
+  let i = 0;
+  while (i < input.length) {
+    re.lastIndex = i;
+    const m = re.exec(input);
+    if (!m || m.index !== i) return null;
+    const raw = m[1];
+    i = re.lastIndex;
+    if (/^\d+$/.test(raw)) tokens.push({ kind: "num", value: parseInt(raw, 10) });
+    else if (raw.startsWith("'")) tokens.push({ kind: "str", value: raw.slice(1, -1) });
+    else if (raw === "(") tokens.push({ kind: "lparen" });
+    else if (raw === ")") tokens.push({ kind: "rparen" });
+    else if (raw === "+" || raw === "-" || raw === "*" || raw === "/") tokens.push({ kind: "op", op: raw });
+    else {
+      const braced = raw.startsWith("{");
+      const name = braced ? raw.slice(1, -1) : raw;
+      if (!braced && FUNCS.has(name)) tokens.push({ kind: "fn", name });
+      else if (!braced && name === "column") tokens.push({ kind: "col" });
+      else if (IDENTS.has(name)) tokens.push({ kind: "id", name });
+      else return null;
+    }
+  }
+  return tokens.length > 0 ? tokens : null;
+}
+function evalTokens(tokens, b) {
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const factor = () => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const t = peek();
+    if (!t) return null;
+    if (t.kind === "num") {
+      pos++;
+      return t.value;
+    }
+    if (t.kind === "id") {
+      const val = b[t.name];
+      if (val === void 0) return null;
+      pos++;
+      return val;
+    }
+    if (t.kind === "fn") {
+      pos++;
+      if (((_a = peek()) == null ? void 0 : _a.kind) !== "lparen") return null;
+      pos++;
+      const inner = expr();
+      if (inner === null) return null;
+      if (((_b = peek()) == null ? void 0 : _b.kind) !== "rparen") return null;
+      pos++;
+      return t.name === "ceil" ? Math.ceil(inner) : Math.floor(inner);
+    }
+    if (t.kind === "col") {
+      pos++;
+      if (((_c = peek()) == null ? void 0 : _c.kind) !== "lparen") return null;
+      pos++;
+      const s = peek();
+      if (!s || s.kind !== "str") return null;
+      pos++;
+      if (((_d = peek()) == null ? void 0 : _d.kind) !== "rparen") return null;
+      pos++;
+      return (_f = (_e = b.columns) == null ? void 0 : _e[s.value]) != null ? _f : 0;
+    }
+    if (t.kind === "lparen") {
+      pos++;
+      const inner = expr();
+      if (inner === null) return null;
+      if (((_g = peek()) == null ? void 0 : _g.kind) !== "rparen") return null;
+      pos++;
+      return inner;
+    }
+    return null;
+  };
+  const term = () => {
+    var _a;
+    let v = factor();
+    if (v === null) return null;
+    while (((_a = peek()) == null ? void 0 : _a.kind) === "op" && (peek().op === "*" || peek().op === "/")) {
+      const op = peek().op;
+      pos++;
+      const r = factor();
+      if (r === null) return null;
+      v = op === "*" ? v * r : v / r;
+    }
+    return v;
+  };
+  const expr = () => {
+    var _a;
+    let v = term();
+    if (v === null) return null;
+    while (((_a = peek()) == null ? void 0 : _a.kind) === "op" && (peek().op === "+" || peek().op === "-")) {
+      const op = peek().op;
+      pos++;
+      const r = term();
+      if (r === null) return null;
+      v = op === "+" ? v + r : v - r;
+    }
+    return v;
+  };
+  const result = expr();
+  if (result === null || pos !== tokens.length) return null;
+  return result;
+}
+var ZERO = {
+  level: 1,
+  class_level: 1,
+  prof: 2,
+  str_mod: 0,
+  dex_mod: 0,
+  con_mod: 0,
+  int_mod: 0,
+  wis_mod: 0,
+  cha_mod: 0,
+  columns: {}
+};
+function isValidMaxFormula(formula) {
+  const toks = tokenize(formula);
+  if (!toks) return false;
+  return evalTokens(toks, ZERO) !== null;
+}
+function evaluateMaxFormula(formula, bindings) {
+  const toks = tokenize(formula);
+  if (!toks) throw new Error(`invalid max_formula: ${JSON.stringify(formula)}`);
+  const v = evalTokens(toks, bindings);
+  if (v === null) throw new Error(`invalid max_formula: ${JSON.stringify(formula)}`);
+  return v;
+}
+function resolveMaxAt(totalLevel, resource) {
+  var _a;
+  let chosen = resource.max_formula;
+  let best = 0;
+  for (const step of (_a = resource.scales_at) != null ? _a : []) {
+    if (step.level <= totalLevel && step.level > best) {
+      best = step.level;
+      chosen = step.max;
+    }
+  }
+  return chosen;
+}
+export {
+  evaluateMaxFormula,
+  isValidMaxFormula,
+  resolveMaxAt
+};

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

@@ -0,0 +1,44 @@
+export type AbilityKey = "str" | "dex" | "con" | "int" | "wis" | "cha";
+export interface ConverterAbilities {
+    str: number;
+    dex: number;
+    con: number;
+    int: number;
+    wis: number;
+    cha: number;
+}
+export type ActionCategory = "action" | "trait" | "reaction" | "legendary" | "bonus" | "special";
+export interface ConversionContext {
+    abilities: ConverterAbilities;
+    profBonus: number;
+    actionName: string;
+    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[];
+}[] | undefined): "int" | "wis" | "cha" | undefined;

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

@@ -0,0 +1,12 @@
+import {
+  STATIC_FALLBACK_CONTEXT,
+  convertDescToTags,
+  detectSpellcastingAbility
+} from "../chunk-RAWJTA45.js";
+import "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  STATIC_FALLBACK_CONTEXT,
+  convertDescToTags,
+  detectSpellcastingAbility
+};

package/dist/dnd/tag-grammar.d.ts

@@ -0,0 +1,19 @@
+import type { Ability } from "../types/choice.js";
+import { ABILITY_KEYS } from "./constants.js";
+export type { Ability };
+export { ABILITY_KEYS as ABILITIES };
+export type CanonicalTagType = "atk" | "dmg" | "dc" | "dice";
+export interface ParsedTerms {
+    abilityTerm?: Ability;
+    pbTerm: boolean;
+    literalTerms: number[];
+    diceTerms: {
+        count: number;
+        sides: number;
+    }[];
+    slugTerms: string[];
+}
+export declare function normalizeTagType(input: string): CanonicalTagType | null;
+export declare function parseTagTerms(content: string): ParsedTerms | {
+    error: string;
+};

package/dist/dnd/tag-grammar.js

@@ -0,0 +1,12 @@
+import {
+  normalizeTagType,
+  parseTagTerms
+} from "../chunk-QYZV2MQA.js";
+import {
+  ABILITY_KEYS
+} from "../chunk-WP2CX2JO.js";
+export {
+  ABILITY_KEYS as ABILITIES,
+  normalizeTagType,
+  parseTagTerms
+};

package/dist/encounter/encounter.ai-schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const encounterInputSchema: z.ZodObject<{
+    party_size: z.ZodNumber;
+    party_level: z.ZodNumber;
+    difficulty: z.ZodEnum<{
+        medium: "medium";
+        easy: "easy";
+        hard: "hard";
+        deadly: "deadly";
+    }>;
+    environment: z.ZodOptional<z.ZodString>;
+    theme: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const encounterOutputSchema: z.ZodObject<{
+    monsters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        cr: z.ZodString;
+        count: z.ZodNumber;
+        role: z.ZodString;
+    }, z.core.$strip>>;
+    tactics: z.ZodString;
+    terrain: z.ZodString;
+    notes: z.ZodString;
+    xp_budget: z.ZodObject<{
+        target: z.ZodNumber;
+        actual: z.ZodNumber;
+        difficulty_rating: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;

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

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

package/dist/encounter/encounter.entity-type.d.ts

@@ -0,0 +1,2 @@
+import type { EntityType } from "@archivist-gg/core";
+export declare const encounterEntityType: EntityType;

package/dist/encounter/encounter.generatable.d.ts

@@ -0,0 +1,2 @@
+import type { Generatable } from "@archivist-gg/core";
+export declare const encounterGeneratable: Generatable;