@archivist-gg/dnd5e 0.3.13 → 0.3.19

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

@@ -4,12 +4,15 @@ import {
 import {
   warnOnce
 } from "./chunk-LVQLWRCU.js";
+import {
+  memoByRevision
+} from "./chunk-4J6DS3EJ.js";
 import {
   slugify
 } from "./chunk-ZCTUYGNV.js";
 import {
   mirrorSpellShapes
-} from "./chunk-XY6X2APM.js";
+} from "./chunk-7Q2VPKCD.js";
 import {
   ABILITY_KEYS
 } from "./chunk-WELIKLZF.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-J53ERF6K.js → chunk-LNT64X7C.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";

package/dist/{chunk-RQNJXADQ.js → chunk-NKZMQV2C.js}

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

package/dist/{chunk-UE6LKRXQ.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
@@ -251,6 +254,25 @@ var knownSpellObjectSchema = z.object({
   always_prepared: z.boolean().optional()
 }).strict();
 var knownSpellEntrySchema = z.union([z.string().min(1), knownSpellObjectSchema]);
+var sheetViewFilterSchema = z.object({
+  show: z.array(z.string().min(1)).optional(),
+  hide: z.array(z.string().min(1)).optional()
+});
+var sheetPoolViewSchema = z.object({
+  show: z.enum(["known", "granted", "not-known"]).optional().catch(void 0),
+  off: z.record(z.string(), z.array(z.string())).optional(),
+  folded: z.array(z.string().min(1)).optional()
+});
+var sheetStateSchema = z.object({
+  // 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()
+});
 var characterSchema = z.object({
   name: z.string().min(1),
   edition: z.enum(["2014", "2024"]),
@@ -323,6 +345,7 @@ var characterSchema = z.object({
     vulnerabilities: z.array(z.string()).default([]),
     condition_immunities: z.array(z.string()).default([])
   }).partial().optional(),
+  sheet: sheetStateSchema.optional(),
   state: characterStateSchema
 });
 

package/dist/{chunk-T5GZBKIQ.js → chunk-NXUY5XQN.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-W6GC6OKK.js";
 import {
   derivePoolLayout
-} from "./chunk-HJQNK3J5.js";
+} from "./chunk-B3DP42OM.js";
 import {
   readTableColumn
 } from "./chunk-IUAAXXNO.js";
@@ -29,6 +29,10 @@ import {
   keptSlugFor,
   resolveBaseItem
 } from "./chunk-CM5CWO4K.js";
+import {
+  bucketOf,
+  memoByRevision
+} from "./chunk-4J6DS3EJ.js";
 import {
   bareEntitySlug,
   slugify,
@@ -41,29 +45,99 @@ import {
   isCanonicalDamageType
 } from "./chunk-PDJSUH24.js";
 
+// src/pc/resource-equivalents.ts
+var RESOURCE_EQUIVALENTS = [
+  { name: "Superiority Dice", ids: ["fighter:superiority-dice", "fighter-2024:superiority-dice"] },
+  { name: "Sorcery Points", ids: ["sorcerer:sorcery-point", "sorcerer:sorcery-points", "sorcerer-2024:sorcery-point"] },
+  { name: "Ki / Focus Points", ids: ["monk:ki", "monk:ki-points", "monk:focus-point", "monk:focus-points"] },
+  { name: "Channel Divinity (Cleric)", ids: ["cleric:channel-divinity", "cleric-2024:channel-divinity", "channel-divinity"] },
+  { name: "Channel Divinity (Paladin)", ids: ["paladin:channel-divinity", "paladin-2024:channel-divinity", "channel-divinity"] },
+  { name: "Bardic Inspiration", ids: ["bard:bardic-inspiration", "bard:bardic-die"] },
+  { name: "Rage", ids: ["barbarian:rage", "barbarian:rages", "barbarian-2024:rages"] },
+  { name: "Wild Shape", ids: ["druid:wild-shape", "druid-2024:wild-shape"] },
+  { name: "Soul Trinkets", ids: ["rogue:soul-trinket", "rogue-2024:soul-trinket"] }
+];
+function equivalentResourceIds(id, groups = RESOURCE_EQUIVALENTS) {
+  const out = [];
+  for (const g of groups) {
+    if (!g.ids.includes(id)) continue;
+    for (const other of g.ids) if (other !== id && !out.includes(other)) out.push(other);
+  }
+  return out;
+}
+function ownedByClass(res, rc) {
+  var _a, _b;
+  const s = (_a = res == null ? void 0 : res.owner) == null ? void 0 : _a.source;
+  if (!s) return false;
+  if (s.kind === "class") return s.slug === ((_b = rc.entity) == null ? void 0 : _b.slug);
+  if (s.kind === "subclass") return !!rc.subclass && s.slug === rc.subclass.slug;
+  return false;
+}
+function payingResourceId(id, index, owner, groups = RESOURCE_EQUIVALENTS) {
+  const candidates = [id, ...equivalentResourceIds(id, groups)].filter((c) => index.has(c));
+  if (candidates.length === 0) return void 0;
+  if (owner) {
+    const own = candidates.find((c) => ownedByClass(index.get(c), owner));
+    if (own) return own;
+  }
+  return candidates[0];
+}
+function classOfSource(source, classes) {
+  var _a, _b;
+  if (source.kind === "class") return (_a = classes.find((c) => {
+    var _a2;
+    return ((_a2 = c.entity) == null ? void 0 : _a2.slug) === source.slug;
+  })) != null ? _a : null;
+  if (source.kind === "subclass") return (_b = classes.find((c) => {
+    var _a2;
+    return ((_a2 = c.subclass) == null ? void 0 : _a2.slug) === source.slug;
+  })) != null ? _b : null;
+  return null;
+}
+function bindFeatureConsumers(features, index, classes) {
+  return features.map((rf) => {
+    const consumes = rf.feature.consumes;
+    const id = consumes == null ? void 0 : consumes.resource;
+    if (!consumes || typeof id !== "string" || id.length === 0) return rf;
+    const payer = payingResourceId(id, index, classOfSource(rf.source, classes));
+    if (payer === void 0 || payer === id) return rf;
+    return { ...rf, feature: { ...rf.feature, consumes: { ...consumes, resource: payer } } };
+  });
+}
+
 // 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);
 }
-function resolvePool(rc, classIndex, pool, registry, index, edition) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  const entity = rc.entity;
-  const level = rc.level;
-  const ownerBare = bareEntitySlug(entity.slug);
-  const ownerPrefix = entity.slug.split("_")[0];
-  const col = pool.count.column;
-  const count = (_a = readTableColumn(entity.table, level, [col])) != null ? _a : 0;
+function poolAnchorLevel(entity, pool) {
   let anchorLevel = 1;
   let columnSeen = false;
   for (let l = 1; l <= 20; l++) {
-    const c = readTableColumn(entity.table, l, [col]);
+    const c = readTableColumn(entity.table, l, [pool.count.column]);
     if (c != null) columnSeen = true;
     if (c != null && c >= 1) {
       anchorLevel = l;
       break;
     }
   }
+  return { anchorLevel, columnSeen };
+}
+function resolvePool(rc, classIndex, pool, registry, index, edition) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const entity = rc.entity;
+  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);
   if (!columnSeen) {
     warnOnce(
       `pool-column:${pool.id}`,
@@ -71,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();
@@ -83,14 +157,15 @@ 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]);
   }
