@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/pc/pool-layout.d.ts

@@ -0,0 +1,47 @@
+import type { EntryAffordance, PoolLayout } from "../types/selection-pool.js";
+import type { ResolvedPoolEntry } from "./pc.types.js";
+/** The ONE `rendering_hint` → `PoolLayout` table (R4-G4 §4.2.2, invariant 3): a DATA table in the
+ *  RESET_LABELS shape. Absent keys route to the default, and R4-G5 added NONE: `pool-selection` and
+ *  `stance` are a measured empty delta (spec §10) and `granted-die-to-ally` became a per-ROW affordance
+ *  in the table below, so this one still holds exactly the two G4 keys. */
+export declare const RENDERING_HINT_LAYOUT: Readonly<Record<string, PoolLayout>>;
+/** The majority mapped hint over the pool's members; members with an empty or unmapped hint do not
+ *  vote; no votes → undefined; a tie between two mapped values → undefined (Gate 0 Q8).
+ *  UNMAPPED is decided by OWN-property lookup, never by truthiness of a plain index (review M-2):
+ *  `rendering_hint` is a free `z.string().optional()` on converter data, so a member may carry any
+ *  string, and an object-literal table answers the `Object.prototype` keys through the prototype
+ *  chain. Measured 2026-09-06 on this table: `constructor`, `toString`, `hasOwnProperty` and
+ *  `valueOf` each index to a FUNCTION and each has `hasOwnProperty` false, while the two mapped
+ *  hints, `dice-pool` and `point-pool`, are the only keys that are both a string and own (review
+ *  M-1: the earlier wording named `dice-pool` alone). Without the guard a lone junk hint voted that
+ *  function as the layout, and one junk member beside genuine `dice-pool` members collapsed a
+ *  correct majority into a phantom tie. */
+export declare function derivePoolLayout(entries: ReadonlyArray<ResolvedPoolEntry>): PoolLayout | undefined;
+/** The ONE `rendering_hint` to `EntryAffordance` table (R4-G5 §4.2.1, invariant 3): the PER-ENTRY sibling of
+ *  `RENDERING_HINT_LAYOUT`. `granted-die-to-ally` is its only key, and the four documents carrying it
+ *  (Commander's Strike x2, Rally x2) are field-identical to the other 39 maneuvers except that hint, so a
+ *  per-row affordance is the only place their meaning can land. `stance` gets NO key (its three hinted documents
+ *  are field-identical to three unhinted siblings: a measured empty delta) and `pool-selection` none. */
+export declare const RENDERING_HINT_AFFORDANCE: Readonly<Record<string, EntryAffordance>>;
+/** The entry's affordance, by OWN-property lookup (`derivePoolLayout`'s precedent, invariant 3): `rendering_hint`
+ *  is a free `z.string().optional()` on converter data, so a member may carry ANY string, and an object-literal
+ *  table answers `constructor` / `toString` / `hasOwnProperty` / `valueOf` through the prototype chain with a
+ *  FUNCTION. Absent, empty and unmapped hints all return undefined. */
+export declare function deriveEntryAffordance(entity: ResolvedPoolEntry["entity"]): EntryAffordance | undefined;
+/** Caption TEMPLATES per affordance, in the `RESET_LABELS` shape: the game sentence lives in DATA here, never in
+ *  a renderer (invariant 3). `{amount}` and `{die}` are filled by `formatAffordanceCaption`.
+ *
+ *  The two placeholders ABUT (R4 {G5, G6} live rider N-1-12): the sheet read `1 d8 to an ally`, which is not how
+ *  a die is written. `{die}` is a FACE by contract · the caller passes what `resolveScalingDie` returns, which is
+ *  `base` or one of `scaling`'s entries, and every one of those in shipped data is face-shaped ("d6" throughout
+ *  the SRD runtime JSON and the compendium bundle) · so amount and face compose into one dice expression. */
+export declare const AFFORDANCE_CAPTIONS: Readonly<Record<EntryAffordance, string>>;
+/** Fill an affordance's caption template. PURE, and pure on purpose: the caller supplies values it has ALREADY
+ *  resolved (the plugin resolves the die through `resolveScalingDie` at the owner's class level, exactly as the
+ *  shipped spend control resolves its own "(d8)" label), so no renderer ever holds the sentence and no engine
+ *  module ever needs the character. A placeholder with no value is left VERBATIM rather than printed as
+ *  "undefined". */
+export declare function formatAffordanceCaption(affordance: EntryAffordance, values: {
+    amount: number;
+    die: string;
+}): string;

