@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/chunk-DPUJDOKV.js

@@ -0,0 +1,365 @@
+import {
+  readTableColumn
+} from "./chunk-IUAAXXNO.js";
+import {
+  bareSlug,
+  baseClassName
+} from "./chunk-VTTA2ALZ.js";
+import {
+  abilityModifier
+} from "./chunk-PDJSUH24.js";
+
+// src/pc/pc.spellcasting.ts
+function hasPreparedColumn(table) {
+  return Object.values(table).some((row) => PREPARED_COLUMNS.some((k) => {
+    var _a;
+    return ((_a = row == null ? void 0 : row.columns) == null ? void 0 : _a[k]) !== void 0;
+  }));
+}
+function resolveSpellcasting(rc) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  const sub = (_b = (_a = rc.subclass) == null ? void 0 : _a.spellcasting) != null ? _b : null;
+  const cls = (_d = (_c = rc.entity) == null ? void 0 : _c.spellcasting) != null ? _d : null;
+  const casterType = (_f = (_e = sub == null ? void 0 : sub.caster_type) != null ? _e : cls == null ? void 0 : cls.caster_type) != null ? _f : null;
+  const ability = (_h = (_g = sub == null ? void 0 : sub.ability) != null ? _g : cls == null ? void 0 : cls.ability) != null ? _h : null;
+  if (!casterType || !ability) return null;
+  const table = (_l = (_k = (sub == null ? void 0 : sub.caster_type) ? (_i = rc.subclass) == null ? void 0 : _i.table : void 0) != null ? _k : (_j = rc.entity) == null ? void 0 : _j.table) != null ? _l : {};
+  const preparation = (_n = (_m = sub == null ? void 0 : sub.preparation) != null ? _m : cls == null ? void 0 : cls.preparation) != null ? _n : hasPreparedColumn(table) ? "prepared" : "known";
+  const spellList = (_p = (_o = sub == null ? void 0 : sub.spell_list) != null ? _o : cls == null ? void 0 : cls.spell_list) != null ? _p : null;
+  return { ability, casterType, preparation, spellList, table };
+}
+function effectiveSpellcastingAbility(classSlug, dataAbility, overrides) {
+  var _a, _b;
+  return (_b = (_a = overrides.spellcasting_ability_by_class) == null ? void 0 : _a[classSlug]) != null ? _b : dataAbility;
+}
+function normalizeKnownSpell(entry) {
+  var _a, _b;
+  if (typeof entry === "string") {
+    return { slug: bareSlug(entry), classSlug: null, source: "class", preparedFlag: void 0, alwaysPrepared: false };
+  }
+  return {
+    slug: bareSlug(entry.spell),
+    classSlug: entry.class ? bareSlug(entry.class) : null,
+    source: (_a = entry.source) != null ? _a : "class",
+    preparedFlag: entry.prepared,
+    alwaysPrepared: (_b = entry.always_prepared) != null ? _b : false
+  };
+}
+function firstListedCasterClass(spellClasses, casterClassSlugs) {
+  var _a;
+  if (!Array.isArray(spellClasses) || spellClasses.length === 0) return null;
+  const listed = new Set(spellClasses.map((c) => baseClassName(String(c))));
+  return (_a = casterClassSlugs.find((slug) => listed.has(baseClassName(slug)))) != null ? _a : null;
+}
+var LISTED_CLASS_NAMES = /* @__PURE__ */ new WeakMap();
+var NO_NAMES = /* @__PURE__ */ new Set();
+function listedSpellClassNames(registry, compendium) {
+  var _a;
+  const count = registry.count();
+  let cached = LISTED_CLASS_NAMES.get(registry);
+  if (!cached || cached.count !== count) {
+    const byCompendium = /* @__PURE__ */ new Map();
+    for (const e of registry.search("", "spell", Number.POSITIVE_INFINITY)) {
+      const classes = e.data.classes;
+      if (!Array.isArray(classes)) continue;
+      let names = byCompendium.get(e.compendium);
+      if (!names) byCompendium.set(e.compendium, names = /* @__PURE__ */ new Set());
+      for (const c of classes) names.add(baseClassName(String(c)));
+    }
+    cached = { count, byCompendium };
+    LISTED_CLASS_NAMES.set(registry, cached);
+  }
+  return (_a = cached.byCompendium.get(compendium)) != null ? _a : NO_NAMES;
+}
+function attributeUnclassedSpell(spellClasses, casters, registry) {
+  var _a;
+  const first = casters[0];
+  if (!first) return null;
+  const listed = firstListedCasterClass(spellClasses, casters.map((c) => c.classSlug));
+  if (listed == null || listed === first.classSlug) return first.classSlug;
+  if (first.spellList == null) return first.classSlug;
+  const compendium = (_a = registry.getByTypeAndSlug("class", first.classSlug)) == null ? void 0 : _a.compendium;
+  if (compendium == null || !listedSpellClassNames(registry, compendium).has(baseClassName(first.classSlug))) return first.classSlug;
+  return listed;
+}
+var FULL_CASTER_SLOTS = [
+  /* 1  */
+  [2, 0, 0, 0, 0, 0, 0, 0, 0],
+  /* 2  */
+  [3, 0, 0, 0, 0, 0, 0, 0, 0],
+  /* 3  */
+  [4, 2, 0, 0, 0, 0, 0, 0, 0],
+  /* 4  */
+  [4, 3, 0, 0, 0, 0, 0, 0, 0],
+  /* 5  */
+  [4, 3, 2, 0, 0, 0, 0, 0, 0],
+  /* 6  */
+  [4, 3, 3, 0, 0, 0, 0, 0, 0],
+  /* 7  */
+  [4, 3, 3, 1, 0, 0, 0, 0, 0],
+  /* 8  */
+  [4, 3, 3, 2, 0, 0, 0, 0, 0],
+  /* 9  */
+  [4, 3, 3, 3, 1, 0, 0, 0, 0],
+  /* 10 */
+  [4, 3, 3, 3, 2, 0, 0, 0, 0],
+  /* 11 */
+  [4, 3, 3, 3, 2, 1, 0, 0, 0],
+  /* 12 */
+  [4, 3, 3, 3, 2, 1, 0, 0, 0],
+  /* 13 */
+  [4, 3, 3, 3, 2, 1, 1, 0, 0],
+  /* 14 */
+  [4, 3, 3, 3, 2, 1, 1, 0, 0],
+  /* 15 */
+  [4, 3, 3, 3, 2, 1, 1, 1, 0],
+  /* 16 */
+  [4, 3, 3, 3, 2, 1, 1, 1, 0],
+  /* 17 */
+  [4, 3, 3, 3, 2, 1, 1, 1, 1],
+  /* 18 */
+  [4, 3, 3, 3, 3, 1, 1, 1, 1],
+  /* 19 */
+  [4, 3, 3, 3, 3, 2, 1, 1, 1],
+  /* 20 */
+  [4, 3, 3, 3, 3, 2, 2, 1, 1]
+];
+var HALF_CASTER_SLOTS = [
+  /* 1  */
+  [0, 0, 0, 0, 0],
+  /* 2  */
+  [2, 0, 0, 0, 0],
+  /* 3  */
+  [3, 0, 0, 0, 0],
+  /* 4  */
+  [3, 0, 0, 0, 0],
+  /* 5  */
+  [4, 2, 0, 0, 0],
+  /* 6  */
+  [4, 2, 0, 0, 0],
+  /* 7  */
+  [4, 3, 0, 0, 0],
+  /* 8  */
+  [4, 3, 0, 0, 0],
+  /* 9  */
+  [4, 3, 2, 0, 0],
+  /* 10 */
+  [4, 3, 2, 0, 0],
+  /* 11 */
+  [4, 3, 3, 0, 0],
+  /* 12 */
+  [4, 3, 3, 0, 0],
+  /* 13 */
+  [4, 3, 3, 1, 0],
+  /* 14 */
+  [4, 3, 3, 1, 0],
+  /* 15 */
+  [4, 3, 3, 2, 0],
+  /* 16 */
+  [4, 3, 3, 2, 0],
+  /* 17 */
+  [4, 3, 3, 3, 1],
+  /* 18 */
+  [4, 3, 3, 3, 1],
+  /* 19 */
+  [4, 3, 3, 3, 2],
+  /* 20 */
+  [4, 3, 3, 3, 2]
+];
+var THIRD_CASTER_SLOTS = [
+  /* 1  */
+  [0, 0, 0, 0],
+  /* 2  */
+  [0, 0, 0, 0],
+  /* 3  */
+  [2, 0, 0, 0],
+  /* 4  */
+  [3, 0, 0, 0],
+  /* 5  */
+  [3, 0, 0, 0],
+  /* 6  */
+  [3, 0, 0, 0],
+  /* 7  */
+  [4, 2, 0, 0],
+  /* 8  */
+  [4, 2, 0, 0],
+  /* 9  */
+  [4, 2, 0, 0],
+  /* 10 */
+  [4, 3, 0, 0],
+  /* 11 */
+  [4, 3, 0, 0],
+  /* 12 */
+  [4, 3, 0, 0],
+  /* 13 */
+  [4, 3, 2, 0],
+  /* 14 */
+  [4, 3, 2, 0],
+  /* 15 */
+  [4, 3, 2, 0],
+  /* 16 */
+  [4, 3, 3, 0],
+  /* 17 */
+  [4, 3, 3, 0],
+  /* 18 */
+  [4, 3, 3, 0],
+  /* 19 */
+  [4, 3, 3, 1],
+  /* 20 */
+  [4, 3, 3, 1]
+];
+var PACT_MAGIC = [
+  /* 1  */
+  { level: 1, total: 1 },
+  /* 2  */
+  { level: 1, total: 2 },
+  /* 3  */
+  { level: 2, total: 2 },
+  /* 4  */
+  { level: 2, total: 2 },
+  /* 5  */
+  { level: 3, total: 2 },
+  /* 6  */
+  { level: 3, total: 2 },
+  /* 7  */
+  { level: 4, total: 2 },
+  /* 8  */
+  { level: 4, total: 2 },
+  /* 9  */
+  { level: 5, total: 2 },
+  /* 10 */
+  { level: 5, total: 2 },
+  /* 11 */
+  { level: 5, total: 3 },
+  /* 12 */
+  { level: 5, total: 3 },
+  /* 13 */
+  { level: 5, total: 3 },
+  /* 14 */
+  { level: 5, total: 3 },
+  /* 15 */
+  { level: 5, total: 3 },
+  /* 16 */
+  { level: 5, total: 3 },
+  /* 17 */
+  { level: 5, total: 4 },
+  /* 18 */
+  { level: 5, total: 4 },
+  /* 19 */
+  { level: 5, total: 4 },
+  /* 20 */
+  { level: 5, total: 4 }
+];
+var ARTIFICER_CASTER_SLOTS = HALF_CASTER_SLOTS.map((row) => [...row]);
+ARTIFICER_CASTER_SLOTS[0] = [2, 0, 0, 0, 0];
+function slotTableFor(caster) {
+  switch (caster) {
+    case "full":
+      return FULL_CASTER_SLOTS;
+    case "half":
+      return HALF_CASTER_SLOTS;
+    case "third":
+      return THIRD_CASTER_SLOTS;
+    case "artificer":
+      return ARTIFICER_CASTER_SLOTS;
+    default: {
+      const _n = caster;
+      throw new Error(`unknown caster type ${String(_n)}`);
+    }
+  }
+}
+function rowToRecord(row) {
+  const out = {};
+  row.forEach((n, i) => {
+    if (n > 0) out[i + 1] = n;
+  });
+  return out;
+}
+function deriveSpellSlots(classes) {
+  let fullLevels = 0, halfLevels = 0, thirdLevels = 0, artificerLevels = 0, warlockLevel = 0;
+  const regular = [];
+  for (const c of classes) {
+    if (c.casterType === "pact") {
+      warlockLevel += c.level;
+      continue;
+    }
+    regular.push({ caster: c.casterType, level: c.level });
+    switch (c.casterType) {
+      case "full":
+        fullLevels += c.level;
+        break;
+      case "half":
+        halfLevels += c.level;
+        break;
+      case "third":
+        thirdLevels += c.level;
+        break;
+      case "artificer":
+        artificerLevels += c.level;
+        break;
+      default: {
+        const _n = c.casterType;
+        throw new Error(`unknown caster type ${String(_n)}`);
+      }
+    }
+  }
+  let standard = {};
+  if (regular.length === 1) {
+    const only = regular[0];
+    const table = slotTableFor(only.caster);
+    const idx = only.level - 1;
+    if (idx >= 0 && idx < table.length) standard = rowToRecord(table[idx]);
+  } else if (regular.length >= 2) {
+    const cl = fullLevels + Math.floor(halfLevels / 2) + Math.floor(thirdLevels / 3) + Math.ceil(artificerLevels / 2);
+    if (cl >= 1 && cl <= FULL_CASTER_SLOTS.length) standard = rowToRecord(FULL_CASTER_SLOTS[cl - 1]);
+  }
+  const pact = warlockLevel >= 1 && warlockLevel <= PACT_MAGIC.length ? PACT_MAGIC[warlockLevel - 1] : null;
+  return { standard, pact };
+}
+var PREPARED_COLUMNS = ["Prepared Spells", "Spells Prepared"];
+function preparedLevelTerm(caster, level) {
+  switch (caster) {
+    case "full":
+    case "pact":
+      return level;
+    case "half":
+    case "artificer":
+      return Math.floor(level / 2);
+    case "third":
+      return Math.floor(level / 3);
+    default: {
+      const _n = caster;
+      throw new Error(`unknown caster type ${String(_n)}`);
+    }
+  }
+}
+function computeSpellLimits(inputs) {
+  const out = [];
+  for (const i of inputs) {
+    const p = i.profile;
+    const cantripsKnown = readTableColumn(p.table, i.level, ["Cantrips Known", "Cantrips"]);
+    const mod = abilityModifier(i.abilityScore);
+    let preparedOrKnown;
+    if (p.preparation === "prepared") {
+      const fromTable = readTableColumn(p.table, i.level, PREPARED_COLUMNS);
+      preparedOrKnown = fromTable !== null ? fromTable : Math.max(1, mod + preparedLevelTerm(p.casterType, i.level));
+    } else {
+      preparedOrKnown = readTableColumn(p.table, i.level, ["Spells Known", "Prepared Spells"]);
+    }
+    out.push({ classSlug: i.classSlug, kind: p.preparation, cantripsKnown, preparedOrKnown });
+  }
+  return out;
+}
+
+export {
+  resolveSpellcasting,
+  effectiveSpellcastingAbility,
+  normalizeKnownSpell,
+  listedSpellClassNames,
+  attributeUnclassedSpell,
+  slotTableFor,
+  deriveSpellSlots,
+  PREPARED_COLUMNS,
+  preparedLevelTerm,
+  computeSpellLimits
+};

