@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/dnd/constants.d.ts

@@ -1,3 +1,4 @@
+import type { Edition } from "../types/edition.js";
 export declare const CR_PROFICIENCY: Record<string, number>;
 export declare const CR_XP: Record<string, number>;
 export declare const ALL_CR_VALUES: string[];
@@ -11,6 +12,27 @@ 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,6 +1,7 @@
 import {
   ABILITY_KEYS,
   ABILITY_NAMES,
+  ABILITY_NAME_TO_KEY,
   ALIGNMENT_ETHICAL,
   ALIGNMENT_MORAL,
   ALL_CR_VALUES,
@@ -14,11 +15,14 @@ import {
   DAMAGE_TYPES,
   SIZE_HIT_DICE,
   SKILL_ABILITY,
-  STANDARD_SENSES
-} from "../chunk-WP2CX2JO.js";
+  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,
@@ -32,5 +36,7 @@ export {
   DAMAGE_TYPES,
   SIZE_HIT_DICE,
   SKILL_ABILITY,
-  STANDARD_SENSES
+  STANDARD_ACTIONS,
+  STANDARD_SENSES,
+  normalizeAbility
 };

package/dist/dnd/formula-tags.js

@@ -5,10 +5,10 @@ import {
 import {
   abilityModifier,
   formatModifier
-} from "../chunk-NAEPSZAM.js";
+} from "../chunk-PDJSUH24.js";
 import {
   ABILITY_KEYS
-} from "../chunk-WP2CX2JO.js";
+} from "../chunk-WELIKLZF.js";
 
 // src/dnd/formula-tags.ts
 function resolveSlugForTag(slug, tagType, registry) {

package/dist/dnd/math.d.ts

@@ -22,3 +22,29 @@ export declare function passivePerception(wisScore: number, perceptionProf: "non
 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,4 +1,6 @@
 import {
+  CHOSEN_DAMAGE_TYPE,
+  CHOSEN_DAMAGE_TYPE_NOTE,
   abilityModifier,
   abilityNameToKey,
   attackBonus,
@@ -6,6 +8,9 @@ import {
   formatModifier,
   hitDiceSizeFromCreatureSize,
   hpFromHitDice,
+  isCanonicalDamageType,
+  isChosenDamageType,
+  isRenderableDamageText,
   parseHitDiceFormula,
   passive,
   passivePerception,
@@ -14,9 +19,11 @@ import {
   saveDC,
   savingThrow,
   skillBonus
-} from "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+} from "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
+  CHOSEN_DAMAGE_TYPE,
+  CHOSEN_DAMAGE_TYPE_NOTE,
   abilityModifier,
   abilityNameToKey,
   attackBonus,
@@ -24,6 +31,9 @@ export {
   formatModifier,
   hitDiceSizeFromCreatureSize,
   hpFromHitDice,
+  isCanonicalDamageType,
+  isChosenDamageType,
+  isRenderableDamageText,
   parseHitDiceFormula,
   passive,
   passivePerception,

package/dist/dnd/prose-tags.js

@@ -1,6 +1,6 @@
 // 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");
+  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) {

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

@@ -1,16 +1,23 @@
 /**
- * Tiny DSL for Resource.max_formula and Resource.recovery[].amount (SP4d). Grammar:
+ * 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 '}' | fn '(' expr ')'
+ *   factor := number | string-arg-only | ident | '{' ident '}' | fn1 '(' expr ')' | fnN '(' expr (',' expr)+ ')'
  *           | "column" '(' string ')' | '(' expr ')'
- *   fn     := 'ceil' | 'floor'
+ *   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)").
- * `999` is the at-will sentinel; it evaluates as the literal 999.
+ * 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;
@@ -27,6 +34,7 @@ export interface FormulaBindings {
      *  Read by the `column('Name')` accessor; missing name → 0. */
     columns: Record<string, number>;
 }
+export declare const AT_WILL_MAX = 999;
 export declare function isValidMaxFormula(formula: string): boolean;
 export declare function evaluateMaxFormula(formula: string, bindings: FormulaBindings): number;
 export interface ScalableResource {
@@ -36,6 +44,24 @@ export interface ScalableResource {
         max: string;
     }[];
 }
-/** The max-formula string in effect at `totalLevel`: the highest `scales_at`
- *  step whose level ≤ totalLevel, else the base `max_formula`. */
+/** 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,159 +1,14 @@
-// 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;
-}
+import {
+  AT_WILL_MAX,
+  evaluateMaxFormula,
+  isValidMaxFormula,
+  resolveMaxAt,
+  resolveMaxCountAt
+} from "../chunk-EVMUJYUD.js";
 export {
+  AT_WILL_MAX,
   evaluateMaxFormula,
   isValidMaxFormula,
-  resolveMaxAt
+  resolveMaxAt,
+  resolveMaxCountAt
 };

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

@@ -2,9 +2,9 @@ import {
   STATIC_FALLBACK_CONTEXT,
   convertDescToTags,
   detectSpellcastingAbility
-} from "../chunk-RAWJTA45.js";
-import "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+} from "../chunk-DEEHHLAP.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
   STATIC_FALLBACK_CONTEXT,
   convertDescToTags,

package/dist/dnd/tag-grammar.js

@@ -4,7 +4,7 @@ import {
 } from "../chunk-QYZV2MQA.js";
 import {
   ABILITY_KEYS
-} from "../chunk-WP2CX2JO.js";
+} from "../chunk-WELIKLZF.js";
 export {
   ABILITY_KEYS as ABILITIES,
   normalizeTagType,

package/dist/dnd/warn-once.d.ts

@@ -0,0 +1,2 @@
+export declare function warnOnce(key: string, msg: string): void;
+export declare function __resetWarnOnceForTests(): void;

package/dist/dnd/warn-once.js

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

package/dist/entities/base-item-resolver.js

@@ -2,8 +2,8 @@ import {
   resolveBaseItem,
   resolveBaseItemOfType,
   vaultPathToSlug
-} from "../chunk-4LZJXJJS.js";
-import "../chunk-LV4SNWZQ.js";
+} from "../chunk-WXWPK3LI.js";
+import "../chunk-6X4KUDMU.js";
 export {
   resolveBaseItem,
   resolveBaseItemOfType,

package/dist/entities/slug.d.ts

@@ -10,3 +10,16 @@ export declare function slugify(name: string): string;
  *  `parts.slice(2).join("_")`. Tolerates a nullish slug (degrades to "") so a
  *  malformed entity can't hard-crash the builder; the resolver backfills real slugs. */
 export declare function bareEntitySlug(slug: string | null | undefined): string;
+/** "[[SRD 2024/Classes/Fighter]]" to "fighter" (tail segment, slugified).
+ *
+ *  The tail goes through the SAME `slugify` that mints registry slugs, so an apostrophe is DELETED rather than
+ *  hyphenated ("Mage's Bane" to "mages-bane", where the old hand-rolled regex minted "mage-s-bane" and missed
+ *  every time). Only ever call this on a human NAME tail, never on a full `<prefix>_<name>` slug, which slugify
+ *  would destroy: `pc.decision-engine.ts`'s `resolveEntityRef` is the function that strips a `[[wikilink]]`
+ *  WITHOUT slugifying, and it is the one to use for a STORED slug.
+ *
+ *  MOVED here from `pc.decision-engine.ts` in R4-G5 T1, beside `bareEntitySlug`, so `pc.pools.ts` can use it
+ *  without importing the decision engine: the engine imports `pc.pools` for `strandedPicks`, and the old
+ *  direction would be a cycle. The engine keeps a re-export, so its three plugin importers and its own test
+ *  are untouched. */
+export declare function wikilinkTailSlug(link: string): string;

package/dist/entities/slug.js

@@ -1,8 +1,10 @@
 import {
   bareEntitySlug,
-  slugify
-} from "../chunk-LV4SNWZQ.js";
+  slugify,
+  wikilinkTailSlug
+} from "../chunk-6X4KUDMU.js";
 export {
   bareEntitySlug,
-  slugify
+  slugify,
+  wikilinkTailSlug
 };

package/dist/entities/wikilink-display.d.ts

@@ -0,0 +1,3 @@
+/** The human name of a wikilink target: `[[Player's Handbook (2024)/OptionalFeatures/Pact of the Blade]]` →
+ *  "Pact of the Blade"; `[[path|Alias]]` → "Alias". The converter emits vault PATHS with no alias. */
+export declare function wikilinkDisplayName(link: string): string;

package/dist/entities/wikilink-display.js

@@ -0,0 +1,10 @@
+// src/entities/wikilink-display.ts
+function wikilinkDisplayName(link) {
+  const inner = link.trim().replace(/^\[\[/, "").replace(/\]\]$/, "");
+  const afterAlias = inner.includes("|") ? inner.slice(inner.lastIndexOf("|") + 1) : inner;
+  const afterSlash = afterAlias.includes("/") ? afterAlias.slice(afterAlias.lastIndexOf("/") + 1) : afterAlias;
+  return afterSlash.trim();
+}
+export {
+  wikilinkDisplayName
+};

package/dist/feat/feat.category-codes.d.ts

@@ -0,0 +1,32 @@
+import type { FeatCategory } from "../types/choice.js";
+/** 5etools feat `category` codes, as DATA beside the schema (never a renderer switch). The converter emits the raw
+ *  code on `exclusive-feat-category` and `feat-category` prerequisites (today only "D", on 14 documents; the G7
+ *  handoff asks it for a name). `FS:P` and `FS:R` are the Paladin- and Ranger-scoped fighting-style categories.
+ *  Measured in data/feats.json: G 80, EB 29, O 25, D 13, FS 10, DG 9, FS:P 1, FS:R 1. Unknown codes fall back to
+ *  the code itself. */
+export declare const FEAT_CATEGORY_CODE_LABELS: Readonly<Record<string, string>>;
+export declare function featCategoryLabel(code: string): string;
+/** 5etools `feat_progression.category` codes to the ENGINE's `FeatCategory` vocabulary (R4-G5 §3.2.5,
+ *  invariant 3): the DATA table the class-side progression reader maps through, beside the label table above.
+ *  MEASURED over the converted corpus 2026-09-07: 18 `feat_progression` rows across 15 documents, codes
+ *  {EB 13, FS 4, FS:P 1, FS:R 1, O 1}. The FS four are Fighter 2024 (level 1), Paladin 2024 and Ranger 2024
+ *  (level 2, each carrying `["FS","FS:P"]` / `["FS","FS:R"]`) and the Champion 2024 SUBCLASS (level 7); the 13
+ *  EB rows are the 12 PHB 2024 classes plus the Eberron Artificer, all at level 19. The single `O` row sits on
+ *  an OPTIONAL FEATURE (Lessons of the First Ones) with a `"*"` progression key, outside the class walk, so `O`
+ *  and `G` have zero live class-side carriers and are declared for completeness. `D` (Dragonmark) and `DG`
+ *  (Dark Gift) map to NOTHING on purpose: they are not player-choosable feat categories in this vocabulary, and
+ *  a row carrying only those emits no decision and warns once at the reader. G7 handoff (spec §11): the
+ *  converter re-emits these codes in engine vocabulary and this table retires. */
+export declare const FEAT_PROGRESSION_CATEGORY: Readonly<Record<string, FeatCategory>>;
+/** The ONE `FeatCategory` to optional-feature `feature_type` pairing (R4-G5 §3.2.5). The shape-B suppression
+ *  reads it to decide that a class carrying a fighting-style `feat_progression` row must NOT also be offered the
+ *  recognizer's `fighting_style` optional-feature synthetic at that level. `Partial<Record<...>>` because three
+ *  of the four categories pair with nothing, which is also what makes the lookup return `string | undefined`
+ *  without an own-property guard. */
+export declare const FEATURE_TYPE_FOR_CATEGORY: Readonly<Partial<Record<FeatCategory, string>>>;
+/** Reduce a `feat_progression` entry's `category` ARRAY to ONE engine category: the FIRST code that maps wins, so
+ *  the shipped `["FS","FS:P"]` (Paladin) and `["FS","FS:R"]` (Ranger) each yield exactly ONE decision instead of
+ *  two. OWN-property guarded (invariant 3): the codes come from converter data, so `constructor` would otherwise
+ *  index a FUNCTION through the prototype chain. Returns undefined when nothing maps (an all-`D` row); the
+ *  CALLER warns, because this stays pure. */
+export declare function featProgressionCategory(codes: readonly string[] | undefined): FeatCategory | undefined;

package/dist/feat/feat.category-codes.js

@@ -0,0 +1,14 @@
+import {
+  FEATURE_TYPE_FOR_CATEGORY,
+  FEAT_CATEGORY_CODE_LABELS,
+  FEAT_PROGRESSION_CATEGORY,
+  featCategoryLabel,
+  featProgressionCategory
+} from "../chunk-YBLDE5CG.js";
+export {
+  FEATURE_TYPE_FOR_CATEGORY,
+  FEAT_CATEGORY_CODE_LABELS,
+  FEAT_PROGRESSION_CATEGORY,
+  featCategoryLabel,
+  featProgressionCategory
+};

package/dist/feat/feat.codec.js

@@ -1,10 +1,12 @@
 import {
   featCodec
-} from "../chunk-73HOFQQ5.js";
-import "../chunk-XTIQWSFM.js";
-import "../chunk-Q5K6LWBZ.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+} from "../chunk-ESS46GR4.js";
+import "../chunk-D5U7GMPX.js";
+import "../chunk-RIXI5D3R.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
   featCodec
 };

package/dist/feat/feat.parser.js

@@ -1,9 +1,11 @@
 import {
   parseFeat
-} from "../chunk-XTIQWSFM.js";
-import "../chunk-Q5K6LWBZ.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+} from "../chunk-D5U7GMPX.js";
+import "../chunk-RIXI5D3R.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
   parseFeat
 };