package/dist/pc/pool-layout.js

@@ -0,0 +1,16 @@
+import {
+  AFFORDANCE_CAPTIONS,
+  RENDERING_HINT_AFFORDANCE,
+  RENDERING_HINT_LAYOUT,
+  deriveEntryAffordance,
+  derivePoolLayout,
+  formatAffordanceCaption
+} from "../chunk-PP2UHLBA.js";
+export {
+  AFFORDANCE_CAPTIONS,
+  RENDERING_HINT_AFFORDANCE,
+  RENDERING_HINT_LAYOUT,
+  deriveEntryAffordance,
+  derivePoolLayout,
+  formatAffordanceCaption
+};

package/dist/pc/roll-scope.d.ts

@@ -0,0 +1,2 @@
+import type { RollKind } from "./pc.types.js";
+export declare function normalizeRollScope(raw: string | undefined, _roll: RollKind): string[] | undefined;

package/dist/pc/roll-scope.js

@@ -0,0 +1,8 @@
+import {
+  normalizeRollScope
+} from "../chunk-TOM66P2P.js";
+import "../chunk-KU3YLF6D.js";
+import "../chunk-WELIKLZF.js";
+export {
+  normalizeRollScope
+};

package/dist/pc/roll-tag-labels.d.ts

@@ -0,0 +1,40 @@
+/**
+ * R4-G3a §5.2 · the tag mechanism's DATA tables: the single source of every roll/outcome tag
+ * TEXT the plugin's three chip surfaces render.
+ *
+ * Invariant 3: captions and tag texts derive from the effect's own fields through ONE
+ * data-shaped table per concern; a closed vocabulary `switch` on game data inside a component is
+ * the smell this replaces (all three surfaces spelled `mode === "advantage" ? "ADV" : "DIS"`,
+ * which renders "DIS" for a `reroll` the moment `mode` widens: a green tree with a false chip).
+ *
+ * `Record<RollModifierMode, …>` / `Record<RollKind, …>` are load-bearing: the aliases come from
+ * `pc.types.ts`, so widening `RollModifierEntry.mode` without extending these tables is a COMPILE
+ * error, not a silent misrender (§14 row 8i's control).
+ *
+ * `ROLL_MODE_WORD` and `ROLL_NOUN` are the PROSE halves (Task 3 consumes them for feature-card
+ * captions); `ROLL_MODE_TAG` is the terse chip half.
+ *
+ * `ROLL_NOUN` is keyed `RollKind | "any"`, one member wider than the folded `RollModifierEntry`.
+ * The fold FANS OUT `roll: "any"` into one entry per roll type (§6.2.1), so no chip surface ever
+ * sees it; the RAW effect on a feature row still carries it, and Task 3 captions raw effects. Its
+ * noun is "rolls" rather than a stand-in member: an `any` modifier covers checks, saves AND attacks
+ * at once, so borrowing "ability checks" for it understates the scope in prose.
+ *
+ * Never an "EVA" literal for the outcome tag:
+ * Evasion is only one of four bearers, and Spellfire Sorcery is not Evasion.
+ */
+import type { RollModifierMode, RollKind, SaveOutcome } from "./pc.types.js";
+export declare const ROLL_MODE_TAG: Record<RollModifierMode, string>;
+export declare const ROLL_MODE_WORD: Record<RollModifierMode, string>;
+export declare const ROLL_NOUN: Record<RollKind | "any", string>;
+export declare const AUTO_FAIL_TAG = "AUTO-FAIL";
+/** R4-G7 T8 RIDER-20 (F-ADV) · the ONE glyph a CONDITIONAL tag appends to its text: a `roll-modifier` entry that carries a
+ *  `condition`, or a `scope` the normaliser could not map (the qualifier the converter left in `scope`), and a `save-outcome`
+ *  entry that carries a `condition`. `ADV` alone reads "always"; `ADV*` says "only sometimes, hover for when". The chip
+ *  carriers append it to the `ROLL_MODE_TAG` / `saveOutcomeTag` text, so the glyph is spelled here once. */
+export declare const CONDITIONAL_TAG_MARK = "*";
+/** The closed `save-outcome` result vocabulary as display glyphs: how much damage you still take.
+ *  `Record<SaveOutcome, string>` (the alias from pc.types.ts) so the union is spelled once. */
+export declare const OUTCOME: Record<SaveOutcome, string>;
+/** `{none, half}` → "0/½": success outcome over failure outcome. */
+export declare const saveOutcomeTag: (onSuccess: SaveOutcome, onFailure: SaveOutcome) => string;

