@archivist-gg/dnd5e 0.3.17 → 0.3.24

package/dist/pc/pc.weapon-grant.d.ts

@@ -1,15 +1,9 @@
 import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
 export interface QualifiedWeaponGrant {
     category: "simple" | "martial";
-    /** Absent: melee and ranged alike. */
     range?: "melee" | "ranged";
-    /** Weapon property keys as the weapon notes carry them (`two_handed`, `finesse`). */
     properties: string[];
-    /** true: the weapon has NONE of `properties` ("that don't have"); false: it has ANY of them ("that have"). */
     without: boolean;
 }
-/** The grant a phrase states, or null when it is not a property-qualified category phrase (a weapon name, "simple"). */
 export declare function parseQualifiedWeaponGrant(text: string): QualifiedWeaponGrant | null;
-/** Does the qualified grant `text` cover `weapon`? False for any text that is not such a grant. Melee / ranged is the attack
- *  mode the classifier reconstructs, not the category suffix (a thrown melee weapon may be filed `*-ranged`). */
 export declare function qualifiedGrantCovers(text: string, weapon: Pick<WeaponEntity, "category" | "properties" | "range" | "slug">): boolean;

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

@@ -1,54 +1,15 @@
 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;
 export type PoolHead = "dice" | "points";
 export interface PoolPresentation {
     head: PoolHead;
 }
-/** A pool tab's ONE data axis (PT spec §9; ART-D's rows axis is retired: every pool tab draws the table).
- *  HEAD: an authored `dice-pool` / `point-pool` wins; otherwise the DERIVED layout decides (points for `point-pool`,
- *  dice for anything else). An authored `blocks` or `spell-like` still parses and is ignored. */
 export declare function poolPresentation(authored?: PoolLayout, derived?: PoolLayout): PoolPresentation;
