@archivist-gg/dnd5e 0.3.0 → 0.3.4

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(),

package/dist/chunk-H7KBLR4X.js

@@ -0,0 +1,81 @@
+import {
+  poolGrantSchema,
+  selectionPoolSchema,
+  tabDeclSchema
+} from "./chunk-23LZLBJK.js";
+import {
+  casterTypeEnum
+} from "./chunk-CJYCVNW2.js";
+import {
+  featureSchema
+} from "./chunk-4FWNK4FD.js";
+import {
+  resourceSchema
+} from "./chunk-YLL2QXY2.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+} from "./chunk-UA5KS2PL.js";
+
+// src/subclass/subclass.schema.ts
+import { z } from "zod";
+var editionEnum = z.enum(["2014", "2024"]);
+var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var spellcastingSchema = z.object({
+  caster_type: casterTypeEnum.optional(),
+  ability: abilityEnum,
+  preparation: z.enum(["known", "prepared"]).optional(),
+  spell_list: z.string().min(1).optional()
+});
+var subclassTableRowSchema = z.object({
+  columns: z.record(z.string(), z.union([z.string(), z.number()])).optional()
+});
+var subclassEntitySchema = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  parent_class: z.string().regex(wikilinkRegex, "parent_class must be a wikilink like [[rogue]]"),
+  edition: editionEnum,
+  source: z.string().min(1),
+  description: z.string(),
+  spellcasting: spellcastingSchema.nullable().optional(),
+  table: z.record(z.string(), subclassTableRowSchema).optional(),
+  features_by_level: z.record(z.string(), z.array(featureSchema)),
+  resources: z.array(resourceSchema),
+  selection_pools: z.array(selectionPoolSchema).optional(),
+  pool_grants: z.array(poolGrantSchema).optional(),
+  tabs: z.array(tabDeclSchema).optional(),
+  rendering_hint: z.string().optional(),
+  // 346
+  short_name: z.string().min(1).optional(),
+  // 346
+  has_fluff: z.boolean().optional(),
+  // 50
+  has_fluff_images: z.boolean().optional(),
+  // 346
+  fluff: z.unknown().optional(),
+  // 62 docs, single key-set {_subclassFluff:{...}} — 5etools-internal
+  table_col_labels: z.array(z.string().min(1)).optional(),
+  // 8
+  cantrip_progression: z.array(z.number()).optional(),
+  // 6
+  prepared_spells_change: z.string().min(1).optional(),
+  // 2
+  prepared_spells_progression: z.array(z.number()).optional(),
+  // 2
+  spells_known_progression: z.array(z.number()).optional(),
+  // 4
+  feat_progression: z.array(progressionSchema).optional(),
+  // 1
+  optionalfeature_progression: z.array(progressionSchema).optional(),
+  // 13 carriers; featureType
+  // on all 13, required on 2
+  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
+  // 212
+  image: imageField
+});
+
+export {
+  subclassEntitySchema
+};

package/dist/{chunk-L7E2UT5A.js → chunk-HB7XZXDK.js}

@@ -1,12 +1,16 @@
 import {
   subclassEntitySchema
-} from "./chunk-W7HWMMBF.js";
+} from "./chunk-H7KBLR4X.js";
+import {
+  aliasFeaturesByLevelActionCost
+} from "./chunk-4U55VNC7.js";
 
 // src/subclass/subclass.parser.ts
 import { parseYaml } from "@archivist-gg/core";
 function parseSubclass(source) {
   const raw = parseYaml(source, ["name", "slug", "parent_class"]);
   if (!raw.success) return raw;
+  aliasFeaturesByLevelActionCost(raw.data.features_by_level);
   const result = subclassEntitySchema.safeParse({ edition: "2014", ...raw.data });
   if (!result.success) {
     return { success: false, error: `subclass schema validation failed: ${result.error.message}` };

package/dist/{chunk-VTYUBINW.js → chunk-HJ5EEZ47.js}

@@ -1,6 +1,6 @@
 import {
   parseBackground
-} from "./chunk-DZXSWSBP.js";
+} from "./chunk-LMBAEIP6.js";
 
 // src/background/background.codec.ts
 import yaml from "js-yaml";

package/dist/{chunk-6NK2MUD3.js → chunk-HZA7OE7N.js}

@@ -1,6 +1,6 @@
 import {
   weaponEntitySchema
-} from "./chunk-AFKTJXRA.js";
+} from "./chunk-2DFENQIJ.js";
 
 // src/weapon/weapon.parser.ts
 import { parseYaml } from "@archivist-gg/core";
