@archivist-gg/dnd5e 0.3.13 → 0.3.19

package/dist/chunk-RD2MID3M.js

@@ -0,0 +1,292 @@
+import {
+  parsePickKey,
+  poolAnchorLevel
+} from "./chunk-NXUY5XQN.js";
+import {
+  featProgressionCategory
+} from "./chunk-YBLDE5CG.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  bucketOf
+} from "./chunk-4J6DS3EJ.js";
+import {
+  bareEntitySlug,
+  wikilinkTailSlug
+} from "./chunk-ZCTUYGNV.js";
+
+// src/pc/pc.member-choices.ts
+var OPTIONAL_FEATURE_TYPE_CODE = {
+  "MV:B": "maneuver",
+  MV: "maneuver",
+  EI: "invocation",
+  MM: "metamagic",
+  "FS:F": "fighting_style"
+};
+function spellFilter(choose, edition) {
+  const where = { edition };
+  for (const part of choose.split("|")) {
+    const [rawKey, rawValue = ""] = part.split("=");
+    const key = rawKey.trim().toLowerCase();
+    const value = rawValue.trim();
+    if (key === "level") {
+      const n = Number(value.split(";")[0]);
+      if (!Number.isInteger(n)) return null;
+      where.level = n;
+    } else if (key === "class") where.list = value.toLowerCase();
+    else if (key === "components & miscellaneous" && /ritual/i.test(value)) where.ritual = true;
+  }
+  return where;
+}
+function isTargetChoice(ch) {
+  return ch.kind === "select-entity" && ch.target === true;
+}
+function progressionCount(p) {
+  var _a;
+  if (Array.isArray(p)) return 0;
+  return (_a = p["*"]) != null ? _a : Math.max(0, ...Object.values(p));
+}
+function spellChoices(entity, used) {
+  var _a, _b;
+  const out = [];
+  for (const block of (_a = entity.additional_spells) != null ? _a : []) {
+    for (const bucket of ["known", "prepared"]) {
+      const byLevel = block[bucket];
+      if (!byLevel || typeof byLevel !== "object") continue;
+      for (const rows of Object.values(byLevel)) {
+        for (const row of Array.isArray(rows) ? rows : []) {
+          const r = row;
+          if (typeof r.choose !== "string") continue;
+          const where = spellFilter(r.choose, entity.edition);
+          if (!where) continue;
+          const base = where.ritual ? "rituals" : where.level === 0 ? "cantrips" : `spells-${(_b = where.level) != null ? _b : "any"}`;
+          const label = where.ritual ? "Rituals" : where.level === 0 ? "Cantrips" : `Level ${where.level} spells`;
+          let id = base;
+          for (let i = 2; used.has(id); i++) id = `${base}-${i}`;
+          used.add(id);
+          out.push({ kind: "select-entity", id, label, count: typeof r.count === "number" ? r.count : 1, entity_type: "spell", where });
+        }
+      }
+    }
+  }
+  return out;
+}
+function memberChoices(entity) {
+  var _a, _b, _c, _d, _e, _f;
+  if (!entity) return [];
+  if ((_a = entity.choices) == null ? void 0 : _a.length) return entity.choices;
+  const out = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const fp of (_b = entity.feat_progression) != null ? _b : []) {
+    const category = featProgressionCategory(fp.category);
+    const count = progressionCount(fp.progression);
+    if (!category || count < 1) continue;
+    const id = used.has("feat") ? `feat-${used.size}` : "feat";
+    used.add(id);
+    out.push({ kind: "select-entity", id, label: fp.name, count, entity_type: "feat", where: { category, edition: entity.edition } });
+  }
+  for (const op of (_c = entity.optionalfeature_progression) != null ? _c : []) {
+    const codes = (_e = (_d = op.feature_type) != null ? _d : op.featureType) != null ? _e : [];
+    const featureType = codes.map((c) => OPTIONAL_FEATURE_TYPE_CODE[c]).find((t) => !!t);
+    const count = progressionCount(op.progression);
+    if (!featureType || count < 1) {
+      if (!featureType) warnOnce(`member-of-code:${entity.slug}`, `Archivist: "${entity.slug}" asks for optional features of type ${codes.join(", ")}, which this engine does not map; no pick is offered`);
+      continue;
+    }
+    const id = op.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "option";
+    used.add(id);
+    out.push({ kind: "select-entity", id, label: op.name, count, entity_type: "optional-feature", where: { feature_type: featureType, edition: entity.edition } });
+  }
+  out.push(...spellChoices(entity, used));
+  for (const pre of (_f = entity.prerequisites) != null ? _f : []) {
+    if (pre.kind !== "spell-choose") continue;
+    const where = spellFilter(pre.choose, entity.edition);
+    if (!where || used.has("cantrip")) continue;
+    used.add("cantrip");
+    out.push({ kind: "select-entity", id: "cantrip", label: where.level === 0 ? "Cantrip" : "Spell", count: 1, entity_type: "spell", where, target: true });
+  }
+  return out;
+}
+function memberSpellTargets(member, read) {
+  var _a;
+  const refs = [];
+  const open = [];
+  for (const ch of memberChoices(member)) {
+    if (ch.kind !== "select-entity" || !isTargetChoice(ch) || ch.entity_type !== "spell") continue;
+    const v = read(ch.id);
+    const picked = (Array.isArray(v) ? v : [v]).filter((x) => typeof x === "string" && x.trim() !== "");
+    if (picked.length) refs.push(...picked);
+    else if (ch.where) open.push(ch.where);
+  }
+  for (const pre of (_a = member.prerequisites) != null ? _a : []) if (pre.kind === "spell-known") refs.push(pre.spell);
+  return refs.length || open.length ? { refs, open } : null;
+}
+function spellMatchesFilter(d, where) {
+  var _a, _b;
+  if (where.list && !((_a = d.classes) != null ? _a : []).includes(where.list)) return false;
+  if (where.level !== void 0 && ((_b = d.level) != null ? _b : 0) !== where.level) return false;
+  if (where.edition && d.edition !== where.edition) return false;
+  if (where.ritual && d.ritual !== true) return false;
+  return true;
+}
+function spellsReached(targets, spells) {
+  if (!targets) return [];
+  const hit = /* @__PURE__ */ new Set();
+  for (const ref of targets.refs) {
+    const full = stripRef(ref);
+    const exact = spells.filter((s) => s.slug === full);
+    const bare = wikilinkTailSlug(ref);
+    for (const s of exact.length ? exact : spells.filter((s2) => bareEntitySlug(s2.slug) === bare)) hit.add(s.slug);
+  }
+  for (const where of targets.open) {
+    const legal = new Set(spells.filter((s) => {
+      var _a;
+      return spellMatchesFilter(s.entity, where) && !!((_a = s.entity.damage_roll) == null ? void 0 : _a.trim());
+    }).map((s) => s.slug));
+    if (legal.size === 1) hit.add([...legal][0]);
+  }
+  return [...new Set(spells.map((s) => s.slug))].filter((slug) => hit.has(slug));
+}
+function siteOf(classIndex, level, poolId, pickKey, member, memberSlug, block) {
+  const choices = memberChoices(member);
+  if (!choices.length) return null;
+  const prefix = `${poolId}:${pickKey}:`;
+  return { classIndex, level, poolId, pickKey, member, memberSlug, choices, prefix, block, read: (id) => block[`${prefix}${id}`] };
+}
+function poolMemberSites(classes, registry) {
+  const out = [];
+  let byBare = null;
+  let all = null;
+  const lookup = (s, ownerPrefix) => {
+    all != null ? all : all = bucketOf(registry, "optional-feature");
+    const bare = bareEntitySlug(s);
+    const owned = all.find((e) => bareEntitySlug(e.slug) === bare && e.slug.split("_")[0] === ownerPrefix);
+    if (owned) return owned;
+    const direct = registry.getByTypeAndSlug("optional-feature", s);
+    if (direct) return direct;
+    byBare != null ? byBare : byBare = new Map(all.map((e) => [bareEntitySlug(e.slug), e]));
+    return byBare.get(bare);
+  };
+  classes.forEach((rc, classIndex) => {
+    var _a, _b, _c, _d, _e;
+    if (!rc.entity) return;
+    const seen = /* @__PURE__ */ new Set();
+    for (const pool of [...(_a = rc.entity.selection_pools) != null ? _a : [], ...(_c = (_b = rc.subclass) == null ? void 0 : _b.selection_pools) != null ? _c : []]) {
+      if (seen.has(pool.id)) continue;
+      seen.add(pool.id);
+      const { anchorLevel } = poolAnchorLevel(rc.entity, pool);
+      const block = (_e = (_d = rc.choices) == null ? void 0 : _d[anchorLevel]) != null ? _e : {};
+      const raw = block[pool.id];
+      const picks = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+      for (const s of picks) {
+        if (typeof s !== "string") continue;
+        const { slugPart, param } = parsePickKey(s);
+        const reg = lookup(slugPart, rc.entity.slug.split("_")[0]);
+        if (!reg) continue;
+        const member = reg.data;
+        const key = member.repeatable === true || param !== null ? s : reg.slug;
+        const site = siteOf(classIndex, anchorLevel, pool.id, key, member, reg.slug, block);
+        if (site) out.push(site);
+      }
+    }
+  });
+  return out;
+}
+function poolMemberSitesOf(resolved) {
+  var _a, _b, _c, _d, _e, _f;
+  const out = [];
+  for (const pool of (_a = resolved.pools) != null ? _a : []) {
+    const block = (_e = (_d = (_c = (_b = resolved.classes) == null ? void 0 : _b[pool.classIndex]) == null ? void 0 : _c.choices) == null ? void 0 : _d[pool.anchorLevel]) != null ? _e : {};
+    for (const e of (_f = pool.selected) != null ? _f : []) {
+      const site = siteOf(pool.classIndex, pool.anchorLevel, pool.id, e.key, e.entity, e.slug, block);
+      if (site) out.push(site);
+    }
+  }
+  return out;
+}
+var stripRef = (ref) => ref.replace(/^\[\[/, "").replace(/\]\]$/, "");
+function featPickSites(classEntries, memberSites, classSlugOf) {
+  const out = [];
+  (classEntries != null ? classEntries : []).forEach((c, classIndex) => {
+    var _a;
+    for (const [lvl, choiceBlock] of Object.entries((_a = c.choices) != null ? _a : {})) {
+      const block = choiceBlock;
+      const feat = block == null ? void 0 : block.feat;
+      if (!block || typeof feat !== "string") continue;
+      const slug = stripRef(feat);
+      if (!slug) continue;
+      const level = /^\d+$/.test(lvl) ? Number(lvl) : null;
+      const cls = classSlugOf(classIndex);
+      out.push({
+        slug,
+        classIndex,
+        level,
+        via: cls && level !== null ? { kind: "class", slug: cls, level } : null,
+        read: (id) => block[`feat:${id}`]
+      });
+    }
+  });
+  for (const site of memberSites) {
+    for (const ch of site.choices) {
+      if (ch.kind !== "select-entity" || ch.entity_type !== "feat" || ch.target === true) continue;
+      const v = site.read(ch.id);
+      for (const ref of Array.isArray(v) ? v : typeof v === "string" ? [v] : []) {
+        if (typeof ref !== "string") continue;
+        const slug = stripRef(ref);
+        if (!slug) continue;
+        const cls = classSlugOf(site.classIndex);
+        out.push({
+          slug,
+          classIndex: site.classIndex,
+          level: site.level,
+          via: cls ? { kind: "pool", slug: site.memberSlug, name: site.member.name, classSlug: cls, level: site.level } : null,
+          read: (id) => site.block[`${site.prefix}feat:${id}`]
+        });
+      }
+    }
+  }
+  return out;
+}
+function raceFeatSites(race, originChoices) {
+  var _a;
+  if (!race) return [];
+  const oc = originChoices != null ? originChoices : {};
+  const out = [];
+  for (const list of [race.choices, ...((_a = race.traits) != null ? _a : []).map((t) => t == null ? void 0 : t.choices)]) {
+    for (const ch of Array.isArray(list) ? list : []) {
+      if ((ch == null ? void 0 : ch.kind) !== "select-entity" || ch.entity_type !== "feat") continue;
+      const v = oc[`race:${ch.id}`];
+      for (const ref of Array.isArray(v) ? v : typeof v === "string" ? [v] : []) {
+        const slug = typeof ref === "string" ? stripRef(ref) : "";
+        if (slug) out.push({ slug, via: { kind: "race", slug: race.slug }, read: (id) => oc[`race:feat:${id}`] });
+      }
+    }
+  }
+  return out;
+}
+function featOfSite(site, feats) {
+  var _a;
+  return (_a = feats.find((f) => f.slug === site.slug)) != null ? _a : feats.find((f) => bareEntitySlug(f.slug) === bareEntitySlug(site.slug));
+}
+function nestedPickKeysToPrune(block, key, next) {
+  const prev = block == null ? void 0 : block[key];
+  if (!block || !Array.isArray(prev)) return [];
+  const keep = new Set(next);
+  const gone = prev.filter((k) => typeof k === "string" && !keep.has(k));
+  if (!gone.length) return [];
+  return Object.keys(block).filter((k) => gone.some((g) => k.startsWith(`${key}:${g}:`)));
+}
+
+export {
+  isTargetChoice,
+  memberChoices,
+  memberSpellTargets,
+  spellsReached,
+  poolMemberSites,
+  poolMemberSitesOf,
+  featPickSites,
+  raceFeatSites,
+  featOfSite,
+  nestedPickKeysToPrune
+};