-/** 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;

package/dist/pc/pool-layout.js

@@ -1,18 +1 @@
-import {
-  AFFORDANCE_CAPTIONS,
-  RENDERING_HINT_AFFORDANCE,
-  RENDERING_HINT_LAYOUT,
-  deriveEntryAffordance,
-  derivePoolLayout,
-  formatAffordanceCaption,
-  poolPresentation
-} from "../chunk-B3DP42OM.js";
-export {
-  AFFORDANCE_CAPTIONS,
-  RENDERING_HINT_AFFORDANCE,
-  RENDERING_HINT_LAYOUT,
-  deriveEntryAffordance,
-  derivePoolLayout,
-  formatAffordanceCaption,
-  poolPresentation
-};
+import{AFFORDANCE_CAPTIONS,RENDERING_HINT_AFFORDANCE,RENDERING_HINT_LAYOUT,deriveEntryAffordance,derivePoolLayout,formatAffordanceCaption,poolPresentation}from"../chunk-O776WL7O.js";export{AFFORDANCE_CAPTIONS,RENDERING_HINT_AFFORDANCE,RENDERING_HINT_LAYOUT,deriveEntryAffordance,derivePoolLayout,formatAffordanceCaption,poolPresentation};

package/dist/pc/resource-equivalents.d.ts

@@ -1,44 +1,6 @@
 import type { ResourceIndex } from "./pc.resources.js";
 import type { FeatureSource, ResolvedClass, ResolvedFeature } from "./pc.types.js";
-/**
- * H3b (spec `2026-09-28-h3b-resource-equivalents-design.md` §2): DECLARED equivalent resource ids. Each group says "these
- * ids name ONE resource": the books and the SRD data mint different ids for the same pool (edition twins such as
- * `fighter:superiority-dice` / `fighter-2024:superiority-dice`, book drift such as `monk:ki` / `monk:focus-point`,
- * singular / plural such as `sorcerer:sorcery-point(s)`). Nothing is ever derived from an id's shape: an id in no group
- * has no equivalent. The order inside a group is the fallback preference ({@link payingResourceId} step 4).
- *
- * The groups were measured over the installed vault (every class paired with every subclass of the same class, census in
- * `.superpowers/sdd/h3b-evidence/`) and each checked against its declaring notes. The bare `channel-divinity` is the SRD
- * 2024 id of BOTH the Cleric and the Paladin, so it sits in both Channel Divinity groups. Equivalence is read as "shares a
- * group with", never transitively: `cleric:` / `cleric-2024:` never answer for `paladin:` / `paladin-2024:`. The bare id
- * does answer for both, so a paladin consumer whose own class owns no Channel Divinity pays from a bare id another class
- * (an SRD 2024 Cleric) declares: the one Channel Divinity pool of the 2014 multiclass rule (review m1, H3b).
- */
-export interface ResourceEquivalentGroup {
-    readonly name: string;
-    readonly ids: readonly string[];
-}
-export declare const RESOURCE_EQUIVALENTS: readonly ResourceEquivalentGroup[];
-/** Every id that shares a group with `id`, in declared order (group order, then the order inside the group), `id` itself
- *  excluded, each once. Empty for an id in no group. */
-export declare function equivalentResourceIds(id: string, groups?: readonly ResourceEquivalentGroup[]): string[];
-/**
- * THE rule (spec §3): which OWNED resource pays for a consumption naming `id`.
- *   1. the candidates are `id`, then its declared equivalents in declared order, kept only when the character owns them;
- *   2. none: `undefined` (the caller keeps the raw id: no control, never a spend from nothing);
- *   3. the first candidate the consumer's OWN class entry declares (`owner`, its class or subclass) pays, so a class's
- *      feature or pool member spends its class's pool even when a feat owns a twin id (TCE Metamagic Adept on a 2014
- *      Sorcerer declares `sorcerer-2024:sorcery-point`);
- *   4. else the first candidate: the named id itself when it is owned.
- * Exactly one id per consumer, so a spend writes one `feature_uses` key.
- */
-export declare function payingResourceId(id: string, index: ResourceIndex, owner?: ResolvedClass | null, groups?: readonly ResourceEquivalentGroup[]): string | undefined;
-/** The class entry a feature belongs to: a class feature's class, a subclass feature's class; none for a race,
- *  background, feat or campaign feature. */
+export declare function equivalentResourceIds(id: string, index: ResourceIndex): string[];
+export declare function payingResourceId(id: string, index: ResourceIndex, owner?: ResolvedClass | null): string | undefined;
 export declare function classOfSource(source: FeatureSource, classes: readonly ResolvedClass[]): ResolvedClass | null;
-/**
- * Spec §4: every resolved feature whose `consumes.resource` has a different payer becomes a COPY (wrapper, feature and
- * consumes; only `resource` changes). The registry `Feature` is shared by every open sheet and is never written; a
- * feature with no `consumes.resource`, one paid by the id it names, or one with no owned candidate keeps its identity.
- */
 export declare function bindFeatureConsumers(features: ResolvedFeature[], index: ResourceIndex, classes: readonly ResolvedClass[]): ResolvedFeature[];

package/dist/pc/roll-scope.js

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

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

@@ -1,40 +1,8 @@
-/**
- * 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

@@ -1,17 +1 @@
-// 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
-};
+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

@@ -1,20 +1,9 @@
 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>;

package/dist/pc/spell-source.js

@@ -1,8 +1 @@
-import {
-  SPELL_SOURCE,
-  spellSource
-} from "../chunk-KR6JF3BF.js";
-export {
-  SPELL_SOURCE,
-  spellSource
-};
+import{SPELL_SOURCE,spellSource}from"../chunk-PZ3ZZ5H5.js";export{SPELL_SOURCE,spellSource};

package/dist/race/race.codec.d.ts

@@ -1,9 +1,3 @@
 import type { DocCodec } from "@archivist-gg/core";
 import type { RaceEntity } from "./race.types.js";
-/**
- * Normalizing codec (0c.1a). `parse` delegates to `parseRace`, which seeds the
- * `edition: "2014"` default and validates against `raceEntitySchema`. `serialize`
- * stays `yaml.dump` (the edit-save path uses obsidian's separate serializer; gate
- * (d) verifies `yaml.dump` round-trips through `parseRace`).
- */
 export declare const raceCodec: DocCodec<RaceEntity>;