package/dist/{chunk-73HOFQQ5.js → chunk-ESS46GR4.js}

@@ -1,6 +1,6 @@
 import {
   parseFeat
-} from "./chunk-XTIQWSFM.js";
+} from "./chunk-D5U7GMPX.js";
 
 // src/feat/feat.codec.ts
 import yaml from "js-yaml";

package/dist/chunk-EVMUJYUD.js

@@ -0,0 +1,195 @@
+// src/dnd/resource-formula.ts
+var IDENTS = /* @__PURE__ */ new Set([
+  "level",
+  "class_level",
+  "prof",
+  "str_mod",
+  "dex_mod",
+  "con_mod",
+  "int_mod",
+  "wis_mod",
+  "cha_mod"
+]);
+var AT_WILL_MAX = 999;
+var FUNCS = /* @__PURE__ */ new Set(["ceil", "floor", "max", "min"]);
+function tokenize(input) {
+  input = input.trim();
+  const tokens = [];
+  const re = /\s*('[^']*'|\{[a-z_]+\}|[a-z_]+|\d+|[+\-*/(),])/y;
+  let i = 0;
+  while (i < input.length) {
+    re.lastIndex = i;
+    const m = re.exec(input);
+    if (!m || m.index !== i) return null;
+    const raw = m[1];
+    i = re.lastIndex;
+    if (/^\d+$/.test(raw)) tokens.push({ kind: "num", value: parseInt(raw, 10) });
+    else if (raw.startsWith("'")) tokens.push({ kind: "str", value: raw.slice(1, -1) });
+    else if (raw === "(") tokens.push({ kind: "lparen" });
+    else if (raw === ")") tokens.push({ kind: "rparen" });
+    else if (raw === ",") tokens.push({ kind: "comma" });
+    else if (raw === "+" || raw === "-" || raw === "*" || raw === "/") tokens.push({ kind: "op", op: raw });
+    else {
+      const braced = raw.startsWith("{");
+      const name = braced ? raw.slice(1, -1) : raw;
+      if (!braced && FUNCS.has(name)) tokens.push({ kind: "fn", name });
+      else if (!braced && name === "column") tokens.push({ kind: "col" });
+      else if (IDENTS.has(name)) tokens.push({ kind: "id", name });
+      else return null;
+    }
+  }
+  return tokens.length > 0 ? tokens : null;
+}
+function evalTokens(tokens, b) {
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const factor = () => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const t = peek();
+    if (!t) return null;
+    if (t.kind === "num") {
+      pos++;
+      return t.value;
+    }
+    if (t.kind === "id") {
+      const val = b[t.name];
+      if (val === void 0) return null;
+      pos++;
+      return val;
+    }
+    if (t.kind === "fn") {
+      pos++;
+      if (((_a = peek()) == null ? void 0 : _a.kind) !== "lparen") return null;
+      pos++;
+      const args = [];
+      const first = expr();
+      if (first === null) return null;
+      args.push(first);
+      while (((_b = peek()) == null ? void 0 : _b.kind) === "comma") {
+        pos++;
+        const next = expr();
+        if (next === null) return null;
+        args.push(next);
+      }
+      if (((_c = peek()) == null ? void 0 : _c.kind) !== "rparen") return null;
+      pos++;
+      if (t.name === "ceil" || t.name === "floor") {
+        if (args.length !== 1) return null;
+        return t.name === "ceil" ? Math.ceil(args[0]) : Math.floor(args[0]);
+      }
+      if (args.length < 2) return null;
+      return t.name === "max" ? Math.max(...args) : Math.min(...args);
+    }
+    if (t.kind === "col") {
+      pos++;
+      if (((_d = peek()) == null ? void 0 : _d.kind) !== "lparen") return null;
+      pos++;
+      const s = peek();
+      if (!s || s.kind !== "str") return null;
+      pos++;
+      if (((_e = peek()) == null ? void 0 : _e.kind) !== "rparen") return null;
+      pos++;
+      return (_g = (_f = b.columns) == null ? void 0 : _f[s.value]) != null ? _g : 0;
+    }
+    if (t.kind === "lparen") {
+      pos++;
+      const inner = expr();
+      if (inner === null) return null;
+      if (((_h = peek()) == null ? void 0 : _h.kind) !== "rparen") return null;
+      pos++;
+      return inner;
+    }
+    return null;
+  };
+  const term = () => {
+    var _a;
+    let v = factor();
+    if (v === null) return null;
+    while (((_a = peek()) == null ? void 0 : _a.kind) === "op" && (peek().op === "*" || peek().op === "/")) {
+      const op = peek().op;
+      pos++;
+      const r = factor();
+      if (r === null) return null;
+      v = op === "*" ? v * r : v / r;
+    }
+    return v;
+  };
+  const expr = () => {
+    var _a;
+    let v = term();
+    if (v === null) return null;
+    while (((_a = peek()) == null ? void 0 : _a.kind) === "op" && (peek().op === "+" || peek().op === "-")) {
+      const op = peek().op;
+      pos++;
+      const r = term();
+      if (r === null) return null;
+      v = op === "+" ? v + r : v - r;
+    }
+    return v;
+  };
+  const result = expr();
+  if (result === null || pos !== tokens.length) return null;
+  return result;
+}
+var ZERO = {
+  level: 1,
+  class_level: 1,
+  prof: 2,
+  str_mod: 0,
+  dex_mod: 0,
+  con_mod: 0,
+  int_mod: 0,
+  wis_mod: 0,
+  cha_mod: 0,
+  columns: {}
+};
+function isValidMaxFormula(formula) {
+  const toks = tokenize(formula);
+  if (!toks) return false;
+  return evalTokens(toks, ZERO) !== null;
+}
+function evaluateMaxFormula(formula, bindings) {
+  const toks = tokenize(formula);
+  if (!toks) throw new Error(`invalid max_formula: ${JSON.stringify(formula)}`);
+  const v = evalTokens(toks, bindings);
+  if (v === null) throw new Error(`invalid max_formula: ${JSON.stringify(formula)}`);
+  return v;
+}
+function resolveMaxAt(totalLevel, resource) {
+  var _a;
+  let chosen = resource.max_formula;
+  let best = 0;
+  for (const step of (_a = resource.scales_at) != null ? _a : []) {
+    if (step.level <= totalLevel && step.level > best) {
+      best = step.level;
+      chosen = step.max;
+    }
+  }
+  return chosen;
+}
+function resolveMaxCountAt(level, resource, bindings) {
+  var _a;
+  const tryEval = (s) => {
+    const toks = tokenize(s);
+    return toks ? evalTokens(toks, bindings) : null;
+  };
+  let best = 0;
+  let chosen = null;
+  for (const step of (_a = resource.scales_at) != null ? _a : []) {
+    if (step.level > level || step.level <= best) continue;
+    const v = tryEval(step.max);
+    if (v === null) continue;
+    best = step.level;
+    chosen = v;
+  }
+  if (chosen !== null) return chosen;
+  return tryEval(resource.max_formula);
+}
+
+export {
+  AT_WILL_MAX,
+  isValidMaxFormula,
+  evaluateMaxFormula,
+  resolveMaxAt,
+  resolveMaxCountAt
+};

