@archivist-gg/dnd5e 0.1.1 → 0.3.0

package/dist/chunk-5MZSB6OM.js

@@ -0,0 +1,1089 @@
+import {
+  ALL_SKILL_SLUGS
+} from "./chunk-BH6AMZVY.js";
+import {
+  normalizeKnownSpell,
+  resolveSpellcasting
+} from "./chunk-M2EMFD6S.js";
+import {
+  readTableColumn
+} from "./chunk-5XUXXAQJ.js";
+import {
+  recognizeDecision
+} from "./chunk-JEYQU3JT.js";
+import {
+  isItemEntity,
+  resolveEntityForEntry
+} from "./chunk-N6N74K6X.js";
+import {
+  bareEntitySlug
+} from "./chunk-LV4SNWZQ.js";
+import {
+  ABILITY_KEYS
+} from "./chunk-WP2CX2JO.js";
+
+// 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) {
+  var _a, _b, _c;
+  if (!originFeatRef) return null;
+  const slug = wikilinkTailSlug(originFeatRef);
+  const feats = entities.search("", "feat", Number.POSITIVE_INFINITY);
+  const lookup = (s) => {
+    var _a2;
+    return (_a2 = feats.find((f) => f.slug === s)) != null ? _a2 : feats.find((f) => f.slug.endsWith(`_${s}`));
+  };
+  let reg = lookup(slug);
+  let variantName;
+  if (!reg) {
+    const rawTail = (_b = (_a = originFeatRef.replace(/^\[\[/, "").replace(/\]\]$/, "").split("/").pop()) == null ? void 0 : _a.trim()) != null ? _b : "";
+    const base = rawTail.replace(/\s*\([^()]*\)\s*$/, "").trim();
+    if (base && base !== rawTail) {
+      const baseReg = lookup(wikilinkTailSlug(`[[${base}]]`));
+      if (baseReg) {
+        reg = baseReg;
+        variantName = rawTail;
+      }
+    }
+  }
+  if (!reg) return null;
+  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;
+    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 featSlugs = collectFeatSlugs(character);
+    const feats = [];
+    for (const slug of featSlugs) {
+      const f = lookup(`[[${slug}]]`, "feat");
+      if (f) feats.push(f);
+    }
+    const originFeat = (background == null ? void 0 : background.origin_feat) ? resolveOriginFeat(this.entities, background.origin_feat) : null;
+    if (originFeat && !feats.some((f) => f.slug === originFeat.feat.slug)) {
+      feats.push(originFeat.feat);
+    }
+    const totalLevel = classes.reduce((sum, c) => sum + c.level, 0);
+    const features = collectResolvedFeatures(race, classes, background, feats);
+    const extraFeatures = collectChosenGrantedFeatures(character, classes, this.entities, race, background);
+    features.push(...extraFeatures);
+    const primaryCasterSlug = (_a = classes.map((c, i) => c.entity && resolveSpellcasting(c) ? stripSlug(character.class[i].name) : null).find((slug) => slug != null)) != null ? _a : null;
+    const spells = [];
+    for (const raw of (_b = character.spells.known) != null ? _b : []) {
+      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 = reg.data;
+      const isCantrip = ((_c = entity.level) != null ? _c : 0) === 0;
+      const classSlug = (_d = n.classSlug) != null ? _d : primaryCasterSlug;
+      const prep = isCantrip || n.alwaysPrepared ? true : (_e = n.preparedFlag) != null ? _e : false;
+      spells.push({ entity, slug: n.slug, classSlug, source: n.source, prepared: prep, alwaysPrepared: n.alwaysPrepared });
+    }
+    const oc = (_f = character.origin_choices) != null ? _f : {};
+    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((_g = entry.choices) != null ? _g : {})) {
+        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 = (_h = classes.map((c) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = resolveSpellcasting(c)) == null ? void 0 : _a2.ability) != null ? _b2 : null;
+    }).find((a) => a != null)) != null ? _h : null;
+    spells.push(...collectItemGrantedSpells(character, ownSpellcastingAbility, 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 resolvedCharacter = {
+      definition: character,
+      race,
+      classes,
+      background,
+      feats,
+      totalLevel,
+      features,
+      spells: dedupeResolvedSpells(spells),
+      pools: [],
+      weaponMasteries: chosenMasteries.bare,
+      state: character.state
+    };
+    resolvedCharacter.pools = resolveAllPools(resolvedCharacter, this.entities);
+    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 collectFeatSlugs(character) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const c of character.class) {
+    for (const [, choiceBlock] of Object.entries(c.choices)) {
+      const feat = choiceBlock == null ? void 0 : choiceBlock.feat;
+      if (typeof feat === "string") {
+        const s = stripSlug(feat);
+        if (s) slugs.add(s);
+      }
+    }
+  }
+  return [...slugs];
+}
+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 = 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 = 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);
+  }
+  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 ? void 0 : _a.length) && !((_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 collectResolvedFeatures(race, classes, background, feats) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  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 : {};
+    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]);
+        out.push({
+          feature: feat,
+          source: { kind: "class", slug, level: lvl },
+          ...chosenInline ? { chosenInline } : {},
+          ...isAsiSlotFeature(feat) ? { buildOnly: true } : {}
+        });
+      }
+    }
+    if ((_c = c.entity.resources) == null ? void 0 : _c.length) {
+      out.push({
+        feature: { name: c.entity.name, resources: c.entity.resources },
+        source: { kind: "class", slug, level: 1 }
+      });
+    }
+    if (c.subclass) {
+      const sSlug = c.subclass.slug;
+      const sByLevel = (_d = c.subclass.features_by_level) != null ? _d : {};
+      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, (_e = c.choices) == null ? void 0 : _e[lvl]);
+          out.push({
+            feature: feat,
+            source: { kind: "subclass", slug: sSlug, level: lvl },
+            ...chosenInline ? { chosenInline } : {},
+            ...isAsiSlotFeature(feat) ? { buildOnly: true } : {}
+          });
+        }
+      }
+      if ((_f = c.subclass.resources) == null ? void 0 : _f.length) {
+        out.push({
+          feature: { name: c.subclass.name, resources: c.subclass.resources },
+          source: { kind: "subclass", slug: sSlug, level: 1 }
+        });
+      }
+    }
+  }
+  if (race) {
+    const traits = (_g = race.traits) != null ? _g : [];
+    for (const feat of traits) {
+      out.push({ feature: feat, source: { kind: "race", slug: race.slug } });
+    }
+  }
+  if (background) {
+    const bgFeature = background.feature;
+    if (bgFeature) {
+      out.push({ feature: bgFeature, source: { kind: "background", slug: background.slug } });
+    }
+  }
+  for (const feat of feats) {
+    const bundled = (_h = feat.features) != null ? _h : [];
+    const entityEffects = (_i = feat.effects) != null ? _i : [];
+    if (bundled.length > 0) {
+      bundled.forEach((f, i) => {
+        var _a2;
+        const feature = i === 0 && entityEffects.length > 0 ? { ...f, effects: [...(_a2 = f.effects) != null ? _a2 : [], ...entityEffects] } : f;
+        out.push({ feature, source: { kind: "feat", slug: feat.slug } });
+      });
+    } else {
+      const name = (_j = feat.name) != null ? _j : feat.slug;
+      const foldedDesc = [feat.description, ...(_k = feat.benefits) != null ? _k : []].filter(Boolean).join("\n\n") || void 0;
+      const buildOnly = ((_l = feat.choices) != null ? _l : []).some((c) => c.kind === "ability-points" && c.points >= 2) && !((_m = feat.effects) == null ? void 0 : _m.length) && !((_n = feat.resources) == null ? void 0 : _n.length) && bundled.length === 0;
+      out.push({
+        feature: {
+          name,
+          ...foldedDesc ? { description: foldedDesc } : {},
+          ...feat.resources ? { resources: feat.resources } : {},
+          ...entityEffects.length > 0 ? { effects: entityEffects } : {}
+        },
+        source: { kind: "feat", slug: feat.slug },
+        ...buildOnly ? { buildOnly: true } : {}
+      });
+    }
+  }
+  return out;
+}
+
+// src/pc/pc.decision-engine.ts
+var warnedDegradedEquipment = /* @__PURE__ */ new Set();
+function wikilinkTailSlug(link) {
+  var _a;
+  const inner = link.replace(/^\[\[/, "").replace(/\]\]$/, "");
+  const tail = (_a = inner.split("/").pop()) != null ? _a : inner;
+  return tail.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+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) {
+        const byBare = /* @__PURE__ */ new Map();
+        for (const e of ctx.registry.search("", choice.entity_type, Number.POSITIVE_INFINITY)) {
+          byBare.set(bareEntitySlug(e.slug), e);
+        }
+        return choice.from.map((slug) => {
+          var _a2;
+          const e = (_a2 = ctx.registry.getByTypeAndSlug(choice.entity_type, slug)) != null ? _a2 : byBare.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] : [];
+      return pool.map((v) => ({ value: v, label: v.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()) }));
+    }
+    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) {
+  const n = selectionCount(choice, selected);
+  const need = requiredCount(choice);
+  if (n === 0) return "unresolved";
+  return n >= need ? "resolved" : "partial";
+}
+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(choice, source, level, featureName, readValue, ctx, ownerBare, opts) {
+  var _a, _b, _c, _d;
+  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 selected = readValue(key);
+  const item = {
+    key,
+    source,
+    level,
+    featureName,
+    choice,
+    description: opts == null ? void 0 : opts.description,
+    options: enumerateOptions(choice, ctx, ownerBare),
+    selected,
+    status: statusOf(choice, selected)
+  };
+  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, { 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,
+        { 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"
+  };
+}
+function collectChosenProficiencies(resolved) {
+  var _a, _b;
+  const out = { skills: [], expertise: [], languages: [], tools: [] };
+  const apply = (choice, selected) => {
+    if (choice.kind !== "select-proficiency") return;
+    const vals = Array.isArray(selected) ? selected : typeof selected === "string" ? [selected] : [];
+    const pool = choice.from;
+    const valid = pool ? vals.filter((v) => pool.includes(v)) : vals;
+    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);
+    }
+  };
+  const walk = (choices, read) => {
+    for (const ch of choices != null ? choices : []) {
+      apply(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);
+      }
+    }
+  };
+  resolved.classes.forEach((c, i) => {
+    var _a2, _b2;
+    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)) {
+      apply({
+        kind: "select-proficiency",
+        id: "skills",
+        count: entity.skill_choices.count,
+        domain: "skill",
+        from: entity.skill_choices.from
+      }, readAt(1)("skills"));
+    }
+    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;
+      walk(rf.feature.choices, readAt(rf.source.level));
+    }
+  });
+  const oc = (_a = resolved.definition.origin_choices) != null ? _a : {};
+  const originRead = (ns) => (id) => oc[`${ns}:${id}`];
+  if (resolved.race) {
+    walk(resolved.race.choices, originRead("race"));
+    for (const t of (_b = resolved.race.traits) != null ? _b : []) walk(t.choices, originRead("race"));
+  }
+  if (resolved.background) {
+    walk(resolved.background.choices, originRead("background"));
+    if (resolved.background.feature) {
+      walk(resolved.background.feature.choices, originRead("background"));
+    }
+  }
+  return out;
+}
+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;
+  const classes = [];
+  resolved.classes.forEach((c, classIndex) => {
+    var _a2, _b2, _c2, _d2, _e2, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    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];
+    };
+    if (classIndex === 0 && ((_b2 = (_a2 = entity.skill_choices) == null ? void 0 : _a2.from) == null ? void 0 : _b2.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
+      ));
+    }
+    if (classIndex === 0) {
+      ((_c2 = entity.starting_equipment) != null ? _c2 : []).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
+        ));
+      });
+    }
+    let sawAuthoredSubclass = false;
+    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;
+      let choices = rf.feature.choices;
+      if (!(choices == null ? void 0 : choices.length)) {
+        const recognized = recognizeDecision(rf.feature);
+        if (recognized === "informational") {
+          push(lvl, {
+            key: (_d2 = rf.feature.id) != null ? _d2 : rf.feature.name,
+            source: src,
+            level: lvl,
+            featureName: rf.feature.name,
+            description: (_f = rf.feature.description) != null ? _f : (_e2 = rf.feature.entries) == null ? void 0 : _e2.join("\n\n"),
+            choice: { kind: "select-inline", id: (_g = rf.feature.id) != null ? _g : rf.feature.name, options: [{ value: "_", label: "_" }] },
+            options: [],
+            selected: void 0,
+            status: "informational"
+          });
+          continue;
+        }
+        choices = recognized != null ? recognized : void 0;
+      }
+      if (!(choices == null ? void 0 : choices.length)) {
+        if (rf.feature.description || ((_h = rf.feature.entries) == null ? void 0 : _h.length)) {
+          push(lvl, {
+            key: (_i = rf.feature.id) != null ? _i : rf.feature.name,
+            source: src,
+            level: lvl,
+            featureName: rf.feature.name,
+            description: (_k = rf.feature.description) != null ? _k : (_j = rf.feature.entries) == null ? void 0 : _j.join("\n\n"),
+            choice: { kind: "select-inline", id: (_l = rf.feature.id) != null ? _l : rf.feature.name, options: [{ value: "_", label: "_" }] },
+            options: [],
+            selected: void 0,
+            status: "informational"
+          });
+        }
+        continue;
+      }
+      for (const ch of choices) {
+        if (ch.kind === "select-entity" && ch.entity_type === "subclass") {
+          sawAuthoredSubclass = true;
+          push(lvl, buildSubclassItem(ch, src, lvl, rf.feature.name, c, ctx, ownerBare, rf.feature.description));
+          continue;
+        }
+        push(lvl, buildItem(
+          ch,
+          src,
+          lvl,
+          rf.feature.name,
+          readAt(lvl),
+          ctx,
+          ownerBare,
+          { description: rf.feature.description }
+        ));
+      }
+    }
+    const subclassLevel = (_m = entity.subclass_level) != null ? _m : 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 synth = {
+        kind: "select-entity",
+        id: pool.id,
+        label: pool.label,
+        count: pool.count,
+        entity_type: "optional-feature",
+        from: pool.available.map((e) => e.slug)
+      };
+      push(pool.anchorLevel, buildItem(
+        synth,
+        { kind: "class", slug: entity.slug, level: pool.anchorLevel },
+        pool.anchorLevel,
+        pool.label,
+        readAt(pool.anchorLevel),
+        ctx,
+        ownerBare
+      ));
+    }
+    const levels = [...byLevel.entries()].sort(([a], [b]) => a - b).map(([level, items]) => ({ level, items }));
+    classes.push({ classIndex, levels });
+  });
+  const origin = [];
+  const oc = (_a = resolved.definition.origin_choices) != null ? _a : {};
+  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, { description }));
+    }
+  };
+  if (resolved.race) {
+    const bare = bareEntitySlug(resolved.race.slug);
+    pushOrigin(
+      resolved.race.choices,
+      "race",
+      { kind: "race", slug: resolved.race.slug },
+      (_b = resolved.race.name) != null ? _b : "Race",
+      bare,
+      resolved.race.description
+    );
+    for (const t of (_c = resolved.race.traits) != null ? _c : []) {
+      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 },
+      (_d = resolved.background.name) != null ? _d : "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
+      );
+      if (originFeat) {
+        const featSource = { kind: "feat", slug: originFeat.feat.slug };
+        const featBare = bareEntitySlug(originFeat.feat.slug);
+        for (const ch of (_e = originFeat.feat.choices) != null ? _e : []) {
+          origin.push(buildItem(
+            ch,
+            featSource,
+            0,
+            originFeat.display,
+            originRead("background"),
+            ctx,
+            featBare,
+            { keyPrefix: "feat:" }
+          ));
+        }
+      }
+    }
+  }
+  return { classes, origin };
+}
+
+// src/pc/pc.pools.ts
+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) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const entity = rc.entity;
+  const level = rc.level;
+  const ownerBare = bareEntitySlug(entity.slug);
+  const col = pool.count.column;
+  const count = (_a = readTableColumn(entity.table, level, [col])) != null ? _a : 0;
+  let anchorLevel = 1;
+  for (let l = 1; l <= 20; l++) {
+    const c = readTableColumn(entity.table, l, [col]);
+    if (c != null && c >= 1) {
+      anchorLevel = l;
+      break;
+    }
+  }
+  const ft = pool.source.where.feature_type;
+  const all = registry.search("", "optional-feature", Number.POSITIVE_INFINITY);
+  const byBare = /* @__PURE__ */ new Map();
+  const available = [];
+  for (const e of all) {
+    const d = e.data;
+    const entry = { slug: e.slug, entity: d };
+    byBare.set(bareEntitySlug(e.slug), entry);
+    if (d.feature_type !== ft) continue;
+    if (!((_b = d.available_to) != null ? _b : []).some((l) => wikilinkTailSlug(l) === ownerBare)) continue;
+    if (levelPrereqMax(d) > level) continue;
+    available.push(entry);
+  }
+  const grantDecls = [
+    ...(_d = (_c = rc.entity) == null ? void 0 : _c.pool_grants) != null ? _d : [],
+    ...(_f = (_e = rc.subclass) == null ? void 0 : _e.pool_grants) != null ? _f : []
+  ];
+  const grantsRaw = grantDecls.filter((g) => g.pool === pool.id).flatMap((g) => g.grants).filter((g) => g.at_level <= level).map((g) => byBare.get(wikilinkTailSlug(g.feature))).filter((e) => e != null);
+  const grantedBare = /* @__PURE__ */ new Set();
+  const grants = grantsRaw.filter((e) => {
+    const key = bareEntitySlug(e.slug);
+    if (grantedBare.has(key)) return false;
+    grantedBare.add(key);
+    return true;
+  });
+  const raw = (_g = rc.choices[anchorLevel]) == null ? void 0 : _g[pool.id];
+  const selectedSlugs = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+  const selected = selectedSlugs.map((s) => byBare.get(bareEntitySlug(s))).filter((e) => e != null).filter((e) => !grantedBare.has(bareEntitySlug(e.slug)));
+  return { id: pool.id, label: pool.label, classIndex, count, anchorLevel, selected, available, grants };
+}
+function resolveAllPools(resolved, registry) {
+  const out = [];
+  resolved.classes.forEach((rc, classIndex) => {
+    var _a, _b, _c;
+    if (!rc.entity) return;
+    const decls = [...(_a = rc.entity.selection_pools) != null ? _a : [], ...(_c = (_b = rc.subclass) == null ? void 0 : _b.selection_pools) != null ? _c : []];
+    const seen = /* @__PURE__ */ new Set();
+    for (const pool of decls) {
+      if (seen.has(pool.id)) continue;
+      seen.add(pool.id);
+      out.push(resolvePool(rc, classIndex, pool, registry));
+    }
+  });
+  return out;
+}
+
+export {
+  levelPrereqMax,
+  resolvePool,
+  resolveAllPools,
+  stripSlug,
+  resolveOriginFeat,
+  PCResolver,
+  collectChosenWeaponMasteries,
+  collectFeatSlugs,
+  collectFeatGrantedSpells,
+  collectItemGrantedSpells,
+  dedupeResolvedSpells,
+  collectChosenGrantedFeatures,
+  collectResolvedFeatures,
+  wikilinkTailSlug,
+  __matchesFilterForTest,
+  collectChosenProficiencies,
+  collectChosenAbilityPoints,
+  buildDecisionLedger
+};