@archivist-gg/dnd5e 0.3.1 → 0.3.5

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-W74BCA7V.js

@@ -0,0 +1,159 @@
+import {
+  durationSchema
+} from "./chunk-WYGD2UGN.js";
+import {
+  actionCostEnum,
+  resourceConsumptionSchema,
+  resourceSchema
+} from "./chunk-YLL2QXY2.js";
+import {
+  choiceSchema
+} from "./chunk-IWRVOCT5.js";
+import {
+  featureEffectSchema
+} from "./chunk-X3D6LXUU.js";
+
+// src/schemas/feature-schema.ts
+import { z as z2 } from "zod";
+
+// src/schemas/attack-schema.ts
+import { z } from "zod";
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var attackSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["melee", "ranged", "spell"]),
+  ability: z.union([abilityEnum, z.array(abilityEnum).nonempty()]).optional(),
+  damage: z.string().optional(),
+  damage_type: z.string().optional(),
+  action: z.enum(["action", "bonus-action", "reaction"]).optional(),
+  properties: z.array(z.string()).optional(),
+  range: z.object({
+    normal: z.number().int().nonnegative().optional(),
+    long: z.number().int().nonnegative().optional(),
+    reach: z.number().int().nonnegative().optional()
+  }).optional(),
+  condition: z.string().optional(),
+  // R4-G6 §5: declared on the `Attack` interface since the monster port, stripped by this schema until now.
+  // Monsters are the only carriers (8,176 bonuses, 1,796 extra-damage riders in the converter corpus).
+  bonus: z.number().optional(),
+  extra_damage: z.object({ dice: z.string(), type: z.string() }).optional()
+});
+
+// src/schemas/feature-schema.ts
+var companionSchema = z2.object({
+  statblock: z2.string().optional(),
+  statblock_wikilink: z2.string().nullable().optional(),
+  count: z2.string().optional(),
+  count_scaling: z2.array(z2.object({
+    level: z2.number().optional(),
+    count: z2.string().optional(),
+    source_quote: z2.string().optional()
+  })).optional(),
+  shares_action_economy: z2.boolean().optional(),
+  turn_order: z2.string().optional(),
+  turn_order_source_quote: z2.string().nullable().optional(),
+  proficiency_bonus_scaled: z2.array(z2.object({
+    stat: z2.string().optional(),
+    formula: z2.string().optional(),
+    source_quote: z2.string().optional()
+  })).optional(),
+  lifecycle: z2.object({
+    created_by: z2.string().optional(),
+    recreate_on: z2.string().nullable().optional(),
+    previous_instance_perishes: z2.boolean().nullable().optional(),
+    vanishes_if_owner_dies: z2.boolean().nullable().optional(),
+    vanishes_after: z2.string().nullable().optional(),
+    source_quote: z2.string().optional()
+  }).nullable().optional(),
+  autonomy: z2.object({
+    when: z2.string().optional(),
+    behaviour: z2.string().optional(),
+    source_quote: z2.string().optional()
+  }).nullable().optional(),
+  variants: z2.array(z2.object({
+    axis: z2.string().optional(),
+    choices: z2.array(z2.string()).optional(),
+    chosen_at: z2.string().optional(),
+    source_quote: z2.string().optional()
+  })).optional(),
+  base_statblock: z2.string().nullable().optional(),
+  overrides: z2.array(z2.object({
+    field: z2.string().optional(),
+    value: z2.string().optional(),
+    source_quote: z2.string().optional()
+  })).optional(),
+  source_quote: z2.string().optional()
+});
+var featureObjectSchema = z2.lazy(
+  () => z2.object({
+    id: z2.string().min(1).optional(),
+    name: z2.string().min(1),
+    description: z2.string().optional(),
+    entries: z2.array(z2.string()).optional(),
+    choices: z2.array(choiceSchema).optional(),
+    grants_resource: z2.string().optional(),
+    consumes: resourceConsumptionSchema.optional(),
+    attacks: z2.array(attackSchema).optional(),
+    action: z2.enum(["action", "bonus-action", "reaction", "free", "special"]).optional(),
+    trigger: z2.string().optional(),
+    dc_formula: z2.string().optional(),
+    effects: z2.array(featureEffectSchema).optional(),
+    sub_features: z2.array(featureSchemaTyped).optional(),
+    resources: z2.array(resourceSchema).optional(),
+    // Phase 3 activatable buffs: a feature flagged `activatable` folds its effects
+    // only while its id is present in state.active_buffs. `passive` renders a tag;
+    // `duration` is a static label (no live countdown this phase).
+    activatable: z2.boolean().optional(),
+    passive: z2.boolean().optional(),
+    duration: durationSchema.optional(),
+    // Converter feature-level keys (164 census strip rows, class 80 + subclass 84; counts per finding 2):
+    class_source: z2.string().min(1).optional(),
+    // class 646 + subclass 1616 leaves
+    rendering_hint: z2.string().optional(),
+    // always "" — NEVER .min(1)
+    subclass_short_name: z2.string().min(1).optional(),
+    // 1616
+    subclass_source: z2.string().min(1).optional(),
+    // 1616
+    header: z2.number().optional(),
+    // 1,237 carriers, ALL numbers
+    is_class_feature_variant: z2.boolean().optional(),
+    gain_subclass_feature: z2.boolean().optional(),
+    gain_subclass_feature_has_content: z2.boolean().optional(),
+    type: z2.string().min(1).optional(),
+    // values {"inset","item"}
+    recharge: z2.object({
+      // ONE class doc (UA Mystic), FOUR features, ALL
+      type: z2.enum(["recharge_on_roll", "per_day", "per_short_rest", "per_long_rest"]),
+      // {type:"per_day",param:1..4}
+      param: z2.number()
+      // tree-wide nested-recharge type census: exactly these
+    }).optional(),
+    // four members (gate1-r1 f9) = the EXISTING FeatureRecharge type
+    // SRD-BUNDLE-side keys (the converter emits NEITHER at feature level; finding 14 — our own
+    // generator emits them and featureSchema strips them, losing the SRD Dragonborn Breath Weapon's
+    // action cost and save DC). MAPPED since R4-G3a §10: `action_cost` is aliased onto `action` by
+    // the race / class / subclass parsers, and `save` renders as the feature card's Save line
+    // (`dc_formula` is echoed as TEXT, never evaluated).
+    action_cost: actionCostEnum.optional(),
+    // ONE vocabulary, imported from schemas/resource-schema
+    // (no cycle: resource-schema imports neither; two spellings of a closed enum is the G1a
+    // "fifth enum consumer" drift — gate1-r2 NEW-12)
+    save: z2.object({ ability: z2.string().min(1), dc_formula: z2.string().min(1) }).optional(),
+    // R4-G5 §7 (ruling G5-UR2): DECLARED so the class / subclass / race parsers stop stripping it on the day the
+    // G7 re-emit lands. The converter withholds it today (`P9_NOT_EMITTED_FIELDS`), so 0 converted and 0 bundle
+    // documents carry it and the census cannot see this key in either state (§12.1); the 47-block cache
+    // round-trip in `tests/feature-schema-widening.test.ts` is its instrument.
+    companion: companionSchema.optional()
+  })
+);
+var featureSchemaTyped = featureObjectSchema.refine(
+  (f) => f.description !== void 0 || f.entries !== void 0 && f.entries.length > 0,
+  { message: "feature requires either description or non-empty entries" }
+);
+var featureSchema = featureSchemaTyped;
+
+export {
+  featureObjectSchema,
+  featureSchema
+};

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-MDEJHMKK.js → chunk-WHVLNFTG.js}

