@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/chunk-VQAXTIBW.js

@@ -0,0 +1,100 @@
+import {
+  imageField
+} from "./chunk-UA5KS2PL.js";
+
+// src/spell/spell.schema.ts
+import { z } from "zod";
+var castingOptionSchema = z.object({
+  type: z.string(),
+  damage_roll: z.string().optional(),
+  target_count: z.number().optional(),
+  duration: z.string().optional(),
+  range: z.number().optional(),
+  concentration: z.boolean().optional(),
+  shape_size: z.number().optional(),
+  desc: z.string().optional()
+});
+var spellMaterialSchema = z.union([
+  z.boolean(),
+  z.string(),
+  z.strictObject({
+    text: z.string(),
+    cost: z.number().optional(),
+    consume: z.union([z.boolean(), z.string()]).optional()
+  })
+]);
+var spellComponentsObjectSchema = z.strictObject({
+  v: z.boolean().optional(),
+  s: z.boolean().optional(),
+  m: spellMaterialSchema.optional(),
+  r: z.boolean().optional()
+});
+var spellDurationEntrySchema = z.discriminatedUnion("type", [
+  z.strictObject({
+    type: z.literal("permanent"),
+    ends: z.array(z.enum(["dispel", "trigger"])).nonempty()
+  }),
+  z.strictObject({
+    type: z.literal("timed"),
+    duration: z.strictObject({
+      type: z.enum(["minute", "hour"]),
+      amount: z.number().int().positive(),
+      up_to: z.boolean().optional()
+    })
+  })
+]);
+var spellEntitySchema = z.object({
+  name: z.string().min(1),
+  level: z.number().int().min(0).optional(),
+  school: z.string().optional(),
+  casting_time: z.string().optional(),
+  range: z.string().optional(),
+  // Union arms per §3.2; `parseSpell` normalises the structured arms back to the corpus's own
+  // string form, so `Spell.components` / `Spell.duration` stay `string` and no consumer changes.
+  components: z.union([z.string(), spellComponentsObjectSchema]).optional(),
+  duration: z.union([z.string(), z.array(spellDurationEntrySchema).nonempty()]).optional(),
+  concentration: z.boolean().optional(),
+  ritual: z.boolean().optional(),
+  classes: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  at_higher_levels: z.array(z.string()).optional(),
+  damage: z.object({ types: z.array(z.string()) }).optional(),
+  saving_throw: z.object({ ability: z.string() }).optional(),
+  casting_options: z.array(castingOptionSchema).optional(),
+  // §2 · the fourteen converter keys this root refused before R4-G2. Doc counts are MEASURED over
+  // the frozen tree; the two zero-carrier keys are declared because the root is `.strict()` and an
+  // images-ON run (`image`) or a non-images-gated fluff flag (`has_fluff_images`) would otherwise
+  // refuse the whole document. Declared-only: NO rendering this phase (booked to G8 by name).
+  rendering_hint: z.string().optional(),
+  // 1,048 docs — NEVER .min(1): every value is ''
+  misc_tags: z.array(z.string()).optional(),
+  // 769
+  area_tags: z.array(z.string()).optional(),
+  // 707
+  condition_inflict: z.array(z.string()).optional(),
+  // 194
+  affects_creature_type: z.array(z.string()).optional(),
+  // 87
+  spell_attack: z.enum(["melee", "ranged"]).optional(),
+  // 77 (ranged 44 / melee 33)
+  ability_check: z.array(z.string()).optional(),
+  // 61
+  damage_resist: z.array(z.string()).optional(),
+  // 35
+  damage_immune: z.array(z.string()).optional(),
+  // 21
+  condition_immune: z.array(z.string()).optional(),
+  // 11
+  damage_vulnerable: z.array(z.string()).optional(),
+  // 2
+  has_fluff: z.boolean().optional(),
+  // 1
+  image: imageField,
+  // 0 today; `imageField` already ends .optional()
+  has_fluff_images: z.boolean().optional()
+  // 0 today
+}).strict();
+
+export {
+  spellEntitySchema
+};

package/dist/{chunk-WP2CX2JO.js → chunk-WELIKLZF.js}

