@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/chunk-XQCSGNXE.js

@@ -0,0 +1,1580 @@
+import {
+  resolveFeatureResources,
+  resolveResourceIndex
+} from "./chunk-UXPGW4TI.js";
+import {
+  attributeUnclassedSpell,
+  effectiveSpellcastingAbility,
+  normalizeKnownSpell,
+  resolveSpellcasting
+} from "./chunk-DPUJDOKV.js";
+import {
+  resolveAllPools,
+  strandedPicks
+} from "./chunk-O4SRD3J5.js";
+import {
+  countColumnsFor,
+  readTableColumn
+} from "./chunk-IUAAXXNO.js";
+import {
+  recognizeDecision
+} from "./chunk-YHYTW5QA.js";
+import {
+  collectAdditionalSpells
+} from "./chunk-MI7P3NX3.js";
+import {
+  isItemEntity,
+  resolveEntityForEntry
+} from "./chunk-UBBKSYBY.js";
+import {
+  assembleEffectFeatures,
+  collectProficiencyEffectGrants
+} from "./chunk-JJ46T5XX.js";
+import {
+  ALL_LANGUAGES,
+  ALL_SKILL_SLUGS,
+  ALL_TOOLS
+} from "./chunk-KU3YLF6D.js";
+import {
+  humanizeProficiency,
+  proficiencyLabel,
+  toProfSlug
+} from "./chunk-RLGQ5PZZ.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  bareEntitySlug,
+  wikilinkTailSlug
+} from "./chunk-6X4KUDMU.js";
+import {
+  FEATURE_TYPE_FOR_CATEGORY,
+  featProgressionCategory
+} from "./chunk-YBLDE5CG.js";
+import {
+  mirrorSpellShapes
+} from "./chunk-OZP6JFGT.js";
+import {
+  ABILITY_KEYS
+} from "./chunk-WELIKLZF.js";
+import {
+  withResolvedActionCost
+} from "./chunk-4U55VNC7.js";
+
+// src/pc/pc.proficiency-grants.ts
+var UNKNOWN_SOURCE = "Unknown";
+function collectProficiencyGrants(resolved) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+  const classArmor = [];
+  const classWeaponFixed = [];
+  const classWeaponCategories = [];
+  const classToolFixed = [];
+  for (const c of resolved.classes) {
+    const prof = (_a = c.entity) == null ? void 0 : _a.proficiencies;
+    if (!prof) continue;
+    const source = (_c = (_b = c.entity) == null ? void 0 : _b.name) != null ? _c : UNKNOWN_SOURCE;
+    for (const a of (_d = prof.armor) != null ? _d : []) classArmor.push({ value: a, source });
+    for (const w of (_f = (_e = prof.weapons) == null ? void 0 : _e.fixed) != null ? _f : []) classWeaponFixed.push({ value: w, source });
+    for (const w of (_h = (_g = prof.weapons) == null ? void 0 : _g.categories) != null ? _h : []) classWeaponCategories.push({ value: w, source });
+    for (const t of (_j = (_i = prof.tools) == null ? void 0 : _i.fixed) != null ? _j : []) classToolFixed.push({ value: t, source });
+  }
+  const raceSource = (_l = (_k = resolved.race) == null ? void 0 : _k.name) != null ? _l : UNKNOWN_SOURCE;
+  const raceLangFixed = ((_o = (_n = (_m = resolved.race) == null ? void 0 : _m.languages) == null ? void 0 : _n.fixed) != null ? _o : []).map(
+    (l) => ({ value: l, source: raceSource })
+  );
+  const bgToolFixed = [];
+  const bgLangFixed = [];
+  const bg = resolved.background;
+  if (bg) {
+    const source = (_p = bg.name) != null ? _p : UNKNOWN_SOURCE;
+    for (const entry of (_q = bg.tool_proficiencies) != null ? _q : []) {
+      if (entry.kind === "fixed") {
+        for (const t of entry.items) bgToolFixed.push({ value: t, source });
+      }
+    }
+    for (const entry of (_r = bg.language_proficiencies) != null ? _r : []) {
+      if (entry.kind === "fixed") {
+        for (const l of entry.languages) bgLangFixed.push({ value: l, source });
+      }
+    }
+  }
+  const featArmor = [];
+  const featWeapons = [];
+  const featTools = [];
+  const featLanguages = [];
+  for (const f of (_s = resolved.feats) != null ? _s : []) {
+    const featView = f;
+    const grants = featView.proficiencies;
+    if (!grants) continue;
+    const source = (_t = f.name) != null ? _t : UNKNOWN_SOURCE;
+    for (const a of (_u = grants.armor) != null ? _u : []) featArmor.push({ value: a, source });
+    for (const w of (_v = grants.weapons) != null ? _v : []) featWeapons.push({ value: w, source });
+    for (const t of (_w = grants.tools) != null ? _w : []) featTools.push({ value: t, source });
+    for (const l of (_x = grants.languages) != null ? _x : []) featLanguages.push({ value: l, source });
+  }
+  const { features: effectFeatures, activeBuffs } = assembleEffectFeatures(resolved);
+  const fx = collectProficiencyEffectGrants(effectFeatures, activeBuffs);
+  const nameFor = (kind, slug) => {
+    var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2, _i2, _j2, _k2, _l2, _m2, _n2, _o2;
+    switch (kind) {
+      case "class":
+        return (_d2 = (_c2 = (_b2 = (_a2 = resolved.classes) == null ? void 0 : _a2.find((c) => {
+          var _a3;
+          return ((_a3 = c.entity) == null ? void 0 : _a3.slug) === slug;
+        })) == null ? void 0 : _b2.entity) == null ? void 0 : _c2.name) != null ? _d2 : UNKNOWN_SOURCE;
+      case "subclass":
+        return (_h2 = (_g2 = (_f2 = (_e2 = resolved.classes) == null ? void 0 : _e2.find((c) => {
+          var _a3;
+          return ((_a3 = c.subclass) == null ? void 0 : _a3.slug) === slug;
+        })) == null ? void 0 : _f2.subclass) == null ? void 0 : _g2.name) != null ? _h2 : UNKNOWN_SOURCE;
+      case "race":
+        return (_j2 = (_i2 = resolved.race) == null ? void 0 : _i2.name) != null ? _j2 : UNKNOWN_SOURCE;
+      case "background":
+        return (_l2 = (_k2 = resolved.background) == null ? void 0 : _k2.name) != null ? _l2 : UNKNOWN_SOURCE;
+      case "feat":
+        return (_o2 = (_n2 = (_m2 = resolved.feats) == null ? void 0 : _m2.find((f) => f.slug === slug)) == null ? void 0 : _n2.name) != null ? _o2 : UNKNOWN_SOURCE;
+      default:
+        return UNKNOWN_SOURCE;
+    }
+  };
+  const toGrants = (list, useRaw) => list.map((g) => ({ value: useRaw ? g.raw : g.value, source: nameFor(g.sourceKind, g.sourceSlug), ...g.expertise ? { expertise: true } : {} }));
+  const effectArmor = toGrants(fx.armor, true);
+  const effectWeapons = toGrants(fx.weapons, true);
+  const effectTools = toGrants(fx.tools, false);
+  const effectLanguages = toGrants(fx.languages, false);
+  return {
+    classArmor,
+    classWeaponFixed,
+    classWeaponCategories,
+    classToolFixed,
+    raceLangFixed,
+    bgToolFixed,
+    bgLangFixed,
+    featArmor,
+    featWeapons,
+    featTools,
+    featLanguages,
+    effectArmor,
+    effectWeapons,
+    effectTools,
+    effectLanguages
+  };
+}
+
+// src/pc/pc.asi-flatten.ts
+function flattenAsiOrFeat(choice) {
+  var _a;
+  if (choice.kind !== "select-inline" || choice.id !== "asi-or-feat") return choice;
+  const featBranches = choice.options.filter((o) => {
+    var _a2;
+    return ((_a2 = o.choices) != null ? _a2 : []).some((c) => c.kind === "select-entity" && c.entity_type === "feat");
+  });
+  if (featBranches.length !== 1) return choice;
+  const inner = (_a = featBranches[0].choices) != null ? _a : [];
+  if (inner.length !== 1) return choice;
+  const only = inner[0];
+  if (only.kind !== "select-entity" || only.entity_type !== "feat") return choice;
+  return only;
+}
+
+// src/pc/pc.decision-engine.ts
+var warnedDegradedEquipment = /* @__PURE__ */ new Set();
+var warnedAmbiguousBare = /* @__PURE__ */ new Set();
+function matchesFilter(e, where, ownerBare) {
+  var _a, _b, _c, _d, _e;
+  const d = e.data;
+  if (where.feature_type && d.feature_type !== where.feature_type) return false;
+  if (where.category && d.category !== where.category) return false;
+  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.weapon_category) {
+    const cat = ((_c = d.category) != null ? _c : "").toLowerCase();
+    if (!cat.startsWith(`${where.weapon_category}-`) && cat !== where.weapon_category) return false;
+  }
+  if (where.armor_category) {
+    if (((_d = d.category) != null ? _d : "").toLowerCase() !== where.armor_category) return false;
+  }
+  if (where.parent_class === "self") {
+    if (!d.parent_class || wikilinkTailSlug(d.parent_class) !== ownerBare) return false;
+  }
+  if (where.available_to === "self") {
+    const list = (_e = d.available_to) != null ? _e : [];
+    if (!list.some((l) => wikilinkTailSlug(l) === ownerBare)) return false;
+  }
+  return true;
+}
+var __matchesFilterForTest = matchesFilter;
+function categoryToEntitySelect(category, id) {
+  const c = category.toLowerCase();
+  if (c === "shield") {
+    return { kind: "select-entity", id, label: "Choose a shield", count: 1, entity_type: "armor", where: { armor_category: "shield" } };
+  }
+  if (c.includes("armor")) {
+    const klass = c.includes("light") ? "light" : c.includes("medium") ? "medium" : c.includes("heavy") ? "heavy" : null;
+    return klass ? { kind: "select-entity", id, label: `Choose ${klass} armor`, count: 1, entity_type: "armor", where: { armor_category: klass } } : { kind: "select-entity", id, label: "Choose armor", count: 1, entity_type: "armor" };
+  }
+  const wc = c.includes("martial") ? "martial" : "simple";
+  return { kind: "select-entity", id, label: `Choose a ${c.replace(/-/g, " ")}`, count: 1, entity_type: "weapon", where: { weapon_category: wc } };
+}
+function enumerateOptions(choice, ctx, ownerBare) {
+  var _a, _b;
+  switch (choice.kind) {
+    case "select-inline":
+      return choice.options.map((o) => ({ value: o.value, label: o.label, description: o.description }));
+    case "select-entity": {
+      if (choice.from) {
+        let byBare;
+        const bareIndex = () => {
+          var _a2, _b2, _c, _d;
+          if (byBare) return byBare;
+          const built = /* @__PURE__ */ new Map();
+          const pool = ctx.registry.search("", choice.entity_type, Number.POSITIVE_INFINITY).slice().sort((a, b) => a.name.localeCompare(b.name) || a.slug.localeCompare(b.slug));
+          const seed = (e) => {
+            const bare = bareEntitySlug(e.slug);
+            if (built.has(bare)) {
+              if (!warnedAmbiguousBare.has(bare)) {
+                warnedAmbiguousBare.add(bare);
+                console.warn(`Archivist: bare slug "${bare}" matches multiple ${choice.entity_type} entities; using "${built.get(bare).slug}"`);
+              }
+              return;
+            }
+            built.set(bare, e);
+          };
+          for (const e of pool) if ((_b2 = (_a2 = ctx.isEntityVisible) == null ? void 0 : _a2.call(ctx, e)) != null ? _b2 : true) seed(e);
+          for (const e of pool) if (!((_d = (_c = ctx.isEntityVisible) == null ? void 0 : _c.call(ctx, e)) != null ? _d : true)) seed(e);
+          byBare = built;
+          return built;
+        };
+        return choice.from.map((slug) => {
+          var _a2;
+          const e = (_a2 = ctx.registry.getByTypeAndSlug(choice.entity_type, slug)) != null ? _a2 : bareIndex().get(slug);
+          return e ? { value: e.slug, label: e.name, entity: e } : { value: slug, label: slug, missing: true };
+        });
+      }
+      const all = ctx.registry.search("", choice.entity_type, Number.POSITIVE_INFINITY);
+      const filtered = choice.where ? all.filter((e) => matchesFilter(e, choice.where, ownerBare)) : all;
+      return filtered.map((e) => ({ value: e.slug, label: e.name, entity: e }));
+    }
+    case "select-proficiency": {
+      const pool = (_a = choice.from) != null ? _a : choice.domain === "skill" ? [...ALL_SKILL_SLUGS] : choice.domain === "language" ? [...ALL_LANGUAGES] : choice.domain === "tool" ? [...ALL_TOOLS] : [];
+      return pool.map((v) => ({ value: v, label: humanizeProficiency(v) }));
+    }
+    case "ability-points": {
+      const pool = (_b = choice.pool) != null ? _b : ["str", "dex", "con", "int", "wis", "cha"];
+      return pool.map((a) => ({ value: a, label: a.toUpperCase() }));
+    }
+  }
+}
+function selectionCount(choice, selected) {
+  if (selected === void 0) return 0;
+  if (choice.kind === "ability-points") {
+    if (typeof selected !== "object" || Array.isArray(selected)) return 0;
+    return Object.values(selected).reduce((s, v) => s + (typeof v === "number" ? v : 0), 0);
+  }
+  if (Array.isArray(selected)) return selected.length;
+  return typeof selected === "string" && selected.length > 0 ? 1 : 0;
+}
+function requiredCount(choice) {
+  var _a;
+  if (choice.kind === "ability-points") return choice.points;
+  if (choice.kind === "select-proficiency") return choice.count;
+  return (_a = choice.count) != null ? _a : 1;
+}
+function statusOf(choice, selected, satisfied) {
+  const n = selectionCount(choice, selected);
+  const need = requiredCount(choice);
+  if (satisfied) return "resolved";
+  if (n === 0) return "unresolved";
+  return n >= need ? "resolved" : "partial";
+}
+var matchPool = (v, pool) => pool.find((p) => toProfSlug(p) === toProfSlug(v));
+var canonicalizeSelection = (value, pool) => {
+  var _a;
+  if (typeof value === "string") return (_a = matchPool(value, pool)) != null ? _a : value;
+  if (Array.isArray(value)) return value.map((v) => {
+    var _a2;
+    return (_a2 = matchPool(v, pool)) != null ? _a2 : v;
+  });
+  return value;
+};
+function resolveEntityRef(ctx, entityType, value) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  const raw = value.replace(/^\[\[/, "").replace(/\]\]$/, "");
+  const direct = ctx.registry.getByTypeAndSlug(entityType, raw);
+  if (direct) return direct;
+  for (const e of ctx.registry.search("", entityType, Number.POSITIVE_INFINITY)) {
+    if (e.slug === raw || bareEntitySlug(e.slug) === raw) return e;
+  }
+  return void 0;
+}
+function buildItem(inputChoice, source, level, featureName, readValue, ctx, ownerBare, effective, opts) {
+  var _a, _b, _c, _d;
+  const choice = flattenAsiOrFeat(inputChoice);
+  const keyPrefix = (_a = opts == null ? void 0 : opts.keyPrefix) != null ? _a : "";
+  const expandFeatChildren = (_b = opts == null ? void 0 : opts.expandFeatChildren) != null ? _b : true;
+  const key = keyPrefix + choice.id;
+  const raw = readValue(key);
+  const preExclusionOptions = enumerateOptions(choice, ctx, ownerBare);
+  let options = preExclusionOptions;
+  const mine = new Set(
+    (Array.isArray(raw) ? raw : raw === void 0 ? [] : [raw]).map((v) => toProfSlug(String(v)))
+  );
+  if (choice.kind === "select-proficiency" && choice.domain === "skill" && choice.from_proficient) {
+    options = options.filter((o) => effective.skill.has(toProfSlug(o.value)) || mine.has(toProfSlug(o.value)));
+  }
+  const postInclusionOptions = options;
+  const excludes = choice.kind === "select-proficiency" && (choice.domain === "language" || choice.domain === "tool" || choice.domain === "skill" && choice.expertise === true);
+  if (excludes && choice.kind === "select-proficiency") {
+    const known = choice.domain === "skill" ? effective.skillExpertise : effective[choice.domain];
+    options = options.filter((o) => !known.has(toProfSlug(o.value)) || mine.has(toProfSlug(o.value)));
+  }
+  const satisfied = excludes && postInclusionOptions.length > 0 && options.length === 0;
+  const selected = choice.kind === "select-proficiency" ? canonicalizeSelection(raw, options.map((o) => o.value)) : raw;
+  const item = {
+    key,
+    source,
+    level,
+    featureName,
+    choice,
+    description: opts == null ? void 0 : opts.description,
+    options,
+    selected,
+    status: statusOf(choice, selected, satisfied),
+    satisfied
+  };
+  if (choice.kind === "select-inline" && typeof selected === "string") {
+    const branch = choice.options.find((o) => o.value === selected);
+    if ((_c = branch == null ? void 0 : branch.choices) == null ? void 0 : _c.length) {
+      item.children = branch.choices.map((c) => buildItem(
+        c,
+        source,
+        level,
+        featureName,
+        readValue,
+        ctx,
+        ownerBare,
+        effective,
+        { keyPrefix, expandFeatChildren }
+      ));
+      if (item.status === "resolved" && item.children.some((c) => c.status !== "resolved")) {
+        item.status = "partial";
+      }
+    }
+  }
+  if (choice.kind === "select-entity" && choice.entity_type === "feat" && expandFeatChildren && typeof selected === "string") {
+    const entity = resolveEntityRef(ctx, "feat", selected);
+    const rawChoices = (_d = entity == null ? void 0 : entity.data) == null ? void 0 : _d.choices;
+    const featChoices = Array.isArray(rawChoices) ? rawChoices : [];
+    if (featChoices.length) {
+      const childPrefix = `${keyPrefix}feat:`;
+      item.children = featChoices.map((c) => buildItem(
+        c,
+        source,
+        level,
+        featureName,
+        readValue,
+        ctx,
+        ownerBare,
+        effective,
+        { keyPrefix: childPrefix, expandFeatChildren: false }
+      ));
+      if (item.status === "resolved" && item.children.some((c) => c.status !== "resolved")) {
+        item.status = "partial";
+      }
+    }
+  }
+  return item;
+}
+function buildSubclassItem(choice, source, level, featureName, c, ctx, ownerBare, description) {
+  const selected = c.subclass ? c.subclass.slug : void 0;
+  return {
+    key: "subclass",
+    source,
+    level,
+    featureName,
+    description,
+    choice,
+    options: enumerateOptions(choice, ctx, ownerBare),
+    selected,
+    status: selected ? "resolved" : "unresolved",
+    // A subclass pick is a select-entity, never a proficiency choice, so no
+    // exclusion can empty its pool.
+    satisfied: false
+  };
+}
+function visitProficiencyChoices(resolved, visit) {
+  var _a, _b, _c;
+  const walk = (choices, read) => {
+    for (const ch of choices != null ? choices : []) {
+      visit(ch, read(ch.id));
+      if (ch.kind === "select-inline") {
+        const sel = read(ch.id);
+        const branch = typeof sel === "string" ? ch.options.find((o) => o.value === sel) : void 0;
+        if (branch == null ? void 0 : branch.choices) walk(branch.choices, read);
+      }
+    }
+  };
+  const oc = (_a = resolved.definition.origin_choices) != null ? _a : {};
+  const originRead = (ns) => (id) => oc[`${ns}:${id}`];
+  const stripRef = (ref) => ref.replace(/^\[\[/, "").replace(/\]\]$/, "");
+  const featBySlug = new Map(((_b = resolved.feats) != null ? _b : []).map((f) => [f.slug, f]));
+  resolved.classes.forEach((c, i) => {
+    var _a2, _b2, _c2, _d;
+    if (!c.entity) return;
+    const entity = c.entity;
+    const readAt = (lvl) => (id) => {
+      var _a3;
+      return (_a3 = c.choices[lvl]) == null ? void 0 : _a3[id];
+    };
+    if (i === 0 && ((_b2 = (_a2 = entity.skill_choices) == null ? void 0 : _a2.from) == null ? void 0 : _b2.length)) {
+      visit({
+        kind: "select-proficiency",
+        id: "skills",
+        count: entity.skill_choices.count,
+        domain: "skill",
+        from: entity.skill_choices.from
+      }, readAt(1)("skills"));
+    }
+    if (i === 0) walk(entity.choices, readAt(1));
+    for (const rf of resolved.features) {
+      if (rf.source.kind !== "class" && rf.source.kind !== "subclass") continue;
+      const belongs = rf.source.kind === "class" ? rf.source.slug === entity.slug : c.subclass != null && rf.source.slug === c.subclass.slug;
+      if (!belongs) continue;
+      for (const copy of (_c2 = rf.foldedFrom) != null ? _c2 : []) walk(copy.choices, readAt(copy.level));
+      walk(rf.feature.choices, readAt(rf.source.level));
+    }
+    for (const atLevel of Object.values((_d = c.choices) != null ? _d : {})) {
+      const block = atLevel;
+      const featRef = block == null ? void 0 : block.feat;
+      if (!block || typeof featRef !== "string") continue;
+      const feat = featBySlug.get(stripRef(featRef));
+      if (!feat) continue;
+      walk(feat.choices, (id) => block[`feat:${id}`]);
+    }
+  });
+  if (resolved.race) {
+    walk(resolved.race.choices, originRead("race"));
+    for (const t of (_c = resolved.race.traits) != null ? _c : []) walk(t.choices, originRead("race"));
+  }
+  if (resolved.background) {
+    walk(resolved.background.choices, originRead("background"));
+    if (resolved.background.feature) {
+      const feature = resolved.background.feature;
+      walk(feature.choices, originRead("background"));
+    }
+  }
+  if (resolved.originFeatSlug) {
+    const of = featBySlug.get(resolved.originFeatSlug);
+    if (of) walk(of.choices, (id) => oc[`background:feat:${id}`]);
+  }
+}
+var filterToPool = (vals, pool) => pool ? vals.map((v) => matchPool(v, pool)).filter((v) => !!v) : vals;
+function collectChosenProficiencies(resolved) {
+  const out = { skills: [], expertise: [], languages: [], tools: [], weapons: [], saves: [] };
+  const isAbility = (v) => ABILITY_KEYS.includes(v);
+  visitProficiencyChoices(resolved, (choice, selected) => {
+    const vals = Array.isArray(selected) ? selected : typeof selected === "string" ? [selected] : [];
+    if (choice.kind === "select-entity" && choice.entity_type === "weapon") {
+      if (choice.id === "weapon-mastery") return;
+      for (const v of vals) {
+        const bare = bareEntitySlug(String(v));
+        if (bare && !out.weapons.includes(bare)) out.weapons.push(bare);
+      }
+      return;
+    }
+    if (choice.kind !== "select-proficiency") return;
+    const valid = filterToPool(vals, choice.from);
+    if (choice.domain === "save") {
+      for (const v of valid) if (isAbility(v) && !out.saves.includes(v)) out.saves.push(v);
+      return;
+    }
+    const bucket = choice.domain === "skill" ? choice.expertise ? out.expertise : out.skills : choice.domain === "language" ? out.languages : choice.domain === "tool" ? out.tools : null;
+    if (bucket) {
+      for (const v of valid) if (!bucket.includes(v)) bucket.push(v);
+    }
+  });
+  return out;
+}
+function proficiencyEntryFor(raw, vocab, origin, sources, expertise) {
+  const hit = matchPool(raw, vocab);
+  const value = hit ? toProfSlug(hit) : raw;
+  const label = hit ? humanizeProficiency(value) : origin === "custom" ? raw : proficiencyLabel(raw);
+  return { value, label, sources, origin, ...expertise ? { expertise: true } : {} };
+}
+function computeEffectiveProficiencies(resolved) {
+  const grants = collectProficiencyGrants(resolved);
+  const chosen = collectChosenProficiencies(resolved);
+  const build = (domain) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const vocab = domain === "languages" ? ALL_LANGUAGES : ALL_TOOLS;
+    const ov = (_b = (_a = resolved.definition) == null ? void 0 : _a.overrides) == null ? void 0 : _b[domain];
+    const adds = (_c = ov == null ? void 0 : ov.add) != null ? _c : [];
+    const removes = (_d = ov == null ? void 0 : ov.remove) != null ? _d : [];
+    const byValue = /* @__PURE__ */ new Map();
+    const push = (raw, origin, source, expertise) => {
+      const probe = proficiencyEntryFor(raw, vocab, origin, source ? [source] : [], expertise);
+      const existing = byValue.get(probe.value);
+      if (!existing) {
+        byValue.set(probe.value, probe);
+        return;
+      }
+      if (source && !existing.sources.includes(source)) existing.sources.push(source);
+      if (expertise) existing.expertise = true;
+      const rank = { grant: 0, pick: 1, manual: 2, custom: 3 };
+      if (rank[origin] < rank[existing.origin]) existing.origin = origin;
+    };
+    const grantBuckets = domain === "languages" ? [grants.raceLangFixed, grants.bgLangFixed, grants.featLanguages, grants.effectLanguages] : [grants.classToolFixed, grants.bgToolFixed, grants.featTools, grants.effectTools];
+    for (const b of grantBuckets) for (const g of b) push(g.value, "grant", g.source, g.expertise);
+    for (const v of domain === "languages" ? chosen.languages : chosen.tools) push(v, "pick");
+    for (const v of adds) push(v, matchPool(v, vocab) ? "manual" : "custom");
+    const triSuppressed = /* @__PURE__ */ new Set();
+    if (domain === "tools") {
+      const tri = (_h = (_g = (_f = (_e = resolved.definition) == null ? void 0 : _e.overrides) == null ? void 0 : _f.tools) == null ? void 0 : _g.proficiency) != null ? _h : {};
+      for (const [tool, state] of Object.entries(tri)) {
+        const key = toProfSlug(tool);
+        if (state === "none") {
+          triSuppressed.add(key);
+          continue;
+        }
+        let entry = [...byValue.values()].find((e) => toProfSlug(e.value) === key);
+        if (!entry) {
+          push(tool, matchPool(tool, vocab) ? "manual" : "custom");
+          entry = [...byValue.values()].find((e) => toProfSlug(e.value) === key);
+        }
+        if (!entry) continue;
+        if (state === "expertise") entry.expertise = true;
+        else delete entry.expertise;
+      }
+    }
+    const suppressed = /* @__PURE__ */ new Set([...removes.map((r) => toProfSlug(r)), ...triSuppressed]);
+    return [...byValue.values()].filter((e) => !suppressed.has(toProfSlug(e.value))).sort((a, b) => a.label < b.label ? -1 : a.label > b.label ? 1 : 0);
+  };
+  return { languages: build("languages"), tools: build("tools") };
+}
+function collectChosenAbilityPoints(resolved) {
+  var _a, _b, _c;
+  const oc = (_a = resolved.definition.origin_choices) != null ? _a : {};
+  const out = { race: {}, background: {} };
+  const fold = (ns, choices) => {
+    var _a2;
+    for (const ch of choices != null ? choices : []) {
+      if (ch.kind !== "ability-points") continue;
+      const raw = oc[`${ns}:${ch.id}`];
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+      let left = ch.points;
+      for (const ab of ABILITY_KEYS) {
+        if (ch.pool && !ch.pool.includes(ab)) continue;
+        const v = raw[ab];
+        if (typeof v !== "number" || v <= 0 || left <= 0) continue;
+        const take = Math.min(v, ch.max_per, left);
+        out[ns][ab] = ((_a2 = out[ns][ab]) != null ? _a2 : 0) + take;
+        left -= take;
+      }
+    }
+  };
+  const race = resolved.race;
+  if (race) {
+    fold("race", race.choices);
+    for (const t of (_b = race.traits) != null ? _b : []) fold("race", t.choices);
+  }
+  const bg = resolved.background;
+  if (bg) {
+    fold("background", bg.choices);
+    fold("background", (_c = bg.feature) == null ? void 0 : _c.choices);
+  }
+  return out;
+}
+function buildDecisionLedger(resolved, ctx) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const eff = computeEffectiveProficiencies(resolved);
+  const chosen = collectChosenProficiencies(resolved);
+  const { features, activeBuffs } = assembleEffectFeatures(resolved);
+  const effectGrants = collectProficiencyEffectGrants(features, activeBuffs);
+  const effective = {
+    language: new Set(eff.languages.map((e) => toProfSlug(e.value))),
+    tool: new Set(eff.tools.map((e) => toProfSlug(e.value))),
+    // Same precedent as computeEffectiveProficiencies' `resolved.definition?.overrides?.[domain]`: the
+    // type says `skills` is non-optional, but consumers build ResolvedCharacter by cast and `tests/` is
+    // typechecked by nothing (the plugin's equipment-step fixtures pass a `definition` with no `skills`).
+    skill: new Set([
+      ...(_c = (_b = (_a = resolved.definition) == null ? void 0 : _a.skills) == null ? void 0 : _b.proficient) != null ? _c : [],
+      ...(_e = (_d = resolved.background) == null ? void 0 : _d.skill_proficiencies) != null ? _e : [],
+      ...chosen.skills,
+      ...effectGrants.skills.map((g) => g.value)
+    ].map(toProfSlug)),
+    skillExpertise: new Set([
+      ...(_h = (_g = (_f = resolved.definition) == null ? void 0 : _f.skills) == null ? void 0 : _g.expertise) != null ? _h : [],
+      ...chosen.expertise,
+      ...effectGrants.skills.filter((g) => g.expertise).map((g) => g.value)
+    ].map(toProfSlug))
+  };
+  const classes = [];
+  resolved.classes.forEach((c, classIndex) => {
+    var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2, _i2, _j2, _k2, _l2, _m2, _n, _o, _p;
+    if (!c.entity) return;
+    const entity = c.entity;
+    const ownerBare = bareEntitySlug(entity.slug);
+    const byLevel = /* @__PURE__ */ new Map();
+    const push = (lvl, item) => {
+      var _a3;
+      const arr = (_a3 = byLevel.get(lvl)) != null ? _a3 : [];
+      arr.push(item);
+      byLevel.set(lvl, arr);
+    };
+    const readAt = (lvl) => (id) => {
+      var _a3;
+      return (_a3 = c.choices[lvl]) == null ? void 0 : _a3[id];
+    };
+    const featProgressions = [...(_a2 = entity.feat_progression) != null ? _a2 : [], ...(_c2 = (_b2 = c.subclass) == null ? void 0 : _b2.feat_progression) != null ? _c2 : []];
+    const suppressedFeatureTypes = /* @__PURE__ */ new Set();
+    for (const decl of [...(_d2 = entity.selection_pools) != null ? _d2 : [], ...(_f2 = (_e2 = c.subclass) == null ? void 0 : _e2.selection_pools) != null ? _f2 : []]) {
+      const rp = resolved.pools.find((p) => p.classIndex === classIndex && p.id === decl.id);
+      if (rp && rp.count >= 1) suppressedFeatureTypes.add(decl.source.where.feature_type);
+    }
+    for (const entry of featProgressions) {
+      const category = featProgressionCategory(entry.category);
+      const ft = category ? FEATURE_TYPE_FOR_CATEGORY[category] : void 0;
+      if (ft) suppressedFeatureTypes.add(ft);
+    }
+    if (classIndex === 0 && ((_h2 = (_g2 = entity.skill_choices) == null ? void 0 : _g2.from) == null ? void 0 : _h2.length)) {
+      const skillChoice = {
+        kind: "select-proficiency",
+        id: "skills",
+        label: "Skill Proficiencies",
+        count: entity.skill_choices.count,
+        domain: "skill",
+        from: entity.skill_choices.from
+      };
+      push(1, buildItem(
+        skillChoice,
+        { kind: "class", slug: entity.slug, level: 1 },
+        1,
+        "Proficiencies",
+        readAt(1),
+        ctx,
+        ownerBare,
+        effective
+      ));
+    }
+    if (classIndex === 0) {
+      for (const ch of (_i2 = entity.choices) != null ? _i2 : []) {
+        push(1, buildItem(
+          ch,
+          { kind: "class", slug: entity.slug, level: 1 },
+          1,
+          "Proficiencies",
+          readAt(1),
+          ctx,
+          ownerBare,
+          effective
+        ));
+      }
+    }
+    if (classIndex === 0) {
+      ((_j2 = entity.starting_equipment) != null ? _j2 : []).forEach((eq, i) => {
+        var _a3;
+        if (eq.kind !== "choice") return;
+        const options = (_a3 = eq.options) != null ? _a3 : [];
+        let degraded = false;
+        const ch = {
+          kind: "select-inline",
+          id: `equipment-${i}`,
+          label: "Starting Equipment",
+          count: 1,
+          options: options.map((opt, j) => {
+            var _a4;
+            const label = typeof opt === "string" ? opt : (_a4 = opt == null ? void 0 : opt.label) != null ? _a4 : "";
+            const grants = opt && typeof opt === "object" && Array.isArray(opt.grants) ? opt.grants : [];
+            if (typeof opt === "string" || !(opt && typeof opt === "object" && Array.isArray(opt.grants))) {
+              degraded = true;
+            }
+            return {
+              value: `option-${j}`,
+              label,
+              choices: grants.flatMap((g, k) => g && typeof g === "object" && "category" in g && g.category ? [categoryToEntitySelect(g.category, `equipment-${i}-opt-${j}-cat-${k}`)] : [])
+            };
+          })
+        };
+        if (degraded && !warnedDegradedEquipment.has(entity.slug)) {
+          warnedDegradedEquipment.add(entity.slug);
+          console.warn(
+            `[archivist] Starting equipment for "${entity.slug}" is in an outdated/unstructured format; its nested picks and seeding are skipped. Re-sync the compendium (delete _compendium.md and reload) to fix.`
+          );
+        }
+        push(1, buildItem(
+          ch,
+          { kind: "class", slug: entity.slug, level: 1 },
+          1,
+          "Starting Equipment",
+          readAt(1),
+          ctx,
+          ownerBare,
+          effective
+        ));
+      });
+    }
+    let sawAuthoredSubclass = false;
+    const staged = [];
+    const authoredRank = (kind, level, feature) => {
+      var _a3, _b3, _c3;
+      const at = (_c3 = (_b3 = (_a3 = kind === "class" ? entity : c.subclass) == null ? void 0 : _a3.features_by_level) == null ? void 0 : _b3[level]) != null ? _c3 : [];
+      const index = at.findIndex((f) => feature.id ? f.id === feature.id : f.name === feature.name);
+      return (kind === "class" ? 0 : 1) * 1e6 + (index < 0 ? 999999 : index);
+    };
+    for (const rf of resolved.features) {
+      const src = rf.source;
+      if (src.kind !== "class" && src.kind !== "subclass") continue;
+      const belongs = src.kind === "class" ? src.slug === entity.slug : c.subclass != null && src.slug === c.subclass.slug;
+      if (!belongs) continue;
+      const lvl = src.level;
+      const stage = (atLvl, item) => {
+        staged.push({ level: atLvl, item, rank: authoredRank(src.kind, atLvl, rf.feature), seq: staged.length });
+      };
+      const emitChoices = (list, atLvl, name, description) => {
+        var _a3;
+        for (const ch of list) {
+          if (ch.kind === "select-entity" && ch.entity_type === "subclass") {
+            sawAuthoredSubclass = true;
+            stage(atLvl, buildSubclassItem(ch, src, atLvl, name, c, ctx, ownerBare, description));
+            continue;
+          }
+          let emitted = ch;
+          if (ch.kind === "select-entity") {
+            const columns = countColumnsFor(ch.id);
+            const fromTable = columns ? readTableColumn(entity.table, c.level, columns) : null;
+            if (fromTable != null) emitted = { ...ch, count: Math.max((_a3 = ch.count) != null ? _a3 : 1, fromTable) };
+          }
+          stage(atLvl, buildItem(
+            emitted,
+            src,
+            atLvl,
+            name,
+            readAt(atLvl),
+            ctx,
+            ownerBare,
+            effective,
+            { description }
+          ));
+        }
+      };
+      const informationalItem = (atLvl, name, description) => {
+        var _a3, _b3;
+        return {
+          key: (_a3 = rf.feature.id) != null ? _a3 : name,
+          source: src,
+          level: atLvl,
+          featureName: name,
+          description,
+          choice: { kind: "select-inline", id: (_b3 = rf.feature.id) != null ? _b3 : name, options: [{ value: "_", label: "_" }] },
+          options: [],
+          selected: void 0,
+          status: "informational",
+          satisfied: false
+        };
+      };
+      const emitCopy = (copy) => {
+        let list = copy.choices;
+        if (!(list == null ? void 0 : list.length)) {
+          const recognized = recognizeDecision({ id: rf.feature.id, name: copy.name, description: copy.description });
+          if (recognized === "informational") {
+            stage(copy.level, informationalItem(copy.level, copy.name, copy.prose));
+            return;
+          }
+          list = recognized != null ? recognized : void 0;
+          if (list == null ? void 0 : list.length) {
+            list = list.filter((ch) => {
+              var _a3;
+              if (ch.kind !== "select-entity") return true;
+              const ft = (_a3 = ch.where) == null ? void 0 : _a3.feature_type;
+              return !(ft !== void 0 && suppressedFeatureTypes.has(ft));
+            });
+          }
+        }
+        if (!(list == null ? void 0 : list.length)) {
+          if (copy.prose) stage(copy.level, informationalItem(copy.level, copy.name, copy.prose));
+          return;
+        }
+        emitChoices(list, copy.level, copy.name, copy.description);
+      };
+      for (const copy of (_k2 = rf.foldedFrom) != null ? _k2 : []) emitCopy({ ...copy, prose: copy.description });
+      emitCopy({
+        level: lvl,
+        name: rf.feature.name,
+        description: rf.feature.description,
+        // The card prose: the description, else the entries joined. `||`, not `??`, so an EMPTY description
+        // falls through to the entries the way this branch's own guard always did.
+        prose: rf.feature.description || (((_l2 = rf.feature.entries) == null ? void 0 : _l2.length) ? rf.feature.entries.join("\n\n") : void 0),
+        choices: rf.feature.choices
+      });
+    }
+    staged.sort((a, b) => a.rank - b.rank || a.seq - b.seq);
+    for (const s of staged) push(s.level, s.item);
+    const subclassLevel = (_m2 = entity.subclass_level) != null ? _m2 : null;
+    if (subclassLevel != null && subclassLevel <= c.level && !sawAuthoredSubclass) {
+      const featureName = (_n = entity.subclass_feature_name) != null ? _n : "Subclass";
+      const synthChoice = {
+        kind: "select-entity",
+        id: "subclass",
+        label: featureName,
+        count: 1,
+        entity_type: "subclass",
+        where: { parent_class: "self" }
+      };
+      push(subclassLevel, buildSubclassItem(
+        synthChoice,
+        { kind: "class", slug: entity.slug, level: subclassLevel },
+        subclassLevel,
+        featureName,
+        c,
+        ctx,
+        ownerBare
+      ));
+    }
+    for (const pool of resolved.pools) {
+      if (pool.classIndex !== classIndex || pool.count < 1) continue;
+      const stranded = strandedPicks(pool);
+      const strandedSlugs = new Set(stranded.map((e) => e.slug));
+      const synth = {
+        kind: "select-entity",
+        id: pool.id,
+        label: pool.label,
+        count: pool.count,
+        entity_type: "optional-feature",
+        from: [...pool.available.map((e) => e.slug), ...stranded.map((e) => e.slug)]
+      };
+      const item = buildItem(
+        synth,
+        { kind: "class", slug: entity.slug, level: pool.anchorLevel },
+        pool.anchorLevel,
+        pool.label,
+        () => pool.selected.map((e) => e.slug),
+        ctx,
+        ownerBare,
+        effective
+      );
+      item.pool = { id: pool.id, anchorLevel: pool.anchorLevel };
+      for (const o of item.options) if (strandedSlugs.has(o.value)) o.stranded = true;
+      push(pool.anchorLevel, item);
+    }
+    for (const entry of featProgressions) {
+      const category = featProgressionCategory(entry.category);
+      if (!category) {
+        warnOnce(
+          `feat-progression-category:${entity.slug}:${entry.name}`,
+          `Archivist: feat_progression "${entry.name}" on "${entity.slug}" carries no category this engine maps (${((_o = entry.category) != null ? _o : []).join(", ")}); no decision is offered`
+        );
+        continue;
+      }
+      const progression = entry.progression;
+      if (Array.isArray(progression)) continue;
+      for (const key of Object.keys(progression)) {
+        const lvl = Number.parseInt(key, 10);
+        if (!Number.isInteger(lvl) || String(lvl) !== key) continue;
+        if (lvl > c.level) continue;
+        if (((_p = byLevel.get(lvl)) != null ? _p : []).some((i) => i.key === "feat")) {
+          warnOnce(
+            `feat-progression-collision:${entity.slug}:${lvl}`,
+            `Archivist: "${entry.name}" on "${entity.slug}" would add a second feat pick at level ${lvl}, where one already exists; skipping`
+          );
+          continue;
+        }
+        const progressionChoice = {
+          kind: "select-entity",
+          id: "feat",
+          label: entry.name,
+          count: 1,
+          entity_type: "feat",
+          where: { category }
+        };
+        push(lvl, buildItem(
+          progressionChoice,
+          { kind: "class", slug: entity.slug, level: lvl },
+          lvl,
+          entry.name,
+          readAt(lvl),
+          ctx,
+          ownerBare,
+          effective
+        ));
+      }
+    }
+    const levels = [...byLevel.entries()].sort(([a], [b]) => a - b).map(([level, items]) => ({ level, items }));
+    classes.push({ classIndex, levels });
+  });
+  const origin = [];
+  const oc = (_i = resolved.definition.origin_choices) != null ? _i : {};
+  const originRead = (ns) => (id) => oc[`${ns}:${id}`];
+  const pushOrigin = (choices, ns, source, featureName, ownerBare, description) => {
+    for (const ch of choices != null ? choices : []) {
+      origin.push(buildItem(
+        ch,
+        source,
+        0,
+        featureName,
+        originRead(ns),
+        ctx,
+        ownerBare,
+        effective,
+        { description }
+      ));
+    }
+  };
+  if (resolved.race) {
+    const bare = bareEntitySlug(resolved.race.slug);
+    pushOrigin(
+      resolved.race.choices,
+      "race",
+      { kind: "race", slug: resolved.race.slug },
+      (_j = resolved.race.name) != null ? _j : "Race",
+      bare,
+      resolved.race.description
+    );
+    for (const t of (_k = resolved.race.traits) != null ? _k : []) {
+      pushOrigin(
+        t.choices,
+        "race",
+        { kind: "race", slug: resolved.race.slug },
+        t.name,
+        bare,
+        t.description
+      );
+    }
+  }
+  if (resolved.background) {
+    const bare = bareEntitySlug(resolved.background.slug);
+    pushOrigin(
+      resolved.background.choices,
+      "background",
+      { kind: "background", slug: resolved.background.slug },
+      (_l = resolved.background.name) != null ? _l : "Background",
+      bare,
+      resolved.background.description
+    );
+    if (resolved.background.feature) {
+      pushOrigin(
+        resolved.background.feature.choices,
+        "background",
+        { kind: "background", slug: resolved.background.slug },
+        resolved.background.feature.name,
+        bare,
+        resolved.background.feature.description
+      );
+    }
+    if (resolved.background.origin_feat) {
+      const originFeat = resolveOriginFeat(
+        ctx.registry,
+        resolved.background.origin_feat,
+        resolved.background.slug
+      );
+      if (originFeat) {
+        const featSource = { kind: "feat", slug: originFeat.feat.slug };
+        const featBare = bareEntitySlug(originFeat.feat.slug);
+        for (const ch of (_m = originFeat.feat.choices) != null ? _m : []) {
+          origin.push(buildItem(
+            ch,
+            featSource,
+            0,
+            originFeat.display,
+            originRead("background"),
+            ctx,
+            featBare,
+            effective,
+            { keyPrefix: "feat:" }
+          ));
+        }
+      }
+    }
+  }
+  return { classes, origin };
+}
+
+// src/pc/pc.resolver.ts
+var SLUG_RE = /^\[\[(.+?)\]\]$/;
+function stripSlug(ref) {
+  if (!ref) return null;
+  const m = ref.match(SLUG_RE);
+  return m ? m[1] : ref;
+}
+function resolveOriginFeat(entities, originFeatRef, ownerSlug) {
+  var _a, _b, _c;
+  if (!originFeatRef) return null;
+  const slug = wikilinkTailSlug(originFeatRef);
+  const inner = originFeatRef.replace(/^\[\[/, "").replace(/\]\]$/, "").trim();
+  const rawTail = (_b = (_a = inner.split("/").pop()) == null ? void 0 : _a.trim()) != null ? _b : "";
+  const base = rawTail.replace(/\s*\([^()]*\)\s*$/, "").trim();
+  const baseSlug = base && base !== rawTail ? wikilinkTailSlug(`[[${base}]]`) : null;
+  const baseInner = baseSlug ? inner.slice(0, inner.length - rawTail.length) + base : null;
+  const prefix = (ownerSlug == null ? void 0 : ownerSlug.includes("_")) ? ownerSlug.slice(0, ownerSlug.indexOf("_")) : null;
+  const feats = entities.search("", "feat", Number.POSITIVE_INFINITY);
+  const byPath = (p) => feats.find((f) => f.filePath === `${p}.md` || f.filePath.endsWith(`/${p}.md`));
+  const sameCompendiumTail = (s) => prefix ? feats.find((f) => f.slug.startsWith(`${prefix}_feat_`) && f.slug.endsWith(`_${s}`)) : void 0;
+  const anyTail = (s) => feats.find((f) => f.slug.endsWith(`_${s}`));
+  const tiers = [
+    () => feats.find((f) => f.slug === slug),
+    // 1 exact slug
+    () => byPath(inner),
+    // 2 PATH
+    () => baseInner ? byPath(baseInner) : void 0,
+    // 3 PATH, parenthetical stripped
+    () => sameCompendiumTail(slug),
+    // 4 same-compendium tail
+    () => baseSlug ? sameCompendiumTail(baseSlug) : void 0,
+    // 5 same-compendium tail, stripped
+    () => anyTail(slug),
+    // 6 any tail
+    () => baseSlug ? anyTail(baseSlug) : void 0
+    // 7 any tail, stripped
+  ];
+  let reg;
+  let hitTier = 0;
+  for (let i = 0; i < tiers.length && !reg; i++) {
+    reg = tiers[i]();
+    hitTier = i + 1;
+  }
+  if (!reg) return null;
+  const variantName = baseSlug && (hitTier === 3 || hitTier === 5 || hitTier === 7) ? rawTail : void 0;
+  const data = reg.data;
+  const feat = data.slug == null ? { ...data, slug: reg.slug } : data;
+  return { feat, display: (_c = variantName != null ? variantName : feat.name) != null ? _c : slug };
+}
+var PCResolver = class {
+  constructor(entities) {
+    this.entities = entities;
+  }
+  /** Exposed so recalc() can apply equipment bonuses (Pass A / Pass B). */
+  get registry() {
+    return this.entities;
+  }
+  resolve(character) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    const warnings = [];
+    const lookup = (rawRef, type) => {
+      const slug = stripSlug(rawRef);
+      if (!slug) return null;
+      const reg = this.entities.getByTypeAndSlug(type, slug);
+      if (!reg) {
+        warnings.push(`Slug [[${slug}]] not found in compendium as ${type}.`);
+        return null;
+      }
+      const data = reg.data;
+      return data.slug == null ? { ...data, slug: reg.slug } : data;
+    };
+    const race = lookup(character.race, "race");
+    const background = lookup(character.background, "background");
+    const classes = character.class.map((c) => ({
+      entity: lookup(c.name, "class"),
+      level: c.level,
+      subclass: lookup(c.subclass, "subclass"),
+      choices: c.choices
+    }));
+    const feats = [];
+    const featVia = /* @__PURE__ */ new Map();
+    for (const pick of collectFeatPicks(character)) {
+      const f = lookup(`[[${pick.slug}]]`, "feat");
+      if (!f) continue;
+      feats.push(f);
+      const classSlug = (_e = (_b = (_a = classes[pick.classIndex]) == null ? void 0 : _a.entity) == null ? void 0 : _b.slug) != null ? _e : stripSlug((_d = (_c = character.class[pick.classIndex]) == null ? void 0 : _c.name) != null ? _d : null);
+      if (classSlug && pick.level !== null && !featVia.has(f.slug)) featVia.set(f.slug, { kind: "class", slug: classSlug, level: pick.level });
+    }
+    const originFeat = (background == null ? void 0 : background.origin_feat) ? resolveOriginFeat(this.entities, background.origin_feat, background.slug) : null;
+    const originFeatSlug = originFeat == null ? void 0 : originFeat.feat.slug;
+    if (originFeat && !feats.some((f) => f.slug === originFeat.feat.slug)) {
+      feats.push(originFeat.feat);
+    }
+    if (originFeat && background && !featVia.has(originFeat.feat.slug)) {
+      featVia.set(originFeat.feat.slug, { kind: "background", slug: background.slug });
+    }
+    const totalLevel = classes.reduce((sum, c) => sum + c.level, 0);
+    const features = collectResolvedFeatures(race, classes, background, feats, featVia);
+    const extraFeatures = collectChosenGrantedFeatures(character, classes, this.entities, race, background);
+    features.push(...extraFeatures);
+    const casters = [];
+    classes.forEach((c, i) => {
+      const profile = c.entity ? resolveSpellcasting(c) : null;
+      const classSlug = profile ? stripSlug(character.class[i].name) : null;
+      if (profile && classSlug != null) casters.push({ classSlug, spellList: profile.spellList });
+    });
+    const spells = [];
+    for (const raw of (_f = character.spells.known) != null ? _f : []) {
+      const n = normalizeKnownSpell(raw);
+      const reg = this.entities.getByTypeAndSlug("spell", n.slug);
+      if (!reg) {
+        warnings.push(`Spell [[${n.slug}]] not found in compendium.`);
+        continue;
+      }
+      const entity = mirrorSpellShapes(reg.data);
+      const isCantrip = ((_g = entity.level) != null ? _g : 0) === 0;
+      const classSlug = (_h = n.classSlug) != null ? _h : attributeUnclassedSpell(entity.classes, casters, this.entities);
+      const prep = isCantrip || n.alwaysPrepared ? true : (_i = n.preparedFlag) != null ? _i : false;
+      spells.push({ entity, slug: n.slug, classSlug, source: n.source, prepared: prep, alwaysPrepared: n.alwaysPrepared, persisted: true });
+    }
+    const oc = (_j = character.origin_choices) != null ? _j : {};
+    if (originFeat) {
+      const read = (childId) => oc[`background:feat:${childId}`];
+      spells.push(...collectFeatGrantedSpells(originFeat.feat, read, this.entities, warnings));
+    }
+    for (const entry of character.class) {
+      for (const atLevel of Object.values((_k = entry.choices) != null ? _k : {})) {
+        const featRef = atLevel.feat;
+        if (typeof featRef !== "string") continue;
+        const slug = stripSlug(featRef);
+        if (!slug) continue;
+        const reg = this.entities.getByTypeAndSlug("feat", slug);
+        if (!reg) continue;
+        const feat = reg.data;
+        const read = (childId) => atLevel[`feat:${childId}`];
+        spells.push(...collectFeatGrantedSpells(feat, read, this.entities, warnings));
+      }
+    }
+    const ownSpellcastingAbility = (_l = classes.map((c) => {
+      if (!c.entity) return null;
+      const p = resolveSpellcasting(c);
+      return p ? effectiveSpellcastingAbility(c.entity.slug, p.ability, character.overrides) : null;
+    }).find((a) => a != null)) != null ? _l : null;
+    spells.push(...collectItemGrantedSpells(character, ownSpellcastingAbility, this.entities, warnings));
+    spells.push(...collectAdditionalSpells({
+      race,
+      feats,
+      classes,
+      totalLevel,
+      ownAbility: ownSpellcastingAbility,
+      alreadyCollected: spells,
+      entities: this.entities,
+      warnings
+    }));
+    const chosenMasteries = collectChosenWeaponMasteries(character);
+    if (chosenMasteries.full.length > 0) {
+      const target = features.find(
+        (rf) => {
+          var _a2;
+          return rf.feature.id === "weapon-mastery" || ((_a2 = rf.feature.choices) == null ? void 0 : _a2.some(
+            (ch) => ch.kind === "select-entity" && ch.id === "weapon-mastery" && ch.entity_type === "weapon"
+          ));
+        }
+      );
+      if (target) {
+        const names = chosenMasteries.full.map(
+          (fullSlug) => {
+            var _a2, _b2;
+            return (_b2 = (_a2 = this.entities.getByTypeAndSlug("weapon", fullSlug)) == null ? void 0 : _a2.name) != null ? _b2 : fullSlug;
+          }
+        );
+        const entry = { label: "Mastered weapons", description: names.join(", ") };
+        target.chosenInline = target.chosenInline ? [...target.chosenInline, entry] : [entry];
+      }
+    }
+    const featureResources = resolveFeatureResources(features);
+    const resolvedCharacter = {
+      definition: character,
+      race,
+      classes,
+      background,
+      feats,
+      ...originFeatSlug ? { originFeatSlug } : {},
+      totalLevel,
+      features,
+      spells: dedupeResolvedSpells(spells),
+      pools: [],
+      resources: featureResources,
+      weaponMasteries: chosenMasteries.bare,
+      state: character.state
+    };
+    resolvedCharacter.pools = resolveAllPools(resolvedCharacter, this.entities, featureResources);
+    resolvedCharacter.resources = resolveResourceIndex(resolvedCharacter);
+    return { character: resolvedCharacter, warnings };
+  }
+};
+function collectChosenWeaponMasteries(character) {
+  var _a, _b;
+  const full = /* @__PURE__ */ new Set();
+  for (const cls of (_a = character.class) != null ? _a : []) {
+    for (const lvl of Object.values((_b = cls.choices) != null ? _b : {})) {
+      const pick = lvl["weapon-mastery"];
+      if (Array.isArray(pick)) {
+        for (const s of pick) if (typeof s === "string") full.add(s);
+      }
+    }
+  }
+  return { full: [...full], bare: [...new Set([...full].map(bareEntitySlug))] };
+}
+function collectFeatPicks(character) {
+  const picks = /* @__PURE__ */ new Map();
+  character.class.forEach((c, classIndex) => {
+    for (const [lvl, choiceBlock] of Object.entries(c.choices)) {
+      const feat = choiceBlock == null ? void 0 : choiceBlock.feat;
+      if (typeof feat === "string") {
+        const s = stripSlug(feat);
+        const level = /^\d+$/.test(lvl) ? Number(lvl) : null;
+        if (s && !picks.has(s)) picks.set(s, { slug: s, classIndex, level });
+      }
+    }
+  });
+  return [...picks.values()];
+}
+function collectFeatGrantedSpells(feat, read, entities, warnings) {
+  var _a;
+  const ability = readChosenSpellAbility(read);
+  const slugs = [];
+  collectSpellPickSlugs(feat.choices, read, slugs);
+  const out = [];
+  for (const rawSlug of slugs) {
+    const slug = (_a = stripSlug(rawSlug)) != null ? _a : rawSlug;
+    const reg = entities.getByTypeAndSlug("spell", slug);
+    if (!reg) {
+      warnings.push(`Feat spell [[${slug}]] not found in compendium.`);
+      continue;
+    }
+    const entity = mirrorSpellShapes(reg.data);
+    out.push({ entity, slug, classSlug: null, source: "feat", prepared: true, alwaysPrepared: true, ability });
+  }
+  return out;
+}
+function collectItemGrantedSpells(character, ownAbility, entities, warnings) {
+  var _a;
+  const out = [];
+  ((_a = character.equipment) != null ? _a : []).forEach((entry, entryIndex) => {
+    var _a2, _b, _c, _d, _e, _f;
+    const spellRef = (_a2 = entry.overrides) == null ? void 0 : _a2.spell;
+    if (!spellRef) return;
+    const { entity: itemEntity } = resolveEntityForEntry(entry.item, entities);
+    const scrollLevel = isItemEntity(itemEntity) ? itemEntity.scroll_level : void 0;
+    if (scrollLevel == null) return;
+    const slug = (_b = stripSlug(spellRef)) != null ? _b : spellRef;
+    const reg = entities.getByTypeAndSlug("spell", slug);
+    if (!reg) {
+      warnings.push(`Scroll spell [[${slug}]] not found in compendium.`);
+      return;
+    }
+    const entity = mirrorSpellShapes(reg.data);
+    const ability = (_f = (_d = (_c = entry.overrides) == null ? void 0 : _c.spell_ability) != null ? _d : ownAbility) != null ? _f : (_e = character.overrides) == null ? void 0 : _e.spellcasting_ability;
+    out.push({ entity, slug, classSlug: null, source: "item", prepared: true, alwaysPrepared: true, ability, entryIndex });
+  });
+  return out;
+}
+function dedupeResolvedSpells(spells) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const s of spells) {
+    const key = s.source === "item" ? `${s.slug}#${s.entryIndex}` : s.slug;
+    const existing = byKey.get(key);
+    if (!existing) {
+      byKey.set(key, s);
+      continue;
+    }
+    if (existing.source === "feat" && s.source !== "feat") {
+      byKey.set(key, { ...s, alwaysPrepared: s.alwaysPrepared || existing.alwaysPrepared, prepared: s.prepared || existing.alwaysPrepared, ...existing.persisted || s.persisted ? { persisted: true } : {} });
+    } else if (s.alwaysPrepared && !existing.alwaysPrepared) {
+      byKey.set(key, { ...existing, alwaysPrepared: true, prepared: true });
+    }
+  }
+  return [...byKey.values()];
+}
+function readChosenSpellAbility(read) {
+  const pick = read("spellcasting-ability");
+  return typeof pick === "string" && ABILITY_KEYS.includes(pick) ? pick : null;
+}
+function collectSpellPickSlugs(choices, read, out) {
+  for (const ch of choices != null ? choices : []) {
+    if (ch.kind === "select-entity" && ch.entity_type === "spell") {
+      const sel = read(ch.id);
+      const picks = Array.isArray(sel) ? sel : typeof sel === "string" ? [sel] : [];
+      for (const p of picks) if (typeof p === "string" && p.length > 0) out.push(p);
+    } else if (ch.kind === "select-inline") {
+      const sel = read(ch.id);
+      const branch = typeof sel === "string" ? ch.options.find((o) => o.value === sel) : void 0;
+      if (branch == null ? void 0 : branch.choices) collectSpellPickSlugs(branch.choices, read, out);
+    }
+  }
+}
+function collectChosenGrantedFeatures(character, classes, registry, race = null, background = null) {
+  var _a, _b;
+  const out = [];
+  classes.forEach((c, i) => {
+    var _a2, _b2, _c, _d;
+    if (!c.entity) return;
+    const entity = c.entity;
+    const entry = character.class[i];
+    if (!entry) return;
+    for (const [lvlStr, atLevel] of Object.entries(entry.choices)) {
+      const lvl = Number(lvlStr);
+      if (!Number.isFinite(lvl) || lvl > entry.level) continue;
+      const features = (_b2 = ((_a2 = entity.features_by_level) != null ? _a2 : {})[lvl]) != null ? _b2 : [];
+      const subFeatures = c.subclass ? (_d = ((_c = c.subclass.features_by_level) != null ? _c : {})[lvl]) != null ? _d : [] : [];
+      for (const feature of [...features, ...subFeatures]) {
+        walkChoiceGrants(feature.choices, atLevel, (granted, suppress) => {
+          out.push({
+            feature: granted,
+            source: { kind: "class", slug: entity.slug, level: lvl },
+            ...suppress ? { renderSuppressed: true } : {}
+          });
+        }, registry);
+      }
+    }
+  });
+  const oc = (_a = character.origin_choices) != null ? _a : {};
+  const originAt = (ns) => {
+    const at = {};
+    for (const [key, val] of Object.entries(oc)) {
+      if (key.startsWith(`${ns}:`)) at[key.slice(ns.length + 1)] = val;
+    }
+    return at;
+  };
+  if (race) {
+    const atRace = originAt("race");
+    const emitRace = (granted, suppress) => {
+      out.push({
+        feature: granted,
+        source: { kind: "race", slug: race.slug },
+        ...suppress ? { renderSuppressed: true } : {}
+      });
+    };
+    walkChoiceGrants(race.choices, atRace, emitRace, registry);
+    for (const trait of (_b = race.traits) != null ? _b : []) {
+      walkChoiceGrants(trait.choices, atRace, emitRace, registry);
+    }
+  }
+  if (background) {
+    const atBg = originAt("background");
+    const emitBg = (granted, suppress) => {
+      out.push({
+        feature: granted,
+        source: { kind: "background", slug: background.slug },
+        ...suppress ? { renderSuppressed: true } : {}
+      });
+    };
+    walkChoiceGrants(background.choices, atBg, emitBg, registry);
+    if (background.feature) {
+      walkChoiceGrants(background.feature.choices, atBg, emitBg, registry);
+    }
+  }
+  return out;
+}
+function walkChoiceGrants(choices, atLevel, emit, registry) {
+  var _a, _b, _c, _d, _e;
+  for (const ch of choices != null ? choices : []) {
+    const sel = atLevel[ch.id];
+    if (ch.kind === "select-entity" && ch.entity_type === "optional-feature") {
+      const slugs = Array.isArray(sel) ? sel : typeof sel === "string" ? [sel] : [];
+      for (const slug of slugs) {
+        const reg = registry.getByTypeAndSlug("optional-feature", (_a = stripSlug(String(slug))) != null ? _a : String(slug));
+        if (!reg) continue;
+        const d = reg.data;
+        emit({
+          id: (_b = d.slug) != null ? _b : String(slug),
+          name: (_c = d.name) != null ? _c : String(slug),
+          description: d.description,
+          effects: d.effects,
+          ...d.action_cost ? { action: d.action_cost } : {}
+        });
+      }
+    }
+    if (ch.kind === "select-inline") {
+      const branch = typeof sel === "string" ? ch.options.find((o) => o.value === sel) : void 0;
+      if ((_d = branch == null ? void 0 : branch.effects) == null ? void 0 : _d.length) {
+        const wc = (_e = branch.choices) == null ? void 0 : _e.find(
+          (c) => c.kind === "select-entity" && c.entity_type === "weapon"
+        );
+        const picked = wc ? atLevel == null ? void 0 : atLevel[wc.id] : void 0;
+        const effects = branch.effects.map(
+          (e) => e.kind === "weapon-ability" && e.weapons === "chosen" && typeof picked === "string" ? { ...e, weapons: [bareEntitySlug(picked)] } : e
+        );
+        emit({ id: `${ch.id}-${branch.value}`, name: branch.label, description: branch.description, effects }, true);
+      }
+      if (branch == null ? void 0 : branch.choices) walkChoiceGrants(branch.choices, atLevel, emit, registry);
+    }
+  }
+}
+function resolveChosenInline(feature, atLevel) {
+  var _a;
+  if (!atLevel) return void 0;
+  const picks = [];
+  for (const ch of (_a = feature.choices) != null ? _a : []) {
+    if (ch.kind !== "select-inline") continue;
+    const sel = atLevel[ch.id];
+    if (typeof sel !== "string") continue;
+    const opt = ch.options.find((o) => o.value === sel);
+    if (!opt) continue;
+    picks.push({ label: opt.label, description: opt.description });
+  }
+  return picks.length ? picks : void 0;
+}
+function isAsiSlotFeature(feature) {
+  var _a, _b, _c, _d;
+  return feature.id === "ability-score-improvement" && !((_a = feature.effects) != null ? _a : []).some((e) => !(e.kind === "ability-score-increase" && e.abilities === "chosen")) && !((_b = feature.resources) == null ? void 0 : _b.length) && !feature.action && !((_c = feature.sub_features) == null ? void 0 : _c.length) && !((_d = feature.attacks) == null ? void 0 : _d.length);
+}
+function foldRepeated(list) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const rf of list) {
+    const id = rf.feature.id;
+    if (!id || rf.buildOnly) continue;
+    const arr = byId.get(id);
+    if (arr) arr.push(rf);
+    else byId.set(id, [rf]);
+  }
+  const out = [];
+  for (const rf of list) {
+    if (!rf.feature.id || rf.buildOnly) {
+      out.push(rf);
+      continue;
+    }
+    const arr = byId.get(rf.feature.id);
+    if (!arr || arr.length === 1) {
+      out.push(rf);
+      continue;
+    }
+    const sorted = [...arr].sort((a, b) => a.source.level - b.source.level);
+    const top = sorted[sorted.length - 1];
+    if (rf !== top) continue;
+    const effects = sorted.flatMap((c) => {
+      var _a;
+      return (_a = c.feature.effects) != null ? _a : [];
+    });
+    const seen = /* @__PURE__ */ new Set();
+    const resources = sorted.flatMap((c) => {
+      var _a;
+      return ((_a = c.feature.resources) != null ? _a : []).filter((r) => !seen.has(r.id) && seen.add(r.id));
+    });
+    const chosenInline = sorted.flatMap((c) => c.chosenInline ? [c.chosenInline] : []);
+    const cardProse = (f) => {
+      var _a, _b;
+      return (_b = f.description) != null ? _b : ((_a = f.entries) == null ? void 0 : _a.length) ? f.entries.join("\n\n") : void 0;
+    };
+    const foldedFrom = sorted.slice(0, -1).map((c) => {
+      var _a;
+      return {
+        level: c.source.level,
+        name: c.feature.name,
+        ...cardProse(c.feature) ? { description: cardProse(c.feature) } : {},
+        ...((_a = c.feature.choices) == null ? void 0 : _a.length) ? { choices: c.feature.choices } : {}
+      };
+    });
+    out.push({
+      ...top,
+      feature: { ...top.feature, ...effects.length ? { effects } : {}, ...resources.length ? { resources } : {} },
+      ...chosenInline.length ? { chosenInline: chosenInline.flat() } : {},
+      ...foldedFrom.length ? { foldedFrom } : {}
+    });
+  }
+  return out;
+}
+function collectResolvedFeatures(race, classes, background, feats, featVia = /* @__PURE__ */ new Map()) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  const out = [];
+  for (const c of classes) {
+    if (!c.entity) continue;
+    const slug = c.entity.slug;
+    const byLevel = (_a = c.entity.features_by_level) != null ? _a : {};
+    const classFeatures = [];
+    const subclassFeatures = [];
+    for (const [lvlStr, feats0] of Object.entries(byLevel)) {
+      const lvl = parseInt(lvlStr, 10);
+      if (Number.isNaN(lvl) || lvl > c.level) continue;
+      for (const feat of feats0) {
+        const chosenInline = resolveChosenInline(feat, (_b = c.choices) == null ? void 0 : _b[lvl]);
+        const feature = withResolvedActionCost(feat);
+        classFeatures.push({
+          feature,
+          source: { kind: "class", slug, level: lvl },
+          ...chosenInline ? { chosenInline } : {},
+          ...isAsiSlotFeature(feature) ? { buildOnly: true } : {}
+        });
+      }
+    }
+    if (c.subclass) {
+      const sSlug = c.subclass.slug;
+      const sByLevel = (_c = c.subclass.features_by_level) != null ? _c : {};
+      for (const [lvlStr, feats0] of Object.entries(sByLevel)) {
+        const lvl = parseInt(lvlStr, 10);
+        if (Number.isNaN(lvl) || lvl > c.level) continue;
+        for (const feat of feats0) {
+          const chosenInline = resolveChosenInline(feat, (_d = c.choices) == null ? void 0 : _d[lvl]);
+          const feature = withResolvedActionCost(feat);
+          subclassFeatures.push({
+            feature,
+            source: { kind: "subclass", slug: sSlug, level: lvl },
+            ...chosenInline ? { chosenInline } : {},
+            ...isAsiSlotFeature(feature) ? { buildOnly: true } : {}
+          });
+        }
+      }
+    }
+    const foldedClass = foldRepeated(classFeatures);
+    const foldedSubclass = foldRepeated(subclassFeatures);
+    out.push(...foldedClass);
+    if ((_e = c.entity.resources) == null ? void 0 : _e.length) {
+      out.push({
+        feature: { name: c.entity.name, resources: c.entity.resources },
+        source: { kind: "class", slug, level: 1 }
+      });
+    }
+    out.push(...foldedSubclass);
+    if ((_g = (_f = c.subclass) == null ? void 0 : _f.resources) == null ? void 0 : _g.length) {
+      out.push({
+        feature: { name: c.subclass.name, resources: c.subclass.resources },
+        source: { kind: "subclass", slug: c.subclass.slug, level: 1 }
+      });
+    }
+  }
+  if (race) {
+    const traits = (_h = race.traits) != null ? _h : [];
+    for (const feat of traits) {
+      out.push({ feature: withResolvedActionCost(feat), source: { kind: "race", slug: race.slug } });
+    }
+  }
+  if (background) {
+    const bgFeature = background.feature;
+    if (bgFeature) {
+      out.push({ feature: withResolvedActionCost(bgFeature), source: { kind: "background", slug: background.slug } });
+    }
+  }
+  for (const feat of feats) {
+    const via = featVia.get(feat.slug);
+    const featSource = { kind: "feat", slug: feat.slug, ...via ? { via } : {} };
+    const bundled = (_i = feat.features) != null ? _i : [];
+    const entityEffects = (_j = feat.effects) != null ? _j : [];
+    if (bundled.length > 0) {
+      bundled.forEach((f, i) => {
+        var _a2, _b2;
+        const feature = i === 0 ? { ...f, action: (_a2 = f.action) != null ? _a2 : feat.action_cost, ...entityEffects.length > 0 ? { effects: [...(_b2 = f.effects) != null ? _b2 : [], ...entityEffects] } : {} } : f;
+        out.push({ feature, source: featSource });
+      });
+    } else {
+      const name = (_k = feat.name) != null ? _k : feat.slug;
+      const foldedDesc = [feat.description, ...(_l = feat.benefits) != null ? _l : []].filter(Boolean).join("\n\n") || void 0;
+      const buildOnly = ((_m = feat.choices) != null ? _m : []).some((c) => c.kind === "ability-points" && c.points >= 2) && !((_n = feat.effects) == null ? void 0 : _n.length) && !((_o = feat.resources) == null ? void 0 : _o.length) && bundled.length === 0;
+      out.push({
+        feature: {
+          name,
+          ...foldedDesc ? { description: foldedDesc } : {},
+          ...feat.resources ? { resources: feat.resources } : {},
+          // R4-G3a §10.2.3: a feat's ENTITY-level action cost (SRD 2024 Boon of the Night Spirit)
+          // reaches the synthesized feature, so the row routes off Passive onto its own economy.
+          ...feat.action_cost ? { action: feat.action_cost } : {},
+          ...entityEffects.length > 0 ? { effects: entityEffects } : {}
+        },
+        source: featSource,
+        ...buildOnly ? { buildOnly: true } : {}
+      });
+    }
+  }
+  return out;
+}
+
+export {
+  stripSlug,
+  resolveOriginFeat,
+  PCResolver,
+  collectChosenWeaponMasteries,
+  collectFeatPicks,
+  collectFeatGrantedSpells,
+  collectItemGrantedSpells,
+  dedupeResolvedSpells,
+  collectChosenGrantedFeatures,
+  collectResolvedFeatures,
+  collectProficiencyGrants,
+  __matchesFilterForTest,
+  collectChosenProficiencies,
+  computeEffectiveProficiencies,
+  collectChosenAbilityPoints,
+  buildDecisionLedger
+};