package/dist/race/race.codec.js

@@ -1,15 +1 @@
-import {
-  raceCodec
-} from "../chunk-AZRGFUSR.js";
-import "../chunk-Y5VVP73C.js";
-import "../chunk-FANQVQ3D.js";
-import "../chunk-4U55VNC7.js";
-import "../chunk-YD2VAHA6.js";
-import "../chunk-WYGD2UGN.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  raceCodec
-};
+import{raceCodec}from"../chunk-HR5MKCP2.js";import"../chunk-BPKG6RZ7.js";import"../chunk-6LCNV26D.js";import"../chunk-S5UCI27C.js";import"../chunk-V6NQ547U.js";import"../chunk-ZE46ADXS.js";import"../chunk-CCFIINBA.js";import"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{raceCodec};

package/dist/race/race.parser.js

@@ -1,14 +1 @@
-import {
-  parseRace
-} from "../chunk-Y5VVP73C.js";
-import "../chunk-FANQVQ3D.js";
-import "../chunk-4U55VNC7.js";
-import "../chunk-YD2VAHA6.js";
-import "../chunk-WYGD2UGN.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  parseRace
-};
+import{parseRace}from"../chunk-BPKG6RZ7.js";import"../chunk-6LCNV26D.js";import"../chunk-S5UCI27C.js";import"../chunk-V6NQ547U.js";import"../chunk-ZE46ADXS.js";import"../chunk-CCFIINBA.js";import"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{parseRace};

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

@@ -1,12 +1,4 @@
 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";

package/dist/race/race.schema.js

@@ -1,14 +1 @@
-import {
-  fixedAsiSchema,
-  raceEntitySchema
-} from "../chunk-FANQVQ3D.js";
-import "../chunk-YD2VAHA6.js";
-import "../chunk-WYGD2UGN.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  fixedAsiSchema,
-  raceEntitySchema
-};
+import{fixedAsiSchema,raceEntitySchema}from"../chunk-6LCNV26D.js";import"../chunk-V6NQ547U.js";import"../chunk-ZE46ADXS.js";import"../chunk-CCFIINBA.js";import"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{fixedAsiSchema,raceEntitySchema};

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

