@archivist-gg/dnd5e 0.3.11 → 0.3.13

package/dist/chunk-T5GZBKIQ.js

@@ -0,0 +1,927 @@
+import {
+  parseCastingTime
+} from "./chunk-W6GC6OKK.js";
+import {
+  derivePoolLayout
+} from "./chunk-HJQNK3J5.js";
+import {
+  readTableColumn
+} from "./chunk-IUAAXXNO.js";
+import {
+  findItemAction,
+  resolveItemAction
+} from "./chunk-ZUQW5VBZ.js";
+import {
+  requiresAttunement
+} from "./chunk-IHE6KVC3.js";
+import {
+  defaultSlotForType,
+  effectiveArmor,
+  isItemEntity,
+  isShieldArmor,
+  resolveEntityForEntry,
+  slotAcTerms
+} from "./chunk-LHZXYFBU.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  keptSlugFor,
+  resolveBaseItem
+} from "./chunk-CM5CWO4K.js";
+import {
+  bareEntitySlug,
+  slugify,
+  wikilinkTailSlug
+} from "./chunk-ZCTUYGNV.js";
+import {
+  parseInlineTag
+} from "./chunk-3TM34RSJ.js";
+import {
+  isCanonicalDamageType
+} from "./chunk-PDJSUH24.js";
+
+// 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, index, edition) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const entity = rc.entity;
+  const level = rc.level;
+  const ownerBare = bareEntitySlug(entity.slug);
+  const ownerPrefix = entity.slug.split("_")[0];
+  const col = pool.count.column;
+  const count = (_a = readTableColumn(entity.table, level, [col])) != null ? _a : 0;
+  let anchorLevel = 1;
+  let columnSeen = false;
+  for (let l = 1; l <= 20; l++) {
+    const c = readTableColumn(entity.table, l, [col]);
+    if (c != null) columnSeen = true;
+    if (c != null && c >= 1) {
+      anchorLevel = l;
+      break;
+    }
+  }
+  if (!columnSeen) {
+    warnOnce(
+      `pool-column:${pool.id}`,
+      `Archivist: pool "${pool.id}" declares count column "${col}", which "${entity.slug}"'s class table carries at no level; the pool resolves count 0 at anchor level 1`
+    );
+  }
+  const ft = pool.source.where.feature_type;
+  const all = registry.search("", "optional-feature", Number.POSITIVE_INFINITY).slice().sort((a, b) => a.name.localeCompare(b.name) || a.slug.localeCompare(b.slug));
+  const entryOf = (slug, entity2, compendium) => ({ slug, entity: entity2, ...compendium ? { compendium } : {}, key: slug, param: null, itemBound: isItemBound(entity2) });
+  const byBare = /* @__PURE__ */ new Map();
+  const candidates = /* @__PURE__ */ new Map();
+  for (const e of all) {
+    const d = e.data;
+    const entry = entryOf(e.slug, d, e.compendium);
+    const bare = bareEntitySlug(e.slug);
+    byBare.set(bare, 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;
+    const group = candidates.get(bare);
+    if (group) group.push(entry);
+    else candidates.set(bare, [entry]);
+  }
+  const available = [];
+  for (const [bare, group] of candidates) {
+    if (group.length === 1) {
+      available.push(group[0]);
+      continue;
+    }
+    const owned = group.find((e) => e.slug.split("_")[0] === ownerPrefix);
+    if (!owned) {
+      warnOnce(
+        `pool-collapse:${bare}`,
+        `Archivist: pool "${pool.id}" holds ${group.length} cross-edition entries for "${bare}" and none shares the owner's compendium prefix "${ownerPrefix}"; keeping "${group[0].slug}"`
+      );
+    }
+    available.push(owned != null ? owned : group[0]);
+  }
+  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 bySlugAvailable = new Map(available.map((e) => [e.slug, e]));
+  const byBareAvailable = new Map(available.map((e) => [bareEntitySlug(e.slug), e]));
+  const resolveStored = (s) => {
+    const exact = bySlugAvailable.get(s);
+    if (exact) return exact;
+    const survivor = byBareAvailable.get(bareEntitySlug(s));
+    if (survivor) return survivor;
+    const full = registry.getByTypeAndSlug("optional-feature", s);
+    if (full) return entryOf(full.slug, full.data, full.compendium);
+    return byBare.get(bareEntitySlug(s));
+  };
+  const raw = (_g = rc.choices[anchorLevel]) == null ? void 0 : _g[pool.id];
+  const selectedSlugs = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+  const selected = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const s of selectedSlugs) {
+    const { slugPart, param } = parsePickKey(s);
+    const entry = resolveStored(slugPart);
+    if (!entry) continue;
+    const repeatable = entry.entity.repeatable === true;
+    if (!repeatable && param !== null) {
+      warnOnce(`pick-param:${pool.id}:${s}`, `Archivist: pool "${pool.id}" pick "${s}" names a parameter, but "${entry.slug}" is not repeatable; the parameter is ignored`);
+    }
+    const nkey = normalizedPickKey(s, repeatable);
+    if (grantedBare.has(bareEntitySlug(entry.slug)) || seenKeys.has(nkey)) continue;
+    seenKeys.add(nkey);
+    selected.push({
+      ...entry,
+      key: repeatable || param !== null ? s : entry.slug,
+      param: repeatable ? param : null,
+      ...repeatable ? { option: resolveCopyOption(entry.entity, param, { classLevel: level, registry, edition }) } : {}
+    });
+  }
+  const members = [...available, ...grants];
+  const layout = derivePoolLayout(members);
+  const votes = /* @__PURE__ */ new Map();
+  for (const e of members) {
+    const id = (_h = e.entity.consumes) == null ? void 0 : _h.resource;
+    if (!id || !index.has(id)) continue;
+    votes.set(id, ((_i = votes.get(id)) != null ? _i : 0) + 1);
+  }
+  let resource;
+  let bestN = 0;
+  for (const [id, n] of votes) if (n > bestN) {
+    resource = id;
+    bestN = n;
+  }
+  const bind = resource ? poolRebinder(rc, pool.id, resource, index) : (e) => e;
+  return {
+    id: pool.id,
+    label: pool.label,
+    classIndex,
+    count,
+    anchorLevel,
+    selected: selected.map(bind),
+    available: available.map(bind),
+    grants: grants.map(bind),
+    ...layout ? { layout } : {},
+    ...resource ? { resource } : {},
+    ...pool.count.label ? { countLabel: pool.count.label } : {},
+    ...pool.active ? { active: pool.active } : {},
+    ...pool.head_resource ? { headResource: pool.head_resource } : {}
+  };
+}
+function poolRebinder(rc, poolId, vote, index) {
+  const declared = declaredResourceIds(rc);
+  const copies = /* @__PURE__ */ new Map();
+  return (e) => {
+    const consumes = e.entity.consumes;
+    const id = consumes == null ? void 0 : consumes.resource;
+    if (!consumes || typeof id !== "string" || id.length === 0 || index.has(id) || declared.has(id)) return e;
+    const done = copies.get(e.key);
+    if (done) return done;
+    warnOnce(
+      `pool-rebind:${poolId}:${id}`,
+      `Archivist: pool "${poolId}" members consume "${id}", which this character does not own; bound to the pool's resource "${vote}"`
+    );
+    const copy = { ...e, entity: { ...e.entity, consumes: { ...consumes, resource: vote } } };
+    copies.set(e.key, copy);
+    return copy;
+  };
+}
+function declaredResourceIds(rc) {
+  var _a;
+  const out = /* @__PURE__ */ new Set();
+  const add = (list) => {
+    for (const r of list != null ? list : []) if (typeof (r == null ? void 0 : r.id) === "string") out.add(r.id);
+  };
+  for (const owner of [rc.entity, rc.subclass]) {
+    if (!owner) continue;
+    add(owner.resources);
+    for (const features of Object.values((_a = owner.features_by_level) != null ? _a : {})) for (const f of features != null ? features : []) add(f.resources);
+  }
+  return out;
+}
+function resolveAllPools(resolved, registry, index) {
+  const out = [];
+  resolved.classes.forEach((rc, classIndex) => {
+    var _a, _b, _c, _d;
+    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, index, (_d = resolved.definition) == null ? void 0 : _d.edition));
+    }
+  });
+  return out;
+}
+function strandedPicks(pool) {
+  const inAvailable = new Set(pool.available.map((e) => e.slug));
+  return pool.selected.filter((e) => !inAvailable.has(e.slug));
+}
+
+// src/pc/pc.infusions.ts
+function poolCountLabel(pool) {
+  var _a;
+  return (_a = pool.countLabel) != null ? _a : "Known";
+}
+function poolActiveWords(pool) {
+  var _a, _b, _c;
+  const a = pool.active;
+  if (!a) return null;
+  return {
+    column: a.column,
+    label: a.label,
+    verb: a.verb,
+    counterLabel: (_a = a.counter_label) != null ? _a : a.label,
+    createLabel: (_b = a.create_label) != null ? _b : "Created",
+    createVerb: (_c = a.create_verb) != null ? _c : "Create"
+  };
+}
+function parsePickKey(stored) {
+  const i = stored.indexOf("#");
+  return i === -1 ? { slugPart: stored, param: null } : { slugPart: stored.slice(0, i), param: stored.slice(i + 1) };
+}
+function normalizedPickKey(stored, repeatable) {
+  const { slugPart, param } = parsePickKey(stored);
+  return repeatable ? `${bareEntitySlug(slugPart)}#${param != null ? param : ""}` : bareEntitySlug(slugPart);
+}
+function markerKey(by) {
+  const { slugPart, param } = parsePickKey(by);
+  return param === null ? bareEntitySlug(slugPart) : `${bareEntitySlug(slugPart)}#${param}`;
+}
+function isItemBound(note) {
+  var _a;
+  return !!note.infuse || note.repeatable === true && !!((_a = note.options) == null ? void 0 : _a.some((r) => !!r.creates));
+}
+var SRD_BOOKS = /* @__PURE__ */ new Set(["SRD 2024", "SRD 5e"]);
+var lc = (v) => String(v != null ? v : "").trim().toLowerCase();
+var linkSlug = (link) => link.replace(/^\[\[/, "").replace(/\]\]$/, "").split("|")[0];
+var itemsOf = (registry) => registry.search("", "item", Number.POSITIVE_INFINITY);
+function matchesFilter(data, f) {
+  var _a;
+  const type = lc(data.type);
+  if (!f.rarity.map(lc).includes(lc(data.rarity))) return false;
+  if (f.types && !f.types.map(lc).includes(type)) return false;
+  if ((_a = f.exclude_types) == null ? void 0 : _a.map(lc).includes(type)) return false;
+  return !(f.cursed === false && data.cursed === true);
+}
+function rowMatches(row, it) {
+  const c = row.creates;
+  if (c.item) return lc(it.name) === lc(row.name) || it.slug === linkSlug(c.item);
+  if (c.variant) return c.variant.candidates.some((l) => bareEntitySlug(linkSlug(l)) === bareEntitySlug(it.slug));
+  return !!c.filter && matchesFilter(it.data, c.filter);
+}
+var rowInstalledIn = (row, items) => {
+  const v = row.creates.item ? void 0 : row.creates.variant;
+  if (!v) return items.filter((it) => rowMatches(row, it));
+  const bares = new Set(v.candidates.map((l) => bareEntitySlug(linkSlug(l))));
+  return items.filter((it) => bares.has(bareEntitySlug(it.slug)));
+};
+var rowInstalled = (row, registry) => rowInstalledIn(row, itemsOf(registry));
+function candidateOrder(edition) {
+  return (a, b) => {
+    const ea = edition && lc(a.data.edition) === edition ? 0 : 1;
+    const eb = edition && lc(b.data.edition) === edition ? 0 : 1;
+    if (ea !== eb) return ea - eb;
+    const sa = SRD_BOOKS.has(a.compendium) ? 0 : 1, sb = SRD_BOOKS.has(b.compendium) ? 0 : 1;
+    if (sa !== sb) return sa - sb;
+    return a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0;
+  };
+}
+function optionCandidates(row, registry, opts = {}) {
+  return candidatesFrom(rowInstalled(row, registry), registry, opts);
+}
+function candidatesFrom(installed, registry, opts) {
+  var _a, _b;
+  const visible = (_a = opts.isEntityVisible) != null ? _a : (() => true);
+  const excluded = ((_b = opts.exclude) != null ? _b : []).map((s) => {
+    var _a2;
+    return registry.getByTypeAndSlug("item", (_a2 = keptSlugFor(s)) != null ? _a2 : s);
+  }).filter((e) => !!e);
+  const exNames = new Set(excluded.map((e) => lc(e.name))), exBares = new Set(excluded.map((e) => bareEntitySlug(e.slug)));
+  const seen = /* @__PURE__ */ new Set(), out = [];
+  for (const e of installed.filter(visible).sort(candidateOrder(opts.edition))) {
+    const bare = bareEntitySlug(e.slug);
+    if (seen.has(bare)) continue;
+    seen.add(bare);
+    if (exNames.has(lc(e.name)) || exBares.has(bare)) continue;
+    out.push(e.slug);
+  }
+  return out;
+}
+function resolveOptionRows(note, registry, opts = {}) {
+  var _a;
+  const items = itemsOf(registry);
+  return ((_a = note.options) != null ? _a : []).map((row) => {
+    const rowItems = rowInstalledIn(row, items);
+    const candidates = candidatesFrom(rowItems, registry, opts);
+    const anyVisible = candidates.length > 0 || candidatesFrom(rowItems, registry, { ...opts, exclude: [] }).length > 0;
+    const installed = rowItems.length > 0;
+    return {
+      key: row.key,
+      name: row.name,
+      minLevel: row.min_level,
+      ...row.attunement !== void 0 ? { attunement: row.attunement } : {},
+      arm: row.creates.item ? "item" : row.creates.variant ? "variant" : "filter",
+      candidates,
+      availability: anyVisible ? "installed" : installed ? "hidden-only" : "not-installed"
+    };
+  });
+}
+function resolveCopyOption(note, param, ctx) {
+  var _a, _b, _c;
+  const rows = (_a = note.options) != null ? _a : [];
+  if (param === null || param === "") return { row: null, status: "needs-choice" };
+  if (note.item_choice === "create") {
+    const row = rows.find((r) => r.key === param);
+    if (!row) return { row: null, status: "invalid" };
+    const installed = rowInstalled(row, ctx.registry).sort(candidateOrder(ctx.edition));
+    if (installed.length === 0) return { row, status: "not-installed" };
+    const own = row.creates.item ? linkSlug(row.creates.item) : void 0;
+    const item = row.creates.item ? ((_b = installed.find((e) => e.slug === own)) != null ? _b : installed[0]).slug : void 0;
+    return { row, ...item ? { item } : {}, status: row.min_level <= ctx.classLevel ? "ok" : "level" };
+  }
+  const slug = (_c = keptSlugFor(param)) != null ? _c : param;
+  const it = ctx.registry.getByTypeAndSlug("item", slug);
+  if (!it) return { row: null, item: slug, status: "not-installed" };
+  const matching = rows.filter((r) => rowMatches(r, it)).sort((a, b) => a.min_level - b.min_level);
+  if (matching.length === 0) return { row: null, item: slug, status: "invalid" };
+  return { row: matching[0], item: slug, status: matching[0].min_level <= ctx.classLevel ? "ok" : "level" };
+}
+var MUNDANE = /* @__PURE__ */ new Set(["", "none", "mundane"]);
+var isMagic = (data) => {
+  const r = data == null ? void 0 : data.rarity;
+  return typeof r === "string" && !MUNDANE.has(r.trim().toLowerCase());
+};
+var plainText = (item) => item.replace(/^\[\[/, "").replace(/\]\]$/, "").split("|").pop().split("/").pop();
+function scaledInfuseItem(infuse, classLevel) {
+  var _a, _b;
+  let item = { ...(_a = infuse.item) != null ? _a : {} };
+  const rows = [...(_b = infuse.scales_at) != null ? _b : []].sort((a, b) => a.level - b.level);
+  for (const row of rows) if (row.level <= classLevel) item = { ...item, ...row.item };
+  return item;
+}
+function wrapInfused(entry, note, classLevel, registry) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const infuse = note.infuse;
+  const item = scaledInfuseItem(infuse, classLevel);
+  const resist = [...(_a = item.resist) != null ? _a : [], ...((_b = infuse.choice) == null ? void 0 : _b.kind) === "damage-type" && ((_c = entry.infusion) == null ? void 0 : _c.choice) ? [entry.infusion.choice] : []];
+  const overlay = {
+    ...item.bonuses ? { bonuses: item.bonuses } : {},
+    resist,
+    ...item.charges ? { charges: item.charges } : {},
+    ...item.action ? { action: item.action } : {},
+    ...item.range ? { range: item.range } : {},
+    ...infuse.attunement ? { attunement: { required: true } } : {}
+  };
+  const base = resolveBaseItem(entry.item, registry);
+  const data = (_d = base == null ? void 0 : base.data) != null ? _d : null;
+  if (base && isMagic(data)) {
+    const b = data;
+    const bonuses = { ...(_e = b.bonuses) != null ? _e : {} };
+    for (const [k, v] of Object.entries((_f = item.bonuses) != null ? _f : {})) if (typeof v === "number") bonuses[k] = (typeof bonuses[k] === "number" ? bonuses[k] : 0) + v;
+    return { entity: {
+      ...b,
+      bonuses,
+      resist: [.../* @__PURE__ */ new Set([...(_g = b.resist) != null ? _g : [], ...resist])],
+      attunement: { required: requiresAttunement(b) || !!infuse.attunement }
+    }, magicBase: true };
+  }
+  const rarity = (_h = infuse.rarity) != null ? _h : "unknown";
+  if (!base) {
+    const text = plainText(entry.item);
+    return { entity: { slug: `infused:${slugify(text)}`, name: text, type: "wondrous item", rarity, ...overlay, description: "" }, magicBase: false };
+  }
+  const name = String((_i = data == null ? void 0 : data.name) != null ? _i : base.name), description = String((_j = data == null ? void 0 : data.description) != null ? _j : "");
+  const slotted = base.entityType === "armor" || base.entityType === "weapon" ? base : typeof (data == null ? void 0 : data.base_item) === "string" ? resolveBaseItem(data.base_item, registry) : null;
+  if (slotted && (slotted.entityType === "armor" || slotted.entityType === "weapon")) {
+    const type = slotted.entityType === "weapon" ? "weapon" : isShieldArmor(slotted.data) ? "shield" : "armor";
+    return { entity: { slug: base.slug, name, type, rarity, base_item: `[[${slotted.slug}]]`, ...overlay, description }, magicBase: false };
+  }
+  return { entity: { slug: base.slug, name, type: String((_k = data == null ? void 0 : data.type) != null ? _k : "adventuring gear"), rarity, ...overlay, description }, magicBase: false };
+}
+function resolveEntryEntity(entry, index, registry, infusions) {
+  const view = !infusions ? void 0 : "views" in infusions ? infusions.views.get(index) : infusions.index === index ? infusions : void 0;
+  if (view) return { entity: view.entity, entityType: view.entityType };
+  return resolveEntityForEntry(entry.item, registry);
+}
+function buildInfusionContext(character, resolved, registry) {
+  var _a, _b, _c, _d, _e;
+  const equipment = (_a = character.equipment) != null ? _a : [];
+  const pools = ((_b = resolved.pools) != null ? _b : []).filter((p) => !!p.active || p.selected.some((e) => e.itemBound));
+  if (pools.length === 0 && !equipment.some((e) => !!e.infusion)) return void 0;
+  const owners = /* @__PURE__ */ new Map();
+  for (const pool of pools) for (const entry of pool.selected) if (entry.itemBound) owners.set(normalizedPickKey(entry.key, entry.entity.repeatable === true), { pool, entry });
+  const views = /* @__PURE__ */ new Map(), flags = [];
+  const newest = /* @__PURE__ */ new Map();
+  equipment.forEach((e, i) => {
+    if (!e.infusion) return;
+    const k = markerKey(e.infusion.by);
+    const j = newest.get(k);
+    if (j === void 0 || equipment[j].infusion.seq < e.infusion.seq) newest.set(k, i);
+  });
+  equipment.forEach((e, i) => {
+    var _a2, _b2, _c2;
+    const m = e.infusion;
+    if (!m) return;
+    const owner = owners.get(markerKey(m.by));
+    const nullView = () => {
+      var _a3, _b3, _c3, _d2, _e2;
+      return {
+        index: i,
+        kind: m.kind,
+        entity: null,
+        entityType: null,
+        key: m.by,
+        seq: m.seq,
+        poolId: (_a3 = owner == null ? void 0 : owner.pool.id) != null ? _a3 : "",
+        classIndex: (_b3 = owner == null ? void 0 : owner.pool.classIndex) != null ? _b3 : -1,
+        noteSlug: (_c3 = owner == null ? void 0 : owner.entry.slug) != null ? _c3 : "",
+        noteName: (_d2 = owner == null ? void 0 : owner.entry.entity.name) != null ? _d2 : "",
+        sourceLabel: (_e2 = owner == null ? void 0 : owner.entry.entity.name) != null ? _e2 : ""
+      };
+    };
+    if (!owner) {
+      flags.push({ index: i, reason: "orphan" });
+      if (m.kind === "created") views.set(i, nullView());
+      return;
+    }
+    if (newest.get(markerKey(m.by)) !== i) {
+      flags.push({ index: i, reason: "duplicate" });
+      if (m.kind === "created") views.set(i, nullView());
+      return;
+    }
+    if (((_a2 = e.qty) != null ? _a2 : 1) > 1) flags.push({ index: i, reason: "stack" });
+    const classLevel = (_c2 = (_b2 = resolved.classes[owner.pool.classIndex]) == null ? void 0 : _b2.level) != null ? _c2 : 0;
+    const base = {
+      index: i,
+      kind: m.kind,
+      key: m.by,
+      seq: m.seq,
+      poolId: owner.pool.id,
+      classIndex: owner.pool.classIndex,
+      noteSlug: owner.entry.slug,
+      noteName: owner.entry.entity.name,
+      sourceLabel: owner.entry.entity.name
+    };
+    if (m.kind === "created") {
+      const own = resolveEntityForEntry(e.item, registry);
+      const it = resolveBaseItem(e.item, registry);
+      const opt = owner.entry.option;
+      const fits = !!it && !!(opt == null ? void 0 : opt.row) && (opt.item === it.slug || rowMatches(opt.row, it));
+      if (!fits) flags.push({ index: i, reason: "mismatch" });
+      views.set(i, { ...base, entity: own.entity, entityType: own.entityType });
+      return;
+    }
+    if (!owner.entry.entity.infuse) {
+      flags.push({ index: i, reason: "orphan" });
+      return;
+    }
+    const w = wrapInfused(e, owner.entry.entity, classLevel, registry);
+    if (w.magicBase) flags.push({ index: i, reason: "magic-base" });
+    views.set(i, { ...base, entity: w.entity, entityType: "item" });
+  });
+  const counters = /* @__PURE__ */ new Map();
+  for (const pool of pools) {
+    const words = poolActiveWords(pool);
+    if (!words) continue;
+    const rc = resolved.classes[pool.classIndex];
+    const max = (_e = readTableColumn((_c = rc == null ? void 0 : rc.entity) == null ? void 0 : _c.table, (_d = rc == null ? void 0 : rc.level) != null ? _d : 0, [words.column])) != null ? _e : 0;
+    const used = [...views.values()].filter((v) => v.poolId === pool.id && v.entity !== null).length;
+    counters.set(pool.id, { label: words.counterLabel, used, max, over: used > max });
+  }
+  return { views, counters, flags };
+}
+function entryCharges(entry, view, registry) {
+  return effectiveItemCharges(entry, registry, view);
+}
+function withEntryCharges(entry, view, current, registry) {
+  var _a, _b, _c, _d, _e, _f;
+  const overlayMax = (view == null ? void 0 : view.kind) === "infused" ? itemChargesMax(view.entity) : void 0;
+  if (overlayMax !== void 0 && entry.infusion) return { ...entry, infusion: { ...entry.infusion, charges: { current: Math.max(0, Math.min(current, overlayMax)) } } };
+  const max = (_e = (_d = (_b = (_a = entry.state) == null ? void 0 : _a.charges) == null ? void 0 : _b.max) != null ? _d : (_c = effectiveItemCharges(entry, registry, view)) == null ? void 0 : _c.max) != null ? _e : Math.max(0, current);
+  return { ...entry, state: { ...(_f = entry.state) != null ? _f : {}, charges: { current: Math.max(0, Math.min(current, max)), max } } };
+}
+function isMarkedEntry(entry) {
+  return !!entry.infusion;
+}
+function splitOne(equipment, index) {
+  var _a, _b;
+  const src = equipment[index];
+  if (!src || ((_a = src.qty) != null ? _a : 1) <= 1) return [...equipment];
+  const one = { item: src.item, qty: 1, ...src.in !== void 0 ? { in: src.in } : {}, ...src.overrides ? { overrides: src.overrides } : {} };
+  return [...equipment.slice(0, index), { ...src, qty: ((_b = src.qty) != null ? _b : 1) - 1 }, one, ...equipment.slice(index + 1)];
+}
+var refuse = (reason) => ({ ok: false, reason });
+function endInfusion(equipment, index, registry) {
+  const entry = equipment[index];
+  if (!(entry == null ? void 0 : entry.infusion)) return { equipment: [...equipment], ended: [] };
+  const { kind, by } = entry.infusion;
+  if (kind === "infused") {
+    const { infusion: _m, ...rest } = entry;
+    const keep = requiresAttunement(resolveEntryEntity(rest, index, registry).entity);
+    const next = keep ? rest : (({ attuned: _a, ...r }) => r)(rest);
+    return { equipment: equipment.map((e, i) => i === index ? next : e), ended: [{ index, key: by, kind, item: entry.item }] };
+  }
+  const moved = equipment.map((e, i) => {
+    if (i === index || entry.id === void 0 || e.in !== entry.id) return e;
+    if (entry.in === void 0) {
+      const { in: _in, ...r } = e;
+      return r;
+    }
+    return { ...e, in: entry.in };
+  });
+  return { equipment: moved.filter((_, i) => i !== index), ended: [{ index: -1, key: by, kind, item: entry.item }] };
+}
+var pickKeyOf = (e) => normalizedPickKey(e.key, e.entity.repeatable === true);
+var nextSeq = (equipment) => equipment.reduce((m, e) => {
+  var _a, _b;
+  return Math.max(m, (_b = (_a = e.infusion) == null ? void 0 : _a.seq) != null ? _b : 0);
+}, 0) + 1;
+function ownedPick(resolved, key) {
+  var _a, _b;
+  const k = markerKey(key);
+  for (const pool of (_a = resolved.pools) != null ? _a : []) {
+    const entry = pool.selected.find((e) => e.itemBound && pickKeyOf(e) === k);
+    if (entry) return { pool, entry, stranded: strandedPicks(pool).includes(entry) || ((_b = entry.option) == null ? void 0 : _b.status) === "level" };
+  }
+  return null;
+}
+var wordsOf = (...texts) => texts.map(lc).join(" ").split(/[^a-z]+/).filter((w) => w !== "");
+function shapeOf(found, text, registry) {
+  var _a, _b, _c;
+  if (!found) return { kind: "gear", words: wordsOf(text) };
+  const data = (_a = found.data) != null ? _a : {};
+  const words = wordsOf((_b = data.name) != null ? _b : text, data.type);
+  const slotted = found.entityType === "armor" || found.entityType === "weapon" ? found : typeof data.base_item === "string" ? resolveBaseItem(data.base_item, registry) : null;
+  if ((slotted == null ? void 0 : slotted.entityType) === "armor") {
+    const armor = slotted.data;
+    return { kind: isShieldArmor(armor) ? "shield" : "armor", words, category: lc(armor.category) };
+  }
+  if ((slotted == null ? void 0 : slotted.entityType) === "weapon") {
+    const w = slotted.data;
+    return { kind: "weapon", words, category: lc(w.category), properties: ((_c = w.properties) != null ? _c : []).filter((p) => typeof p === "string").map(lc) };
+  }
+  return { kind: "gear", words };
+}
+function admits(t, s) {
+  var _a, _b, _c, _d;
+  if (t.kind !== s.kind) return false;
+  if (((_a = t.category) == null ? void 0 : _a.length) && !t.category.map(lc).includes(((_b = s.category) != null ? _b : "").split("-")[0])) return false;
+  if (t.property && !((_c = s.properties) != null ? _c : []).includes(lc(t.property))) return false;
+  if (((_d = t.name_any) == null ? void 0 : _d.length) && !t.name_any.some((n) => {
+    const w = wordsOf(n);
+    return w.length > 0 && w.every((x) => s.words.includes(x));
+  })) return false;
+  return true;
+}
+function targetVerdict(entry, infuse, registry) {
+  const found = resolveBaseItem(entry.item, registry);
+  if (!infuse.targets.some((t) => admits(t, shapeOf(found, plainText(entry.item), registry)))) return "target-kind";
+  return found && isMagic(found.data) ? "magic-base" : "ok";
+}
+function newObjectEntry(name, infuse, registry, visible) {
+  const want = lc(name);
+  const found = [];
+  for (const type of ["armor", "weapon", "item"]) {
+    for (const e of registry.search(name, type, Number.POSITIVE_INFINITY)) {
+      if (lc(e.name) === want && !isMagic(e.data) && visible(e) && infuse.targets.some((t) => admits(t, shapeOf(e, e.name, registry)))) found.push(e);
+    }
+  }
+  const first = found.sort(candidateOrder(void 0))[0];
+  return first ? { item: `[[${first.slug}]]`, qty: 1 } : { item: name, qty: 1 };
+}
+function endBySeqs(equipment, seqs, registry) {
+  let eq = [...equipment];
+  let slots = eq.map((_, i) => i);
+  const rows = [];
+  for (const { seq, by } of seqs) {
+    const i = eq.findIndex((e) => {
+      var _a;
+      return ((_a = e.infusion) == null ? void 0 : _a.seq) === seq && e.infusion.by === by;
+    });
+    if (i === -1) continue;
+    const w = endInfusion(eq, i, registry);
+    for (const row of w.ended) rows.push({ row, slot: slots[i] });
+    if (eq[i].infusion.kind === "created") slots = slots.filter((_, j) => j !== i);
+    eq = w.equipment;
+  }
+  return { equipment: eq, ended: rows.map(({ row, slot }) => row.kind === "infused" ? { ...row, index: slots.indexOf(slot) } : row) };
+}
+function displaced(equipment, resolved, pool, key) {
+  var _a;
+  const k = markerKey(key);
+  const out = equipment.filter((e) => !!e.infusion && markerKey(e.infusion.by) === k).map((e) => ({ seq: e.infusion.seq, by: e.infusion.by }));
+  const counter = (_a = resolved.infusions) == null ? void 0 : _a.counters.get(pool.id);
+  if (!counter) return out;
+  const live = [...resolved.infusions.views.values()].filter((v) => v.poolId === pool.id && v.classIndex === pool.classIndex && v.entity !== null && markerKey(v.key) !== k).sort((a, b) => a.seq - b.seq);
+  let used = live.length;
+  for (const v of live) {
+    if (used + 1 <= counter.max) break;
+    out.push({ seq: v.seq, by: v.key });
+    used--;
+  }
+  return out;
+}
+function infuseEntry(character, resolved, registry, req) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const owned = ownedPick(resolved, req.key);
+  if (!owned) return refuse("not-owned");
+  const infuse = owned.entry.entity.infuse;
+  if (!infuse) return refuse("not-infusing");
+  if (owned.stranded) return refuse("stranded");
+  const wantsChoice = ((_a = infuse.choice) == null ? void 0 : _a.kind) === "damage-type";
+  const choice = lc(req.choice);
+  if (wantsChoice && choice === "") return refuse("choice-required");
+  if (wantsChoice && !isCanonicalDamageType(choice)) return refuse("bad-choice");
+  if (wantsChoice && ((_b = infuse.choice) == null ? void 0 : _b.options) && !infuse.choice.options.some((o) => lc(o) === choice)) return refuse("bad-choice");
+  const equipment = (_c = character.equipment) != null ? _c : [];
+  const charges = scaledInfuseItem(infuse, (_e = (_d = resolved.classes[owned.pool.classIndex]) == null ? void 0 : _d.level) != null ? _e : 0).charges;
+  const marker = {
+    kind: "infused",
+    by: owned.entry.key,
+    seq: nextSeq(equipment),
+    ...wantsChoice ? { choice } : {},
+    ...charges ? { charges: { current: charges.max } } : {}
+  };
+  let placed;
+  if (typeof req.target === "number") {
+    const target = equipment[req.target];
+    if (!target) return refuse("no-target");
+    if (target.infusion) return refuse("marked");
+    const verdict = targetVerdict(target, infuse, registry);
+    if (verdict !== "ok") return refuse(verdict);
+    const split = ((_f = target.qty) != null ? _f : 1) > 1;
+    placed = split ? splitOne(equipment, req.target) : [...equipment];
+    const i = split ? req.target + 1 : req.target;
+    placed[i] = { ...placed[i], infusion: marker };
+  } else {
+    const name = req.target.newObject.trim();
+    if (name === "") return refuse("no-target");
+    placed = [...equipment, { ...newObjectEntry(name, infuse, registry, (_g = req.isEntityVisible) != null ? _g : (() => true)), infusion: marker }];
+  }
+  return { ok: true, ...endBySeqs(placed, displaced(equipment, resolved, owned.pool, owned.entry.key), registry) };
+}
+function createEntry(character, resolved, registry, req) {
+  var _a, _b;
+  const owned = ownedPick(resolved, req.key);
+  if (!owned) return refuse("not-owned");
+  const note = owned.entry.entity;
+  if (!(note.repeatable === true && !!((_a = note.options) == null ? void 0 : _a.some((r) => !!r.creates)))) return refuse("not-creating");
+  if (owned.stranded) return refuse("stranded");
+  const opt = owned.entry.option;
+  if (!(opt == null ? void 0 : opt.row) || opt.status !== "ok") return refuse("invalid-item");
+  const it = registry.getByTypeAndSlug("item", linkSlug(req.item.trim()));
+  if (!it || !(opt.item === it.slug || rowMatches(opt.row, it))) return refuse("invalid-item");
+  const equipment = (_b = character.equipment) != null ? _b : [];
+  const placed = [...equipment, { item: `[[${it.slug}]]`, qty: 1, infusion: { kind: "created", by: owned.entry.key, seq: nextSeq(equipment) } }];
+  return { ok: true, ...endBySeqs(placed, displaced(equipment, resolved, owned.pool, owned.entry.key), registry) };
+}
+function markersWhere(equipment, pick) {
+  const out = [];
+  equipment.forEach((e, index) => {
+    const m = e.infusion;
+    if (m && pick(m)) out.push({ index, key: m.by, kind: m.kind, item: e.item, seq: m.seq, by: m.by });
+  });
+  return out;
+}
+var asRows = (list) => list.map(({ index, key, kind, item }) => ({ index, key, kind, item }));
+var storedKeys = (v) => typeof v === "string" ? [v] : Array.isArray(v) ? v : [];
+function choiceEnds(character, resolved, req) {
+  var _a, _b, _c, _d, _e, _f;
+  const pool = ((_a = resolved.pools) != null ? _a : []).find((p) => p.classIndex === req.classIndex && p.id === req.choiceKey);
+  if (!pool || !(pool.active || pool.selected.some((e) => e.itemBound))) return [];
+  const choices = (_c = (_b = character.class[req.classIndex]) == null ? void 0 : _b.choices) != null ? _c : {};
+  const kept = new Set(req.next.map(markerKey));
+  for (const lvl of Object.keys(choices)) if (Number(lvl) !== req.level) for (const s of storedKeys((_d = choices[Number(lvl)]) == null ? void 0 : _d[req.choiceKey])) kept.add(markerKey(s));
+  const removed = new Set(storedKeys((_e = choices[req.level]) == null ? void 0 : _e[req.choiceKey]).map(markerKey).filter((k) => !kept.has(k)));
+  return markersWhere((_f = character.equipment) != null ? _f : [], (m) => removed.has(markerKey(m.by)));
+}
+function infusionsEndedByChoice(character, resolved, _registry, req) {
+  return asRows(choiceEnds(character, resolved, req));
+}
+function reconcileChoiceEdit(character, resolved, registry, req) {
+  var _a;
+  const list = choiceEnds(character, resolved, req);
+  return list.length === 0 ? null : endBySeqs((_a = character.equipment) != null ? _a : [], list, registry);
+}
+function classEnds(character, resolved, req) {
+  var _a, _b, _c, _d, _e;
+  let pools = ((_a = resolved.pools) != null ? _a : []).filter((p) => p.classIndex === req.classIndex);
+  if (!("remove" in req)) {
+    const old = (_c = (_b = resolved.classes[req.classIndex]) == null ? void 0 : _b.subclass) != null ? _c : null;
+    if (!old || req.subclass !== null && bareEntitySlug(linkSlug(req.subclass.trim())) === bareEntitySlug(old.slug)) return [];
+    const ids = new Set(((_d = old.selection_pools) != null ? _d : []).map((p) => p.id));
+    pools = pools.filter((p) => ids.has(p.id));
+  }
+  const owned = /* @__PURE__ */ new Set();
+  for (const pool of pools) for (const e of pool.selected) if (e.itemBound) owned.add(pickKeyOf(e));
+  return markersWhere((_e = character.equipment) != null ? _e : [], (m) => owned.has(markerKey(m.by)));
+}
+function infusionsEndedByClassEdit(character, resolved, _registry, req) {
+  return asRows(classEnds(character, resolved, req));
+}
+function reconcileClassEdit(character, resolved, registry, req) {
+  var _a;
+  const list = classEnds(character, resolved, req);
+  return list.length === 0 ? null : endBySeqs((_a = character.equipment) != null ? _a : [], list, registry);
+}
+function eligibleTargets(character, resolved, registry, key) {
+  var _a, _b;
+  const infuse = (_a = ownedPick(resolved, key)) == null ? void 0 : _a.entry.entity.infuse;
+  if (!infuse) return [];
+  const out = [];
+  ((_b = character.equipment) != null ? _b : []).forEach((e, index) => {
+    var _a2;
+    if (!e.infusion && targetVerdict(e, infuse, registry) === "ok") out.push({ index, stack: ((_a2 = e.qty) != null ? _a2 : 1) > 1 });
+  });
+  return out;
+}
+
+// src/pc/pc.entry-overrides.ts
+var WEAPON_DEFAULT_ACTION_COST = "action";
+var linkOf = (item) => {
+  var _a, _b;
+  return (_b = (_a = item.match(/^\[\[(.+)\]\]$/)) == null ? void 0 : _a[1]) != null ? _b : null;
+};
+var ruleOf = (entry, registry, view) => resolveEntryEntity(entry, view ? view.index : -1, registry, view != null ? view : null);
+function isWeaponLikeEntry(entry, registry, view) {
+  if (!registry) return false;
+  const r = ruleOf(entry, registry, view);
+  return defaultSlotForType(r.entityType, r.entity, registry) === "mainhand";
+}
+function itemsRowBranch(entry, registry, view) {
+  var _a, _b;
+  const link = linkOf(entry.item);
+  if (!link || !registry) return false;
+  const t = view ? view.entityType : (_b = (_a = registry.getBySlug(link)) == null ? void 0 : _a.entityType) != null ? _b : null;
+  return t !== "weapon" && t !== "armor" && !isWeaponLikeEntry(entry, registry, view);
+}
+function customizableOverrideKeys(entry, registry) {
+  const keys = new Set(isConsumedOnUse(entry, registry) ? ["name"] : ["name", "charges", "recovery"]);
+  if (!registry) return keys;
+  const r = ruleOf(entry, registry);
+  const slot = defaultSlotForType(r.entityType, r.entity, registry);
+  const weaponLike = slot === "mainhand";
+  const itemsRow = itemsRowBranch(entry, registry);
+  if (weaponLike) {
+    keys.add("bonus");
+    keys.add("damage_bonus");
+    keys.add("extra_damage");
+  }
+  if (slot === "armor" || slot === "shield") keys.add("ac_bonus");
+  if (weaponLike || itemsRow) keys.add("action");
+  if (itemsRow) keys.add("range");
+  if (r.entityType === "item") keys.add("resist");
+  return keys;
+}
+function defaultActionCost(entry, registry, view) {
+  var _a, _b, _c, _d, _e;
+  if (isWeaponLikeEntry(entry, registry, view)) return WEAPON_DEFAULT_ACTION_COST;
+  const link = linkOf(entry.item);
+  if (!link || !registry || !itemsRowBranch(entry, registry, view)) return null;
+  const withoutOverrides = { ...entry, overrides: void 0 };
+  const type = view ? (_a = view.entity) == null ? void 0 : _a.type : (_c = (_b = registry.getBySlug(link)) == null ? void 0 : _b.data) == null ? void 0 : _c.type;
+  return (_e = (_d = resolveItemAction(link, withoutOverrides, type, { view, spellCost: scrollSpellCost(entry, registry) })) == null ? void 0 : _d.cost) != null ? _e : null;
+}
+var SPELL_COST = { action: "action", bonus: "bonus-action", reaction: "reaction" };
+function scrollSpellCost(entry, registry) {
+  var _a, _b, _c, _d, _e;
+  const ref = (_a = entry.overrides) == null ? void 0 : _a.spell;
+  if (!ref || !registry) return void 0;
+  const castingTime = (_d = (_c = registry.getByTypeAndSlug("spell", (_b = linkOf(ref)) != null ? _b : ref)) == null ? void 0 : _c.data) == null ? void 0 : _d.casting_time;
+  const kind = typeof castingTime === "string" ? (_e = parseCastingTime(castingTime)) == null ? void 0 : _e.kind : void 0;
+  return kind ? SPELL_COST[kind] : void 0;
+}
+var chargesOf = (e) => e == null ? void 0 : e.charges;
+function itemChargesMax(entity) {
+  const c = chargesOf(entity);
+  if (typeof c === "number") return c > 0 ? c : void 0;
+  const m = c == null ? void 0 : c.max;
+  return typeof m === "number" && m > 0 ? m : void 0;
+}
+var RESET_OF = (r) => {
+  const s = String(r != null ? r : "").toLowerCase();
+  return s.includes("dawn") ? "dawn" : s.includes("short") ? "short" : s.includes("long") ? "long" : "special";
+};
+function rechargeAmount(c) {
+  var _a, _b;
+  const raw = [c.recharge_amount, c.dice].find((v) => typeof v === "string" && v.trim() !== "");
+  if (!raw) return "1";
+  const bare = raw.trim().replace(/^`+|`+$/g, "");
+  return ((_b = (_a = parseInlineTag(bare)) == null ? void 0 : _a.content) != null ? _b : bare).replace(/\s+/g, "");
+}
+var recoveryOf = (c, needRecharge) => !c || typeof c === "number" || needRecharge && (typeof c.recharge !== "string" || c.recharge.trim() === "") ? void 0 : { amount: rechargeAmount(c), reset: RESET_OF(c.recharge) };
+function effectiveItemRecovery(entry, registry, view) {
+  var _a, _b;
+  if (isConsumedOnUse(entry, registry, view)) return void 0;
+  if (view && view.entity === null) return void 0;
+  if ((view == null ? void 0 : view.kind) === "infused" && itemChargesMax(view.entity) !== void 0) return recoveryOf(chargesOf(view.entity), false);
+  if ((_a = entry.state) == null ? void 0 : _a.recovery) return entry.state.recovery;
+  const own = registry ? recoveryOf(chargesOf(ruleOf(entry, registry, view).entity), true) : void 0;
+  if (own) return own;
+  const link = linkOf(entry.item);
+  return link ? (_b = findItemAction(link)) == null ? void 0 : _b.recovery : void 0;
+}
+function isConsumedOnUse(entry, registry, view) {
+  var _a;
+  const link = linkOf(entry.item);
+  if (!link) return false;
+  if ((_a = findItemAction(link)) == null ? void 0 : _a.consumed) return true;
+  const entity = entityOf(entry, registry, view);
+  return (entity == null ? void 0 : entity.type) === "potion" || isScrollEntity(entity);
+}
+function isScrollEntity(entity) {
+  if (!entity || typeof entity !== "object") return false;
+  return entity.type === "scroll" || isCastableScroll(entity);
+}
+function isCastableScroll(entity) {
+  return !!entity && typeof entity === "object" && entity.scroll_level != null;
+}
+function entityOf(entry, registry, view) {
+  if (!registry || !linkOf(entry.item)) return null;
+  return ruleOf(entry, registry, view).entity;
+}
+function effectiveItemCharges(entry, registry, view) {
+  var _a, _b, _c, _d, _e, _f;
+  if (isConsumedOnUse(entry, registry, view)) return void 0;
+  if (view && view.entity === null) return void 0;
+  const infused = (view == null ? void 0 : view.kind) === "infused" ? itemChargesMax(view.entity) : void 0;
+  if (infused !== void 0) return { current: Math.max(0, Math.min((_c = (_b = (_a = entry.infusion) == null ? void 0 : _a.charges) == null ? void 0 : _b.current) != null ? _c : infused, infused)), max: infused };
+  const stored = (_d = entry.state) == null ? void 0 : _d.charges;
+  if (stored) return stored;
+  const own = registry ? itemChargesMax(ruleOf(entry, registry, view).entity) : void 0;
+  if (own !== void 0) return { current: own, max: own };
+  const link = linkOf(entry.item);
+  const max = link ? (_f = (_e = findItemAction(link)) == null ? void 0 : _e.max_charges) != null ? _f : 0 : 0;
+  return max > 0 ? { current: max, max } : void 0;
+}
+function effectiveItemArmorClass(entry, registry, view) {
+  var _a;
+  if (!registry) return null;
+  const { entity } = ruleOf(entry, registry, view);
+  const armor = effectiveArmor(entity, registry);
+  if (!armor) return null;
+  const shield = isShieldArmor(armor);
+  const bonus = isItemEntity(entity) && typeof ((_a = entity.bonuses) == null ? void 0 : _a.ac) === "number" ? entity.bonuses.ac : 0;
+  const terms = slotAcTerms(armor, entry);
+  return {
+    value: terms.armor + terms.override + bonus,
+    shield,
+    // raw vault data may omit the key (the armour type's `flat` note applies to it too): absent reads as no Dex
+    addDex: !shield && armor.ac.add_dex === true
+  };
+}
+
+export {
+  WEAPON_DEFAULT_ACTION_COST,
+  isWeaponLikeEntry,
+  customizableOverrideKeys,
+  defaultActionCost,
+  scrollSpellCost,
+  itemChargesMax,
+  effectiveItemRecovery,
+  isConsumedOnUse,
+  isScrollEntity,
+  isCastableScroll,
+  effectiveItemCharges,
+  effectiveItemArmorClass,
+  poolCountLabel,
+  poolActiveWords,
+  parsePickKey,
+  normalizedPickKey,
+  markerKey,
+  isItemBound,
+  optionCandidates,
+  resolveOptionRows,
+  resolveCopyOption,
+  scaledInfuseItem,
+  resolveEntryEntity,
+  buildInfusionContext,
+  entryCharges,
+  withEntryCharges,
+  isMarkedEntry,
+  splitOne,
+  endInfusion,
+  infuseEntry,
+  createEntry,
+  infusionsEndedByChoice,
+  reconcileChoiceEdit,
+  infusionsEndedByClassEdit,
+  reconcileClassEdit,
+  eligibleTargets,
+  levelPrereqMax,
+  resolvePool,
+  resolveAllPools,
+  strandedPicks
+};