package/dist/{chunk-2BWAID3Y.js → chunk-FDBWYMZK.js}

@@ -1,9 +1,13 @@
 import {
   featureSchema
-} from "./chunk-CZPMTQOY.js";
+} from "./chunk-4FWNK4FD.js";
 import {
   choiceSchema
-} from "./chunk-NXSWH3AE.js";
+} from "./chunk-T26ZVCL5.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField
+} from "./chunk-UA5KS2PL.js";
 
 // src/race/race.schema.ts
 import { z } from "zod";
@@ -55,9 +59,31 @@ var raceEntitySchema = z.object({
   variant_label: z.string().min(1),
   traits: z.array(featureSchema),
   choices: z.array(choiceSchema).optional(),
-  subspecies_of: z.string().regex(wikilinkRegex).optional()
+  subspecies_of: z.string().regex(wikilinkRegex).optional(),
+  rendering_hint: z.string().optional(),
+  has_fluff: z.boolean().optional(),
+  has_fluff_images: z.boolean().optional(),
+  creature_type: z.array(z.string().min(1)).optional(),
+  // guarded non-empty at the emitter (finding 24)
+  creature_type_tags: z.array(z.string().min(1)).optional(),
+  additional_spells: z.union([
+    z.array(additionalSpellsEntrySchema),
+    // converter form, 109 docs
+    additionalSpellsEntrySchema
+    // SHIPPED-BUNDLE bare-object form, 3 docs (§2.8)
+  ]).optional(),
+  // The four RAW 5etools PASSTHROUGHS (race-mapper.ts D13 block copies them VERBATIM, no shape
+  // guard — finding 24): today's variant set is a snapshot, not a contract (lineage is already
+  // string|null|boolean), and NO G row ever reads them. Maximally loose by ruling; the guard
+  // test §9.5 pins today's variant classes since the census goes blind under z.unknown().
+  trait_tags: z.unknown().optional(),
+  lineage: z.unknown().optional(),
+  height_and_weight: z.unknown().optional(),
+  sound_clip: z.unknown().optional(),
+  image: imageField
 });
 
 export {
+  fixedAsiSchema,
   raceEntitySchema
 };