@archivist-gg/dnd5e 0.3.11 → 0.3.17

package/dist/race/race.parser.js

@@ -1,13 +1,13 @@
 import {
   parseRace
-} from "../chunk-BL3VELKP.js";
-import "../chunk-V6LJFP4R.js";
+} from "../chunk-Y5VVP73C.js";
+import "../chunk-FANQVQ3D.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-YD2VAHA6.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseRace

package/dist/race/race.schema.js

@@ -1,12 +1,12 @@
 import {
   fixedAsiSchema,
   raceEntitySchema
-} from "../chunk-V6LJFP4R.js";
-import "../chunk-PI4LLJG4.js";
+} from "../chunk-FANQVQ3D.js";
+import "../chunk-YD2VAHA6.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
   fixedAsiSchema,

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

@@ -2,9 +2,9 @@ import { z } from "zod";
 export declare const attackSchema: z.ZodObject<{
     name: z.ZodString;
     type: z.ZodEnum<{
-        spell: "spell";
         melee: "melee";
         ranged: "ranged";
+        spell: "spell";
     }>;
     ability: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         str: "str";

package/dist/schemas/choice-schema.js

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

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

@@ -18,6 +18,31 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     minimum: z.ZodOptional<z.ZodNumber>;
     condition: z.ZodOptional<z.ZodString>;
     subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"save-bonus">;
+    ability: z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>;
+    minimum: z.ZodOptional<z.ZodNumber>;
+    saves: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>>;
+    inactive_while: z.ZodOptional<z.ZodEnum<{
+        incapacitated: "incapacitated";
+        unconscious: "unconscious";
+    }>>;
+    condition: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"half-proficiency">;
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -93,11 +118,24 @@ export declare const featureEffectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"damage-bonus">;
     damage_type: z.ZodString;
     amount: z.ZodString;
-    applies_to: z.ZodOptional<z.ZodEnum<{
-        weapon: "weapon";
+    applies_to: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         spell: "spell";
         all: "all";
-    }>>;
+    }>, z.ZodEnum<{
+        weapon: "weapon";
+        melee: "melee";
+        ranged: "ranged";
+        unarmed: "unarmed";
+        finesse: "finesse";
+        thrown: "thrown";
+    }>, z.ZodArray<z.ZodEnum<{
+        weapon: "weapon";
+        melee: "melee";
+        ranged: "ranged";
+        unarmed: "unarmed";
+        finesse: "finesse";
+        thrown: "thrown";
+    }>>]>>;
     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,6 @@
 import {
   featureEffectSchema
-} from "../chunk-XTRDCSJB.js";
+} from "../chunk-2JSQE3DD.js";
 export {
   featureEffectSchema
 };

package/dist/schemas/feature-schema.js

@@ -1,11 +1,11 @@
 import {
   featureObjectSchema,
   featureSchema
-} from "../chunk-PI4LLJG4.js";
+} from "../chunk-YD2VAHA6.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 export {
   featureObjectSchema,
   featureSchema

package/dist/schemas/selection-pool-schema.d.ts