@@ -5,23 +5,31 @@ import {
   actionCostEnum,
   resetTriggerEnum,
   resourceConsumptionSchema
-} from "./chunk-PZOWBI3B.js";
+} from "./chunk-YLL2QXY2.js";
 import {
   featureEffectSchema
-} from "./chunk-NXR3BD2V.js";
+} from "./chunk-X3D6LXUU.js";
+import {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+} from "./chunk-UA5KS2PL.js";
 
 // src/optional-feature/optional-feature.schema.ts
 import { z } from "zod";
 var editionEnum = z.enum(["2014", "2024"]);
 var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
 var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
+var namedRefSchema = z.object({ name: z.string().min(1), source: z.string().min(1).optional(), visible_stats: z.boolean().optional() });
 var prerequisiteSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("level"), min: z.number().int().positive() }),
+  z.object({ kind: z.literal("level"), min: z.number().int().positive(), class: namedRefSchema.optional(), subclass: namedRefSchema.optional() }),
   z.object({ kind: z.literal("spell-known"), spell: z.string().regex(wikilinkRegex) }),
   z.object({ kind: z.literal("pact"), pact: z.enum(["tome", "blade", "chain", "talisman"]) }),
   z.object({ kind: z.literal("class"), class: z.string().regex(wikilinkRegex) }),
   z.object({ kind: z.literal("ability"), ability: abilityEnum, min: z.number().int().positive() }),
