@archivist-gg/dnd5e 0.3.1 → 0.3.4

package/dist/item/item.codec.js

@@ -1,8 +1,9 @@
 import {
   itemCodec
-} from "../chunk-4JHOHWBI.js";
-import "../chunk-7VJ6BOA5.js";
-import "../chunk-K6Q5OUGK.js";
+} from "../chunk-4XTNPNQB.js";
+import "../chunk-SMLXZUBH.js";
+import "../chunk-GFZ7PITJ.js";
+import "../chunk-UA5KS2PL.js";
 export {
   itemCodec
 };

package/dist/item/item.enrichment.js

@@ -1,9 +1,9 @@
 import {
   enrichItem
-} from "../chunk-GJOI2GHP.js";
-import "../chunk-RAWJTA45.js";
-import "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+} from "../chunk-6GNXYAYP.js";
+import "../chunk-DEEHHLAP.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
   enrichItem
 };

package/dist/item/item.parser.js

@@ -1,7 +1,8 @@
 import {
   parseItem
-} from "../chunk-7VJ6BOA5.js";
-import "../chunk-K6Q5OUGK.js";
+} from "../chunk-SMLXZUBH.js";
+import "../chunk-GFZ7PITJ.js";
+import "../chunk-UA5KS2PL.js";
 export {
   parseItem
 };

package/dist/item/item.schema.d.ts

@@ -32,6 +32,22 @@ export declare const itemEntitySchema: z.ZodObject<{
             value: z.ZodNumber;
             when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
         }, z.core.$strip>]>>;
+        spell_damage: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        ability_check: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        proficiency_bonus: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
+        saving_throw_concentration: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            value: z.ZodNumber;
+            when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        }, z.core.$strip>]>>;
         ability_scores: z.ZodOptional<z.ZodObject<{
             static: z.ZodOptional<z.ZodObject<{
                 str: z.ZodOptional<z.ZodNumber>;
@@ -67,6 +83,18 @@ export declare const itemEntitySchema: z.ZodObject<{
                     when: z.ZodArray<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
                 }, z.core.$strip>]>>;
             }, z.core.$strip>>;