package/dist/chunk-TRBGC4ZG.js

@@ -0,0 +1,112 @@
+import {
+  spellSource
+} from "./chunk-KR6JF3BF.js";
+import {
+  resourceLevelFor
+} from "./chunk-KSTV7J2U.js";
+import {
+  addToRoll
+} from "./chunk-WOHX7YTH.js";
+import {
+  baseClassName
+} from "./chunk-VTTA2ALZ.js";
+
+// src/pc/pc.amount-bindings.ts
+function ownerClassSlug(source, resolved) {
+  var _a, _b, _c;
+  if (!source) return null;
+  if (source.kind === "class") return source.slug;
+  if (source.kind === "subclass") return (_c = (_b = (_a = resolved.classes.find((c) => {
+    var _a2;
+    return ((_a2 = c.subclass) == null ? void 0 : _a2.slug) === source.slug;
+  })) == null ? void 0 : _a.entity) == null ? void 0 : _b.slug) != null ? _c : null;
+  if (source.kind === "feat" && source.via) {
+    if (source.via.kind === "class") return source.via.slug;
+    if (source.via.kind === "pool") return source.via.classSlug;
+  }
+  return null;
+}
+function casterRow(classSlug, derived) {
+  var _a, _b;
+  const rows = (_a = derived.spellcastingClasses) != null ? _a : [];
+  const own = classSlug ? rows.find((c) => baseClassName(c.classSlug) === baseClassName(classSlug)) : void 0;
+  return (_b = own != null ? own : rows[0]) != null ? _b : null;
+}
+function amountBindingsFor(owner, resolved, derived) {
+  const classSlug = ownerClassSlug(owner, resolved);
+  const classSource = classSlug ? { kind: "class", slug: classSlug, level: 0 } : owner;
+  const classLevel = classSource ? resourceLevelFor(classSource, resolved) : resolved.totalLevel;
+  const row = casterRow(classSlug, derived);
+  return {
+    level: resolved.totalLevel,
+    class_level: classLevel,
+    prof: derived.proficiencyBonus,
+    str_mod: derived.mods.str,
+    dex_mod: derived.mods.dex,
+    con_mod: derived.mods.con,
+    int_mod: derived.mods.int,
+    wis_mod: derived.mods.wis,
+    cha_mod: derived.mods.cha,
+    columns: {},
+    ...row ? { spell_mod: derived.mods[row.ability], spell_dc: row.saveDC } : {}
+  };
+}
+function spellcastingFor(spell, derived) {
+  var _a, _b;
+  if ((spellSource(spell).ownAbility || spell.classSlug == null) && spell.ability) {
+    const own = (_a = derived.abilitySpellcasting) == null ? void 0 : _a[spell.ability];
+    if (own) return { ability: spell.ability, saveDC: own.saveDC, attackBonus: own.attackBonus };
+  }
+  const row = casterRow((_b = spell.classSlug) != null ? _b : null, derived);
+  return row ? { ability: row.ability, saveDC: row.saveDC, attackBonus: row.attackBonus } : null;
+}
+function spellAmountBindings(spell, resolved, derived) {
+  const cast = spellcastingFor(spell, derived);
+  const base = amountBindingsFor(spell.classSlug ? { kind: "class", slug: spell.classSlug, level: 0 } : void 0, resolved, derived);
+  const out = { ...base };
+  delete out.spell_mod;
+  delete out.spell_dc;
+  return cast ? { ...out, spell_mod: derived.mods[cast.ability], spell_dc: cast.saveDC } : out;
+}
+function spellRollBonus(spell) {
+  var _a;
+  const roll = (_a = spell.damage_roll) == null ? void 0 : _a.trim();
+  const text = spell.description;
+  if (!roll || !text) return null;
+  const esc = roll.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`(?<![\\w])${esc}\`?\\s*(?:plus|\\+)\\s*your\\s+spellcasting\\s+(?:ability\\s+)?modifier`, "i");
+  return re.test(text) ? "{spell_mod}" : null;
+}
+function foldsIntoRoll(rider, spell) {
+  var _a, _b;
+  const own = ((_b = (_a = spell.entity.damage) == null ? void 0 : _a.types) != null ? _b : []).map((t) => t.toLowerCase());
+  return !rider.condition && (!rider.damage_type || own.includes(rider.damage_type.toLowerCase()));
+}
+var reaching = (spell, derived) => {
+  var _a;
+  return ((_a = derived.spellDamageRiders) != null ? _a : []).filter((r) => {
+    var _a2;
+    return (_a2 = r.spells) == null ? void 0 : _a2.includes(spell.slug);
+  });
+};
+function addSpellDamageRiders(roll, spell, derived) {
+  return addToRoll(roll, reaching(spell, derived).filter((r) => foldsIntoRoll(r, spell)).map((r) => r.amount));
+}
+function spellDamageRiderLines(spell, derived) {
+  return reaching(spell, derived).filter((r) => !foldsIntoRoll(r, spell)).map((r) => ({
+    amount: r.amount,
+    ...r.damage_type ? { damage_type: r.damage_type } : {},
+    ...r.source ? { source: r.source } : {},
+    ...r.condition ? { condition: r.condition } : {}
+  }));
+}
+
+export {
+  ownerClassSlug,
+  amountBindingsFor,
+  spellcastingFor,
+  spellAmountBindings,
+  spellRollBonus,
+  addSpellDamageRiders,
+  spellDamageRiderLines
+};