@@ -1,7 +1 @@
-/** 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

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

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

@@ -42,23 +42,15 @@ 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

@@ -40,4 +40,9 @@ export declare const attackSchema: z.ZodObject<{
         dice: z.ZodString;
         type: z.ZodString;
     }, z.core.$strip>>;
+    weapon_category: z.ZodOptional<z.ZodEnum<{
+        simple: "simple";
+        martial: "martial";
+    }>>;
+    mastery: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

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

@@ -1,14 +1,9 @@
 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";
+    "half-up": "half-up";
 }>;
 export type CasterType = z.infer<typeof casterTypeEnum>;

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

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

package/dist/schemas/choice-schema.js

@@ -1,7 +1 @@
-import {
-  choiceSchema
-} from "../chunk-5MXFW4O3.js";
-import "../chunk-2JSQE3DD.js";
-export {
-  choiceSchema
-};
+import{choiceSchema}from"../chunk-KBFSJ5WE.js";import"../chunk-6IC53O3Q.js";export{choiceSchema};

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

@@ -1,6 +1,4 @@
 import { z } from "zod";
-/** A buff/effect duration. Parsed in Phase 2 and rendered as a static label;
- *  Phase 3's activatable-buff toggle consumes the structured form. */
 export declare const durationSchema: z.ZodUnion<readonly [z.ZodLiteral<"instantaneous">, z.ZodLiteral<"until-dispelled">, z.ZodObject<{
     amount: z.ZodNumber;
     unit: z.ZodEnum<{

package/dist/schemas/duration-schema.js

@@ -1,6 +1 @@
-import {
-  durationSchema
-} from "../chunk-WYGD2UGN.js";
-export {
-  durationSchema
-};
+import{durationSchema}from"../chunk-ZE46ADXS.js";export{durationSchema};

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

@@ -1,25 +1,5 @@
 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<{
@@ -31,16 +11,6 @@ export declare const additionalSpellsEntrySchema: z.ZodObject<{
     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>]>;

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

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

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

@@ -1,7 +1,5 @@
 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

@@ -1,12 +1 @@
-import {
-  equipmentGrantSchema,
-  equipmentOptionSchema,
-  startingEquipmentEntrySchema,
-  startingGoldSchema
-} from "../chunk-IN4M4X7P.js";
-export {
-  equipmentGrantSchema,
-  equipmentOptionSchema,
-  startingEquipmentEntrySchema,
-  startingGoldSchema
-};
+import{equipmentGrantSchema,equipmentOptionSchema,startingEquipmentEntrySchema,startingGoldSchema}from"../chunk-TKIEPC6F.js";export{equipmentGrantSchema,equipmentOptionSchema,startingEquipmentEntrySchema,startingGoldSchema};

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

@@ -1,33 +1,6 @@
-/** 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;

package/dist/schemas/feature-effect-schema.d.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
 export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"initiative-bonus">;
-    value: z.ZodNumber;
+    value: z.ZodOptional<z.ZodNumber>;
+    amount: z.ZodOptional<z.ZodString>;
     condition: z.ZodOptional<z.ZodString>;
     subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
@@ -128,6 +129,7 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         unarmed: "unarmed";
         finesse: "finesse";
         thrown: "thrown";
+        "pact-weapon": "pact-weapon";
     }>, z.ZodArray<z.ZodEnum<{
         weapon: "weapon";
         melee: "melee";
@@ -135,7 +137,17 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         unarmed: "unarmed";
         finesse: "finesse";
         thrown: "thrown";
+        "pact-weapon": "pact-weapon";
     }>>]>>;
+    spell_scope: z.ZodOptional<z.ZodObject<{
+        list: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodNumber>;
+        school: z.ZodOptional<z.ZodString>;
+        damage_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        damage_type_pick: z.ZodOptional<z.ZodString>;
+        spells: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        once: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
     condition: z.ZodOptional<z.ZodString>;
     subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
@@ -224,6 +236,23 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         level: z.ZodNumber;
         count: z.ZodNumber;
     }, z.core.$strip>>>;
+    applies_to: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        weapon: "weapon";
+        melee: "melee";
+        ranged: "ranged";
+        unarmed: "unarmed";
+        finesse: "finesse";
+        thrown: "thrown";
+        "pact-weapon": "pact-weapon";
+    }>, z.ZodArray<z.ZodEnum<{
+        weapon: "weapon";
+        melee: "melee";
+        ranged: "ranged";
+        unarmed: "unarmed";
+        finesse: "finesse";
+        thrown: "thrown";
+        "pact-weapon": "pact-weapon";
+    }>>]>>;
     condition: z.ZodOptional<z.ZodString>;
     subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{

package/dist/schemas/feature-effect-schema.js

@@ -1,6 +1 @@
-import {
-  featureEffectSchema
-} from "../chunk-2JSQE3DD.js";
-export {
-  featureEffectSchema
-};
+import{featureEffectSchema}from"../chunk-6IC53O3Q.js";export{featureEffectSchema};

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

@@ -1,10 +1,4 @@
 import { z } from "zod";
 import type { Feature } from "../types/feature.js";
-/**
- * The feature OBJECT, declared once (R4-G6 §4.2). Typed against the `Feature` interface so a wrong leaf fails
- * `tsc`; exported UN-REFINED for the monster schema, whose name-only authored traits the hand parser accepted.
- * The recursion runs through the REFINED schema so a nested class sub_feature keeps the description-or-entries
- * rule; the refined `featureSchema` below keeps its exported `z.ZodType<unknown>` for every other root.
- */
 export declare const featureObjectSchema: z.ZodType<Feature>;
 export declare const featureSchema: z.ZodType<unknown>;