@@ -11,8 +11,18 @@ export declare const selectionPoolSchema: z.ZodObject<{
     }, z.core.$strip>;
     count: z.ZodObject<{
         column: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     replaceable: z.ZodOptional<z.ZodBoolean>;
+    active: z.ZodOptional<z.ZodObject<{
+        column: z.ZodString;
+        label: z.ZodString;
+        verb: z.ZodString;
+        counter_label: z.ZodOptional<z.ZodString>;
+        create_label: z.ZodOptional<z.ZodString>;
+        create_verb: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    head_resource: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const poolGrantSchema: z.ZodObject<{
     pool: z.ZodString;

package/dist/schemas/selection-pool-schema.js

@@ -2,7 +2,7 @@ import {
   poolGrantSchema,
   selectionPoolSchema,
   tabDeclSchema
-} from "../chunk-23LZLBJK.js";
+} from "../chunk-G6MHJDVT.js";
 export {
   poolGrantSchema,
   selectionPoolSchema,

package/dist/spell/spell.codec.js

@@ -1,7 +1,7 @@
 import {
   spellCodec
-} from "../chunk-MWCCGPG3.js";
-import "../chunk-XY6X2APM.js";
+} from "../chunk-OOSRUJBI.js";
+import "../chunk-7Q2VPKCD.js";
 import "../chunk-ZDAEGJH4.js";
 import "../chunk-UA5KS2PL.js";
 export {

package/dist/spell/spell.parser.d.ts

@@ -1,4 +1,4 @@
-import { Spell } from "./spell.types.js";
+import { Spell, SpellMaterial } from "./spell.types.js";
 import { ParseResult } from "@archivist-gg/core";
 /**
  * §3.3 · collapse the converter's structured `components` object to the corpus's own string form
@@ -13,6 +13,11 @@ import { ParseResult } from "@archivist-gg/core";
  * the unreachable-shape fallback (the schema has already accepted the value by the time we run).
  */
 export declare function normalizeSpellComponents(value: unknown): string;
+/**
+ * D2b-B · the structured material component the string form cannot carry: `components.m` when it is an OBJECT (`text` with an
+ * optional `cost` and `consume`), copied field by field; `undefined` for every other shape. Structural narrowing, as above.
+ */
+export declare function spellMaterialOf(value: unknown): SpellMaterial | undefined;
 /**
  * §3.3 · collapse the converter's structured `duration` array to the corpus's own lowercase string
  * form (`until dispelled`, `up to 1 hour`), leaving a string input byte-unchanged. Concentration is

package/dist/spell/spell.parser.js

@@ -2,13 +2,15 @@ import {
   mirrorSpellShapes,
   normalizeSpellComponents,
   normalizeSpellDuration,
-  parseSpell
-} from "../chunk-XY6X2APM.js";
+  parseSpell,
+  spellMaterialOf
+} from "../chunk-7Q2VPKCD.js";
 import "../chunk-ZDAEGJH4.js";
 import "../chunk-UA5KS2PL.js";
 export {
   mirrorSpellShapes,
   normalizeSpellComponents,
   normalizeSpellDuration,
-  parseSpell
+  parseSpell,
+  spellMaterialOf
 };

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

@@ -1,5 +1,10 @@
 import type { CastingOption } from "@archivist-gg/dnd5e/types/casting-option";
 export type { CastingOption };
+export interface SpellMaterial {
+    text: string;
+    cost?: number;
+    consume?: boolean | string;
+}
 export interface Spell {
     name: string;
     level?: number;
@@ -7,6 +12,11 @@ export interface Spell {
     casting_time?: string;
     range?: string;
     components?: string;
+    /** D2b-B: the converter's structured material component (`components.m` as an object), kept beside the `components` string,
+     *  which cannot carry its numbers: `cost` in copper pieces as authored (5etools), `consume` true or a word ("optional").
+     *  Absent for a string `components`, a bare `m: true` or a string `m`. A PARSE output only, never a YAML key: the codec
+     *  drops it on serialize. */
+    material?: SpellMaterial;
     duration?: string;
     concentration?: boolean;
     ritual?: boolean;

package/dist/srd/retired-items.d.ts

@@ -0,0 +1,14 @@
+export interface RetiredItem {
+    retired_slug: string;
+    retired_name: string;
+    /** The bundle-relative note path the retired record shipped at (dnd5e 0.3.12). */
+    retired_path: string;
+    kept_slug: string;
+    kept_name: string;
+}
+export declare const RETIRED_ITEMS: readonly RetiredItem[];
+/** The kept slug for a retired item slug, or undefined. */
+export declare function keptSlugFor(slug: string): string | undefined;
+/** The kept slug for an UNWRAPPED link target: a slug, or a compendium path (`SRD 5e/Magic Items/Hand Crossbow +2`), read
+ *  the way `resolveBaseItem` reads one. A vault-root path (`Compendium/SRD 5e/...`) never resolved and is left alone. */
+export declare function keptSlugForLink(target: string): string | undefined;

package/dist/srd/retired-items.js

@@ -0,0 +1,11 @@
+import {
+  RETIRED_ITEMS,
+  keptSlugFor,
+  keptSlugForLink
+} from "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
+export {
+  RETIRED_ITEMS,
+  keptSlugFor,
+  keptSlugForLink
+};

package/dist/subclass/subclass.codec.js

@@ -1,16 +1,16 @@
 import {
   subclassCodec
-} from "../chunk-R747YKS7.js";
-import "../chunk-J77CKYV3.js";
-import "../chunk-BLRW2UU6.js";
+} from "../chunk-QZSWN2KT.js";
+import "../chunk-OFCSP6MT.js";
+import "../chunk-LF5AGJA4.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-23LZLBJK.js";
+import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-YD2VAHA6.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
   subclassCodec

package/dist/subclass/subclass.parser.js

@@ -1,15 +1,15 @@
 import {
   parseSubclass
-} from "../chunk-J77CKYV3.js";
-import "../chunk-BLRW2UU6.js";
+} from "../chunk-OFCSP6MT.js";
+import "../chunk-LF5AGJA4.js";
 import "../chunk-4U55VNC7.js";
-import "../chunk-23LZLBJK.js";
+import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-YD2VAHA6.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseSubclass

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

@@ -106,8 +106,18 @@ export declare const subclassEntitySchema: z.ZodObject<{
         }, z.core.$strip>;
         count: z.ZodObject<{
             column: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
         replaceable: z.ZodOptional<z.ZodBoolean>;
+        active: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            label: z.ZodString;
+            verb: z.ZodString;
+            counter_label: z.ZodOptional<z.ZodString>;
+            create_label: z.ZodOptional<z.ZodString>;
+            create_verb: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        head_resource: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     pool_grants: z.ZodOptional<z.ZodArray<z.ZodObject<{
         pool: z.ZodString;

package/dist/subclass/subclass.schema.js

@@ -1,13 +1,13 @@
 import {
   subclassEntitySchema
-} from "../chunk-BLRW2UU6.js";
-import "../chunk-23LZLBJK.js";
+} from "../chunk-LF5AGJA4.js";
+import "../chunk-G6MHJDVT.js";
 import "../chunk-CJYCVNW2.js";
-import "../chunk-PI4LLJG4.js";
+import "../chunk-YD2VAHA6.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-2M34FLAY.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
   subclassEntitySchema

package/dist/types/choice.d.ts

@@ -75,11 +75,21 @@ export interface EntityFilter {
     /** Armor proficiency class. Matched against an armor entity's `category`
      *  field exactly; "shield" selects shields. */
     armor_category?: "light" | "medium" | "heavy" | "shield";
+    /** Item axis: an item entity's `type` ("instrument", "artisan's tools", "gaming set"); ANY listed type matches.
+     *  Compared case-insensitively with apostrophes, separators and a plural "s" folded (`categoryWords` in
+     *  pc.tool-picks.ts), so "artisans tools" matches "artisan's tools". A starting-equipment tool category
+     *  (`musical-instrument`, `artisan's-tools`, `gaming-set`, or an `X-or-Y` union of them) sets it. */
+    item_type?: string[];
+    /** Item axis: true keeps only MUNDANE items, dropping one whose `rarity` names a magic tier. Starting gear sets
+     *  it, because magic instruments (Instrument of Scribing, +3 Rhythm-Maker's Drum) also carry `type: instrument`. */
+    mundane?: boolean;
     /** Spell axis: filter spells by class list, level, and edition. Set together on a
      *  select-entity{entity_type:"spell"} choice (e.g. Magic Initiate). */
     list?: string;
     level?: number;
     edition?: string;
+    /** D2b-A: true keeps only spells a note marks `ritual` (Pact of the Tome's rituals). */
+    ritual?: boolean;
 }
 export interface InlineOption {
     value: string;
@@ -108,6 +118,9 @@ export type Choice = {
     entity_type: string;
     from?: string[];
     where?: EntityFilter;
+    /** D2b-A: the pick names a TARGET (the cantrip a blast invocation's rider reaches), not a grant: nothing it picks
+     *  becomes the character's own (a spell, a feat, a feature). */
+    target?: true;
 } | {
     kind: "select-proficiency";
     id: string;

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

@@ -1,7 +1,9 @@
 /** One thing a starting-equipment option grants. `item` is a BARE compendium
  *  slug (e.g. "chain-mail"); the seeder resolves it to the full edition slug.
  *  `category` is a player-picked class of item ("martial-weapon",
- *  "simple-weapon", "martial-melee-weapon", "any-armor", "shield", …) resolved
+ *  "simple-weapon", "martial-melee-weapon", "any-armor", "shield",
+ *  "musical-instrument", "artisan's-tools", "gaming-set", a tool `X-or-Y` union;
+ *  the vocabulary is `categoryToEntitySelect`'s in pc.decision-engine.ts) resolved
  *  by a nested select-entity. `gold` is gp folded into the bundle. */
 export type EquipmentGrant = 
 /** `contains_value` (COPPER; `1500` = 15 gp) is seeded as gold by the plugin's starting-equipment seeder
@@ -19,6 +21,21 @@ export type EquipmentGrant =
 } | {
     gold: number;
 };
+/** THE rule for which grant is a player-picked CATEGORY: an object whose `category` is a non-empty string. Shared by
+ *  the engine's nested-pick synthesis and the plugin's seeder, so the nth category grant of an option always
+ *  consumes the nth pick key and the two can never count a malformed grant differently. */
+export declare function isCategoryGrant(g: unknown): g is Extract<EquipmentGrant, {
+    category: string;
+}>;
+/** The persistence key of the nested pick for grant `k` of option `j` of starting-equipment entry `i`: the one
+ *  spelling the engine emits and the plugin reads. `k` indexes the option's WHOLE grant list, not its category
+ *  grants alone. */
+export declare const equipmentCategoryKey: (i: number, j: number, k: number) => string;
+/** The ORDERED pick keys of one option's category grants, the order `resolveGrants` consumes them in. */
+export declare const equipmentCategoryKeys: (grants: readonly unknown[], i: number, j: number) => string[];
+/** True for a starting-equipment decision key (`equipment-<i>` and its nested picks). The Equipment step owns
+ *  these; every other step's decision strip leaves them out. */
+export declare const isStartingEquipmentKey: (key: string) => boolean;
 /** One selectable option of a `kind:"choice"` starting-equipment entry. `label`
  *  is the human display string (the `.pc-cb-eqopt` text); `grants` is what seeds. */
 export interface EquipmentOption {

package/dist/types/equipment-grant.js

@@ -0,0 +1,12 @@
+import {
+  equipmentCategoryKey,
+  equipmentCategoryKeys,
+  isCategoryGrant,
+  isStartingEquipmentKey
+} from "../chunk-2LULMQTF.js";
+export {
+  equipmentCategoryKey,
+  equipmentCategoryKeys,
+  isCategoryGrant,
+  isStartingEquipmentKey
+};

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

@@ -1,5 +1,10 @@
 import type { Ability } from "./choice.js";
 export type SenseType = "darkvision" | "blindsight" | "tremorsense" | "truesight";
+/** A damage rider's weapon scope, the `damage-bonus` arm's structured `applies_to` words (ART-c1 Task 9b, controller
+ *  ruling 8): `melee` and `ranged` are the weapon's CATEGORY (a thrown melee weapon stays melee), `unarmed` the engine's
+ *  Unarmed Strike row, `finesse` and `thrown` the row's properties, and `weapon` every attack row (today's reach, the
+ *  Unarmed Strike row included). A list reaches a row when ANY word matches it. */
+export type WeaponScope = "weapon" | "melee" | "ranged" | "unarmed" | "finesse" | "thrown";
 /** 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 = {
@@ -22,6 +27,12 @@ export type FeatureEffect = ({
     skills: string[];
     ability: Ability;
     minimum?: number;
+} & Qualified) | ({
+    kind: "save-bonus";
+    ability: Ability;
+    minimum?: number;
+    saves?: Ability[];
+    inactive_while?: "incapacitated" | "unconscious";
 } & Qualified) | ({
     kind: "half-proficiency";
     skills?: string[];
@@ -69,7 +80,7 @@ export type FeatureEffect = ({
     kind: "damage-bonus";
     damage_type: string;
     amount: string;
-    applies_to?: "weapon" | "spell" | "all";
+    applies_to?: "spell" | "all" | WeaponScope | WeaponScope[];
 } & Qualified) | ({
     kind: "proficiency";
     proficiency_type: "skill" | "tool" | "language" | "saving-throw" | "armor" | "weapon";

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

@@ -1,3 +1,4 @@
+import type { Choice } from "./choice.js";
 import type { FeatureEffect } from "./feature-effect.js";
 import type { ActionCost, ResetTrigger, ResourceConsumption } from "./resource.js";
 import type { Duration } from "../schemas/duration-schema.js";
@@ -8,7 +9,7 @@ import type { AdditionalSpellsEntry, ProgressionEntry } from "../schemas/entity-
  * `feature_type` field is now an open string (see {@link OptionalFeatureEntity})
  * so homebrew categories parse; this union is kept purely as a reference list.
  */
-export type OptionalFeatureKind = "invocation" | "fighting_style" | "metamagic" | "maneuver" | "infusion";
+export type OptionalFeatureKind = "invocation" | "fighting_style" | "metamagic" | "maneuver" | "infusion" | "artificer_plan";
 /** A class/subclass named reference carried by a level prerequisite; mirrors namedRefSchema. */
 export type OptionalFeatureNamedRef = {
     name: string;
@@ -45,6 +46,76 @@ export type OptionalFeaturePrerequisite = {
     entry?: string;
     entry_summary?: string;
 };
+/** ART-a (spec §4.2). */
+export interface FilterSpec {
+    rarity: string[];
+    types?: string[];
+    exclude_types?: string[];
+    cursed?: false;
+}
+export interface OptionCreates {
+    item?: string;
+    variant?: {
+        candidates: string[];
+    };
+    filter?: FilterSpec;
+}
+export interface OptionRow {
+    key: string;
+    name: string;
+    min_level: number;
+    attunement?: boolean;
+    creates: OptionCreates;
+}
+export interface InfuseItem {
+    bonuses?: {
+        ac?: number;
+        weapon_attack?: number;
+        weapon_damage?: number;
+        spell_attack?: number;
+        saving_throws?: number;
+        speed?: {
+            walk?: number;
+            fly?: number;
+            swim?: number;
+            climb?: number;
+        };
+    };
+    resist?: string[];
+    charges?: {
+        max: number;
+        dice?: string;
+        recharge?: string;
+        recharge_amount?: string;
+    };
+    action?: ActionCost;
+    /** ART-c1 (R-3 a): the Actions row's range ("Self"); absent draws no range. */
+    range?: string;
+}
+export interface InfuseTarget {
+    kind: "armor" | "shield" | "weapon" | "gear";
+    category?: string[];
+    property?: string;
+    name_any?: string[];
+}
+export interface InfuseBlock {
+    targets: InfuseTarget[];
+    targets_label?: string;
+    new_object?: string;
+    rarity?: string;
+    attunement?: {
+        required: true;
+    };
+    choice?: {
+        kind: "damage-type";
+        options?: string[];
+    };
+    item?: InfuseItem;
+    scales_at?: Array<{
+        level: number;
+        item: InfuseItem;
+    }>;
+}
 export interface OptionalFeatureEntity {
     slug: string;
     name: string;
@@ -87,4 +158,16 @@ export interface OptionalFeatureEntity {
     optionalfeature_progression?: ProgressionEntry[];
     /** One wikilink, or an array of them for the multi-fluff-image emit. */
     image?: string | string[];
+    /** ART-a (spec §4.1): a pick is a COPY `<note slug>#<param>`; needs `options` and `item_choice`. */
+    repeatable?: true;
+    /** `learn`: the param is the item's FULL slug (TCE); `create`: the param is a row key, the item chosen at Create (EFA). */
+    item_choice?: "learn" | "create";
+    /** The table a copy's param must satisfy (spec §4.2). */
+    options?: OptionRow[];
+    /** This member infuses an existing object; its effect is an item-vocabulary overlay (spec §4.2). */
+    infuse?: InfuseBlock;
+    /** D2b-A (design §2.2 step 1): the member's OWN choices (Lessons of the First Ones' Origin feat, Superior Technique's
+     *  maneuver, Pact of the Tome's cantrips and rituals), in the same `Choice` vocabulary features and feats use. Absent,
+     *  the engine derives them from the raw keys the note already carries (`memberChoices`, `pc.member-choices.ts`). */
+    choices?: Choice[];
 }

package/dist/types/selection-pool.d.ts

@@ -1,3 +1,12 @@
+/** ART-a (spec §4.5): the at-once counter of an item-bound pool; its defaults are applied at read (`poolActiveWords`). */
+export interface PoolActive {
+    column: string;
+    label: string;
+    verb: string;
+    counter_label?: string;
+    create_label?: string;
+    create_verb?: string;
+}
 /** A (sub)class-declared selectable pool (e.g. Interdict Boons). The engine is
  *  generic: every game-specific string lives here in data, never in code. */
 export interface SelectionPool {
@@ -10,11 +19,17 @@ export interface SelectionPool {
             available_to: "self";
         };
     };
-    /** Pick count read from the owning class table column at the current level. */
+    /** Pick count read from the owning class table column at the current level. `label` is the known-counter word,
+     *  read through `poolCountLabel` (absent reads "Known", ART-a spec §4.5). */
     count: {
         column: string;
+        label?: string;
     };
     replaceable?: boolean;
+    /** ART-a (spec §4.5): the at-once counter (Infused Items, Magic Items). */
+    active?: PoolActive;
+    /** ART-a (spec §4.5): a resource id the tab head shows when the pool spends none of its own. */
+    head_resource?: string;
 }
 /** Subclass auto-grants that extend a named pool and do NOT count toward picks. */
 export interface PoolGrant {
@@ -28,8 +43,8 @@ export interface PoolGrant {
  *  members' `rendering_hint` at resolve time onto `ResolvedPool.layout` (pc/pool-layout.ts), and that
  *  derivation is UNCONDITIONAL: it runs whether or not the declaration carries a `layout`. R4-G4 T5
  *  LANDED the precedence in the plugin: `TabsContainer`'s dynamic-pool-tab loop reads the AUTHORED
- *  value first, then `ResolvedPool.layout`, then the `spell-like` default, and `PoolTab`'s `LAYOUTS`
- *  registry routes all four members (an unknown string degrades to `spell-like` and never throws).
+ *  value first, then `ResolvedPool.layout`. Since PT (spec §9) every pool tab draws one table and the value
+ *  picks only the tab's HEAD (`poolPresentation`); `spell-like` and `blocks` still parse and are ignored.
  *  R4-G5 CLOSED that list, and NOT by adding values: `pool-selection` and `stance` never get a layout value
  *  (measured, spec §10: the three `stance`-hinted documents are field-identical to three unhinted siblings, and
  *  `pool-selection`'s meaning is delivered by `spell-like` plus the §5 head), and `granted-die-to-ally` is a

package/dist/weapon/weapon.classify.d.ts

@@ -1,13 +1,15 @@
 import type { WeaponEntity } from "./weapon.types.js";
 /** The two attack modes a weapon supports, derived from data the SRD pipeline
- *  actually preserves. The SRD runtime data miscategorizes throwable MELEE
- *  weapons (dagger/spear/handaxe/javelin/light hammer/trident) as `*-ranged`,
- *  so the melee/ranged split is reconstructed here instead of trusted:
- *  a category-ranged weapon is PURE ranged only when it needs ammunition or
- *  loading, or is one of the two genuinely-ranged thrown weapons (dart, net —
- *  a closed SRD set; a homebrew weapon whose bare slug is exactly "dart"/"net"
- *  is force-classified pure ranged). Everything else category-ranged is a
- *  throwable melee weapon. `reach` is 5 ft, +5 with the reach property. */
+ *  actually preserves. Since dnd5e 0.3.13 the SRD data files the throwable
+ *  MELEE weapons (dagger/spear/handaxe/javelin/light hammer/trident) as
+ *  `*-melee`, but older SRD data, imported records and homebrew can still file
+ *  them as `*-ranged` (by their thrown range), so the melee/ranged split is
+ *  reconstructed here instead of trusted: a category-ranged weapon is PURE
+ *  ranged only when it needs ammunition or loading, or is one of the two
+ *  genuinely-ranged thrown weapons (dart, net: a closed SRD set; a homebrew
+ *  weapon whose bare slug is exactly "dart"/"net" is force-classified pure
+ *  ranged). Everything else category-ranged is a throwable melee weapon.
+ *  `reach` is 5 ft., +5 with the reach property. */
 export interface WeaponRangeModes {
     melee: {
         reach: number;