@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/spell/spell.schema.js

@@ -1,6 +1,7 @@
 import {
   spellEntitySchema
-} from "../chunk-Y4I74YEG.js";
+} from "../chunk-VQAXTIBW.js";
+import "../chunk-UA5KS2PL.js";
 export {
   spellEntitySchema
 };

package/dist/spell/spell.types.d.ts

@@ -20,6 +20,20 @@ export interface Spell {
         ability: string;
     };
     casting_options?: CastingOption[];
+    rendering_hint?: string;
+    misc_tags?: string[];
+    area_tags?: string[];
+    condition_inflict?: string[];
+    affects_creature_type?: string[];
+    spell_attack?: "melee" | "ranged";
+    ability_check?: string[];
+    damage_resist?: string[];
+    damage_immune?: string[];
+    condition_immune?: string[];
+    damage_vulnerable?: string[];
+    has_fluff?: boolean;
+    image?: string | string[];
+    has_fluff_images?: boolean;
     source?: string;
     edition?: "2014" | "2024" | string;
 }

package/dist/subclass/subclass.codec.d.ts

@@ -3,7 +3,7 @@ import type { SubclassEntity } from "./subclass.types.js";
 /**
  * Normalizing codec (0c.1a). `parse` delegates to `parseSubclass`, which validates
  * against `subclassEntitySchema`. `subclass.types` is this entity's dnd5e home for
- * `SubclassEntity` (consumed by the PC resolver/types); its `Edition`/`SpellcastingConfig`
+ * `SubclassEntity` (consumed by the PC resolver/types); its `Edition`/`SubclassSpellcastingConfig`
  * imports resolve dnd5e-internally from `class.types`. `serialize` stays `yaml.dump`
  * (the edit-save path uses obsidian's separate serializer; gate (d) verifies `yaml.dump`
  * round-trips through `parseSubclass`).

package/dist/subclass/subclass.codec.js

@@ -1,14 +1,17 @@
 import {
   subclassCodec
-} from "../chunk-XLSVNUTK.js";
-import "../chunk-L7E2UT5A.js";
-import "../chunk-W7HWMMBF.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-R3VAKWKW.js";
+import "../chunk-HB7XZXDK.js";
+import "../chunk-H7KBLR4X.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.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 {
   subclassCodec
 };

package/dist/subclass/subclass.parser.js

@@ -1,13 +1,16 @@
 import {
   parseSubclass
-} from "../chunk-L7E2UT5A.js";
-import "../chunk-W7HWMMBF.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-HB7XZXDK.js";
+import "../chunk-H7KBLR4X.js";
+import "../chunk-4U55VNC7.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.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 {
   parseSubclass
 };

package/dist/subclass/subclass.schema.d.ts

@@ -10,12 +10,13 @@ export declare const subclassEntitySchema: z.ZodObject<{
     source: z.ZodString;
     description: z.ZodString;
     spellcasting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        caster_type: z.ZodEnum<{
-            pact: "pact";
-            full: "full";
+        caster_type: z.ZodOptional<z.ZodEnum<{
             half: "half";
+            full: "full";
+            pact: "pact";
             third: "third";
-        }>;
+            artificer: "artificer";
+        }>>;
         ability: z.ZodEnum<{
             str: "str";
             dex: "dex";
@@ -24,11 +25,11 @@ export declare const subclassEntitySchema: z.ZodObject<{
             wis: "wis";
             cha: "cha";
         }>;
-        preparation: z.ZodEnum<{
+        preparation: z.ZodOptional<z.ZodEnum<{
             known: "known";
             prepared: "prepared";
-        }>;
-        spell_list: z.ZodString;
+        }>>;
+        spell_list: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     table: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -49,6 +50,7 @@ export declare const subclassEntitySchema: z.ZodObject<{
         reset: z.ZodEnum<{
             "short-rest": "short-rest";
             "long-rest": "long-rest";
+            either: "either";
             dawn: "dawn";
             dusk: "dusk";
             turn: "turn";
@@ -74,12 +76,17 @@ export declare const subclassEntitySchema: z.ZodObject<{
             reset: z.ZodEnum<{
                 "short-rest": "short-rest";
                 "long-rest": "long-rest";
+                either: "either";
                 dawn: "dawn";
                 dusk: "dusk";
                 turn: "turn";
                 round: "round";
                 custom: "custom";
             }>;
+            restores: z.ZodOptional<z.ZodEnum<{
+                uses: "uses";
+                "spell-slots": "spell-slots";
+            }>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
     selection_pools: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -112,7 +119,47 @@ export declare const subclassEntitySchema: z.ZodObject<{
             layout: z.ZodOptional<z.ZodEnum<{
                 "spell-like": "spell-like";
                 blocks: "blocks";
+                "dice-pool": "dice-pool";
+                "point-pool": "point-pool";
             }>>;
         }, z.core.$strip>;
     }, z.core.$strip>>>;
+    rendering_hint: z.ZodOptional<z.ZodString>;
+    short_name: z.ZodOptional<z.ZodString>;
+    has_fluff: z.ZodOptional<z.ZodBoolean>;
+    has_fluff_images: z.ZodOptional<z.ZodBoolean>;
+    fluff: z.ZodOptional<z.ZodUnknown>;
+    table_col_labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cantrip_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    prepared_spells_change: z.ZodOptional<z.ZodString>;
+    prepared_spells_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    spells_known_progression: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    feat_progression: z.ZodOptional<z.ZodArray<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>>>;
+    optionalfeature_progression: z.ZodOptional<z.ZodArray<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>>>;
+    additional_spells: z.ZodOptional<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>>>;
+    image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strip>;

package/dist/subclass/subclass.schema.js

@@ -1,12 +1,14 @@
 import {
   subclassEntitySchema
-} from "../chunk-W7HWMMBF.js";
-import "../chunk-4TIJKN6O.js";
-import "../chunk-CZPMTQOY.js";
+} from "../chunk-H7KBLR4X.js";
+import "../chunk-23LZLBJK.js";
+import "../chunk-CJYCVNW2.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 {
   subclassEntitySchema
 };

package/dist/subclass/subclass.types.d.ts

@@ -1,6 +1,7 @@
 import type { Feature, Resource } from "@archivist-gg/dnd5e";
-import type { Edition, SpellcastingConfig } from "@archivist-gg/dnd5e/class/class.types";
+import type { Edition, SubclassSpellcastingConfig } from "@archivist-gg/dnd5e/class/class.types";
 import type { SelectionPool, PoolGrant, TabDecl } from "@archivist-gg/dnd5e/types/selection-pool";
+import type { AdditionalSpellsEntry, ProgressionEntry } from "@archivist-gg/dnd5e/schemas/entity-extras-schema";
 export interface SubclassEntity {
     slug: string;
     name: string;
@@ -8,7 +9,7 @@ export interface SubclassEntity {
     edition: Edition;
     source: string;
     description: string;
-    spellcasting?: SpellcastingConfig | null;
+    spellcasting?: SubclassSpellcastingConfig | null;
     table?: Record<number, {
         columns?: Record<string, string | number>;
     }>;
@@ -17,4 +18,21 @@ export interface SubclassEntity {
     selection_pools?: SelectionPool[];
     pool_grants?: PoolGrant[];
     tabs?: TabDecl[];
+    /** Converter/bundle extras declared by subclass.schema.ts §2.7; all optional, none read today. */
+    rendering_hint?: string;
+    short_name?: string;
+    has_fluff?: boolean;
+    has_fluff_images?: boolean;
+    /** RAW 5etools passthrough (single measured key-set `{_subclassFluff:{…}}`): mirrors `z.unknown()`. */
+    fluff?: unknown;
+    table_col_labels?: string[];
+    cantrip_progression?: number[];
+    prepared_spells_change?: string;
+    prepared_spells_progression?: number[];
+    spells_known_progression?: number[];
+    feat_progression?: ProgressionEntry[];
+    optionalfeature_progression?: ProgressionEntry[];
+    additional_spells?: AdditionalSpellsEntry[];
+    /** One wikilink, or an array of them for the multi-fluff-image emit. */
+    image?: string | string[];
 }

