@archivist-gg/dnd5e 0.3.17 → 0.3.19

package/dist/{chunk-VRV3NNTA.js → chunk-LICYHPI3.js}

@@ -4,6 +4,9 @@ import {
 import {
   warnOnce
 } from "./chunk-LVQLWRCU.js";
+import {
+  memoByRevision
+} from "./chunk-4J6DS3EJ.js";
 import {
   slugify
 } from "./chunk-ZCTUYGNV.js";
@@ -41,6 +44,10 @@ function normalizeSpellRef(ref) {
   return out.length > 0 ? out : null;
 }
 function buildSpellNameIndex(entities) {
+  return memoByRevision(SPELL_NAME_INDEX, entities, () => spellNameIndexOf(entities));
+}
+var SPELL_NAME_INDEX = /* @__PURE__ */ new WeakMap();
+function spellNameIndexOf(entities) {
   var _a;
   const byName = /* @__PURE__ */ new Map();
   for (const e of entities.search("", "spell", Number.POSITIVE_INFINITY)) {
@@ -95,20 +102,78 @@ var entryHasInSliceLeaf = (e, comparand, own) => readAbility(e.ability, own) !==
   const lv = e[b];
   return !!lv && typeof lv === "object" && !Array.isArray(lv) && Object.entries(lv).some(([k, v]) => (k === "_" || Number(k) <= comparand) && Array.isArray(v) && v.some((x) => typeof x === "string"));
 });
+function chosenRaceOptionKeys(race, read) {
+  var _a;
+  const out = /* @__PURE__ */ new Set();
+  const r = race;
+  const lists = [r.choices, ...((_a = r.traits) != null ? _a : []).map((t) => t == null ? void 0 : t.choices)];
+  for (const list of lists) {
+    for (const c of Array.isArray(list) ? list : []) {
+      if ((c == null ? void 0 : c.kind) !== "select-inline" || typeof c.id !== "string" || RACE_STRUCTURAL_PSEUDO.has(c.id)) continue;
+      const v = read(c.id);
+      for (const value of Array.isArray(v) ? v : typeof v === "string" ? [v] : []) {
+        if (typeof value !== "string") continue;
+        out.add(slugify(value));
+        const opt = (Array.isArray(c.options) ? c.options : []).find((o) => (o == null ? void 0 : o.value) === value);
+        if (typeof (opt == null ? void 0 : opt.label) === "string") out.add(slugify(opt.label));
+      }
+    }
+  }
+  return out;
+}
+function innateLeaves(innate, comparand) {
+  if (!innate || typeof innate !== "object" || Array.isArray(innate)) return [];
+  const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : v && typeof v === "object" ? Object.values(v).flatMap(strings) : [];
+  return Object.entries(innate).filter(([k]) => k === "_" || Number(k) <= comparand).flatMap(([, v]) => strings(v));
+}
+function memberAtWillLeaves(innate, comparand, slug) {
+  if (!innate || typeof innate !== "object" || Array.isArray(innate)) return [];
+  const out = [];
+  for (const [k, v] of Object.entries(innate)) {
+    if (!(k === "_" || Number(k) <= comparand)) continue;
+    if (Array.isArray(v)) {
+      out.push(...v);
+      continue;
+    }
+    for (const [usage, list] of v && typeof v === "object" ? Object.entries(v) : []) {
+      if (usage === "will" && Array.isArray(list)) out.push(...list);
+      else warnOnce(`addspells:usage:${slug}:innate:${k}:${usage}`, `archivist: additional_spells on "${slug}" innate.${k}.${usage} is a usage economy (skipped; G8)`);
+    }
+  }
+  return out;
+}
 function collectAdditionalSpells(args) {
+  var _a, _b;
   const { race, feats, classes, totalLevel, ownAbility, alreadyCollected, entities, warnings } = args;
+  const raceChoice = (_a = args.raceChoice) != null ? _a : (() => void 0);
   let index = null;
   const indexOf = () => index != null ? index : index = buildSpellNameIndex(entities);
   const out = [];
   const carriers = [];
   const asRaw = (x) => x == null ? void 0 : x.additional_spells;
   if (race && raceIsUngated(race)) carriers.push({ root: "race", slug: race.slug, edition: editionOf(race), entries: entriesOf(asRaw(race)), comparand: totalLevel, classSlug: null });
+  else if (race) {
+    const chosen = chosenRaceOptionKeys(race, raceChoice);
+    for (const e of entriesOf(asRaw(race))) {
+      if (typeof e.name === "string" && chosen.has(slugify(e.name))) {
+        carriers.push({ root: "race", slug: race.slug, edition: editionOf(race), entries: [e], comparand: totalLevel, classSlug: null });
+      }
+    }
+  }
   for (const f of feats) carriers.push({ root: "feat", slug: f.slug, edition: editionOf(f), entries: entriesOf(asRaw(f)), comparand: totalLevel, classSlug: null });
   for (const c of classes) {
     if (!c.entity) continue;
     carriers.push({ root: "class", slug: c.entity.slug, edition: editionOf(c.entity), entries: entriesOf(asRaw(c.entity)), comparand: c.level, classSlug: c.entity.slug });
     if (c.subclass) carriers.push({ root: "subclass", slug: c.subclass.slug, edition: editionOf(c.subclass), entries: entriesOf(asRaw(c.subclass)), comparand: c.level, classSlug: c.entity.slug });
   }
+  for (const pool of (_b = args.pools) != null ? _b : []) {
+    const c = classes[pool.classIndex];
+    if (!(c == null ? void 0 : c.entity)) continue;
+    for (const m of [...pool.selected, ...pool.grants]) {
+      if (m.itemBound === true) continue;
+      carriers.push({ root: "member", slug: m.slug, edition: editionOf(m.entity), entries: entriesOf(asRaw(m.entity)), comparand: c.level, classSlug: c.entity.slug });
+    }
+  }
   for (const car of carriers) {
     if (car.entries.length === 0) continue;
     if (car.entries.length > 1) {
@@ -116,12 +181,21 @@ function collectAdditionalSpells(args) {
       continue;
     }
     const entry = car.entries[0];
-    const ability = readAbility(entry.ability, ownAbility);
+    let ability = readAbility(entry.ability, ownAbility);
+    if (ability === "choose" && car.root === "race") {
+      const pick = raceChoice("spellcasting-ability");
+      const allowed = entry.ability.choose;
+      ability = typeof pick === "string" && Array.isArray(allowed) && allowed.includes(pick) ? pick : "choose";
+    }
     if (ability === "choose") continue;
-    for (const bucket of ["known", "prepared"]) {
+    const buckets = ["known", "prepared"].map((bucket) => {
       const levels = entry[bucket];
-      if (!levels || typeof levels !== "object" || Array.isArray(levels)) continue;
-      for (const [k, v] of Object.entries(levels)) {
+      return [bucket, !levels || typeof levels !== "object" || Array.isArray(levels) ? [] : Object.entries(levels)];
+    });
+    if (car.root === "race") buckets.push(["innate", [["_", innateLeaves(entry.innate, car.comparand)]]]);
+    if (car.root === "member") buckets.push(["at-will", [["_", memberAtWillLeaves(entry.innate, car.comparand, car.slug)]]]);
+    for (const [bucket, levelEntries] of buckets) {
+      for (const [k, v] of levelEntries) {
         if (!(k === "_" || Number(k) <= car.comparand)) continue;
         if (!Array.isArray(v)) {
           warnOnce(`addspells:usage:${car.slug}:${bucket}:${k}`, `archivist: additional_spells on "${car.slug}" ${bucket}.${k} is a usage economy (skipped; G8)`);
@@ -142,7 +216,8 @@ function collectAdditionalSpells(args) {
             source: car.root === "race" ? "race" : car.root === "feat" ? "feat" : "class",
             prepared: true,
             alwaysPrepared: true,
-            ...ability ? { ability } : {}
+            ...ability ? { ability } : {},
+            ...bucket === "at-will" ? { atWill: true } : {}
           });
         }
       }
@@ -157,5 +232,6 @@ export {
   buildSpellNameIndex,
   resolveSpellByName,
   raceIsUngated,
+  chosenRaceOptionKeys,
   collectAdditionalSpells
 };

package/dist/{chunk-LF5AGJA4.js → chunk-LNT64X7C.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-CJYCVNW2.js";
 import {
   featureSchema
-} from "./chunk-YD2VAHA6.js";
+} from "./chunk-B2QHP6UF.js";
 import {
   resourceSchema
 } from "./chunk-ZJXSXVFP.js";

package/dist/{chunk-6EI737IO.js → chunk-NKZMQV2C.js}

@@ -1,6 +1,6 @@
 import {
   backgroundEntitySchema
-} from "./chunk-3MGQFFNE.js";
+} from "./chunk-QFWQKS3M.js";
 
 // src/background/background.parser.ts
 import { parseYaml } from "@archivist-gg/core";

package/dist/{chunk-T6QIF5XR.js → chunk-NTU2DXNG.js}

@@ -143,13 +143,16 @@ var characterOverridesShape = z.object({
      *  `toProfSlug` output with the apostrophe RETAINED ("thieves'-tools"), matching the engine's
      *  own tool vocabulary in types/choice.ts. The READER is wider: `computeEffectiveProficiencies`
      *  normalises each key with `toProfSlug` on read, so a hand-typed "Thieves' Tools" also
-     *  matches; and the plugin's two writers (`CharacterEditState.setToolProficiency` and the
+     *  matches; and the plugin's two writers (`CharacterEditState.setToolExpertise` and the
      *  `addProficiency` clearance) match an existing key by slug too, so a key the note ALREADY
      *  carries is written THROUGH in its own spelling rather than duplicated · nothing here
      *  re-spells it (review M-4: "repaired in place" read as "normalised", which it is not).
      *  `languages` gets no such sibling: languages have no tri (§9.3). */
     proficiency: z.record(z.string(), proficiencyTri).optional()
   }).optional(),
+  /** D4 A: weapon and armor proficiency edits, the `languages` shape. Same no-defaults rule. */
+  weapons: z.object({ add: z.array(z.string()).optional(), remove: z.array(z.string()).optional() }).optional(),
+  armor: z.object({ add: z.array(z.string()).optional(), remove: z.array(z.string()).optional() }).optional(),
   /** Manual defense edits. SUPPRESSION-ONLY, and the missing `add` channel is a DELIBERATE
    *  asymmetry with `languages`/`tools` above · do not "complete the pattern". The additive
    *  store is `character.defenses.*`, which already exists and works; a second additive
@@ -261,7 +264,11 @@ var sheetPoolViewSchema = z.object({
   folded: z.array(z.string().min(1)).optional()
 });
 var sheetStateSchema = z.object({
-  layout: z.object({ saves: z.enum(["section"]).optional().catch(void 0) }).optional(),
+  // D13 (D3-A): `body: wide` is the wide three-column sheet (it draws the saves as a section, like `saves: section`).
+  layout: z.object({
+    saves: z.enum(["section"]).optional().catch(void 0),
+    body: z.enum(["wide"]).optional().catch(void 0)
+  }).optional(),
   favorites: z.array(z.string().min(1)).optional(),
   filters: z.object({ actions: sheetViewFilterSchema.optional(), passive: sheetViewFilterSchema.optional() }).optional(),
   pools: z.record(z.string(), sheetPoolViewSchema).optional()

package/dist/{chunk-3VZZDKRA.js → chunk-NXUY5XQN.js}

@@ -7,6 +7,10 @@ import {
 import {
   readTableColumn
 } from "./chunk-IUAAXXNO.js";
+import {
+  findItemAction,
+  resolveItemAction
+} from "./chunk-ZUQW5VBZ.js";
 import {
   requiresAttunement
 } from "./chunk-IHE6KVC3.js";
@@ -18,10 +22,6 @@ import {
   resolveEntityForEntry,
   slotAcTerms
 } from "./chunk-LHZXYFBU.js";
-import {
-  findItemAction,
-  resolveItemAction
-} from "./chunk-ZUQW5VBZ.js";
 import {
   warnOnce
 } from "./chunk-LVQLWRCU.js";
@@ -29,6 +29,10 @@ import {
   keptSlugFor,
   resolveBaseItem
 } from "./chunk-CM5CWO4K.js";
+import {
+  bucketOf,
+  memoByRevision
+} from "./chunk-4J6DS3EJ.js";
 import {
   bareEntitySlug,
   slugify,
@@ -102,6 +106,11 @@ function bindFeatureConsumers(features, index, classes) {
 }
 
 // src/pc/pc.pools.ts
+var SORTED_OPTIONAL_FEATURES = /* @__PURE__ */ new WeakMap();
+function sortedOptionalFeatures(registry) {
+  return memoByRevision(SORTED_OPTIONAL_FEATURES, registry, () => bucketOf(registry, "optional-feature").slice().sort((a, b) => a.name.localeCompare(b.name) || a.slug.localeCompare(b.slug)));
+}
+var SRD_OWNER_PREFIXES = /* @__PURE__ */ new Set(["srd-5e", "srd-2024"]);
 function levelPrereqMax(d) {
   var _a;
   return ((_a = d.prerequisites) != null ? _a : []).filter((p) => p.kind === "level").reduce((m, p) => Math.max(m, p.min), 0);
@@ -125,6 +134,7 @@ function resolvePool(rc, classIndex, pool, registry, index, edition) {
   const level = rc.level;
   const ownerBare = bareEntitySlug(entity.slug);
   const ownerPrefix = entity.slug.split("_")[0];
+  const ownEdition = SRD_OWNER_PREFIXES.has(ownerPrefix) ? entity.edition : void 0;
   const col = pool.count.column;
   const count = (_a = readTableColumn(entity.table, level, [col])) != null ? _a : 0;
   const { anchorLevel, columnSeen } = poolAnchorLevel(entity, pool);
@@ -135,7 +145,7 @@ function resolvePool(rc, classIndex, pool, registry, index, edition) {
     );
   }
   const ft = pool.source.where.feature_type;
-  const all = registry.search("", "optional-feature", Number.POSITIVE_INFINITY).slice().sort((a, b) => a.name.localeCompare(b.name) || a.slug.localeCompare(b.slug));
+  const all = sortedOptionalFeatures(registry);
   const entryOf = (slug, entity2, compendium) => ({ slug, entity: entity2, ...compendium ? { compendium } : {}, key: slug, param: null, itemBound: isItemBound(entity2) });
   const byBare = /* @__PURE__ */ new Map();
   const candidates = /* @__PURE__ */ new Map();
@@ -147,6 +157,7 @@ function resolvePool(rc, classIndex, pool, registry, index, edition) {
     if (d.feature_type !== ft) continue;
     if (!((_b = d.available_to) != null ? _b : []).some((l) => wikilinkTailSlug(l) === ownerBare)) continue;
     if (levelPrereqMax(d) > level) continue;
+    if (ownEdition && d.edition && d.edition !== ownEdition) continue;
     const group = candidates.get(bare);
     if (group) group.push(entry);
     else candidates.set(bare, [entry]);
@@ -353,13 +364,49 @@ function rowMatches(row, it) {
   if (c.variant) return c.variant.candidates.some((l) => bareEntitySlug(linkSlug(l)) === bareEntitySlug(it.slug));
   return !!c.filter && matchesFilter(it.data, c.filter);
 }
-var rowInstalledIn = (row, items) => {
-  const v = row.creates.item ? void 0 : row.creates.variant;
-  if (!v) return items.filter((it) => rowMatches(row, it));
-  const bares = new Set(v.candidates.map((l) => bareEntitySlug(linkSlug(l))));
-  return items.filter((it) => bares.has(bareEntitySlug(it.slug)));
-};
-var rowInstalled = (row, registry) => rowInstalledIn(row, itemsOf(registry));
+function buildItemIndex(items) {
+  const lcType = [], lcRarity = [];
+  const byLcName = /* @__PURE__ */ new Map(), bySlug = /* @__PURE__ */ new Map(), byBare = /* @__PURE__ */ new Map();
+  const push = (m, k, i) => {
+    const l = m.get(k);
+    if (l) l.push(i);
+    else m.set(k, [i]);
+  };
+  items.forEach((it, i) => {
+    const data = it.data;
+    lcType.push(lc(data.type));
+    lcRarity.push(lc(data.rarity));
+    push(byLcName, lc(it.name), i);
+    if (!bySlug.has(it.slug)) bySlug.set(it.slug, i);
+    push(byBare, bareEntitySlug(it.slug), i);
+  });
+  return { items, lcType, lcRarity, byLcName, bySlug, byBare };
+}
+var ITEM_INDEX = /* @__PURE__ */ new WeakMap();
+var itemIndexOf = (registry) => memoByRevision(ITEM_INDEX, registry, () => buildItemIndex(itemsOf(registry)));
+var inBucketOrder = (ix, hits) => [...hits].sort((a, b) => a - b).map((i) => ix.items[i]);
+function rowInstalledIn(row, ix) {
+  var _a, _b, _c;
+  const c = row.creates;
+  if (c.item) {
+    const hits = new Set((_a = ix.byLcName.get(lc(row.name))) != null ? _a : []);
+    const own = ix.bySlug.get(linkSlug(c.item));
+    if (own !== void 0) hits.add(own);
+    return inBucketOrder(ix, hits);
+  }
+  if (c.variant) {
+    const hits = /* @__PURE__ */ new Set();
+    for (const l of c.variant.candidates) for (const i of (_b = ix.byBare.get(bareEntitySlug(linkSlug(l)))) != null ? _b : []) hits.add(i);
+    return inBucketOrder(ix, hits);
+  }
+  const f = c.filter;
+  if (!f) return [];
+  const rarities = new Set(f.rarity.map(lc));
+  const types = f.types ? new Set(f.types.map(lc)) : null;
+  const excluded = new Set(((_c = f.exclude_types) != null ? _c : []).map(lc));
+  return ix.items.filter((it, i) => rarities.has(ix.lcRarity[i]) && (!types || types.has(ix.lcType[i])) && !excluded.has(ix.lcType[i]) && !(f.cursed === false && it.data.cursed === true));
+}
+var rowInstalled = (row, registry) => rowInstalledIn(row, itemIndexOf(registry));
 function candidateOrder(edition) {
   return (a, b) => {
     const ea = edition && lc(a.data.edition) === edition ? 0 : 1;
@@ -393,9 +440,10 @@ function candidatesFrom(installed, registry, opts) {
 }
 function resolveOptionRows(note, registry, opts = {}) {
   var _a;
-  const items = itemsOf(registry);
+  const ix = itemIndexOf(registry);
   return ((_a = note.options) != null ? _a : []).map((row) => {
-    const rowItems = rowInstalledIn(row, items);
+    var _a2;
+    const rowItems = rowInstalledIn(row, ix);
     const candidates = candidatesFrom(rowItems, registry, opts);
     const anyVisible = candidates.length > 0 || candidatesFrom(rowItems, registry, { ...opts, exclude: [] }).length > 0;
     const installed = rowItems.length > 0;
@@ -407,7 +455,7 @@ function resolveOptionRows(note, registry, opts = {}) {
       arm: row.creates.item ? "item" : row.creates.variant ? "variant" : "filter",
       candidates,
       availability: anyVisible ? "installed" : installed ? "hidden-only" : "not-installed",
-      ...rowItemWords(row, candidates[0] ? registry.getByTypeAndSlug("item", candidates[0]) : rowItems[0])
+      ...rowItemWords(row, candidates[0] ? ix.items[(_a2 = ix.bySlug.get(candidates[0])) != null ? _a2 : -1] : rowItems[0])
     };
   });
 }

package/dist/{chunk-QZSWN2KT.js → chunk-NZO7M5GV.js}

@@ -1,6 +1,6 @@
 import {
   parseSubclass
-} from "./chunk-OFCSP6MT.js";
+} from "./chunk-UNYR5GLI.js";
 
 // src/subclass/subclass.codec.ts
 import yaml from "js-yaml";

package/dist/{chunk-5MXFW4O3.js → chunk-OOL4KMG2.js}

@@ -1,6 +1,6 @@
 import {
   featureEffectSchema
-} from "./chunk-2JSQE3DD.js";
+} from "./chunk-JXWNXIIZ.js";
 
 // src/schemas/choice-schema.ts
 import { z } from "zod";

package/dist/{chunk-H5PTKYXL.js → chunk-QA3YCOML.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-KU3YLF6D.js";
 import {
   toProfSlug
-} from "./chunk-RLGQ5PZZ.js";
+} from "./chunk-5JXFJ5AU.js";
 
 // src/pc/pc.tool-picks.ts
 var TOOL_CATEGORIES = {

package/dist/{chunk-3MGQFFNE.js → chunk-QFWQKS3M.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-IN4M4X7P.js";
 import {
   choiceSchema
-} from "./chunk-5MXFW4O3.js";
+} from "./chunk-OOL4KMG2.js";
 import {
   additionalSpellsEntrySchema,
   imageField

package/dist/{chunk-HTYMW5CH.js → chunk-RD2MID3M.js}

@@ -1,7 +1,7 @@
 import {
   parsePickKey,
   poolAnchorLevel
-} from "./chunk-3VZZDKRA.js";
+} from "./chunk-NXUY5XQN.js";
 import {
   featProgressionCategory
 } from "./chunk-YBLDE5CG.js";
@@ -9,7 +9,11 @@ import {
   warnOnce
 } from "./chunk-LVQLWRCU.js";
 import {
-  bareEntitySlug
+  bucketOf
+} from "./chunk-4J6DS3EJ.js";
+import {
+  bareEntitySlug,
+  wikilinkTailSlug
 } from "./chunk-ZCTUYGNV.js";
 
 // src/pc/pc.member-choices.ts
@@ -104,6 +108,46 @@ function memberChoices(entity) {
   }
   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;
@@ -115,7 +159,7 @@ function poolMemberSites(classes, registry) {
   let byBare = null;
   let all = null;
   const lookup = (s, ownerPrefix) => {
-    all != null ? all : all = registry.search("", "optional-feature", Number.POSITIVE_INFINITY);
+    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;
@@ -204,6 +248,23 @@ function featPickSites(classEntries, memberSites, classSlugOf) {
   }
   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));
@@ -220,9 +281,12 @@ function nestedPickKeysToPrune(block, key, next) {
 export {
   isTargetChoice,
   memberChoices,
+  memberSpellTargets,
+  spellsReached,
   poolMemberSites,
   poolMemberSitesOf,
   featPickSites,
+  raceFeatSites,
   featOfSite,
   nestedPickKeysToPrune
 };

package/dist/{chunk-PXVNAY7T.js → chunk-TRBGC4ZG.js}

@@ -4,6 +4,9 @@ import {
 import {
   resourceLevelFor
 } from "./chunk-KSTV7J2U.js";
+import {
+  addToRoll
+} from "./chunk-WOHX7YTH.js";
 import {
   baseClassName
 } from "./chunk-VTTA2ALZ.js";
@@ -74,11 +77,36 @@ function spellRollBonus(spell) {
   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
+  spellRollBonus,
+  addSpellDamageRiders,
+  spellDamageRiderLines
 };

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

@@ -8,7 +8,7 @@ import {
 } from "./chunk-CJYCVNW2.js";
 import {
   featureSchema
-} from "./chunk-YD2VAHA6.js";
+} from "./chunk-B2QHP6UF.js";
 import {
   resourceSchema
 } from "./chunk-ZJXSXVFP.js";
@@ -18,7 +18,7 @@ import {
 } from "./chunk-IN4M4X7P.js";
 import {
   choiceSchema
-} from "./chunk-5MXFW4O3.js";
+} from "./chunk-OOL4KMG2.js";
 import {
   additionalSpellsEntrySchema,
   imageField,

package/dist/{chunk-OFCSP6MT.js → chunk-UNYR5GLI.js}

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

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

@@ -8,10 +8,10 @@ import {
 } from "./chunk-ZJXSXVFP.js";
 import {
   choiceSchema
-} from "./chunk-5MXFW4O3.js";
+} from "./chunk-OOL4KMG2.js";
 import {
   featureEffectSchema
-} from "./chunk-2JSQE3DD.js";
+} from "./chunk-JXWNXIIZ.js";
 import {
   additionalSpellsEntrySchema,
   imageField,

package/dist/{chunk-7ATNGKBS.js → chunk-VP5TIXDK.js}

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

package/dist/{chunk-QH36K2PU.js → chunk-WOHX7YTH.js}

@@ -141,6 +141,12 @@ function resolveAmountText(text, b) {
   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;
@@ -153,6 +159,7 @@ function diceRollPrefix(text) {
 export {
   normalizeAmountPhrases,
   resolveAmountText,
+  addToRoll,
   diceRollOf,
   diceRollPrefix
 };

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

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

package/dist/{chunk-RYLXAYIQ.js → chunk-ZOWKWMD2.js}

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

package/dist/class/class.codec.js

@@ -1,17 +1,17 @@
 import {
   classCodec
-} from "../chunk-MBX25B6D.js";
-import "../chunk-YKL6SHRJ.js";
+} from "../chunk-GVWEFECG.js";
+import "../chunk-XTEFPUSN.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-UUBJCNQU.js";
+import "../chunk-UJCK5IW4.js";
 import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-YD2VAHA6.js";
+import "../chunk-B2QHP6UF.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
 import "../chunk-IN4M4X7P.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
+import "../chunk-OOL4KMG2.js";
+import "../chunk-JXWNXIIZ.js";
 import "../chunk-UA5KS2PL.js";
 export {
   classCodec