+            choose: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                from: z.ZodArray<z.ZodEnum<{
+                    str: "str";
+                    dex: "dex";
+                    con: "con";
+                    int: "int";
+                    wis: "wis";
+                    cha: "cha";
+                }>>;
+                count: z.ZodNumber;
+                amount: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
         }, z.core.$strip>>;
         speed: z.ZodOptional<z.ZodObject<{
             walk: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
@@ -93,6 +121,7 @@ export declare const itemEntitySchema: z.ZodObject<{
     condition_immune: z.ZodOptional<z.ZodArray<z.ZodString>>;
     charges: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         max: z.ZodNumber;
+        dice: z.ZodOptional<z.ZodString>;
         recharge: z.ZodOptional<z.ZodString>;
         recharge_amount: z.ZodOptional<z.ZodString>;
         destroy_on_empty: z.ZodOptional<z.ZodObject<{
@@ -107,6 +136,9 @@ export declare const itemEntitySchema: z.ZodObject<{
         will: z.ZodOptional<z.ZodArray<z.ZodString>>;
         rest: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         limited: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        other: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ability: z.ZodOptional<z.ZodString>;
+        ritual: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     attunement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         required: z.ZodBoolean;
@@ -114,14 +146,28 @@ export declare const itemEntitySchema: z.ZodObject<{
         tags: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             class: z.ZodString;
             subclass: z.ZodOptional<z.ZodString>;
+            alignment: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
         }, z.core.$strip>, z.ZodObject<{
             alignment: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+            race: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             race: z.ZodString;
+            alignment: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
         }, z.core.$strip>, z.ZodObject<{
             creature_type: z.ZodString;
+            size: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             spellcasting: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            background: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            psionics: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            int: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            skill_proficiency: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            language_proficiency: z.ZodArray<z.ZodString>;
         }, z.core.$strip>]>>>;
     }, z.core.$strip>, z.ZodBoolean, z.ZodString]>>;
     grants: z.ZodOptional<z.ZodObject<{
@@ -138,14 +184,24 @@ export declare const itemEntitySchema: z.ZodObject<{
         capacity_weight: z.ZodOptional<z.ZodNumber>;
         weightless: z.ZodOptional<z.ZodBoolean>;
         pack_contents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        capacity: z.ZodOptional<z.ZodObject<{
+            weight: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            item: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+            weightless: z.ZodOptional<z.ZodBoolean>;
+            volume: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
-    light: z.ZodOptional<z.ZodObject<{
+    light: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         bright_radius: z.ZodNumber;
         dim_radius: z.ZodNumber;
-    }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        bright: z.ZodOptional<z.ZodNumber>;
+        dim: z.ZodOptional<z.ZodNumber>;
+        shape: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>>;
     cursed: z.ZodOptional<z.ZodBoolean>;
     sentient: z.ZodOptional<z.ZodBoolean>;
-    focus: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    focus: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodArray<z.ZodString>]>>;
     tier: z.ZodOptional<z.ZodEnum<{
         major: "major";
         minor: "minor";
@@ -178,6 +234,16 @@ export declare const itemEntitySchema: z.ZodObject<{
     scroll_level: z.ZodOptional<z.ZodNumber>;
     unidentified: z.ZodOptional<z.ZodBoolean>;
     masked_category: z.ZodOptional<z.ZodString>;
+    modify_speed: z.ZodOptional<z.ZodObject<{
+        equal: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        static: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        multiply: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        bonus: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strict>>;
+    rendering_hint: z.ZodOptional<z.ZodString>;
+    has_fluff: z.ZodOptional<z.ZodBoolean>;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     damage_dice: z.ZodOptional<z.ZodString>;
     damage_type: z.ZodOptional<z.ZodString>;

package/dist/item/item.schema.js

@@ -1,7 +1,8 @@
 import {
   conditionSchema,
   itemEntitySchema
-} from "../chunk-K6Q5OUGK.js";
+} from "../chunk-GFZ7PITJ.js";
+import "../chunk-UA5KS2PL.js";
 export {
   conditionSchema,
   itemEntitySchema

package/dist/item/item.types.d.ts

@@ -1,16 +1,34 @@
 import type { Ability, ArmorCategory } from "@archivist-gg/dnd5e/armor/armor.types";
 import type { WeaponCategory, WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
 import type { ConditionalBonus } from "@archivist-gg/dnd5e/types/item-conditions.types";
+import type { imageField } from "@archivist-gg/dnd5e/schemas/entity-extras-schema";
+import type { z } from "zod";
 export type ItemRarity = "common" | "uncommon" | "rare" | "very rare" | "legendary" | "artifact" | string;
 export type AttunementTag = {
     class: string;
     subclass?: string;
+    alignment?: string | string[];
 } | {
-    alignment: string;
+    alignment: string | string[];
+    race?: string;
 } | {
     race: string;
+    alignment?: string | string[];
 } | {
     creature_type: string;
+    size?: string;
+} | {
+    spellcasting: boolean;
+} | {
+    background: string;
+} | {
+    psionics: boolean;
+} | {
+    int: number;
+} | {
+    skill_proficiency: string[];
+} | {
+    language_proficiency: string[];
 };
 export interface ItemEntity {
     name: string;
@@ -25,9 +43,20 @@ export interface ItemEntity {
         spell_attack?: number | ConditionalBonus;
         spell_save_dc?: number | ConditionalBonus;
         saving_throws?: number | ConditionalBonus;
+        spell_damage?: number | ConditionalBonus;
+        ability_check?: number | ConditionalBonus;
+        proficiency_bonus?: number | ConditionalBonus;
+        saving_throw_concentration?: number | ConditionalBonus;
         ability_scores?: {
             static?: Partial<Record<Ability, number>>;
             bonus?: Partial<Record<Ability, number | ConditionalBonus>>;
+            /** "choose `count` of `from`, each +`amount`". `amount` is OPTIONAL — the
+             *  Kwalish Deck of Several Things carries `count` with no `amount`. */
+            choose?: Array<{
+                from: Ability[];
+                count: number;
+                amount?: number;
+            }>;
         };
         speed?: {
             walk?: number | ConditionalBonus;
@@ -42,6 +71,8 @@ export interface ItemEntity {
     condition_immune?: string[];
     charges?: {
         max: number;
+        /** Dice regained per recharge, e.g. "1d4 - 1". */
+        dice?: string;
         recharge?: string;
         recharge_amount?: string;
         destroy_on_empty?: {
@@ -57,6 +88,11 @@ export interface ItemEntity {
         rest?: Record<string, string[]>;
         /** Total uses with no recharge — item often consumed when empty. */
         limited?: Record<string, string[]>;
+        /** Spells the document lists without a cost model. */
+        other?: string[];
+        /** Casting ability for the item's attached spells. */
+        ability?: string;
+        ritual?: string[];
     };
     attunement?: {
         required: boolean;
@@ -77,14 +113,29 @@ export interface ItemEntity {
         capacity_weight?: number;
         weightless?: boolean;
         pack_contents?: string[];
+        /** Structured 5etools capacity. `item` entries are records of
+         *  "<item tag>": <count>, e.g. {"sling bullet|xphb": 20}. */
+        capacity?: {
+            weight?: number[];
+            item?: Array<Record<string, number>>;
+            weightless?: boolean;
+            volume?: number[];
+        };
     };
+    /** Two DIFFERENT spellings, never unified: the object form
+     *  {bright_radius, dim_radius} (173 carriers) and the converter's array of
+     *  per-source entries keyed bright/dim/shape (97 entries over 81 docs). */
     light?: {
         bright_radius: number;
         dim_radius: number;
-    };
+    } | Array<{
+        bright?: number;
+        dim?: number;
+        shape?: string;
+    }>;
     cursed?: boolean;
     sentient?: boolean;
-    focus?: boolean | "arcane" | "druid" | "holy";
+    focus?: boolean | "arcane" | "druid" | "holy" | string[];
     tier?: "major" | "minor";
     damage?: WeaponEntity["damage"] | string;
     weapon_category?: WeaponCategory;
@@ -114,6 +165,21 @@ export interface ItemEntity {
     /** Generic category label shown for an unidentified item (e.g. "potion",
      *  "scroll", "wand") in place of its real name. */
     masked_category?: string;
+    /** Speed overrides the item applies. `equal` maps a mode to another mode's
+     *  value (e.g. {fly: "walk"}); static/multiply/bonus are numeric, and `bonus`
+     *  is keyed "*" on its single carrier. */
+    modify_speed?: {
+        equal?: Record<string, string>;
+        static?: Record<string, number>;
+        multiply?: Record<string, number>;
+        bonus?: Record<string, number>;
+    };
+    /** Carried by every converter item doc, always as "" today. */
+    rendering_hint?: string;
+    has_fluff?: boolean;
+    has_fluff_images?: boolean;
+    /** One wikilink, or an array for >= 2 fluff images (images-ON emit). */
+    image?: z.infer<typeof imageField>;
     raw?: Record<string, unknown>;
     damage_dice?: string;
     damage_type?: string;

package/dist/monster/monster.codec.d.ts

@@ -3,11 +3,12 @@ import type { Monster } from "./monster.types.js";
 /** Deprecated alias kept for the barrel re-export (`index.ts:7`) + `monster.resolve.ts:2`. */
 export type MonsterRaw = Monster;
 /**
- * Normalizing codec (0c.1a B8). `parse` delegates to `parseMonster`, which maps
- * the `legendary` alias and extracts Legendary-Resistance from trait text into the
- * canonical `legendary_resistance` field. This canonicalization is intended and
- * persists on save (B3); resolve-derived PB/XP are NOT added here. `serialize` stays
- * `yaml.dump` (the edit-save path uses obsidian's separate `editableToYaml` — document
- * that two-serializer split here; gate (d) Step 6 verifies `yaml.dump` round-trips).
+ * Normalizing codec (0c.1a B8). `parse` delegates to `parseMonster`, which runs the legacy migrations of R4-G6 §4.1
+ * (the `legendary` alias, scalar `ac` / `hp`, numeric-string coercion, the non-finite scrub, the null step, the
+ * `senses` / `languages` string lift, `desc`, a malformed `recharge`), validates against `monsterSchema`, relocates
+ * undeclared top-level keys into `raw`, and extracts Legendary-Resistance from trait text into the canonical
+ * `legendary_resistance` field. All of it is intended and persists on save (B3); resolve-derived PB/XP are NOT added
+ * here. `serialize` stays `yaml.dump` (the edit-save path uses obsidian's separate `editableToYaml`: that
+ * two-serializer split is documented here; gate (d) Step 6 verifies `yaml.dump` round-trips).
  */
 export declare const monsterCodec: DocCodec<Monster>;

package/dist/monster/monster.enrichment.js

@@ -5,10 +5,10 @@ import {
   getChallengeRatingXP,
   getProficiencyBonus,
   parseCR
-} from "../chunk-66XXW2Z2.js";
-import "../chunk-RAWJTA45.js";
-import "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+} from "../chunk-6PXTNCBP.js";
+import "../chunk-DEEHHLAP.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
   CR_TO_XP,
   convertMonsterEntries,

package/dist/monster/monster.format.d.ts

@@ -0,0 +1,135 @@
+/**
+ * R4-G6 §6 · READ-time decoding of the converter's 5etools-shaped monster leaves. Pure functions; every table is
+ * DATA in this module (memory: rendering policy from the schema / data, never a switch on game vocabulary in a
+ * renderer). Every function accepts the authored string / number shape AND the structured shape, and on the
+ * string / number arms reproduces the plugin renderer's historical output byte for byte (invariant 5: the SRD
+ * render pins are the proof).
+ */
+import type { Abilities } from "../types/index.js";
+import type { AlignmentEntry, DamageQualifier, MonsterAC, MonsterCRStructured, MonsterGearEntry, MonsterHP, MonsterInitiative, MonsterSectionHeader, MonsterSpeed, MonsterSpellcasting, MonsterTypeStructured } from "./monster.types.js";
+/** The plugin renderer's historical helper, byte for byte (`/\b\w/g`), so `player's` becomes `Player'S`. */
+export declare function capitalizeWords(str: string): string;
+/** `capitalizeWords` applied OUTSIDE wikilink targets: the plain text and the ALIAS of `[[target|alias]]` are
+ *  title-cased, the target never is (1,202 `ac[].from` links carry an apostrophe the plain helper mangles). */
+export declare function capitalizeOutsideLinks(str: string): string;
+export declare const SIZE_CODES: Readonly<Record<string, string>>;
+export declare function formatSize(size: string | string[] | undefined, note?: string): string;
+/** The FIRST decoded size word, lower-cased: the hit-die table and the edit-mode size select key on it. */
+export declare function sizeWord(size: string | string[] | undefined): string;
+export declare const ALIGNMENT_CODES: Readonly<Record<string, string>>;
+/** The multi-code SETS 5etools prints as a phrase, keyed by the sorted code set (the measured combos). */
+export declare const ALIGNMENT_SETS: Readonly<Record<string, string>>;
+export declare function formatAlignment(alignment: string | (string | AlignmentEntry)[] | undefined, prefix?: string): string;
+/** The decoded text lower-cased: the edit-mode alignment selects match on it. */
+export declare function alignmentWords(alignment: string | (string | AlignmentEntry)[] | undefined): string;
+export declare const IRREGULAR_PLURALS: Readonly<Record<string, string>>;
+export declare function formatType(type: string | MonsterTypeStructured | undefined, level?: number): string;
+export interface FormattedCR {
+    crText: string;
+    xp: number;
+    pb: number;
+    tableMiss: boolean;
+    lair?: string;
+    coven?: string;
+    xpLair?: number;
+    xpOverride?: number;
+}
+export declare function formatCR(cr: string | MonsterCRStructured | undefined): FormattedCR | undefined;
+/** Thousands-separated without `toLocaleString` (ICU-independent, deterministic across Node and Electron). */
+export declare function formatXP(xp: number): string;
+/** The bare `cr` text (today's Challenge value; `formatCR` normalises it before the PB / XP table reads). */
+export declare function crString(cr: string | MonsterCRStructured | undefined): string | undefined;
+export declare function challengeLine(cr: string | MonsterCRStructured | undefined, pbNote?: string): string | undefined;
+/** R4 {G5, G6} live rider N-3-3: a BRACED entry joins with a SPACE, every other with ", ". The braces
+ *  flag marks an entry that reads as a parenthetical on the one before it ("15 (17 with mage armor)"),
+ *  so emitting the list comma as well gave the Archmage and the converter's Feonor
+ *  `Armor Class. 12, (15 with mage armor)`. The separator therefore belongs to the entry that FOLLOWS
+ *  it, not to the list, which is why this joins by hand rather than with `Array.join`. A braced entry
+ *  that opens the line still stands alone, and two unbraced entries still take the comma. */
+export declare function formatAC(ac: MonsterAC[] | undefined): string;
+export declare function formatHP(hp: MonsterHP | undefined): {
+    text: string;
+    formula?: string;
+};
+export declare const SPEED_MODES: readonly ["walk", "fly", "swim", "climb", "burrow"];
+export type SpeedMode = (typeof SPEED_MODES)[number];
+export declare function formatSpeed(speed: MonsterSpeed | undefined): string;
+/** The numeric part of a speed value, or 0 (the edit-mode number inputs and the `> 0` gates read this). */
+export declare function speedNumber(speed: MonsterSpeed | undefined, mode: SpeedMode): number;
+export declare function formatQualifiers(list: (string | DamageQualifier)[] | null | undefined): string[];
+/** The STRING entries only (the edit-mode multi-selects are `string[]`; structured entries are merged back on save). */
+export declare function qualifierStrings(list: (string | DamageQualifier)[] | null | undefined): string[];
+export declare const INITIATIVE_MODES: Readonly<Record<string, string>>;
+export declare function formatInitiative(initiative: number | MonsterInitiative | undefined, abilities: Abilities | undefined, pb: number): string | undefined;
+export declare function formatGear(gear: (string | MonsterGearEntry)[] | undefined): string;
+/**
+ * The Languages line (R4 {G5, G6} live rider 3, Z-9-9). Each entry is title-cased, as this line has always
+ * been, EXCEPT that the word immediately following an amount keeps the case it was authored in: that word is
+ * the amount's unit. `capitalizeWords` reached it too, so a block read `Deep Speech; Telepathy 120 Ft.` while
+ * the Senses line right above printed its own `darkvision 120 ft.` verbatim (Aboleth, Baphomet).
+ *
+ * The rule is a SHAPE, not a list of unit words: no vocabulary table enters this formatter. Measured over the
+ * converter corpus' 4,042 monster notes that carry a `languages` block, the words that follow an amount there
+ * are `ft` (527), `mile` (10), `miles` (7), `feet` (1), the conjunctions `and` (7) and `or` (2), and NINE
+ * language names already authored with a capital (`Elvish`, `Common`, `Terran`, `Druidic`, `Ignan`, `Sylvan`,
+ * `Celestial`, `Draconic`, `Auran`). Keeping the AUTHORED case rather than lower-casing is what leaves those
+ * language names alone; the two conjunctions stop being title-cased, which is correct English and reaches no
+ * SRD bundle document (there, `ft` is the only word that ever follows an amount).
+ *
+ * What this does NOT change: the rest of an entry's free prose is still title-cased, so
+ * "understands Common and Deep Speech but can't speak" still renders with each word capitalised. That is the
+ * line's shipped register and a separate copy question, recorded rather than changed here.
+ */
+export declare function formatLanguages(list: string[] | undefined): string;
+/**
+ * A monster's `skills` (and `skills_other.one_of`) KEY to the name a reader sees (R4 {G5, G6} live rider 3,
+ * Z-9-8). Those keys are written with a separator · the SRD bundle's Donkey carries `animal_handling` and
+ * `sleight_of_hand` · and `capitalizeWords` only upper-cases the first letter of each WORD, so the separator
+ * survived and the line read `Animal_handling +0`. The separator is normalised and the CANONICAL list answers;
+ * a key the list does not know keeps `capitalizeWords`, which is byte for byte what every key rendered before
+ * (invariant 5: the sixteen one-word skills already agreed with the list, so only the two-word two move).
+ */
+export declare function skillDisplayName(key: string): string;
+export declare function formatSkillsOther(list: unknown[] | undefined): string | undefined;
+/**
+ * The generated legendary-action sentence (R4-G6 spec §6), used only when the document authors no
+ * `section_headers` row for the section (plugin `monster.sections.ts`).
+ *
+ * `short_name` is read exactly as authored: a STRING is the subject verbatim; `true` and `false` both say "this
+ * document has no separate short name", so the whole name prints; only an ABSENT key derives one through
+ * `shortNameOfNamed`. Measured over the two shipped corpora (`g7-t8-wE-f1-d9-corpus.txt`): 24 monster documents carry
+ * a `short_name` (11 `true`, 13 a string) and NONE carries `false`, so the false arm is a contract read from the type,
+ * not an observed rendering.
+ */
+export declare function legendaryIntro(m: {
+    name: string;
+    is_named_creature?: boolean;
+    short_name?: string | boolean;
+    legendary_actions_lair_count?: number;
+}, count: number): string;
+export declare function sectionHeader(m: {
+    section_headers?: MonsterSectionHeader[];
+    mythic_header?: string[];
+}, section: "legendary_actions" | "mythic" | "reactions"): string[] | undefined;
+export type PlacedSection = "traits" | "actions" | "bonus_actions" | "reactions" | "legendary_actions";
+/** ONE object: the 5etools `displayAs` vocabulary to the stat-block section (the plugin never switches on it). */
+export declare const DISPLAY_AS_SECTION: Readonly<Record<string, Exclude<PlacedSection, "traits">>>;
+export declare function displayAsSection(displayAs: string | undefined): PlacedSection;
+declare const GROUP_ORDER: readonly ["will", "daily", "rest", "restLong", "recharge", "legendary", "charges", "ritual"];
+/** ONE label table: EVERY group of `GROUP_ORDER` owns its label text here, so the eight FREQUENCY-group labels are
+ *  DATA; the slot-table wording (`Cantrips (At Will):`, `N Level (N Slots):`) is generated in `spellcastingLines`
+ *  and deliberately outside this table. Title-cased to match the SRD 2024 statblock prose the vault already
+ *  shows beside these entries. `plain` is a plain sub-key's label, and the whole label of the two count-less groups
+ *  `will` and `ritual`; `each` is its `Ne` twin, absent where a group has no twin; `six` is `recharge`'s
+ *  already-at-6 form. `N` stands for the sub-key's count. `charges` alone ends without a colon: `spellcastingLines`
+ *  appends ` (chargesItem):` after it (§8.2). The KEY type is `GROUP_ORDER`'s union, so a ninth group without a row
+ *  is a compile error rather than a runtime `undefined`. */
+export declare const SPELLCASTING_LABELS: Readonly<Record<(typeof GROUP_ORDER)[number], {
+    plain: string;
+    each?: string;
+    six?: string;
+}>>;
+export declare function spellcastingLines(block: MonsterSpellcasting): string[];
+/** The measured node vocabulary to markdown; never throws; an unknown type recurses into its children only. */
+export declare function entriesToMarkdown(tree: unknown): string;
+export {};

package/dist/monster/monster.format.js

@@ -0,0 +1,78 @@
+import {
+  ALIGNMENT_CODES,
+  ALIGNMENT_SETS,
+  DISPLAY_AS_SECTION,
+  INITIATIVE_MODES,
+  IRREGULAR_PLURALS,
+  SIZE_CODES,
+  SPEED_MODES,
+  SPELLCASTING_LABELS,
+  alignmentWords,
+  capitalizeOutsideLinks,
+  capitalizeWords,
+  challengeLine,
+  crString,
+  displayAsSection,
+  entriesToMarkdown,
+  formatAC,
+  formatAlignment,
+  formatCR,
+  formatGear,
+  formatHP,
+  formatInitiative,
+  formatLanguages,
+  formatQualifiers,
+  formatSize,
+  formatSkillsOther,
+  formatSpeed,
+  formatType,
+  formatXP,
+  legendaryIntro,
+  qualifierStrings,
+  sectionHeader,
+  sizeWord,
+  skillDisplayName,
+  speedNumber,
+  spellcastingLines
+} from "../chunk-2FRUSVZS.js";
+import "../chunk-6PXTNCBP.js";
+import "../chunk-DEEHHLAP.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
+export {
+  ALIGNMENT_CODES,
+  ALIGNMENT_SETS,
+  DISPLAY_AS_SECTION,
+  INITIATIVE_MODES,
+  IRREGULAR_PLURALS,
+  SIZE_CODES,
+  SPEED_MODES,
+  SPELLCASTING_LABELS,
+  alignmentWords,
+  capitalizeOutsideLinks,
+  capitalizeWords,
+  challengeLine,
+  crString,
+  displayAsSection,
+  entriesToMarkdown,
+  formatAC,
+  formatAlignment,
+  formatCR,
+  formatGear,
+  formatHP,
+  formatInitiative,
+  formatLanguages,
+  formatQualifiers,
+  formatSize,
+  formatSkillsOther,
+  formatSpeed,
+  formatType,
+  formatXP,
+  legendaryIntro,
+  qualifierStrings,
+  sectionHeader,
+  sizeWord,
+  skillDisplayName,
+  speedNumber,
+  spellcastingLines
+};

package/dist/monster/monster.parser.d.ts

@@ -1,3 +1,8 @@
-import { Monster } from "./monster.types.js";
+import type { Monster } from "./monster.types.js";
 import type { ParseResult } from "@archivist-gg/core";
+/**
+ * R4-G6 §4.1 · the hand parser's tolerances made explicit, BEFORE `safeParse`. Each step rewrites only a shape the
+ * old parser already rewrote, coerced or dropped; the converter corpora are untouched by it (0 / 0 / 0 measured).
+ */
+export declare function migrateLegacy(raw: Record<string, unknown>): void;
 export declare function parseMonster(source: string): ParseResult<Monster>;

package/dist/monster/monster.parser.js

@@ -1,6 +1,15 @@
 import {
+  migrateLegacy,
   parseMonster
-} from "../chunk-7P65Q426.js";
+} from "../chunk-COEOOQX2.js";
+import "../chunk-6PKV5V2H.js";
+import "../chunk-4FWNK4FD.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
+  migrateLegacy,
   parseMonster
 };