@@ -203,6 +203,10 @@ var CONDITIONS = [
   "Unconscious"
 ];
 var STANDARD_SENSES = ["Blindsight", "Darkvision", "Tremorsense", "Truesight"];
+var STANDARD_ACTIONS = {
+  "2014": ["Attack", "Cast a Spell", "Dash", "Disengage", "Dodge", "Help", "Hide", "Ready", "Search", "Use an Object"],
+  "2024": ["Attack", "Dash", "Disengage", "Dodge", "Help", "Hide", "Influence", "Magic", "Ready", "Search", "Study", "Utilize"]
+};
 var ALIGNMENT_ETHICAL = ["Lawful", "Neutral", "Chaotic", "Unaligned", "Any"];
 var ALIGNMENT_MORAL = ["Good", "Neutral", "Evil"];
 var ALL_SECTIONS = [
@@ -214,6 +218,20 @@ var ALL_SECTIONS = [
   "Lair Actions",
   "Mythic Actions"
 ];
+var ABILITY_NAME_TO_KEY = {
+  strength: "str",
+  dexterity: "dex",
+  constitution: "con",
+  intelligence: "int",
+  wisdom: "wis",
+  charisma: "cha"
+};
+function normalizeAbility(value) {
+  var _a;
+  const k = value.trim().toLowerCase();
+  if (ABILITY_KEYS.includes(k)) return k;
+  return (_a = ABILITY_NAME_TO_KEY[k]) != null ? _a : null;
+}
 
 export {
   CR_PROFICIENCY,
@@ -229,7 +247,10 @@ export {
   DAMAGE_NONMAGICAL_VARIANTS,
   CONDITIONS,
   STANDARD_SENSES,
+  STANDARD_ACTIONS,
   ALIGNMENT_ETHICAL,
   ALIGNMENT_MORAL,
-  ALL_SECTIONS
+  ALL_SECTIONS,
+  ABILITY_NAME_TO_KEY,
+  normalizeAbility
 };

package/dist/chunk-WPWOHGPI.js

@@ -0,0 +1,172 @@
+// src/schemas/feature-effect-schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var subjectField = z.string().min(1).optional();
+var conditionField = z.string().optional();
+var featureEffectSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("initiative-bonus"), value: z.number().int(), condition: conditionField, subject: subjectField }),
+  // `condition` here is the condition NAME (frightened, poisoned); the qualifier is `while`.
+  z.object({ kind: z.literal("immune-condition"), condition: z.string().min(1), while: z.string().optional(), subject: subjectField }),
+  z.object({ kind: z.literal("resistance"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
+  z.object({ kind: z.literal("hp-per-level-bonus"), value: z.number().int(), condition: conditionField, subject: subjectField }),
+  z.object({
+    kind: z.literal("speed-bonus"),
+    mode: z.enum(["walk", "fly", "swim", "climb", "burrow"]),
+    value: z.number().int(),
+    // when true, value is an absolute floor (Math.max), not additive; currently
+    // only surfaced for mode:"walk" · other modes have no derived speed yet.
+    set: z.boolean().optional(),
+    // R4-G7 §7.3: the WHOLE progression lives inside the effect, because the overlay's `class_features`
+    // map is keyed `<class>:<feature-slug>` with no level component and, after §7.1's fold, the sheet
+    // reads exactly ONE copy of a repeated feature. The engine takes the highest entry at or below the
+    // effect's OWN source level (`levelFor`), and applies it to the additive bonus and to a `set` floor
+    // alike. The Monk's Unarmored Movement is the shipped carrier shape.
+    scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), value: z.number().int() })).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("sense"),
+    type: z.enum(["darkvision", "blindsight", "tremorsense", "truesight"]),
+    range: z.number().int().nonnegative(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  // `condition` here is the condition NAME being applied.
+  z.object({
+    kind: z.literal("apply-condition"),
+    condition: z.string().min(1),
+    duration: z.string().optional(),
+    ends_on: z.array(z.string()).optional(),
+    save_repeat: z.object({ ability: z.string().min(1), timing: z.string().min(1) }).optional(),
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("damage-bonus"),
+    // intentionally an open string, NOT a damage-type enum: must accept the
+    // literal "chosen" (player-selected damage type at action time) alongside
+    // canonical damage types. Do not tighten to an enum.
+    damage_type: z.string().min(1),
+    amount: z.string().min(1),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("proficiency"),
+    proficiency_type: z.enum(["skill", "tool", "language", "saving-throw", "armor", "weapon"]),
+    value: z.string().min(1),
+    expertise: z.boolean().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({ kind: z.literal("ac-bonus"), value: z.number().int(), requires_armor: z.boolean().optional(), condition: conditionField, subject: subjectField }),
+  z.object({
+    kind: z.literal("unarmored-ac"),
+    abilities: z.array(abilityEnum),
+    base: z.number().int().optional(),
+    allow_shield: z.boolean().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("unarmed-strike"),
+    // R4-G7 §7.2: a bare die expression, `<count>d<faces>`. `resolveUnarmedStrike` averages the flat arm with
+    // /^(\d+)d(\d+)$/ and silently averages anything else as 1, so a modifier tail ("1d6+1") or a missing
+    // half ("d6", "1d") must refuse here rather than mis-average there. The `i` arm keeps an authored `1D6`.
+    dice: z.union([z.string().regex(/^\d+d\d+$/i), z.object({ column: z.string().min(1) })]).optional(),
+    abilities: z.array(abilityEnum).nonempty().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("weapon-ability"),
+    ability: z.union([abilityEnum, z.literal("spellcasting")]),
+    weapons: z.union([z.literal("chosen"), z.string(), z.array(z.string())]).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("roll-modifier"),
+    mode: z.enum(["advantage", "disadvantage", "reroll", "add-d4"]),
+    roll: z.enum(["ability-check", "saving-throw", "attack", "any"]),
+    scope: z.string().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("extra-attack"),
+    // `count` is EXTRA attacks, never total attacks: the engine renders `1 + count`.
+    count: z.number().int().positive(),
+    // R4-G7 §7.3, the `speed-bonus` twin: the SRD 5e Fighter's one Extra Attack feature carries its whole
+    // 5 / 11 / 20 progression here, because `bucketFeaturesByLevel` emits one overlay record into every
+    // `gained_at` bucket and a per-copy count cannot be authored.
+    scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), count: z.number().int().positive() })).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("crit-range"),
+    min_roll: z.number().int().min(2).max(20),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({
+    kind: z.literal("reroll-damage"),
+    max_reroll: z.number().int().positive(),
+    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
+    once_per_die: z.boolean().optional(),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  z.object({ kind: z.literal("attack-rule"), flag: z.enum(["no-ranged-in-melee-disadvantage"]), condition: conditionField, subject: subjectField }),
+  // R4-G1a declared these seven converter-emitted arms with the engine folding NOTHING for them
+  // (spec D3). R4-G3a §3-§7 gives SIX of them semantics: immunity / vulnerability FOLD (defenses
+  // pane); temp-hp / heal / extra-action are still NOT folded, the plugin reads them raw as
+  // row-local captions; save-outcome FOLDS (save-chip tag rail).
+  // `ability-score-increase` folds FLAT at the fold since R4-G3b §4 (fixed-list arms only; `chosen` arms
+  // are the ASI slot's second encoding; `max` is unread by user ruling).
+  // Damage immunity / vulnerability. NOT `immune-condition`, which is condition immunity.
+  z.object({ kind: z.literal("immunity"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
+  z.object({ kind: z.literal("vulnerability"), damage_type: z.string().min(1), condition: conditionField, subject: subjectField }),
+  // `amount` is the open non-empty STRING `damage-bonus.amount` already uses: "2d6", "5", "your Artificer level".
+  z.object({ kind: z.literal("temp-hp"), amount: z.string().min(1), condition: conditionField, subject: subjectField }),
+  z.object({ kind: z.literal("heal"), amount: z.string().min(1), condition: conditionField, subject: subjectField }),
+  z.object({
+    kind: z.literal("ability-score-increase"),
+    // "chosen" follows `weapon-ability.weapons`; the list follows `unarmored-ac.abilities`.
+    abilities: z.union([z.literal("chosen"), z.array(abilityEnum).min(1)]),
+    amount: z.number().int().positive(),
+    // Required-WITH-NULL, never optional: "the prose stated no cap" and "the extractor forgot" must not look alike.
+    choose: z.number().int().positive().nullable(),
+    max: z.number().int().positive().nullable(),
+    condition: conditionField,
+    subject: subjectField
+  }).refine((e) => e.abilities === "chosen" === (e.choose !== null), {
+    path: ["choose"],
+    message: 'choose is required IFF abilities is "chosen": a fixed LIST is its own count'
+  }),
+  // `extra-action` is an additional ACTION on your turn; `extra-attack` is attacks WITHIN the Attack action.
+  z.object({
+    kind: z.literal("extra-action"),
+    count: z.number().int().positive(),
+    action_type: z.enum(["action", "bonus-action", "reaction"]),
+    condition: conditionField,
+    subject: subjectField
+  }),
+  // `save-outcome` remaps the OUTCOME; `roll-modifier` modifies the ROLL.
+  z.object({
+    kind: z.literal("save-outcome"),
+    ability: z.union([abilityEnum, z.literal("any")]),
+    on_success: z.enum(["none", "half", "full"]),
+    on_failure: z.enum(["none", "half", "full"]),
+    applies_to: z.string().nullable(),
+    condition: conditionField,
+    subject: subjectField
+  })
+]);
+
+export {
+  featureEffectSchema
+};

package/dist/{chunk-GZ46OVGZ.js → chunk-WSVMLNTO.js}

@@ -1,7 +1,7 @@
 import {
   STATIC_FALLBACK_CONTEXT,
   convertDescToTags
-} from "./chunk-RAWJTA45.js";
+} from "./chunk-DEEHHLAP.js";
 
 // src/spell/spell.enrichment.ts
 function enrichSpell(raw) {

package/dist/{chunk-4LZJXJJS.js → chunk-WXWPK3LI.js}

@@ -1,6 +1,6 @@
 import {
   slugify
-} from "./chunk-LV4SNWZQ.js";
+} from "./chunk-6X4KUDMU.js";
 
 // src/entities/base-item-resolver.ts
 function unwrapWikilink(input) {
@@ -10,7 +10,11 @@ function unwrapWikilink(input) {
   const pipe = inner.indexOf("|");
   return pipe === -1 ? inner : inner.slice(0, pipe);
 }
-var FOLDER_TO_TYPE = { Weapons: "weapon", Armor: "armor" };
+var FOLDER_TO_TYPE = {
+  Weapons: "weapon",
+  Armor: "armor",
+  "Magic Items": "item"
+};
 function vaultPathToSlug(target) {
   const segments = target.split("/").map((s) => s.trim()).filter((s) => s.length > 0);
   if (segments.length === 0) return "";

package/dist/{chunk-ZZGEVJKX.js → chunk-XBQMCEI2.js}

@@ -1,6 +1,6 @@
 import {
   parseRace
-} from "./chunk-PHQRGDRQ.js";
+} from "./chunk-XGOFP7AQ.js";
 
 // src/race/race.codec.ts
 import yaml from "js-yaml";

package/dist/{chunk-PHQRGDRQ.js → chunk-XGOFP7AQ.js}

@@ -1,12 +1,16 @@
 import {
   raceEntitySchema
-} from "./chunk-2BWAID3Y.js";
+} from "./chunk-FDBWYMZK.js";
+import {
+  aliasFeatureListActionCost
+} from "./chunk-4U55VNC7.js";
 
 // src/race/race.parser.ts
 import { parseYaml } from "@archivist-gg/core";
 function parseRace(source) {
   const raw = parseYaml(source, ["name", "slug"]);
   if (!raw.success) return raw;
+  aliasFeatureListActionCost(raw.data.traits);
   const result = raceEntitySchema.safeParse({ edition: "2014", ...raw.data });
   if (!result.success) {
     return { success: false, error: `race schema validation failed: ${result.error.message}` };

package/dist/chunk-XJ2F2WO6.js

@@ -0,0 +1,8 @@
+// src/pc/pc.defense-normalize.ts
+function toDefenseSlug(s) {
+  return s.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+export {
+  toDefenseSlug
+};