package/dist/pc/roll-tag-labels.js

@@ -0,0 +1,17 @@
+// src/pc/roll-tag-labels.ts
+var ROLL_MODE_TAG = { advantage: "ADV", disadvantage: "DIS", reroll: "RR", "add-d4": "+D4" };
+var ROLL_MODE_WORD = { advantage: "advantage", disadvantage: "disadvantage", reroll: "a reroll", "add-d4": "+1d4" };
+var ROLL_NOUN = { "ability-check": "ability checks", "saving-throw": "saving throws", attack: "attack rolls", any: "rolls" };
+var AUTO_FAIL_TAG = "AUTO-FAIL";
+var CONDITIONAL_TAG_MARK = "*";
+var OUTCOME = { none: "0", half: "\xBD", full: "1" };
+var saveOutcomeTag = (onSuccess, onFailure) => `${OUTCOME[onSuccess]}/${OUTCOME[onFailure]}`;
+export {
+  AUTO_FAIL_TAG,
+  CONDITIONAL_TAG_MARK,
+  OUTCOME,
+  ROLL_MODE_TAG,
+  ROLL_MODE_WORD,
+  ROLL_NOUN,
+  saveOutcomeTag
+};

package/dist/pc/spell-source.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedSpell } from "./pc.types.js";
+/** R4-G3b §6 · ONE data-shaped routing descriptor per ResolvedSpell.source, read by the plugin's Spells-tab components in
+ *  place of thirteen hardcoded `source ===` arms (the standing rule: policy from data, never a vocabulary switch in a
+ *  component). No `label` (nothing renders a source caption; a provenance caption is G8's) and no `removable` (that is
+ *  ResolvedSpell.persisted: membership in character.spells.known). `domain` is declared but NO grant producer
+ *  hardcodes it; the one thing that reaches a sheet carrying it is a hand-authored `spells.known[].source:
+ *  domain`, permitted by pc.schema.ts and passed through by normalizeKnownSpell (pc.spellcasting.ts). */
+export interface SpellSourceDescriptor {
+    /** The row's DC / attack bonus come from its own `ability` when it carries one, not from a class. */
+    ownAbility: boolean;
+    /** Which surface the row belongs to: the class/grant spellbook sections, or Scrolls & Consumables. */
+    section: "spellbook" | "consumable";
+    /** A leveled row at a level the character owns no slot for gets its own free-cast block. */
+    freeCastWhenNoSlot: boolean;
+    /** The row is preparable/lockable in the Prepare list (and seeds its level filter chips). */
+    showInPrepare: boolean;
+    /** The row is a grant, so it lifts the Spells tab's "No Spellcasting" empty state on its own. */
+    countsAsGranted: boolean;
+}
+export declare const SPELL_SOURCE: Record<ResolvedSpell["source"], SpellSourceDescriptor>;
+export declare const spellSource: (s: Pick<ResolvedSpell, "source">) => SpellSourceDescriptor;

package/dist/pc/spell-source.js