-  const available = [];
+  const collapsed = [];
   for (const [bare, group] of candidates) {
     if (group.length === 1) {
-      available.push(group[0]);
+      collapsed.push(group[0]);
       continue;
     }
     const owned = group.find((e) => e.slug.split("_")[0] === ownerPrefix);
@@ -100,7 +175,7 @@ function resolvePool(rc, classIndex, pool, registry, index, edition) {
         `Archivist: pool "${pool.id}" holds ${group.length} cross-edition entries for "${bare}" and none shares the owner's compendium prefix "${ownerPrefix}"; keeping "${group[0].slug}"`
       );
     }
-    available.push(owned != null ? owned : group[0]);
+    collapsed.push(owned != null ? owned : group[0]);
   }
   const grantDecls = [
     ...(_d = (_c = rc.entity) == null ? void 0 : _c.pool_grants) != null ? _d : [],
@@ -114,6 +189,7 @@ function resolvePool(rc, classIndex, pool, registry, index, edition) {
     grantedBare.add(key);
     return true;
   });
+  const available = collapsed.filter((e) => !grantedBare.has(bareEntitySlug(e.slug)));
   const bySlugAvailable = new Map(available.map((e) => [e.slug, e]));
   const byBareAvailable = new Map(available.map((e) => [bareEntitySlug(e.slug), e]));
   const resolveStored = (s) => {
@@ -152,8 +228,9 @@ function resolvePool(rc, classIndex, pool, registry, index, edition) {
   const votes = /* @__PURE__ */ new Map();
   for (const e of members) {
     const id = (_h = e.entity.consumes) == null ? void 0 : _h.resource;
-    if (!id || !index.has(id)) continue;
-    votes.set(id, ((_i = votes.get(id)) != null ? _i : 0) + 1);
+    const payer = id ? payingResourceId(id, index, rc) : void 0;
+    if (!payer) continue;
+    votes.set(payer, ((_i = votes.get(payer)) != null ? _i : 0) + 1);
   }
   let resource;
   let bestN = 0;
@@ -161,7 +238,7 @@ function resolvePool(rc, classIndex, pool, registry, index, edition) {
     resource = id;
     bestN = n;
   }
-  const bind = resource ? poolRebinder(rc, pool.id, resource, index) : (e) => e;
+  const bind = poolRebinder(rc, pool.id, resource, index);
   return {
     id: pool.id,
     label: pool.label,
@@ -184,14 +261,20 @@ function poolRebinder(rc, poolId, vote, index) {
   return (e) => {
     const consumes = e.entity.consumes;
     const id = consumes == null ? void 0 : consumes.resource;
-    if (!consumes || typeof id !== "string" || id.length === 0 || index.has(id) || declared.has(id)) return e;
+    if (!consumes || typeof id !== "string" || id.length === 0) return e;
+    const payer = payingResourceId(id, index, rc);
+    if (payer === id) return e;
+    const target = payer != null ? payer : vote !== void 0 && !declared.has(id) ? vote : void 0;
+    if (target === void 0) return e;
     const done = copies.get(e.key);
     if (done) return done;
-    warnOnce(
-      `pool-rebind:${poolId}:${id}`,
-      `Archivist: pool "${poolId}" members consume "${id}", which this character does not own; bound to the pool's resource "${vote}"`
-    );
-    const copy = { ...e, entity: { ...e.entity, consumes: { ...consumes, resource: vote } } };
+    if (payer === void 0) {
+      warnOnce(
+        `pool-rebind:${poolId}:${id}`,
+        `Archivist: pool "${poolId}" members consume "${id}", which this character does not own; bound to the pool's resource "${target}"`
+      );
+    }
+    const copy = { ...e, entity: { ...e.entity, consumes: { ...consumes, resource: target } } };
     copies.set(e.key, copy);
     return copy;
   };
@@ -281,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;
@@ -321,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;
@@ -334,10 +454,23 @@ function resolveOptionRows(note, registry, opts = {}) {
       ...row.attunement !== void 0 ? { attunement: row.attunement } : {},
       arm: row.creates.item ? "item" : row.creates.variant ? "variant" : "filter",
       candidates,
-      availability: anyVisible ? "installed" : installed ? "hidden-only" : "not-installed"
+      availability: anyVisible ? "installed" : installed ? "hidden-only" : "not-installed",
+      ...rowItemWords(row, candidates[0] ? ix.items[(_a2 = ix.bySlug.get(candidates[0])) != null ? _a2 : -1] : rowItems[0])
     };
   });
 }
+function rowItemWords(row, item) {
+  var _a, _b, _c, _d;
+  const f = row.creates.filter;
+  if (f) return { type: ((_a = f.types) == null ? void 0 : _a[0]) ? lc(f.types[0]) : null, rarity: f.rarity[0] ? lc(f.rarity[0]) : null, charges: null };
+  const data = (_b = item == null ? void 0 : item.data) != null ? _b : {};
+  const max = (_c = data.charges) == null ? void 0 : _c.max;
+  return {
+    type: lc(data.type) || null,
+    rarity: lc(data.rarity) || null,
+    charges: typeof max === "number" && max > 0 ? { max, ...typeof ((_d = data.charges) == null ? void 0 : _d.recharge) === "string" ? { recharge: data.charges.recharge } : {} } : null
+  };
+}
 function resolveCopyOption(note, param, ctx) {
   var _a, _b, _c;
   const rows = (_a = note.options) != null ? _a : [];
@@ -920,7 +1053,9 @@ export {
   infusionsEndedByClassEdit,
   reconcileClassEdit,
   eligibleTargets,
+  bindFeatureConsumers,
   levelPrereqMax,
+  poolAnchorLevel,
   resolvePool,
   resolveAllPools,
   strandedPicks

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

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

package/dist/{chunk-BRGLDWUP.js → chunk-OOL4KMG2.js}

@@ -1,6 +1,6 @@
 import {
   featureEffectSchema
-} from "./chunk-ZMJQUZQH.js";
+} from "./chunk-JXWNXIIZ.js";
 
 // src/schemas/choice-schema.ts
 import { z } from "zod";
@@ -16,7 +16,9 @@ var entityFilterSchema = z.object({
   mundane: z.boolean().optional(),
   list: z.string().min(1).optional(),
   level: z.number().int().min(0).max(9).optional(),
-  edition: z.string().min(1).optional()
+  edition: z.string().min(1).optional(),
+  // D2b-A (design §2.2 step 1): Pact of the Tome's "level 1 ritual spells".
+  ritual: z.boolean().optional()
 }).strict();
 var inlineOptionSchema = z.lazy(() => z.object({
   value: z.string().min(1),
@@ -40,7 +42,9 @@ var choiceSchema = z.lazy(() => z.discriminatedUnion("kind", [
     count: z.number().int().positive().optional(),
     entity_type: z.string().min(1),
     from: z.array(z.string().min(1)).nonempty().optional(),
-    where: entityFilterSchema.optional()
+    where: entityFilterSchema.optional(),
+    // D2b-A: a pick that names a target (a blast's cantrip), never a grant.
+    target: z.literal(true).optional()
   }).strict(),
   z.object({
     kind: z.literal("select-proficiency"),

package/dist/{chunk-MWCCGPG3.js → chunk-OOSRUJBI.js}

@@ -1,6 +1,6 @@
 import {
   parseSpell
-} from "./chunk-XY6X2APM.js";
+} from "./chunk-7Q2VPKCD.js";
 
 // src/spell/spell.codec.ts
 import yaml from "js-yaml";
@@ -9,7 +9,8 @@ var spellCodec = {
     return parseSpell(doc.body);
   },
   serialize(spell) {
-    return yaml.dump(spell, { lineWidth: -1, sortKeys: false });
+    const { material: _material, ...doc } = spell;
+    return yaml.dump(doc, { lineWidth: -1, sortKeys: false });
   }
 };
 

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-MUIU7RZ3.js → chunk-QFWQKS3M.js}

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