package/dist/types/choice.d.ts

@@ -3,6 +3,62 @@ import type { FeatureEffect } from "./feature-effect.js";
 export type Ability = keyof Abilities;
 export type SkillSlug = "acrobatics" | "animal-handling" | "arcana" | "athletics" | "deception" | "history" | "insight" | "intimidation" | "investigation" | "medicine" | "nature" | "perception" | "performance" | "persuasion" | "religion" | "sleight-of-hand" | "stealth" | "survival";
 export declare const ALL_SKILL_SLUGS: SkillSlug[];
+/** The language vocabulary the engine matches every language grant and pick
+ *  against: 8 standard + 8 exotic + 2 SECRET. It is NOT "the SRD language set" —
+ *  the two secret languages are class-taught and appear on no SRD language list.
+ *  Slugs are edition-agnostic, apostrophe-retaining and canonical under
+ *  `toProfSlug`, exactly as ALL_TOOLS is.
+ *
+ *  A cross-repo CONTRACT with three kinds of consumer, so widening this list is a
+ *  data change at all three · named by symbol, because line cites rot:
+ *   · the SRD GENERATOR: `race-merge.ts` builds `KNOWN_LANGUAGES = new Set(ALL_LANGUAGES)`
+ *     and `extractLanguagesFromTraits` gates species prose tokens through it, so
+ *     this constant is INPUT DATA to canonical species output. That name belongs
+ *     to the generator and to nothing else. Guarded by
+ *     `tests/srd-canonical/merger-rules/srd-race-languages.test.ts`.
+ *   · the ENGINE: `enumerateOptions` uses it as the from-less `domain:"language"`
+ *     picker pool, and `computeEffectiveProficiencies` canonicalizes grants, picks
+ *     and manual adds against it through `pc.decision-engine.ts`'s one canonical
+ *     comparison, `matchPool` — a module-level helper it shares with its other call
+ *     sites, not one of its own. `computeEffectiveProficiencies` reads ALL_LANGUAGES
+ *     from HERE, directly — it does not go through the generator's KNOWN_LANGUAGES.
+ *   · the PLUGIN: `proficiency-edit-modal.ts` renders its LANGUAGE section from
+ *     `[...ALL_LANGUAGES, ...suppressed]`.
+ *  Membership is also what makes two spellings of one language FOLD onto a single
+ *  row: a vocabulary MISS keys on the raw string and splits the row in two. */
+export declare const STANDARD_LANGUAGES: string[];
+export declare const EXOTIC_LANGUAGES: string[];
+/** Secret languages: granted by a class feature (Druid, Rogue), never carried by a
+ *  race or background language list. `thieves'-cant` RETAINS the ASCII apostrophe —
+ *  the file's stated convention, and the slug `toProfSlug` already produces from
+ *  both live spellings (the converter's `Thieves' Cant` and the 2014 SRD prose's
+ *  U+2019 form). */
+export declare const SECRET_LANGUAGES: string[];
+export declare const ALL_LANGUAGES: string[];
+/** The SRD tool set: 17 artisan's tools + 10 musical instruments + 2 gaming sets
+ *  + 6 other tools = 35. Like ALL_LANGUAGES this is a SINGLE edition-agnostic
+ *  list covering 2014 and 2024, and where the two editions name the same tool
+ *  differently the 2024 name wins. Across all 35 entries there is exactly one
+ *  such delta: `Playing Card Set` (2014) vs `Playing Cards` (2024), resolved
+ *  here to "playing-cards".
+ *
+ *  Apostrophes are RETAINED ("thieves'-tools", "calligrapher's-supplies").
+ *  These are the slugs the product already emits · see
+ *  `tools/srd-canonical/merger-rules/background-merge.ts`, whose output is live
+ *  in `background.2024.json` · and humanizeProficiency is apostrophe-safe.
+ *  Stripping the apostrophes would diverge from that live data and CREATE the
+ *  collision it would claim to avoid.
+ *
+ *  Every entry is already canonical under toProfSlug (identity) and the set is
+ *  collision-free under it. Ordering is alphabetical within each subset, and
+ *  ALL_TOOLS composes the four subsets in that order, mirroring
+ *  ALL_LANGUAGES = STANDARD + EXOTIC + SECRET. The list is a cross-repo contract: a
+ *  one-entry divergence is silent and permanent, so it is pinned verbatim. */
+export declare const ARTISANS_TOOLS: string[];
+export declare const MUSICAL_INSTRUMENTS: string[];
+export declare const GAMING_SETS: string[];
+export declare const OTHER_TOOLS: string[];
+export declare const ALL_TOOLS: string[];
 export type FeatCategory = "origin" | "general" | "fighting-style" | "epic-boon";
 /** Closed, enumerated registry filter — YAML can never express a query the
  *  engine would apply unsafely. `"self"` resolves against the owning

package/dist/types/choice.js

@@ -1,6 +1,24 @@
 import {
-  ALL_SKILL_SLUGS
-} from "../chunk-BH6AMZVY.js";
+  ALL_LANGUAGES,
+  ALL_SKILL_SLUGS,
+  ALL_TOOLS,
+  ARTISANS_TOOLS,
+  EXOTIC_LANGUAGES,
+  GAMING_SETS,
+  MUSICAL_INSTRUMENTS,
+  OTHER_TOOLS,
+  SECRET_LANGUAGES,
+  STANDARD_LANGUAGES
+} from "../chunk-KU3YLF6D.js";
 export {
-  ALL_SKILL_SLUGS
+  ALL_LANGUAGES,
+  ALL_SKILL_SLUGS,
+  ALL_TOOLS,
+  ARTISANS_TOOLS,
+  EXOTIC_LANGUAGES,
+  GAMING_SETS,
+  MUSICAL_INSTRUMENTS,
+  OTHER_TOOLS,
+  SECRET_LANGUAGES,
+  STANDARD_LANGUAGES
 };

package/dist/types/equipment-grant.d.ts

@@ -3,12 +3,19 @@
  *  `category` is a player-picked class of item ("martial-weapon",
  *  "simple-weapon", "martial-melee-weapon", "any-armor", "shield", …) resolved
  *  by a nested select-entity. `gold` is gp folded into the bundle. */
