@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/chunk-KU3YLF6D.js

@@ -0,0 +1,106 @@
+// src/types/choice.ts
+var ALL_SKILL_SLUGS = [
+  "acrobatics",
+  "animal-handling",
+  "arcana",
+  "athletics",
+  "deception",
+  "history",
+  "insight",
+  "intimidation",
+  "investigation",
+  "medicine",
+  "nature",
+  "perception",
+  "performance",
+  "persuasion",
+  "religion",
+  "sleight-of-hand",
+  "stealth",
+  "survival"
+];
+var STANDARD_LANGUAGES = [
+  "common",
+  "dwarvish",
+  "elvish",
+  "giant",
+  "gnomish",
+  "goblin",
+  "halfling",
+  "orc"
+];
+var EXOTIC_LANGUAGES = [
+  "abyssal",
+  "celestial",
+  "deep-speech",
+  "draconic",
+  "infernal",
+  "primordial",
+  "sylvan",
+  "undercommon"
+];
+var SECRET_LANGUAGES = ["druidic", "thieves'-cant"];
+var ALL_LANGUAGES = [
+  ...STANDARD_LANGUAGES,
+  ...EXOTIC_LANGUAGES,
+  ...SECRET_LANGUAGES
+];
+var ARTISANS_TOOLS = [
+  "alchemist's-supplies",
+  "brewer's-supplies",
+  "calligrapher's-supplies",
+  "carpenter's-tools",
+  "cartographer's-tools",
+  "cobbler's-tools",
+  "cook's-utensils",
+  "glassblower's-tools",
+  "jeweler's-tools",
+  "leatherworker's-tools",
+  "mason's-tools",
+  "painter's-supplies",
+  "potter's-tools",
+  "smith's-tools",
+  "tinker's-tools",
+  "weaver's-tools",
+  "woodcarver's-tools"
+];
+var MUSICAL_INSTRUMENTS = [
+  "bagpipes",
+  "drum",
+  "dulcimer",
+  "flute",
+  "horn",
+  "lute",
+  "lyre",
+  "pan-flute",
+  "shawm",
+  "viol"
+];
+var GAMING_SETS = ["dice-set", "playing-cards"];
+var OTHER_TOOLS = [
+  "disguise-kit",
+  "forgery-kit",
+  "herbalism-kit",
+  "navigator's-tools",
+  "poisoner's-kit",
+  "thieves'-tools"
+];
+var ALL_TOOLS = [
+  ...ARTISANS_TOOLS,
+  ...MUSICAL_INSTRUMENTS,
+  ...GAMING_SETS,
+  ...OTHER_TOOLS
+];
+
+export {
+  ALL_SKILL_SLUGS,
+  STANDARD_LANGUAGES,
+  EXOTIC_LANGUAGES,
+  SECRET_LANGUAGES,
+  ALL_LANGUAGES,
+  ARTISANS_TOOLS,
+  MUSICAL_INSTRUMENTS,
+  GAMING_SETS,
+  OTHER_TOOLS,
+  ALL_TOOLS
+};

package/dist/{chunk-5INR4NSL.js → chunk-LDDCNPHD.js}

@@ -1,6 +1,6 @@
 import {
   parseWeapon
-} from "./chunk-6NK2MUD3.js";
+} from "./chunk-HZA7OE7N.js";
 
 // src/weapon/weapon.codec.ts
 import yaml from "js-yaml";

package/dist/{chunk-5ZBE4CWV.js → chunk-LMBAEIP6.js}

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

package/dist/chunk-LVQLWRCU.js

@@ -0,0 +1,15 @@
+// src/dnd/warn-once.ts
+var seen = /* @__PURE__ */ new Set();
+function warnOnce(key, msg) {
+  if (seen.has(key)) return;
+  seen.add(key);
+  console.warn(msg);
+}
+function __resetWarnOnceForTests() {
+  seen.clear();
+}
+
+export {
+  warnOnce,
+  __resetWarnOnceForTests
+};

package/dist/chunk-MI7P3NX3.js

