@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/{chunk-6IRYTM5V.js → chunk-DPUJDOKV.js}

@@ -1,28 +1,32 @@
 import {
   readTableColumn
-} from "./chunk-5XUXXAQJ.js";
+} from "./chunk-IUAAXXNO.js";
 import {
-  bareSlug
+  bareSlug,
+  baseClassName
 } from "./chunk-VTTA2ALZ.js";
 import {
   abilityModifier
-} from "./chunk-NAEPSZAM.js";
+} 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;
+  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 sc = sub != null ? sub : cls;
-  if (!sc) return null;
-  const table = (_i = (_h = sub ? (_e = rc.subclass) == null ? void 0 : _e.table : (_f = rc.entity) == null ? void 0 : _f.table) != null ? _h : (_g = rc.entity) == null ? void 0 : _g.table) != null ? _i : {};
-  return {
-    ability: sc.ability,
-    casterType: sc.caster_type,
-    preparation: sc.preparation,
-    spellList: sc.spell_list,
-    table
-  };
+  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;
@@ -41,6 +45,43 @@ function normalizeKnownSpell(entry) {
     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],
@@ -209,6 +250,24 @@ var PACT_MAGIC = [
   /* 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) => {
@@ -217,7 +276,7 @@ function rowToRecord(row) {
   return out;
 }
 function deriveSpellSlots(classes) {
-  let fullLevels = 0, halfLevels = 0, thirdLevels = 0, warlockLevel = 0;
+  let fullLevels = 0, halfLevels = 0, thirdLevels = 0, artificerLevels = 0, warlockLevel = 0;
   const regular = [];
   for (const c of classes) {
     if (c.casterType === "pact") {
@@ -225,28 +284,55 @@ function deriveSpellSlots(classes) {
       continue;
     }
     regular.push({ caster: c.casterType, level: c.level });
-    if (c.casterType === "full") fullLevels += c.level;
-    else if (c.casterType === "half") halfLevels += c.level;
-    else if (c.casterType === "third") thirdLevels += 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 (only.caster === "half") {
-      if (idx >= 0 && idx < HALF_CASTER_SLOTS.length) standard = rowToRecord(HALF_CASTER_SLOTS[idx]);
-    } else if (only.caster === "third") {
-      if (idx >= 0 && idx < THIRD_CASTER_SLOTS.length) standard = rowToRecord(THIRD_CASTER_SLOTS[idx]);
-    } else {
-      if (only.level >= 1 && only.level <= FULL_CASTER_SLOTS.length) standard = rowToRecord(FULL_CASTER_SLOTS[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);
+    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) {
@@ -255,8 +341,8 @@ function computeSpellLimits(inputs) {
     const mod = abilityModifier(i.abilityScore);
     let preparedOrKnown;
     if (p.preparation === "prepared") {
-      const levelTerm = p.casterType === "half" ? Math.floor(i.level / 2) : i.level;
-      preparedOrKnown = Math.max(1, mod + levelTerm);
+      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"]);
     }
@@ -269,6 +355,11 @@ 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
 };

package/dist/{chunk-K6Q5OUGK.js → chunk-GFZ7PITJ.js}

@@ -1,3 +1,7 @@
+import {
+  imageField
+} from "./chunk-UA5KS2PL.js";
+
 // src/item/item.schema.ts
 import { z } from "zod";
 var tier1Conditions = [
@@ -41,6 +45,7 @@ var conditionalBonusSchema = z.object({
   when: z.array(conditionSchema)
 });
 var numberOrConditional = z.union([z.number().int(), conditionalBonusSchema]);
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
 var bonusesSchema = z.object({
   ac: numberOrConditional.optional(),
   weapon_attack: numberOrConditional.optional(),
@@ -48,6 +53,12 @@ var bonusesSchema = z.object({
   spell_attack: numberOrConditional.optional(),
   spell_save_dc: numberOrConditional.optional(),
   saving_throws: numberOrConditional.optional(),
+  // Converter-measured (spec §4): 24 / 3 / 2 / 1 carriers. Same numberOrConditional
+  // shape as the six above, so a conditional arm is legal on these too.
+  spell_damage: numberOrConditional.optional(),
+  ability_check: numberOrConditional.optional(),
+  proficiency_bonus: numberOrConditional.optional(),
+  saving_throw_concentration: numberOrConditional.optional(),
   ability_scores: z.object({
     // partial: each ability is independently optional. z.record(enum, …) in
     // Zod v4 treats every enum key as required, which doesn't match the
@@ -67,7 +78,16 @@ var bonusesSchema = z.object({
       int: numberOrConditional.optional(),
       wis: numberOrConditional.optional(),
       cha: numberOrConditional.optional()
-    }).optional()
+    }).optional(),
+    // "choose `count` of `from`, each +`amount`" (6 measured leaves). `amount` is
+    // OPTIONAL: Lost Laboratory of Kwalish/Deck of Several Things carries
+    // {from: [all six], count: 1} with NO amount, and a required `amount` would
+    // refuse that document outright.
+    choose: z.array(z.strictObject({
+      from: z.array(abilityEnum),
+      count: z.number().int().positive(),
+      amount: z.number().int().optional()
+    })).optional()
   }).optional(),
   speed: z.object({
     walk: numberOrConditional.optional(),
@@ -78,6 +98,9 @@ var bonusesSchema = z.object({
 });
 var chargesSchema = z.object({
   max: z.number().int(),
+  // Dice regained per recharge, e.g. "1d4 - 1" (68 carriers). Distinct from
+  // `recharge_amount`, which the canonical pipeline also emits as a string.
+  dice: z.string().optional(),
   recharge: z.string().optional(),
   recharge_amount: z.string().optional(),
   destroy_on_empty: z.object({
@@ -96,16 +119,37 @@ var attachedSpellsSchema = z.object({
   // Source canonical pipeline emits this for Necklace of Fireballs, Helm of
   // Brilliance, Candle of Invocation, Efreeti Bottle. Key is total available
   // uses (e.g. "9": ["fireball"] for the necklace's 9 beads).
-  limited: z.record(z.string(), z.array(z.string())).optional()
+  limited: z.record(z.string(), z.array(z.string())).optional(),
+  // Converter-measured (spec §4): spells the item lists without a cost model (18),
+  // the casting ability for the item's attached spells (10), and ritual-only
+  // spells (1).
+  other: z.array(z.string()).optional(),
+  ability: z.string().optional(),
+  ritual: z.array(z.string()).optional()
 });
 var attunementTagSchema = z.union([
-  z.object({ class: z.string(), subclass: z.string().optional() }),
+  z.object({
+    class: z.string(),
+    subclass: z.string().optional(),
+    alignment: z.union([z.string(), z.array(z.string())]).optional()
+  }),
   // alignment can be a single string OR an array of alignment-letter codes
   // (e.g. ["G"] for good, ["L", "G"] for lawful good).
-  z.object({ alignment: z.union([z.string(), z.array(z.string())]) }),
-  z.object({ race: z.string() }),
-  z.object({ creature_type: z.string() }),
-  z.object({ spellcasting: z.boolean() })
+  z.object({
+    alignment: z.union([z.string(), z.array(z.string())]),
+    race: z.string().optional()
+  }),
+  z.object({
+    race: z.string(),
+    alignment: z.union([z.string(), z.array(z.string())]).optional()
+  }),
+  z.object({ creature_type: z.string(), size: z.string().optional() }),
+  z.object({ spellcasting: z.boolean() }),
+  z.object({ background: z.string() }),
+  z.object({ psionics: z.boolean() }),
+  z.object({ int: z.number().int() }),
+  z.object({ skill_proficiency: z.array(z.string()) }),
+  z.object({ language_proficiency: z.array(z.string()) })
 ]);
 var attunementCanonicalSchema = z.object({
   required: z.boolean(),
@@ -122,15 +166,27 @@ var grantsSchema = z.object({
     blindsight: z.number().optional()
   }).optional()
 });
+var containerCapacitySchema = z.strictObject({
+  weight: z.array(z.number()).optional(),
+  item: z.array(z.record(z.string(), z.number())).optional(),
+  weightless: z.boolean().optional(),
+  volume: z.array(z.number()).optional()
+});
 var containerSchema = z.object({
   capacity_weight: z.number().optional(),
   weightless: z.boolean().optional(),
-  pack_contents: z.array(z.string()).optional()
+  pack_contents: z.array(z.string()).optional(),
+  capacity: containerCapacitySchema.optional()
 });
 var lightSchema = z.object({
   bright_radius: z.number(),
   dim_radius: z.number()
 });
+var lightEntrySchema = z.strictObject({
+  bright: z.number().optional(),
+  dim: z.number().optional(),
+  shape: z.string().optional()
+});
 var itemEntitySchema = z.object({
   name: z.string().min(1),
   slug: z.string().optional(),
@@ -147,10 +203,12 @@ var itemEntitySchema = z.object({
   attunement: z.union([attunementCanonicalSchema, z.boolean(), z.string()]).optional(),
   grants: grantsSchema.optional(),
   container: containerSchema.optional(),
-  light: lightSchema.optional(),
+  light: z.union([lightSchema, z.array(lightEntrySchema).nonempty()]).optional(),
   cursed: z.boolean().optional(),
   sentient: z.boolean().optional(),
-  focus: z.union([z.boolean(), z.string()]).optional(),
+  // 54 docs carry a LIST of classes that may use the item as a focus
+  // (e.g. ["Druid", "Ranger"]); 26 carry a single string, 2 a boolean.
+  focus: z.union([z.boolean(), z.string(), z.array(z.string())]).optional(),
   tier: z.enum(["major", "minor"]).optional(),
   damage: z.union([
     z.object({
@@ -182,6 +240,24 @@ var itemEntitySchema = z.object({
   scroll_level: z.number().optional(),
   unidentified: z.boolean().optional(),
   masked_category: z.string().optional(),
+  // Converter-modelled top-level keys (spec §4). Declared here so they survive
+  // parse AND listed in the parser's KNOWN_KEYS so they are not additionally
+  // copied into `raw` — the schema and the raw-bag are independent gates.
+  // `modify_speed` (124 carriers): equal 101 (string-valued, e.g. {fly: "walk"}) ·
+  // static 20 · multiply 3 · bonus 1 (keyed "*").
+  modify_speed: z.strictObject({
+    equal: z.record(z.string(), z.string()).optional(),
+    static: z.record(z.string(), z.number()).optional(),
+    multiply: z.record(z.string(), z.number()).optional(),
+    bonus: z.record(z.string(), z.number()).optional()
+  }).optional(),
+  // Carried by all 6,046 converter item docs, ALWAYS as the empty string today:
+  // `.min(1)` is forbidden here.
+  rendering_hint: z.string().optional(),
+  has_fluff: z.boolean().optional(),
+  has_fluff_images: z.boolean().optional(),
+  // Already `.optional()` at its source — never append a second one.
+  image: imageField,
   raw: z.record(z.string(), z.unknown()).optional(),
   // Legacy fields preserved
   damage_dice: z.string().optional(),