@@ -21,7 +21,14 @@ var KNOWN_KEYS = /* @__PURE__ */ new Set([
   "page",
   "edition",
   "entries",
-  "raw"
+  "raw",
+  // Root extras declared on weaponEntitySchema (spec §5). The schema declaring them is NOT
+  // enough: this set is the second, independent gate — a key missing here is copied into
+  // `raw` as well, so the two lists must move together.
+  "rendering_hint",
+  "has_fluff",
+  "has_fluff_images",
+  "image"
 ]);
 var FLAG_PROPERTIES = /* @__PURE__ */ new Set([
   "finesse",

package/dist/{chunk-A4WENOUQ.js → chunk-I2NDWFDD.js}

@@ -1,6 +1,6 @@
 import {
   CONDITION_SLUGS
-} from "./chunk-TZK36BU7.js";
+} from "./chunk-S7REMWW4.js";
 
 // src/pc/pc.schema.ts
 import { z } from "zod";
@@ -79,7 +79,7 @@ var equipmentEntrySchema = z.object({
   // finished file never carries it.
   granted_by: z.string().optional()
 });
-var characterOverridesSchema = z.object({
+var characterOverridesShape = z.object({
   scores: z.partialRecord(abilityEnum, z.number().int()).optional(),
   saves: z.partialRecord(abilityEnum, z.object({
     bonus: z.number().int().optional(),
@@ -102,16 +102,59 @@ var characterOverridesSchema = z.object({
   ac: z.number().int().optional(),
   speed: z.number().int().optional(),
   initiative: z.number().int().optional(),
-  spellcasting: z.object({
-    saveDC: z.number().int().optional(),
-    attackBonus: z.number().int().optional()
-  }).optional(),
+  spellcasting_ability_by_class: z.record(z.string(), abilityEnum).optional(),
   // Character-level DC-ability fallback for own-ability-less spells (e.g. a Spell
   // Scroll cast by a non-caster). Same ability enum as the per-instance spell_ability.
   spellcasting_ability: abilityEnum.optional(),
   spell_slots: z.record(z.coerce.number().int(), z.number().int().nonnegative()).optional(),
-  attunement_limit: z.number().int().nonnegative().optional()
-}).default({});
+  attunement_limit: z.number().int().nonnegative().optional(),
+  /** Manual proficiency edits. `remove` SUPPRESSES a rules-granted entry ("a dwarf who doesn't know
+   *  dwarvish"). NOTHING here may carry a default, at either level, or an untouched note stops being
+   *  byte-identical:
+   *    - a `.default({})` on `languages`/`tools` materializes the key on every note that carries any
+   *      `overrides` block at all;
+   *    - a `.default([])` on `add`/`remove` materializes the sibling array whenever the parent key IS
+   *      present, which is every add-only entry the mutators write. (It cannot fire while the parent
+   *      is absent, but that is the uninteresting half of the case.)
+   *  That rule covers `tools.proficiency` too: no default at any of its three levels.
+   *  Every reader uses `?? []` (`?? {}` for the record). */
+  languages: z.object({ add: z.array(z.string()).optional(), remove: z.array(z.string()).optional() }).optional(),
+  tools: z.object({
+    add: z.array(z.string()).optional(),
+    remove: z.array(z.string()).optional(),
+    /** R4-G4 §9.3 (UR1): a per-tool tri. An OPEN key space (tool names are not an enum, unlike
+     *  `skillEnum` above); no `bonus` sibling, because tools have no numeric consumer. `expertise`
+     *  beats a data grant, `none` suppresses one, `proficient` clears a data expertise · applied in
+     *  `computeEffectiveProficiencies` (pc.decision-engine.ts). A key a WRITER CREATES is
+     *  `toProfSlug` output with the apostrophe RETAINED ("thieves'-tools"), matching the engine's
+     *  own tool vocabulary in types/choice.ts. The READER is wider: `computeEffectiveProficiencies`
+     *  normalises each key with `toProfSlug` on read, so a hand-typed "Thieves' Tools" also
+     *  matches; and the plugin's two writers (`CharacterEditState.setToolProficiency` and the
+     *  `addProficiency` clearance) match an existing key by slug too, so a key the note ALREADY
+     *  carries is written THROUGH in its own spelling rather than duplicated · nothing here
+     *  re-spells it (review M-4: "repaired in place" read as "normalised", which it is not).
+     *  `languages` gets no such sibling: languages have no tri (§9.3). */
+    proficiency: z.record(z.string(), proficiencyTri).optional()
+  }).optional(),
+  /** Manual defense edits. SUPPRESSION-ONLY, and the missing `add` channel is a DELIBERATE
+   *  asymmetry with `languages`/`tools` above · do not "complete the pattern". The additive
+   *  store is `character.defenses.*`, which already exists and works; a second additive
+   *  channel would recreate exactly the two-writers divergence R4-P5 exists to remove.
+   *  The schema persists what the note wrote, VERBATIM · it neither normalizes nor validates
+   *  the strings. As of this commit the store has NO consumer at all: Task 5 writes the first,
+   *  and the intent it is to implement is that entries be matched with `toDefenseSlug`
+   *  (pc.defense-normalize.ts), so a note may author any spelling.
+   *  The no-defaults rule of the block above applies here at all three levels: a default on
+   *  `defenses`, on a bucket, or on `remove` rewrites an untouched note. Readers should
+   *  therefore treat every level as possibly absent (`?? []`). */
+  defenses: z.object({
+    resistances: z.object({ remove: z.array(z.string()).optional() }).optional(),
+    immunities: z.object({ remove: z.array(z.string()).optional() }).optional(),
+    vulnerabilities: z.object({ remove: z.array(z.string()).optional() }).optional(),
+    condition_immunities: z.object({ remove: z.array(z.string()).optional() }).optional()
+  }).optional()
+});
+var characterOverridesSchema = characterOverridesShape.default({});
 var characterStateSchema = z.object({
   hp: z.object({
     current: z.number().int(),
@@ -252,5 +295,6 @@ var characterSchema = z.object({
 });
 
 export {
+  characterOverridesShape,
   characterSchema
 };

package/dist/{chunk-RSDRMH54.js → chunk-IMZFOOVL.js}

@@ -1,6 +1,6 @@
 import {
   parseOptionalFeature
-} from "./chunk-4F6AIZ36.js";
+} from "./chunk-5XMQPTHD.js";
 
 // src/optional-feature/optional-feature.codec.ts
 import yaml from "js-yaml";

package/dist/{chunk-3DZ74AKK.js → chunk-IN4M4X7P.js}

@@ -1,8 +1,14 @@
 // src/schemas/equipment-grant-schema.ts
 import { z } from "zod";
 var equipmentGrantSchema = z.union([
-  z.object({ item: z.string().min(1), qty: z.number().int().positive().optional() }).strict(),
-  z.object({ category: z.string().min(1), qty: z.number().int().positive().optional() }).strict(),
+  z.object({
+    item: z.string().min(1),
+    qty: z.number().int().positive().optional(),
+    contains_value: z.number().int().nonnegative().optional(),
+    display_name: z.string().min(1).optional(),
+    worth_value: z.number().int().nonnegative().optional()
+  }).strict(),
+  z.object({ category: z.string().min(1), qty: z.number().int().positive().optional(), display_name: z.string().min(1).optional() }).strict(),
   z.object({ gold: z.number().int().positive() }).strict()
 ]);
 var equipmentOptionSchema = z.object({

package/dist/chunk-IUAAXXNO.js

@@ -0,0 +1,58 @@
+// src/pc/pc.table-column.ts
+function readTableColumn(table, level, keys) {
+  var _a;
+  const cols = (_a = table == null ? void 0 : table[level]) == null ? void 0 : _a.columns;
+  if (!cols) return null;
+  for (const k of keys) {
+    const raw = cols[k];
+    if (raw === void 0 || raw === null) continue;
+    const n = typeof raw === "number" ? raw : parseInt(String(raw), 10);
+    if (!Number.isNaN(n)) return n;
+  }
+  return null;
+}
+function numericColumnsAt(table, level) {
+  var _a;
+  const out = {};
+  const cols = (_a = table == null ? void 0 : table[level]) == null ? void 0 : _a.columns;
+  if (!cols) return out;
+  for (const [k, raw] of Object.entries(cols)) {
+    if (raw === void 0 || raw === null) continue;
+    const n = typeof raw === "number" ? raw : parseInt(String(raw), 10);
+    if (!Number.isNaN(n)) out[k] = n;
+  }
+  return out;
+}
+var COUNT_COLUMNS = {
+  "weapon-mastery": ["Weapon Mastery"]
+};
+function countColumnsFor(choiceId) {
+  if (!Object.prototype.hasOwnProperty.call(COUNT_COLUMNS, choiceId)) return void 0;
+  return COUNT_COLUMNS[choiceId];
+}
+function diceColumnAt(table, level, key) {
+  var _a;
+  const cols = (_a = table == null ? void 0 : table[level]) == null ? void 0 : _a.columns;
+  if (!cols || !Object.prototype.hasOwnProperty.call(cols, key)) return null;
+  const raw = cols[key];
+  if (typeof raw !== "string") return null;
+  const cell = raw.trim();
+  return /^\d+d\d+$/i.test(cell) ? cell : null;
+}
+var UNARMED_DIE_COLUMNS = {
+  "martial-arts": "Martial Arts"
+};
+function unarmedDieColumnFor(featureSlug) {
+  if (!Object.prototype.hasOwnProperty.call(UNARMED_DIE_COLUMNS, featureSlug)) return void 0;
+  return UNARMED_DIE_COLUMNS[featureSlug];
+}
+
+export {
+  readTableColumn,
+  numericColumnsAt,
+  COUNT_COLUMNS,
+  countColumnsFor,
+  diceColumnAt,
+  UNARMED_DIE_COLUMNS,
+  unarmedDieColumnFor
+};

package/dist/{chunk-XJNECUPT.js → chunk-JC5UNIVM.js}

@@ -1,3 +1,7 @@
+import {
+  imageField
+} from "./chunk-UA5KS2PL.js";
+
 // src/armor/armor.schema.ts
 import { z } from "zod";
 var acSchema = z.object({
@@ -23,7 +27,22 @@ var armorEntitySchema = z.object({
   page: z.number().int().optional(),
   edition: z.string().optional(),
   entries: z.array(z.unknown()).optional(),
+  // Root extras the converter and the SRD bundle emit on more than one root (spec §5).
+  // Carrier counts measured on the G1b close census. `rendering_hint` is ALWAYS the empty
+  // string today, so `.min(1)` is forbidden here.
+  rendering_hint: z.string().optional(),
+  // 27
+  has_fluff: z.boolean().optional(),
+  // 0 carriers — symmetry with weapon
+  has_fluff_images: z.boolean().optional(),
+  // 13
+  // Already `.optional()` at its source — never append a second one.
+  image: imageField,
+  // 0 today (images-OFF tree)
   raw: z.record(z.string(), z.unknown()).optional()
+  // `.loose()` is load-bearing for the `strength_required` alias (armor.parser.ts): the alias
+  // rides through onto the typed output as an inert extra, which is what keeps its census
+  // disposal `kept` instead of minting a `stripped` row. See the parser's comment.
 }).loose();
 
 export {