@@ -0,0 +1,161 @@
+import {
+  RACE_STRUCTURAL_PSEUDO
+} from "./chunk-PVCEA4HZ.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  slugify
+} from "./chunk-6X4KUDMU.js";
+import {
+  mirrorSpellShapes
+} from "./chunk-OZP6JFGT.js";
+import {
+  ABILITY_KEYS
+} from "./chunk-WELIKLZF.js";
+
+// src/pc/pc.additional-spells.ts
+var entriesOf = (a) => Array.isArray(a) ? a : a && typeof a === "object" ? [a] : [];
+var editionOf = (x) => {
+  const e = x == null ? void 0 : x.edition;
+  return typeof e === "string" ? e : void 0;
+};
+var prefixOf = (slug) => {
+  var _a;
+  return (_a = slug.split("_")[0]) != null ? _a : slug;
+};
+function normalizeSpellRef(ref) {
+  var _a, _b, _c;
+  if (typeof ref !== "string") return null;
+  let s = ref.trim();
+  const wl = /^\[\[(.+)\]\]$/.exec(s);
+  if (wl) {
+    const target = (_a = wl[1].split("|")[0]) != null ? _a : "";
+    const tail = (_b = target.split("/").pop()) != null ? _b : target;
+    const w = slugify(tail.replace(/#.*$/, "").trim());
+    return w.length > 0 ? w : null;
+  }
+  s = s.replace(/#.*$/, "");
+  s = (_c = s.split("|")[0]) != null ? _c : "";
+  const out = slugify(s.trim());
+  return out.length > 0 ? out : null;
+}
+function buildSpellNameIndex(entities) {
+  var _a;
+  const byName = /* @__PURE__ */ new Map();
+  for (const e of entities.search("", "spell", Number.POSITIVE_INFINITY)) {
+    const raw = e.data.name;
+    const key = slugify(typeof raw === "string" ? raw : e.name);
+    const list = (_a = byName.get(key)) != null ? _a : [];
+    list.push(e);
+    byName.set(key, list);
+  }
+  return { byName };
+}
+function resolveSpellByName(opts) {
+  var _a;
+  const { entities, index, nameSlug, carrierSlug, carrierEdition, alreadyCollected } = opts;
+  const own = alreadyCollected.find((s) => {
+    var _a2;
+    return slugify(String((_a2 = s.entity.name) != null ? _a2 : "")) === nameSlug;
+  });
+  if (own) return { entity: own.entity, slug: own.slug };
+  const exact = entities.getByTypeAndSlug("spell", `${prefixOf(carrierSlug)}_spell_${nameSlug}`);
+  if (exact) return { entity: mirrorSpellShapes(exact.data), slug: exact.slug };
+  const cands = (_a = index.byName.get(nameSlug)) != null ? _a : [];
+  if (cands.length === 0) {
+    warnOnce(`addspells:miss:${nameSlug}`, `archivist: additional_spells ref "${nameSlug}" matches no spell in the compendium`);
+    return null;
+  }
+  const prefix = prefixOf(carrierSlug);
+  let pool = cands.filter((e) => prefixOf(e.slug) === prefix);
+  if (pool.length === 0) pool = cands;
+  if (carrierEdition !== void 0) {
+    const same = pool.filter((e) => editionOf(e.data) === carrierEdition);
+    if (same.length > 0) pool = same;
+  }
+  pool = [...pool].sort((a, b) => a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+  if (pool.length > 1) warnOnce(`addspells:multi:${nameSlug}`, `archivist: additional_spells ref "${nameSlug}" matches ${cands.length} spells; using "${pool[0].slug}"`);
+  return { entity: mirrorSpellShapes(pool[0].data), slug: pool[0].slug };
+}
+var hasContentSelectInline = (choices) => Array.isArray(choices) && choices.some((c) => (c == null ? void 0 : c.kind) === "select-inline" && typeof c.id === "string" && !RACE_STRUCTURAL_PSEUDO.has(c.id) || Array.isArray(c == null ? void 0 : c.options) && c.options.some((o) => hasContentSelectInline(o == null ? void 0 : o.choices)));
+function raceIsUngated(race) {
+  var _a;
+  const r = race;
+  if (hasContentSelectInline(r.choices)) return false;
+  return !((_a = r.traits) != null ? _a : []).some((t) => hasContentSelectInline(t == null ? void 0 : t.choices));
+}
+var readAbility = (v, own) => {
+  if (v && typeof v === "object" && "choose" in v) return "choose";
+  if (typeof v !== "string") return void 0;
+  if (v === "inherit") return own != null ? own : void 0;
+  return ABILITY_KEYS.includes(v) ? v : void 0;
+};
+var entryHasInSliceLeaf = (e, comparand, own) => readAbility(e.ability, own) !== "choose" && ["known", "prepared"].some((b) => {
+  const lv = e[b];
+  return !!lv && typeof lv === "object" && !Array.isArray(lv) && Object.entries(lv).some(([k, v]) => (k === "_" || Number(k) <= comparand) && Array.isArray(v) && v.some((x) => typeof x === "string"));
+});
+function collectAdditionalSpells(args) {
+  const { race, feats, classes, totalLevel, ownAbility, alreadyCollected, entities, warnings } = args;
+  let index = null;
+  const indexOf = () => index != null ? index : index = buildSpellNameIndex(entities);
+  const out = [];
+  const carriers = [];
+  const asRaw = (x) => x == null ? void 0 : x.additional_spells;
+  if (race && raceIsUngated(race)) carriers.push({ root: "race", slug: race.slug, edition: editionOf(race), entries: entriesOf(asRaw(race)), comparand: totalLevel, classSlug: null });
+  for (const f of feats) carriers.push({ root: "feat", slug: f.slug, edition: editionOf(f), entries: entriesOf(asRaw(f)), comparand: totalLevel, classSlug: null });
+  for (const c of classes) {
+    if (!c.entity) continue;
+    carriers.push({ root: "class", slug: c.entity.slug, edition: editionOf(c.entity), entries: entriesOf(asRaw(c.entity)), comparand: c.level, classSlug: c.entity.slug });
+    if (c.subclass) carriers.push({ root: "subclass", slug: c.subclass.slug, edition: editionOf(c.subclass), entries: entriesOf(asRaw(c.subclass)), comparand: c.level, classSlug: c.entity.slug });
+  }
+  for (const car of carriers) {
+    if (car.entries.length === 0) continue;
+    if (car.entries.length > 1) {
+      if (car.entries.some((e) => entryHasInSliceLeaf(e, car.comparand, ownAbility))) warnOnce(`addspells:siblings:${car.slug}`, `archivist: additional_spells on "${car.slug}" has ${car.entries.length} sibling entries (a choose-one grant); skipped`);
+      continue;
+    }
+    const entry = car.entries[0];
+    const ability = readAbility(entry.ability, ownAbility);
+    if (ability === "choose") continue;
+    for (const bucket of ["known", "prepared"]) {
+      const levels = entry[bucket];
+      if (!levels || typeof levels !== "object" || Array.isArray(levels)) continue;
+      for (const [k, v] of Object.entries(levels)) {
+        if (!(k === "_" || Number(k) <= car.comparand)) continue;
+        if (!Array.isArray(v)) {
+          warnOnce(`addspells:usage:${car.slug}:${bucket}:${k}`, `archivist: additional_spells on "${car.slug}" ${bucket}.${k} is a usage economy (skipped; G8)`);
+          continue;
+        }
+        for (const leaf of v) {
+          const nameSlug = normalizeSpellRef(leaf);
+          if (!nameSlug) continue;
+          const hit = resolveSpellByName({ entities, index: indexOf(), nameSlug, carrierSlug: car.slug, carrierEdition: car.edition, alreadyCollected: [...alreadyCollected, ...out] });
+          if (!hit) {
+            warnings.push(`additional_spells ref "${String(leaf)}" on ${car.slug} not found in compendium.`);
+            continue;
+          }
+          out.push({
+            entity: hit.entity,
+            slug: hit.slug,
+            classSlug: car.classSlug,
+            source: car.root === "race" ? "race" : car.root === "feat" ? "feat" : "class",
+            prepared: true,
+            alwaysPrepared: true,
+            ...ability ? { ability } : {}
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+export {
+  prefixOf,
+  normalizeSpellRef,
+  buildSpellNameIndex,
+  resolveSpellByName,
+  raceIsUngated,
+  collectAdditionalSpells
+};

package/dist/chunk-O4SRD3J5.js

@@ -0,0 +1,165 @@
+import {
+  derivePoolLayout
+} from "./chunk-PP2UHLBA.js";
+import {
+  readTableColumn
+} from "./chunk-IUAAXXNO.js";
+import {
+  warnOnce
+} from "./chunk-LVQLWRCU.js";
+import {
+  bareEntitySlug,
+  wikilinkTailSlug
+} from "./chunk-6X4KUDMU.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) {
+  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 byBare = /* @__PURE__ */ new Map();
+  const candidates = /* @__PURE__ */ new Map();
+  for (const e of all) {
+    const d = e.data;
+    const entry = { slug: e.slug, entity: d, ...e.compendium ? { compendium: 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) {
+      const d = full.data;
+      return { slug: full.slug, entity: d, ...full.compendium ? { compendium: 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 seenBare = /* @__PURE__ */ new Set();
+  for (const s of selectedSlugs) {
+    const entry = resolveStored(s);
+    if (!entry) continue;
+    const bare = bareEntitySlug(entry.slug);
+    if (grantedBare.has(bare) || seenBare.has(bare)) continue;
+    seenBare.add(bare);
+    selected.push(entry);
+  }
+  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;
+  }
+  return {
+    id: pool.id,
+    label: pool.label,
+    classIndex,
+    count,
+    anchorLevel,
+    selected,
+    available,
+    grants,
+    ...layout ? { layout } : {},
+    ...resource ? { resource } : {}
+  };
+}
+function resolveAllPools(resolved, registry, index) {
+  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, index));
+    }
+  });
+  return out;
+}
+function strandedPicks(pool) {
+  const inAvailable = new Set(pool.available.map((e) => e.slug));
+  return pool.selected.filter((e) => !inAvailable.has(e.slug));
+}
+
+export {
+  levelPrereqMax,
+  resolvePool,
+  resolveAllPools,
+  strandedPicks
+};

package/dist/{chunk-D3CLOBE3.js → chunk-OSQFPGLM.js}

@@ -1,25 +1,25 @@
 import {
   classifyWeaponRange
-} from "./chunk-353WXS6S.js";
-import {
-  normKey
-} from "./chunk-O5EYMKFH.js";
+} from "./chunk-UIRMA5KM.js";
 import {
   defaultSlotForType,
   effectiveArmor,
   isItemEntity,
   isWeaponEntity,
   resolveEntityForEntry
-} from "./chunk-N6N74K6X.js";
+} from "./chunk-UBBKSYBY.js";
+import {
+  normKey
+} from "./chunk-RLGQ5PZZ.js";
 import {
   readNumericBonus
 } from "./chunk-LWFTHJIE.js";
 import {
   resolveBaseItem
-} from "./chunk-4LZJXJJS.js";
+} from "./chunk-WXWPK3LI.js";
 import {
   bareEntitySlug
-} from "./chunk-LV4SNWZQ.js";
+} from "./chunk-6X4KUDMU.js";
 
 // src/weapon/weapon-mastery.ts
 var MASTERY = {
@@ -405,7 +405,7 @@ function magicBonusesForWeaponEntry(entry, registry, ctx) {
     itemRiders = Array.isArray(entity.damage_riders) ? entity.damage_riders.filter((r) => {
       var _a2;
       return ((_a2 = r.applies_to) != null ? _a2 : "weapon") !== "spell";
-    }).map((r) => ({ amount: r.amount, damage_type: r.damage_type, source: entity.name })) : [];
+    }).map((r) => ({ amount: r.amount, damage_type: r.damage_type, source: entity.name, ...r.condition ? { condition: r.condition } : {} })) : [];
   }
   return {
     atk: itemAttack + entryAttack,
@@ -482,6 +482,40 @@ function buildAttackRow(args) {
   }
   return row;
 }
+function buildUnarmedRow(mods, proficiencyBonus, spec) {
+  var _a;
+  const candidates = ["str", ...(_a = spec == null ? void 0 : spec.abilities) != null ? _a : []];
+  let ability = "str";
+  for (const ab of candidates) if (mods[ab] >= mods[ability]) ability = ab;
+  const abilityMod = mods[ability];
+  const toHit = abilityMod + proficiencyBonus;
+  const flat = `${abilityMod >= 0 ? "+" : ""}${abilityMod}`.replace(/^\+0$/, "");
+  const damageDice = (spec == null ? void 0 : spec.dice) ? `${spec.dice}${flat}` : String(Math.max(0, 1 + abilityMod));
+  const label = `${ability.toUpperCase()} modifier`;
+  return {
+    id: "unarmed-strike",
+    name: "Unarmed Strike",
+    unarmed: true,
+    range: "5 ft",
+    toHit,
+    damageDice,
+    damageType: "bludgeoning",
+    properties: [],
+    proficient: true,
+    breakdown: {
+      toHit: [
+        { source: label, amount: abilityMod, kind: "ability" },
+        { source: "Proficiency bonus", amount: proficiencyBonus, kind: "ability" }
+      ],
+      damage: [
+        { source: "Base damage", amount: 0, kind: "ability" },
+        { source: label, amount: abilityMod, kind: "ability" }
+      ]
+    },
+    subLabel: "Unarmed",
+    actionCost: "action"
+  };
+}
 function humanizeWeaponToken(s) {
   return s.replace(/[-_]/g, " ").replace(/(^|[\s(])\w/g, (c) => c.toUpperCase());
 }
@@ -594,5 +628,7 @@ function computeSlotsAndAttacks(resolved, mods, profs, registry, warnings, profi
 export {
   emptyAppliedBonuses,
   computeAppliedBonuses,
+  isWeaponSlugProficient,
+  buildUnarmedRow,
   computeSlotsAndAttacks
 };