@@ -0,0 +1,13 @@
+// src/pc/spell-source.ts
+var SPELL_SOURCE = {
+  class: { ownAbility: false, section: "spellbook", freeCastWhenNoSlot: false, showInPrepare: true, countsAsGranted: false },
+  feat: { ownAbility: true, section: "spellbook", freeCastWhenNoSlot: true, showInPrepare: true, countsAsGranted: true },
+  item: { ownAbility: false, section: "consumable", freeCastWhenNoSlot: false, showInPrepare: false, countsAsGranted: true },
+  race: { ownAbility: true, section: "spellbook", freeCastWhenNoSlot: true, showInPrepare: true, countsAsGranted: true },
+  domain: { ownAbility: false, section: "spellbook", freeCastWhenNoSlot: false, showInPrepare: true, countsAsGranted: false }
+};
+var spellSource = (s) => SPELL_SOURCE[s.source];
+export {
+  SPELL_SOURCE,
+  spellSource
+};

package/dist/race/race.codec.js

@@ -1,13 +1,15 @@
 import {
   raceCodec
-} from "../chunk-ZZGEVJKX.js";
-import "../chunk-PHQRGDRQ.js";
-import "../chunk-2BWAID3Y.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-XBQMCEI2.js";
+import "../chunk-XGOFP7AQ.js";
+import "../chunk-FDBWYMZK.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-4FWNK4FD.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
   raceCodec
 };

package/dist/race/race.parser.js

@@ -1,12 +1,14 @@
 import {
   parseRace
-} from "../chunk-PHQRGDRQ.js";
-import "../chunk-2BWAID3Y.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-XGOFP7AQ.js";
+import "../chunk-FDBWYMZK.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-4FWNK4FD.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
   parseRace
 };

package/dist/race/race.schema.d.ts

@@ -1,4 +1,23 @@
 import { z } from "zod";