-export type EquipmentGrant = {
+export type EquipmentGrant = 
+/** `contains_value` (COPPER; `1500` = 15 gp) is seeded as gold by the plugin's starting-equipment seeder
+ *  (R4-G3b §9); `worth_value` is never seeded; `display_name` is read by grantLabel. */
+{
     item: string;
     qty?: number;
+    contains_value?: number;
+    display_name?: string;
+    worth_value?: number;
 } | {
     category: string;
     qty?: number;
+    display_name?: string;
 } | {
     gold: number;
 };

package/dist/types/feature-effect.d.ts

@@ -1,28 +1,46 @@
 import type { Ability } from "./choice.js";
 export type SenseType = "darkvision" | "blindsight" | "tremorsense" | "truesight";
-export type FeatureEffect = {
+/** Present on every arm: whose numbers the effect changes. Absent === "self". The engine's fold readers skip
+ *  every effect whose subject is present and not "self" (`foldsOnSelf` in pc.feature-effects.ts). */
+type Subject = {
+    subject?: string;
+};
+/** A prose qualifier, carried for display; on `apply-condition` and `immune-condition` the `condition` key is the
+ *  condition NAME instead, so those two arms do not carry this qualifier. */
+type Qualified = {
+    condition?: string;
+} & Subject;
+/**
+ * Hand-written MIRROR of `featureEffectSchema` (schemas/feature-effect-schema.ts). The two are cross-checked at the
+ * four parser returns and by `_kindPin` in the schema file; edit both in the same commit.
+ */
+export type FeatureEffect = ({
     kind: "initiative-bonus";
     value: number;
-} | {
+} & Qualified) | ({
     kind: "immune-condition";
     condition: string;
     while?: string;
-} | {
+} & Subject) | ({
     kind: "resistance";
     damage_type: string;
-} | {
+} & Qualified) | ({
     kind: "hp-per-level-bonus";
     value: number;
-} | {
+} & Qualified) | ({
     kind: "speed-bonus";
     mode: "walk" | "fly" | "swim" | "climb" | "burrow";
     value: number;
     set?: boolean;
-} | {
+    scales_at?: {
+        level: number;
+        value: number;
+    }[];
+} & Qualified) | ({
     kind: "sense";
     type: SenseType;
     range: number;
-} | {
+} & Qualified) | ({
     kind: "apply-condition";
     condition: string;
     duration?: string;
@@ -31,49 +49,86 @@ export type FeatureEffect = {
         ability: string;
         timing: string;
     };
-} | {
+} & Subject) | ({
     kind: "damage-bonus";
     damage_type: string;
     amount: string;
     applies_to?: "weapon" | "spell" | "all";
-    condition?: string;
-} | {
+} & Qualified) | ({
     kind: "proficiency";
     proficiency_type: "skill" | "tool" | "language" | "saving-throw" | "armor" | "weapon";
     value: string;
-} | {
+    expertise?: boolean;
+} & Qualified) | ({
     kind: "ac-bonus";
     value: number;
     requires_armor?: boolean;
-} | {
+} & Qualified) | ({
     kind: "unarmored-ac";
     abilities: Ability[];
     base?: number;
     allow_shield?: boolean;
-} | {
+} & Qualified) | ({
+    kind: "unarmed-strike";
+    dice?: string | {
+        column: string;
+    };
+    abilities?: Ability[];
+} & Qualified) | ({
     kind: "weapon-ability";
     ability: Ability | "spellcasting";
     weapons?: string | string[];
-} | {
+} & Qualified) | ({
     kind: "roll-modifier";
-    mode: "advantage" | "disadvantage";
-    roll: "ability-check" | "saving-throw" | "attack";
+    mode: "advantage" | "disadvantage" | "reroll" | "add-d4";
+    roll: "ability-check" | "saving-throw" | "attack" | "any";
     scope?: string;
-    condition?: string;
-} | {
+} & Qualified) | ({
     kind: "crit-range";
     min_roll: number;
     applies_to?: "weapon" | "spell" | "all";
-    condition?: string;
-} | {
+} & Qualified) | ({
     kind: "extra-attack";
     count: number;
-} | {
+    scales_at?: {
+        level: number;
+        count: number;
+    }[];
+} & Qualified) | ({
     kind: "reroll-damage";
     max_reroll: number;
     applies_to?: "weapon" | "spell" | "all";
     once_per_die?: boolean;
-} | {
+} & Qualified) | ({
     kind: "attack-rule";
     flag: "no-ranged-in-melee-disadvantage";
-};
+} & Qualified) | ({
+    kind: "immunity";
+    damage_type: string;
+} & Qualified) | ({
+    kind: "vulnerability";
+    damage_type: string;
+} & Qualified) | ({
+    kind: "temp-hp";
+    amount: string;
+} & Qualified) | ({
+    kind: "heal";
+    amount: string;
+} & Qualified) | ({
+    kind: "ability-score-increase";
+    abilities: "chosen" | Ability[];
+    amount: number;
+    choose: number | null;
+    max: number | null;
+} & Qualified) | ({
+    kind: "extra-action";
+    count: number;
+    action_type: "action" | "bonus-action" | "reaction";
+} & Qualified) | ({
+    kind: "save-outcome";
+    ability: Ability | "any";
+    on_success: "none" | "half" | "full";
+    on_failure: "none" | "half" | "full";
+    applies_to: string | null;
+} & Qualified);
+export {};

package/dist/types/feature.d.ts

@@ -1,5 +1,5 @@
 import type { Choice } from "./choice.js";
-import type { Resource, ResourceConsumption } from "./resource.js";
+import type { Resource, ResourceConsumption, ActionCost } from "./resource.js";
 import type { Attack } from "./attack.js";
 import type { FeatureEffect } from "./feature-effect.js";
 import type { Duration } from "../schemas/duration-schema.js";
@@ -15,6 +15,56 @@ export interface FeatureRecharge {
     type: "recharge_on_roll" | "per_day" | "per_short_rest" | "per_long_rest";
     param: number;
 }
+/** The converter's 14-key companion binding (R4-G5 §7, ruling G5-UR2 "declare now, card after the G7 re-emit").
+ *  DECLARED, not read: the converter withholds the key today (`P9_NOT_EMITTED_FIELDS`), 0 converted and 0 bundle
+ *  notes carry it, and the Passive-tab card is a G8 booking. Every closed-vocabulary leaf is a plain `string` and
+ *  every position the converter can emit as null is `| null`, for the reason the schema mirror states: a class,
+ *  subclass or race parser refuses a WHOLE document on one nested leaf failure, so a mirror stricter than the
+ *  emitter is a total-loss risk on the day the re-emit lands. */
+export interface FeatureCompanion {
+    statblock?: string;
+    statblock_wikilink?: string | null;
+    count?: string;
+    count_scaling?: Array<{
+        level?: number;
+        count?: string;
+        source_quote?: string;
+    }>;
+    shares_action_economy?: boolean;
+    turn_order?: string;
+    turn_order_source_quote?: string | null;
+    proficiency_bonus_scaled?: Array<{
+        stat?: string;
+        formula?: string;
+        source_quote?: string;
+    }>;
+    lifecycle?: {
+        created_by?: string;
+        recreate_on?: string | null;
+        previous_instance_perishes?: boolean | null;
+        vanishes_if_owner_dies?: boolean | null;
+        vanishes_after?: string | null;
+        source_quote?: string;
+    } | null;
+    autonomy?: {
+        when?: string;
+        behaviour?: string;
+        source_quote?: string;
+    } | null;
+    variants?: Array<{
+        axis?: string;
+        choices?: string[];
+        chosen_at?: string;
+        source_quote?: string;
+    }>;
+    base_statblock?: string | null;
+    overrides?: Array<{
+        field?: string;
+        value?: string;
+        source_quote?: string;
+    }>;
+    source_quote?: string;
+}
 export interface Feature {
     id?: string;
     name: string;
@@ -38,4 +88,23 @@ export interface Feature {
     passive?: boolean;
     /** How long the buff lasts; rendered as a static label (no live countdown). */
     duration?: Duration;
+    class_source?: string;
+    /** Always "" on every measured carrier — never constrain it non-empty. */
+    rendering_hint?: string;
+    subclass_short_name?: string;
+    subclass_source?: string;
+    header?: number;
+    is_class_feature_variant?: boolean;
+    gain_subclass_feature?: boolean;
+    gain_subclass_feature_has_content?: boolean;
+    /** 5etools entry type; values {"inset","item"}. */
+    type?: string;
+    action_cost?: ActionCost;
+    save?: {
+        ability: string;
+        dc_formula: string;
+    };
+    /** The companion this feature binds (R4-G5 §7). Declared so the class / subclass / race parsers stop stripping
+     *  it on the day the G7 re-emit lands; nothing reads it in G5. */
+    companion?: FeatureCompanion;
 }