package/dist/{chunk-PLOSP4XQ.js → chunk-UJCK5IW4.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-CJYCVNW2.js";
 import {
   featureSchema
-} from "./chunk-FPGXFD2M.js";
+} from "./chunk-B2QHP6UF.js";
 import {
   resourceSchema
 } from "./chunk-ZJXSXVFP.js";
@@ -18,7 +18,7 @@ import {
 } from "./chunk-IN4M4X7P.js";
 import {
   choiceSchema
-} from "./chunk-BRGLDWUP.js";
+} from "./chunk-OOL4KMG2.js";
 import {
   additionalSpellsEntrySchema,
   imageField,
@@ -110,6 +110,15 @@ var classEntitySchema = z.object({
   description: z.string(),
   hit_die: hitDieEnum,
   primary_abilities: z.array(abilityEnum).nonempty(),
+  // D2b-A (A-1): the class's recommended Standard Array (SRD 5.2 "Standard Array by Class"); absent on 2014 classes.
+  standard_array: z.strictObject({
+    str: z.number().int(),
+    dex: z.number().int(),
+    con: z.number().int(),
+    int: z.number().int(),
+    wis: z.number().int(),
+    cha: z.number().int()
+  }).optional(),
   saving_throws: z.array(abilityEnum).length(2),
   proficiencies: z.object({
     armor: z.array(armorCategoryEnum),

package/dist/{chunk-5KGV6TF7.js → chunk-UNYR5GLI.js}

@@ -1,6 +1,6 @@
 import {
   subclassEntitySchema
-} from "./chunk-J53ERF6K.js";
+} from "./chunk-LNT64X7C.js";
 import {
   aliasFeaturesByLevelActionCost
 } from "./chunk-4U55VNC7.js";

package/dist/{chunk-JNNNBEUH.js → chunk-VN5DLURA.js}

@@ -6,9 +6,12 @@ import {
   resetTriggerEnum,
   resourceConsumptionSchema
 } from "./chunk-ZJXSXVFP.js";
+import {
+  choiceSchema
+} from "./chunk-OOL4KMG2.js";
 import {
   featureEffectSchema
-} from "./chunk-ZMJQUZQH.js";
+} from "./chunk-JXWNXIIZ.js";
 import {
   additionalSpellsEntrySchema,
   imageField,
@@ -138,7 +141,9 @@ var optionalFeatureEntitySchema = z.object({
   repeatable: z.literal(true).optional(),
   item_choice: z.enum(["learn", "create"]).optional(),
   options: z.array(optionRowSchema).optional(),
-  infuse: infuseBlockSchema.optional()
+  infuse: infuseBlockSchema.optional(),
+  // D2b-A (design §2.2 step 1): a pool member's own choices, the vocabulary features and feats use.
+  choices: z.array(choiceSchema).optional()
 }).superRefine((d, ctx) => {
   var _a;
   if (d.repeatable && (!d.options || !d.item_choice)) ctx.addIssue({ code: "custom", message: "a repeatable note needs options and item_choice" });

package/dist/{chunk-EL6QPF6I.js → chunk-VP5TIXDK.js}

@@ -1,6 +1,6 @@
 import {
   featureObjectSchema
-} from "./chunk-FPGXFD2M.js";
+} from "./chunk-B2QHP6UF.js";
 import {
   imageField
 } from "./chunk-UA5KS2PL.js";

package/dist/chunk-WOHX7YTH.js

@@ -0,0 +1,165 @@
+import {
+  evaluateMaxFormula,
+  isValidMaxFormula
+} from "./chunk-EVMUJYUD.js";
+
+// src/dnd/amount-text.ts
+var ABILITY_WORD = {
+  strength: "str",
+  dexterity: "dex",
+  constitution: "con",
+  intelligence: "int",
+  wisdom: "wis",
+  charisma: "cha",
+  str: "str",
+  dex: "dex",
+  con: "con",
+  int: "int",
+  wis: "wis",
+  cha: "cha"
+};
+var ABILITY_RE = "(Strength|Dexterity|Constitution|Intelligence|Wisdom|Charisma)";
+var CLASS_RE = "(Artificer|Barbarian|Bard|Cleric|Druid|Fighter|Monk|Paladin|Ranger|Rogue|Sorcerer|Warlock|Wizard)";
+var TOKEN_ALIAS = {
+  prof_bonus: "prof",
+  proficiency_bonus: "prof",
+  spellcasting_mod: "spell_mod",
+  spell_save_dc: "spell_dc"
+};
+var IDENT_LABEL = {
+  level: "level",
+  class_level: "class level",
+  prof: "PB",
+  str_mod: "STR mod",
+  dex_mod: "DEX mod",
+  con_mod: "CON mod",
+  int_mod: "INT mod",
+  wis_mod: "WIS mod",
+  cha_mod: "CHA mod",
+  spell_mod: "spellcasting mod",
+  spell_dc: "spell save DC"
+};
+var abilityToken = (word) => `{${ABILITY_WORD[word.toLowerCase()]}_mod}`;
+var PHRASES = [
+  // Save DCs: "your spell save DC", "your sorcerer spell save DC", "the spell save DC from this class's Spellcasting feature".
+  [/\b(?:your|the)\s+(?:[a-z]+\s+)?spell save DC(?:\s+from this class's Spellcasting feature)?/gi, "{spell_dc}"],
+  // "8 plus your Wisdom modifier and Proficiency Bonus" (2024) / the 2014 order is caught by the rows below.
+  [
+    new RegExp(`\\b8 plus your ${ABILITY_RE} modifier and (?:your )?Proficiency Bonus`, "gi"),
+    (_m, a) => `8 + ${abilityToken(a)} + {prof}`
+  ],
+  // The spellcasting modifier, in every spelling the notes carry.
+  [/\b(?:your\s+)?spellcasting ability modifier\b/gi, "{spell_mod}"],
+  [/\b(?:your\s+)?spellcasting modifier\b/gi, "{spell_mod}"],
+  [/\b(?:your\s+)?spell(?:casting)? mod\b/gi, "{spell_mod}"],
+  // An ability modifier: "your Wisdom modifier", "Intelligence modifier", "WIS mod".
+  [new RegExp(`\\b(?:your\\s+)?${ABILITY_RE} modifier\\b`, "gi"), (_m, a) => abilityToken(a)],
+  [/\b(STR|DEX|CON|INT|WIS|CHA) mod(?:ifier)?\b/g, (_m, a) => abilityToken(a)],
+  // Class level: "half your Warlock level", "your fighter level"; the character's level.
+  [new RegExp(`\\bhalf your ${CLASS_RE} level(?:\\s*\\(round(?:ed)? up\\))`, "gi"), "ceil({class_level} / 2)"],
+  [new RegExp(`\\bhalf your ${CLASS_RE} level(?:\\s*\\(round(?:ed)? down\\))?`, "gi"), "floor({class_level} / 2)"],
+  [/\bhalf your level in this class(?:\s*\(round(?:ed)? up\))/gi, "ceil({class_level} / 2)"],
+  [/\bhalf your level in this class(?:\s*\(round(?:ed)? down\))?/gi, "floor({class_level} / 2)"],
+  [new RegExp(`\\byour ${CLASS_RE} level\\b`, "gi"), "{class_level}"],
+  [/\byour level in this class\b/gi, "{class_level}"],
+  [/\byour (?:character )?level\b/gi, "{level}"],
+  // Proficiency bonus.
+  [/\b(?:your\s+)?proficiency bonus\b/gi, "{prof}"],
+  [/\bPB\b/g, "{prof}"]
+];
+function normalizeAmountPhrases(text) {
+  let out = text;
+  for (const [re, to] of PHRASES) out = out.replace(re, to);
+  if (out === text) return text;
+  out = out.replace(/\s+plus\s+/gi, " + ").replace(/\s+minus\s+/gi, " - ").replace(/\btwice (\{[a-z_]+\})/gi, "2 * $1");
+  return out;
+}
+var TRAILING_MIN = /\s*\(minimum(?: bonus)? of \+?(\d+)[^)]*\)\s*$/i;
+var DICE = /^\d*d\d+$/i;
+function tidySigns(s) {
+  return s.replace(/\+\s*-\s*/g, "- ").replace(/-\s*-\s*/g, "+ ");
+}
+function foldDice(expr) {
+  const parts = expr.replace(/\s+/g, "").match(/[+-]?[^+-]+/g);
+  if (!parts) return null;
+  const dice = [];
+  let sum = 0;
+  for (const raw of parts) {
+    const sign = raw.startsWith("-") ? -1 : 1;
+    const body = raw.replace(/^[+-]/, "");
+    if (DICE.test(body)) {
+      if (sign < 0) return null;
+      dice.push(body.toLowerCase());
+      continue;
+    }
+    if (!isValidMaxFormula(body)) return null;
+    sum += sign * evaluateMaxFormula(body, ZERO_BINDINGS);
+  }
+  if (dice.length === 0) return null;
+  const n = Math.trunc(sum);
+  return `${dice.join("+")}${n > 0 ? `+${n}` : n < 0 ? `${n}` : ""}`;
+}
+var ZERO_BINDINGS = {
+  level: 0,
+  class_level: 0,
+  prof: 0,
+  str_mod: 0,
+  dex_mod: 0,
+  con_mod: 0,
+  int_mod: 0,
+  wis_mod: 0,
+  cha_mod: 0,
+  columns: {}
+};
+function resolveAmountText(text, b) {
+  const normalized = normalizeAmountPhrases(text);
+  if (!normalized.includes("{")) return text;
+  const values = b;
+  let unbound = false;
+  const substitute = (numeric2) => normalized.replace(/\{([a-z_]+)\}/g, (_m, raw) => {
+    var _a, _b;
+    const id = (_a = TOKEN_ALIAS[raw]) != null ? _a : raw;
+    const v = values[id];
+    if (typeof v !== "number" || !Number.isFinite(v)) {
+      unbound = true;
+      return (_b = IDENT_LABEL[id]) != null ? _b : raw;
+    }
+    return numeric2 && v < 0 ? `(0 - ${-v})` : String(v);
+  });
+  const display = tidySigns(substitute(false));
+  if (unbound) return text.includes("{") ? display : text;
+  const min = TRAILING_MIN.exec(display);
+  const minText = min ? display.slice(min.index) : "";
+  const numeric = substitute(true);
+  const numericCore = numeric.replace(TRAILING_MIN, "");
+  if (isValidMaxFormula(numericCore)) {
+    const v = evaluateMaxFormula(numericCore, ZERO_BINDINGS);
+    return String(Math.trunc(min ? Math.max(Number(min[1]), v) : v));
+  }
+  const roll = foldDice(min ? display.slice(0, min.index) : display);
+  if (roll) return `${roll}${minText}`;
+  if (/\b(?:floor|ceil|max|min)\(/.test(display)) return text;
+  return display;
+}
+function addToRoll(roll, amounts) {
+  var _a;
+  if (!amounts.length) return roll;
+  const text = tidySigns([roll, ...amounts].join(" + "));
+  return (_a = foldDice(text)) != null ? _a : text;
+}
+function diceRollOf(resolved) {
+  var _a, _b;
+  return (_b = (_a = diceRollPrefix(resolved)) == null ? void 0 : _a.notation) != null ? _b : null;
+}
+function diceRollPrefix(text) {
+  const m = /^(\d*d\d+(?:\s*[+-]\s*\d+)*)(?=\s|$)/i.exec(text);
+  return m ? { raw: m[1], notation: m[1].replace(/\s+/g, "") } : null;
+}
+
+export {
+  normalizeAmountPhrases,
+  resolveAmountText,
+  addToRoll,
+  diceRollOf,
+  diceRollPrefix
+};

package/dist/{chunk-G7ED5H2G.js → chunk-XTEFPUSN.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-4U55VNC7.js";
 import {
   classEntitySchema
-} from "./chunk-PLOSP4XQ.js";
+} from "./chunk-UJCK5IW4.js";
 
 // src/class/class.parser.ts
 import { parseYaml } from "@archivist-gg/core";

package/dist/{chunk-6ZY3U6BQ.js → chunk-ZOWKWMD2.js}

@@ -1,6 +1,6 @@
 import {
   parseFeat
-} from "./chunk-4SLOJXJ4.js";
+} from "./chunk-3SFGWFVQ.js";
 
 // src/feat/feat.codec.ts
 import yaml from "js-yaml";