-  z.object({ kind: z.literal("other"), detail: z.string() })
+  z.object({ kind: z.literal("other"), detail: z.string() }),
+  z.object({ kind: z.literal("optionalfeature"), optionalfeature: z.string().regex(wikilinkRegex) }),
+  z.object({ kind: z.literal("spell-choose"), choose: z.string().min(1), entry: z.string().optional(), entry_summary: z.string().optional() })
 ]);
 var usesSchema = z.object({
   max: z.union([z.number(), z.string()]),
@@ -44,7 +52,20 @@ var optionalFeatureEntitySchema = z.object({
   passive: z.boolean().optional(),
   // Phase 3 activatable buffs: an activatable boon folds its effects only while
   // its slug is present in state.active_buffs (toggled in the PoolTab).
-  activatable: z.boolean().optional()
+  activatable: z.boolean().optional(),
+  rendering_hint: z.string().optional(),
+  // the ONE root with load-bearing VALUES (88 records, G4's)
+  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
+  // 54
+  is_class_feature_variant: z.boolean().optional(),
+  // 25
+  has_fluff_images: z.boolean().optional(),
+  // 2
+  feat_progression: z.array(progressionSchema).optional(),
+  // 1
+  optionalfeature_progression: z.array(progressionSchema).optional(),
+  // 1
+  image: imageField
 });
 
 export {

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-X3D6LXUU.js

@@ -0,0 +1,185 @@
+// 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({
+    // The attunement CAP, as data. `value` is an absolute cap ("you can now attune to up to four"),
+    // never an increment, so two grants MAX rather than sum and a grant can never lower the cap:
+    // recalc folds it as Math.max(3, granted). `scales_at` carries a whole progression on ONE effect —
+    // the `speed-bonus` / `extra-attack` shape (R4-G7 §7.3) — because the overlay has no level axis and
+    // the Artificer's three steps (10 -> 4, 14 -> 5, 18 -> 6) would otherwise need three separate
+    // features, one of which is embedded prose inside another feature's description.
+    kind: z.literal("attunement-limit"),
+    value: z.number().int().positive(),
+    scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), value: z.number().int().positive() })).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-XJ2F2WO6.js

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

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

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

package/dist/chunk-YBLDE5CG.js

@@ -0,0 +1,42 @@
+// src/feat/feat.category-codes.ts
+var FEAT_CATEGORY_CODE_LABELS = {
+  D: "Dragonmark",
+  G: "General",
+  O: "Origin",
+  FS: "Fighting Style",
+  EB: "Epic Boon",
+  DG: "Dark Gift",
+  "FS:P": "Fighting Style",
+  "FS:R": "Fighting Style"
+};
+function featCategoryLabel(code) {
+  var _a;
+  return (_a = FEAT_CATEGORY_CODE_LABELS[code]) != null ? _a : code;
+}
+var FEAT_PROGRESSION_CATEGORY = {
+  FS: "fighting-style",
+  "FS:P": "fighting-style",
+  "FS:R": "fighting-style",
+  EB: "epic-boon",
+  O: "origin",
+  G: "general"
+};
+var FEATURE_TYPE_FOR_CATEGORY = {
+  "fighting-style": "fighting_style"
+};
+function featProgressionCategory(codes) {
+  for (const code of codes != null ? codes : []) {
+    if (Object.prototype.hasOwnProperty.call(FEAT_PROGRESSION_CATEGORY, code)) {
+      return FEAT_PROGRESSION_CATEGORY[code];
+    }
+  }
+  return void 0;
+}
+
+export {
+  FEAT_CATEGORY_CODE_LABELS,
+  featCategoryLabel,
+  FEAT_PROGRESSION_CATEGORY,
+  FEATURE_TYPE_FOR_CATEGORY,
+  featProgressionCategory
+};

package/dist/{chunk-JEYQU3JT.js → chunk-YHYTW5QA.js}

@@ -1,24 +1,8 @@
 // src/pc/decision-recognizer.ts
 var DECISION_SIGNAL = [/\bchoose (one|two|three|a|an)\b/i, /\bof your choice\b/i, /\byour choice of\b/i];
-var ASI_OR_FEAT = {
-  kind: "select-inline",
-  id: "asi-or-feat",
-  count: 1,
-  options: [
-    {
-      value: "asi",
-      label: "Ability Score Increase",
-      choices: [{ kind: "ability-points", id: "asi", points: 2, max_per: 2 }]
-    },
-    {
-      value: "feat",
-      label: "Feat",
-      choices: [{ kind: "select-entity", id: "feat", entity_type: "feat", count: 1 }]
-    }
-  ]
-};
+var ASI_FEAT = { kind: "select-entity", id: "feat", entity_type: "feat", count: 1 };
 var TABLE = {
-  "ability-score-improvement": [ASI_OR_FEAT],
+  "ability-score-improvement": [ASI_FEAT],
   "expertise": [{ kind: "select-proficiency", id: "expertise", count: 2, domain: "skill", from_proficient: true, expertise: true }],
   "fighting-style": [{ kind: "select-entity", id: "fighting-style", count: 1, entity_type: "optional-feature", where: { feature_type: "fighting_style", available_to: "self" } }]
 };