+/** Exported so the SRD overlay validates AUTHORED fixed increases against the
+ *  FIXED ARM canonical output is validated against, derived from this one
+ *  definition so the two cannot drift. Note the precise relationship:
+ *  `raceEntitySchema` below validates `ability_score_increases` with `asiSchema`,
+ *  the UNION, of which this is one arm · `overlay.schema.ts` deliberately narrows
+ *  to this arm alone, because the choice-shaped arm folds nothing at runtime
+ *  (`flattenRaceAsi` reads only `"ability" in asi`), so rejecting it at authoring
+ *  time is a guard, not a limitation. */
+export declare const fixedAsiSchema: z.ZodObject<{
+    ability: z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
 export declare const raceEntitySchema: z.ZodObject<{
     slug: z.ZodString;
     name: z.ZodString;
@@ -10,8 +29,8 @@ export declare const raceEntitySchema: z.ZodObject<{
     description: z.ZodString;
     size: z.ZodEnum<{
         medium: "medium";
-        tiny: "tiny";
         small: "small";
+        tiny: "tiny";
         large: "large";
         huge: "huge";
     }>;
@@ -64,4 +83,35 @@ export declare const raceEntitySchema: z.ZodObject<{
     traits: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
     choices: z.ZodOptional<z.ZodArray<z.ZodType<import("../index.js").Choice, unknown, z.core.$ZodTypeInternals<import("../index.js").Choice, unknown>>>>;
     subspecies_of: z.ZodOptional<z.ZodString>;
+    rendering_hint: z.ZodOptional<z.ZodString>;
+    has_fluff: z.ZodOptional<z.ZodBoolean>;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    creature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    creature_type_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    additional_spells: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            choose: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>]>>;
+        known: z.ZodOptional<z.ZodUnknown>;
+        innate: z.ZodOptional<z.ZodUnknown>;
+        prepared: z.ZodOptional<z.ZodUnknown>;
+        expanded: z.ZodOptional<z.ZodUnknown>;
+        resourceName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            choose: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>]>>;
+        known: z.ZodOptional<z.ZodUnknown>;
+        innate: z.ZodOptional<z.ZodUnknown>;
+        prepared: z.ZodOptional<z.ZodUnknown>;
+        expanded: z.ZodOptional<z.ZodUnknown>;
+        resourceName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    trait_tags: z.ZodOptional<z.ZodUnknown>;
+    lineage: z.ZodOptional<z.ZodUnknown>;
+    height_and_weight: z.ZodOptional<z.ZodUnknown>;
+    sound_clip: z.ZodOptional<z.ZodUnknown>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strip>;

package/dist/race/race.schema.js

@@ -1,11 +1,14 @@
 import {
+  fixedAsiSchema,
   raceEntitySchema
-} from "../chunk-2BWAID3Y.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-FDBWYMZK.js";
+import "../chunk-4FWNK4FD.js";
 import "../chunk-WYGD2UGN.js";
-import "../chunk-PZOWBI3B.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
+import "../chunk-UA5KS2PL.js";
 export {
+  fixedAsiSchema,
   raceEntitySchema
 };

package/dist/race/race.structural.d.ts

@@ -0,0 +1,7 @@
+/** R4-G3b §5.2.9 · the STRUCTURAL pseudo-choices of a race entry: Size / Speed / Darkvision are surfaced as glance tiles
+ *  and are not content. Shared by the plugin's two trait-name folds (keyed on TRAIT NAMES, lowercased) and by the
+ *  resolver's `additional_spells` race gate (keyed on select-inline CHOICE IDS; on the corpus only `size` occurs as an
+ *  id, 18 carriers, 17 saved by this exemption). A measured v1 exception to the schema-not-renderer rule: it must never
+ *  grow into an allowlist of lineage ids (the structural replacement is the NEXT-REGEN / G7 ask). NOT imported by any
+ *  schema, parser, codec or srd module (the T6/T12 grep guard keeps it out of the generators graph). */
+export declare const RACE_STRUCTURAL_PSEUDO: ReadonlySet<string>;

package/dist/race/race.structural.js

@@ -0,0 +1,6 @@
+import {
+  RACE_STRUCTURAL_PSEUDO
+} from "../chunk-PVCEA4HZ.js";
+export {
+  RACE_STRUCTURAL_PSEUDO
+};

package/dist/race/race.types.d.ts

@@ -1,5 +1,6 @@
 import type { Feature, Ability, Speed, Choice } from "@archivist-gg/dnd5e";
 import type { Edition } from "@archivist-gg/dnd5e/types/edition";
+import type { AdditionalSpellsEntry } from "@archivist-gg/dnd5e/schemas/entity-extras-schema";
 export type Size = "tiny" | "small" | "medium" | "large" | "huge";
 export type FixedAbilityIncrease = {
     ability: Ability;
@@ -41,4 +42,23 @@ export interface RaceEntity {
     traits: Feature[];
     choices?: Choice[];
     subspecies_of?: string;
+    /** Converter/bundle extras declared by race.schema.ts §2.3. Every one is optional: none is
+     *  read by the pc pipeline today, and declaring them is what stops the parser silently
+     *  dropping them (the "declare or lose" rule). */
+    rendering_hint?: string;
+    has_fluff?: boolean;
+    has_fluff_images?: boolean;
+    creature_type?: string[];
+    creature_type_tags?: string[];
+    /** DUAL ARITY (§2.8): the converter emits an array on 109 docs, the shipped SRD bundle a bare
+     *  object on 3 (`SRD 2024/Races/{Elf,Tiefling}.md`, `SRD 5e/Races/Tiefling.md`). */
+    additional_spells?: AdditionalSpellsEntry[] | AdditionalSpellsEntry;
+    /** The four RAW 5etools passthroughs: `unknown` mirrors the schema's `z.unknown()`. Today's
+     *  variant set is a snapshot, not a contract, so the type stays maximally loose. */
+    trait_tags?: unknown;
+    lineage?: unknown;
+    height_and_weight?: unknown;
+    sound_clip?: unknown;
+    /** One wikilink, or an array of them for the multi-fluff-image emit. */
+    image?: string | string[];
 }

package/dist/schemas/attack-schema.d.ts

@@ -35,4 +35,9 @@ export declare const attackSchema: z.ZodObject<{
         reach: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     condition: z.ZodOptional<z.ZodString>;
+    bonus: z.ZodOptional<z.ZodNumber>;
+    extra_damage: z.ZodOptional<z.ZodObject<{
+        dice: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/schemas/caster-type-schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+/** THE caster-type vocabulary, declared once (R4-G1a D6a). "artificer" is a fifth progression (level-1 slots,
+ *  then the half-caster table; multiclass contributes half its levels rounded UP; prepared count is Int mod +
+ *  floor(level/2) when no table column supplies it). The XPHB Paladin and Ranger carry it in the converter's
+ *  emission. Imported by the class and subclass schemas, the class types, pc.types and the generator's overlay
+ *  schema and class merger: never redeclare it. */
+export declare const casterTypeEnum: z.ZodEnum<{
+    half: "half";
+    full: "full";
+    pact: "pact";
+    third: "third";
+    artificer: "artificer";
+}>;
+export type CasterType = z.infer<typeof casterTypeEnum>;

package/dist/schemas/caster-type-schema.js

@@ -0,0 +1,6 @@
+import {
+  casterTypeEnum
+} from "../chunk-CJYCVNW2.js";
+export {
+  casterTypeEnum
+};

package/dist/schemas/choice-schema.js

@@ -1,7 +1,7 @@
 import {
   choiceSchema
-} from "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+} from "../chunk-T26ZVCL5.js";
+import "../chunk-WPWOHGPI.js";
 export {
   choiceSchema
 };

package/dist/schemas/entity-extras-schema.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+/**
+ * Shared leaf schemas for the entity "extras" the converter and the SRD bundle
+ * emit on more than one root. Six root schemas will import from here (race,
+ * feat, optional-feature, background, class, subclass; the wiring lands in T2/T3)
+ * so a shape is declared ONCE.
+ *
+ * Everything here is additive and `.optional()` at the point of use: no
+ * `.default()`, no tightening, no new required field. A raw-blob leaf is always
+ * `z.unknown().optional()` — a bare `z.unknown()` inside `z.object` is NOT
+ * optional under zod v4 (`safeParse({})` fails `expected nonoptional`).
+ */
+/** Images-ON emit (scripts/lib/image-format.ts): one wikilink string, or an array for ≥2 fluff
+ *  images; `thumbnail` monster-only. ZERO carriers on the frozen images-OFF tree — see §9.4.
+ *  NO .nonempty() on the array arm (gate1-r1 f13): the variant set is unestablished (Gate 0
+ *  finding 25) and the phase's own rule — a new declaration must be INCAPABLE of refusing —
+ *  outranks a speculative arity constraint on the one key a future convert:images run feeds. */
+export declare const imageField: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+/** 5etools additionalSpells. Key-set measured COMPLETE over all 52 distinct sets on 5 roots:
+ *  {ability, expanded, innate, known, name, prepared, resourceName} (Gate 0 finding 5).
+ *  Loose leaves are deliberate: level keys are arbitrary strings ("1","s0","_","1e","pb","cha"…),
+ *  the known.'1' string-keying is converter-owned (A §7.2) and passes through VERBATIM. */
+export declare const additionalSpellsEntrySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        choose: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>]>>;
+    known: z.ZodOptional<z.ZodUnknown>;
+    innate: z.ZodOptional<z.ZodUnknown>;
+    prepared: z.ZodOptional<z.ZodUnknown>;
+    expanded: z.ZodOptional<z.ZodUnknown>;
+    resourceName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** optionalfeature_progression / feat_progression containers. Measured distribution (finding 4):
+ *  `progression` is a record on 42 of 46 containers (keys numeric strings + "*", values number) and
+ *  an ARRAY (number[], len 20) on class.optionalfeature_progression ONLY (4 docs: both PHB Warlocks,
+ *  TCE + Eberron Artificer). `featureType` (camelCase) is the ONLY spelling on all 13 subclass
+ *  optionalfeature_progression containers; `feature_type` (snake) on class/feat/optional-feature —
+ *  true of their optionalfeature_progression containers; `class.feat_progression`'s 16 containers
+ *  carry neither spelling; `required` on 2 subclass docs ({"3": ["Elemental Attunement|PHB"]}).
+ *  Union order is SAFE
+ *  (executed: record.safeParse(array) fails invalid_type). Distribution recorded in T0's census
+ *  baseline — NO test asserts it; §9.3 characterises the SHAPES only. */
+export declare const progressionSchema: z.ZodObject<{
+    name: z.ZodString;
+    progression: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodNumber>, z.ZodArray<z.ZodNumber>]>;
+    feature_type: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    featureType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type AdditionalSpellsEntry = z.infer<typeof additionalSpellsEntrySchema>;
+export type ProgressionEntry = z.infer<typeof progressionSchema>;

package/dist/schemas/entity-extras-schema.js

@@ -0,0 +1,10 @@
+import {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+} from "../chunk-UA5KS2PL.js";
+export {
+  additionalSpellsEntrySchema,
+  imageField,
+  progressionSchema
+};

package/dist/schemas/equipment-grant-schema.d.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import type { EquipmentGrant, EquipmentOption, StartingEquipmentEntry, StartingGold } from "../types/equipment-grant.js";
+/** Every arm stays `.strict()`: one stray key refuses the whole document on purpose (the builder's render path
+ *  maps over grants). The three passthrough keys are DECLARED, not tolerated. */
 export declare const equipmentGrantSchema: z.ZodType<EquipmentGrant>;
 export declare const equipmentOptionSchema: z.ZodType<EquipmentOption>;
 export declare const startingEquipmentEntrySchema: z.ZodType<StartingEquipmentEntry>;

package/dist/schemas/equipment-grant-schema.js

@@ -3,7 +3,7 @@ import {
   equipmentOptionSchema,
   startingEquipmentEntrySchema,
   startingGoldSchema
-} from "../chunk-3DZ74AKK.js";
+} from "../chunk-IN4M4X7P.js";
 export {
   equipmentGrantSchema,
   equipmentOptionSchema,

package/dist/schemas/feature-alias.d.ts

@@ -0,0 +1,34 @@
+/** R4-G3a §10.2.1: the SRD bundle spells a race trait's action cost `action_cost`; the canonical key is
+ *  `action`. Alias fills a hole, declared wins, never deleted (the `armor.parser.ts` strength_required
+ *  precedent; the resolver's optional-feature grant alias is the in-repo precedent for the KEY).
+ *
+ *  No `package.json` exports entry, because the plugin never imports this module: the sheet's resolver
+ *  applies the alias at resolve time through `withResolvedActionCost` (R4-G3a Task 12), and the ONE plugin
+ *  site that reads a race trait's action cost off the RAW registry entity (the race block's tracker gate,
+ *  R4-G3b §11) reads BOTH spellings with a nullish fallback rather than importing this helper. Not imported
+ *  is NOT the same as parser-internal, and the module is not parser-internal: MEASURED 2026-09-04, every
+ *  export here reaches the plugin's built `main.js`, `withResolvedActionCost` through `pc/pc.resolver.ts`
+ *  and the raw-YAML aliasers through the race / class / subclass parsers, which the plugin pulls in with
+ *  `dnd5ePack` (pack → entity types → codecs → parsers). What is parser-only is where the aliasers RUN:
+ *  their three call sites are `race.parser.ts`, `class.parser.ts` and `subclass.parser.ts`, so they fire on
+ *  the entity-note codec path and never on the sheet's, which reads RAW registry objects.
+ *
+ *  This one is applied on the RAW YAML object before `safeParse`, so the aliased value goes through the
+ *  same enum validation as a declared one (an out-of-vocabulary `action_cost` refuses the document rather
+ *  than smuggling a bad `action` past the schema). */
+export declare function aliasFeatureActionCost(f: Record<string, unknown>): void;
+/** The list form: race `traits[]`, and one level's `features_by_level[lvl]` array. Non-arrays and
+ *  non-object members are left alone; a malformed document is the schema's business, not ours. */
+export declare function aliasFeatureListActionCost(list: unknown): void;
+/** The `features_by_level` record form, shared by the class and subclass parsers. Zero bundle
+ *  carriers live here today; it is aliased for symmetry so a future class-side `action_cost` is
+ *  not a second silent routing bug. */
+export declare function aliasFeaturesByLevelActionCost(byLevel: unknown): void;
+/** Resolve-time mirror of `aliasFeatureActionCost` (R4-G3a Task 12): the PC sheet resolves RAW registry entities
+ *  (never parsed by dnd5e), so the parser-side alias is invisible to it. Returns the same object when nothing applies
+ *  (registry entities are shared and must not be mutated), else a shallow copy with `action` filled from
+ *  `action_cost`. Declared `action` wins. */
+export declare function withResolvedActionCost<T extends {
+    action?: unknown;
+    action_cost?: unknown;
+}>(f: T): T;