@archivist-gg/dnd5e 0.3.11 → 0.3.17

package/dist/optional-feature/optional-feature.codec.js

@@ -1,11 +1,12 @@
 import {
   optionalFeatureCodec
-} from "../chunk-JANNRGJC.js";
-import "../chunk-PJMG5XV3.js";
-import "../chunk-MQ747UCR.js";
+} from "../chunk-G6PBI2BU.js";
+import "../chunk-PQZ4LM4Z.js";
+import "../chunk-DOXSFYLH.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
   optionalFeatureCodec

package/dist/optional-feature/optional-feature.parser.js

@@ -1,10 +1,11 @@
 import {
   parseOptionalFeature
-} from "../chunk-PJMG5XV3.js";
-import "../chunk-MQ747UCR.js";
+} from "../chunk-PQZ4LM4Z.js";
+import "../chunk-DOXSFYLH.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseOptionalFeature

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

@@ -1,4 +1,108 @@
 import { z } from "zod";
+export declare const optionRowSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    min_level: z.ZodNumber;
+    attunement: z.ZodOptional<z.ZodBoolean>;
+    creates: z.ZodObject<{
+        item: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodObject<{
+            candidates: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        filter: z.ZodOptional<z.ZodObject<{
+            rarity: z.ZodArray<z.ZodString>;
+            types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            exclude_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cursed: z.ZodOptional<z.ZodLiteral<false>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const infuseBlockSchema: z.ZodObject<{
+    targets: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            weapon: "weapon";
+            armor: "armor";
+            shield: "shield";
+            gear: "gear";
+        }>;
+        category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        property: z.ZodOptional<z.ZodString>;
+        name_any: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    targets_label: z.ZodOptional<z.ZodString>;
+    new_object: z.ZodOptional<z.ZodString>;
+    rarity: z.ZodOptional<z.ZodString>;
+    attunement: z.ZodOptional<z.ZodObject<{
+        required: z.ZodLiteral<true>;
+    }, z.core.$strict>>;
+    choice: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"damage-type">;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    item: z.ZodOptional<z.ZodObject<{
+        bonuses: z.ZodOptional<z.ZodObject<{
+            ac: z.ZodOptional<z.ZodNumber>;
+            weapon_attack: z.ZodOptional<z.ZodNumber>;
+            weapon_damage: z.ZodOptional<z.ZodNumber>;
+            spell_attack: z.ZodOptional<z.ZodNumber>;
+            saving_throws: z.ZodOptional<z.ZodNumber>;
+            speed: z.ZodOptional<z.ZodObject<{
+                walk: z.ZodOptional<z.ZodNumber>;
+                fly: z.ZodOptional<z.ZodNumber>;
+                swim: z.ZodOptional<z.ZodNumber>;
+                climb: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        resist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        charges: z.ZodOptional<z.ZodObject<{
+            max: z.ZodNumber;
+            dice: z.ZodOptional<z.ZodString>;
+            recharge: z.ZodOptional<z.ZodString>;
+            recharge_amount: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        action: z.ZodOptional<z.ZodEnum<{
+            action: "action";
+            "bonus-action": "bonus-action";
+            reaction: "reaction";
+            free: "free";
+            special: "special";
+        }>>;
+        range: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        level: z.ZodNumber;
+        item: z.ZodObject<{
+            bonuses: z.ZodOptional<z.ZodObject<{
+                ac: z.ZodOptional<z.ZodNumber>;
+                weapon_attack: z.ZodOptional<z.ZodNumber>;
+                weapon_damage: z.ZodOptional<z.ZodNumber>;
+                spell_attack: z.ZodOptional<z.ZodNumber>;
+                saving_throws: z.ZodOptional<z.ZodNumber>;
+                speed: z.ZodOptional<z.ZodObject<{
+                    walk: z.ZodOptional<z.ZodNumber>;
+                    fly: z.ZodOptional<z.ZodNumber>;
+                    swim: z.ZodOptional<z.ZodNumber>;
+                    climb: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            resist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            charges: z.ZodOptional<z.ZodObject<{
+                max: z.ZodNumber;
+                dice: z.ZodOptional<z.ZodString>;
+                recharge: z.ZodOptional<z.ZodString>;
+                recharge_amount: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            action: z.ZodOptional<z.ZodEnum<{
+                action: "action";
+                "bonus-action": "bonus-action";
+                reaction: "reaction";
+                free: "free";
+                special: "special";
+            }>>;
+            range: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
 export declare const optionalFeatureEntitySchema: z.ZodObject<{
     slug: z.ZodString;
     name: z.ZodString;
@@ -79,6 +183,31 @@ export declare const optionalFeatureEntitySchema: 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>>;
@@ -154,11 +283,24 @@ export declare const optionalFeatureEntitySchema: 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<{
@@ -463,6 +605,116 @@ export declare const optionalFeatureEntitySchema: z.ZodObject<{
         required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
     image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    repeatable: z.ZodOptional<z.ZodLiteral<true>>;
+    item_choice: z.ZodOptional<z.ZodEnum<{
+        learn: "learn";
+        create: "create";
+    }>>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+        min_level: z.ZodNumber;
+        attunement: z.ZodOptional<z.ZodBoolean>;
+        creates: z.ZodObject<{
+            item: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodObject<{
+                candidates: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            filter: z.ZodOptional<z.ZodObject<{
+                rarity: z.ZodArray<z.ZodString>;
+                types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                exclude_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                cursed: z.ZodOptional<z.ZodLiteral<false>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    infuse: z.ZodOptional<z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                weapon: "weapon";
+                armor: "armor";
+                shield: "shield";
+                gear: "gear";
+            }>;
+            category: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            property: z.ZodOptional<z.ZodString>;
+            name_any: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        targets_label: z.ZodOptional<z.ZodString>;
+        new_object: z.ZodOptional<z.ZodString>;
+        rarity: z.ZodOptional<z.ZodString>;
+        attunement: z.ZodOptional<z.ZodObject<{
+            required: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+        choice: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"damage-type">;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        item: z.ZodOptional<z.ZodObject<{
+            bonuses: z.ZodOptional<z.ZodObject<{
+                ac: z.ZodOptional<z.ZodNumber>;
+                weapon_attack: z.ZodOptional<z.ZodNumber>;
+                weapon_damage: z.ZodOptional<z.ZodNumber>;
+                spell_attack: z.ZodOptional<z.ZodNumber>;
+                saving_throws: z.ZodOptional<z.ZodNumber>;
+                speed: z.ZodOptional<z.ZodObject<{
+                    walk: z.ZodOptional<z.ZodNumber>;
+                    fly: z.ZodOptional<z.ZodNumber>;
+                    swim: z.ZodOptional<z.ZodNumber>;
+                    climb: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            resist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            charges: z.ZodOptional<z.ZodObject<{
+                max: z.ZodNumber;
+                dice: z.ZodOptional<z.ZodString>;
+                recharge: z.ZodOptional<z.ZodString>;
+                recharge_amount: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            action: z.ZodOptional<z.ZodEnum<{
+                action: "action";
+                "bonus-action": "bonus-action";
+                reaction: "reaction";
+                free: "free";
+                special: "special";
+            }>>;
+            range: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            item: z.ZodObject<{
+                bonuses: z.ZodOptional<z.ZodObject<{
+                    ac: z.ZodOptional<z.ZodNumber>;
+                    weapon_attack: z.ZodOptional<z.ZodNumber>;
+                    weapon_damage: z.ZodOptional<z.ZodNumber>;
+                    spell_attack: z.ZodOptional<z.ZodNumber>;
+                    saving_throws: z.ZodOptional<z.ZodNumber>;
+                    speed: z.ZodOptional<z.ZodObject<{
+                        walk: z.ZodOptional<z.ZodNumber>;
+                        fly: z.ZodOptional<z.ZodNumber>;
+                        swim: z.ZodOptional<z.ZodNumber>;
+                        climb: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                resist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                charges: z.ZodOptional<z.ZodObject<{
+                    max: z.ZodNumber;
+                    dice: z.ZodOptional<z.ZodString>;
+                    recharge: z.ZodOptional<z.ZodString>;
+                    recharge_amount: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                action: z.ZodOptional<z.ZodEnum<{
+                    action: "action";
+                    "bonus-action": "bonus-action";
+                    reaction: "reaction";
+                    free: "free";
+                    special: "special";
+                }>>;
+                range: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodType<import("../index.js").Choice, unknown, z.core.$ZodTypeInternals<import("../index.js").Choice, unknown>>>>;
 }, z.core.$strip>;
 export type OptionalFeatureSchemaInput = z.input<typeof optionalFeatureEntitySchema>;
 export type OptionalFeatureSchemaOutput = z.output<typeof optionalFeatureEntitySchema>;

package/dist/optional-feature/optional-feature.schema.js

@@ -1,10 +1,15 @@
 import {
+  infuseBlockSchema,
+  optionRowSchema,
   optionalFeatureEntitySchema
-} from "../chunk-MQ747UCR.js";
+} from "../chunk-DOXSFYLH.js";
 import "../chunk-WYGD2UGN.js";
 import "../chunk-ZJXSXVFP.js";
-import "../chunk-XTRDCSJB.js";
+import "../chunk-5MXFW4O3.js";
+import "../chunk-2JSQE3DD.js";
 import "../chunk-UA5KS2PL.js";
 export {
+  infuseBlockSchema,
+  optionRowSchema,
   optionalFeatureEntitySchema
 };

package/dist/pc/pc.additional-spells.js

@@ -5,11 +5,11 @@ import {
   prefixOf,
   raceIsUngated,
   resolveSpellByName
-} from "../chunk-3HX5VLWP.js";
+} from "../chunk-VRV3NNTA.js";
 import "../chunk-PVCEA4HZ.js";
 import "../chunk-LVQLWRCU.js";
-import "../chunk-6X4KUDMU.js";
-import "../chunk-XY6X2APM.js";
+import "../chunk-ZCTUYGNV.js";
+import "../chunk-7Q2VPKCD.js";
 import "../chunk-ZDAEGJH4.js";
 import "../chunk-WELIKLZF.js";
 import "../chunk-UA5KS2PL.js";

package/dist/pc/pc.amount-bindings.d.ts

@@ -0,0 +1,32 @@
+/**
+ * D2b-A · the numbers an amount resolves against (design §1.2 A). The modifier and the save DC are those of the class
+ * that OWNS the feature or grants the spell (multiclass: the granting class, user ruling 2026-09-27).
+ */
+import type { Ability } from "@archivist-gg/dnd5e/types/choice";
+import type { Spell } from "@archivist-gg/dnd5e/spell/spell.types";
+import type { AmountBindings } from "@archivist-gg/dnd5e/dnd/amount-text";
+import type { DerivedStats, FeatureSource, ResolvedCharacter, ResolvedSpell } from "./pc.types.js";
+/** The derived fields the bindings read (recalc builds them before its return; the sheet passes `ctx.derived`). */
+export type AmountDerived = Pick<DerivedStats, "proficiencyBonus" | "mods" | "spellcastingClasses"> & Partial<Pick<DerivedStats, "abilitySpellcasting">>;
+/** The class slug that owns `source`: a class by its slug, a subclass by the class that holds it, a feat through the
+ *  slot it was taken at (`via`), a pool member through its pool's class. Null for race, background and campaign. */
+export declare function ownerClassSlug(source: FeatureSource | undefined, resolved: Pick<ResolvedCharacter, "classes">): string | null;
+/** The bindings an amount owned by `owner` resolves against: `class_level` is the OWNING class's level (the total level
+ *  for a race, background or unowned source), `spell_mod` / `spell_dc` come from that class's spellcasting row, else
+ *  the first caster's, else they stay unbound (the amount prints its words or a label). */
+export declare function amountBindingsFor(owner: FeatureSource | undefined, resolved: Pick<ResolvedCharacter, "classes" | "totalLevel">, derived: AmountDerived): AmountBindings;
+/** How a spell is cast: its ability, save DC and attack bonus. A grant that carries its OWN ability (a feat's chosen
+ *  ability, a race grant, a class-less row) reads `abilitySpellcasting`; every other spell reads its class's row, else
+ *  the first caster's. The one lookup the Spells tab's DC, attack and effect cells share. */
+export declare function spellcastingFor(spell: Pick<ResolvedSpell, "source" | "classSlug" | "ability">, derived: AmountDerived): {
+    ability: Ability;
+    saveDC: number;
+    attackBonus: number;
+} | null;
+/** The bindings a spell's effect resolves against: its caster's modifier and save DC (see {@link spellcastingFor}). */
+export declare function spellAmountBindings(spell: Pick<ResolvedSpell, "source" | "classSlug" | "ability">, resolved: Pick<ResolvedCharacter, "classes" | "totalLevel">, derived: AmountDerived): AmountBindings;
+/** What a spell adds to its base roll ONCE, in token form: `{spell_mod}` when its text reads "<the base roll> plus (or
+ *  +) your spellcasting (ability) modifier" (35 vault notes: Healing Word, Cure Wounds, Spiritual Weapon, ...), else
+ *  null. Read from the note's own words at read time; the roll must be the one the phrase follows, so a spell whose
+ *  modifier rides a different roll (a heal beside a damage roll) adds nothing. */
+export declare function spellRollBonus(spell: Pick<Spell, "damage_roll" | "description">): string | null;

package/dist/pc/pc.amount-bindings.js

@@ -0,0 +1,23 @@
+import {
+  amountBindingsFor,
+  ownerClassSlug,
+  spellAmountBindings,
+  spellRollBonus,
+  spellcastingFor
+} from "../chunk-PXVNAY7T.js";
+import "../chunk-KR6JF3BF.js";
+import "../chunk-KSTV7J2U.js";
+import "../chunk-DPUJDOKV.js";
+import "../chunk-IUAAXXNO.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-EVMUJYUD.js";
+import "../chunk-VTTA2ALZ.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
+export {
+  amountBindingsFor,
+  ownerClassSlug,
+  spellAmountBindings,
+  spellRollBonus,
+  spellcastingFor
+};

package/dist/pc/pc.asi-flatten.d.ts

@@ -1,4 +1,5 @@
-import type { Choice } from "../types/choice.js";
+import type { RegisteredEntity } from "@archivist-gg/core";
+import type { Choice, Ability } from "../types/choice.js";
 /**
  * Normalizes the authored two-step "Ability Score Increase or Feat" decision
  * into the flat feat pick the product now uses.
@@ -16,3 +17,63 @@ import type { Choice } from "../types/choice.js";
  * Pure: never mutates its input, never synthesizes a new object.
  */
 export declare function flattenAsiOrFeat(choice: Choice): Choice;
+/** The structural registry read `resolveLegacyAsiFeat` makes; the ledger's DecisionRegistry and core's EntityRegistry both
+ *  satisfy it. */
+type FeatSearch = {
+    search(query: string, entityType: string, limit: number): RegisteredEntity[];
+};
+/**
+ * The legacy ASI-branch allocation a class level SAVED, or null (H234 H4(2), spec §5.2 item 1): the SHEET's predicate,
+ * which `collectClassAsiBranch` (pc.recalc.ts) folds per level, and the base of the Builder's {@link convertibleLegacyAsi}.
+ *
+ * Non-null exactly when `block` is an object whose `feat` is NOT a string and whose `asi` is a non-array object with at
+ * least one numeric ability entry; returns a FRESH object of those entries. It ignores `asi-or-feat`, so an explicit
+ * `"feat"` branch with no feat picked still folds on the sheet, as it always has.
+ *
+ * A string `feat` beside an `asi` is R4-P4 Decision B's orphan (the level took the feat branch and the picker never cleared
+ * the abandoned branch's child keys): null. Do NOT loosen the test to `"feat" in block` or a `startsWith("feat")` prefix
+ * test: the first strands a non-string `feat` (a legacy hand edit) with no fold at all, the second skips every
+ * correctly-flattened block. The `typeof … === "string"` test MIRRORS `collectClassFeatAbilityPoints`' own gate, so the two
+ * can never both decline on this predicate (they can both decline when the feat slug resolves to no entity: an
+ * unresolvable pick grants nothing, by design).
+ */
+export declare function legacyAsiBranch(block: unknown): Partial<Record<Ability, number>> | null;
+/** The BUILDER's predicate (spec §5.2 item 2, Gate 1 M-9): {@link legacyAsiBranch} when `asi-or-feat` is absent or
+ *  `"asi"`, else null. An explicit `"feat"` branch is a two-step pick in progress (a homebrew non-flattenable two-step keeps
+ *  `asi-or-feat` as its own row's key), so the Builder neither aliases nor converts it and today's orphan rule applies.
+ *  The ledger alias and {@link migrateLegacyAsiLevel} both use THIS predicate, so an aliased row never receives an inert
+ *  write. The sheet's fold keeps the value-agnostic {@link legacyAsiBranch}. */
+export declare function convertibleLegacyAsi(block: unknown): Partial<Record<Ability, number>> | null;
+/** The ASI feat a class answers a legacy level with, deterministically (spec §5.3, Gate 0 M-7). Candidates: the registered
+ *  feats whose bare slug is `ability-score-improvement` and which carry an `ability-points` choice with a string `id`.
+ *  Rank: (1) the class entity's slug prefix (the pool collapse's identity rule), (2) the class entity's edition, (3)
+ *  ascending slug in code-unit order. `childId` is that choice's own `id`, read from the data. Null with no candidate or no
+ *  class entity. A pure function of (registry, class entity), so the ledger alias and the write path always agree. */
+export declare function resolveLegacyAsiFeat(registry: FeatSearch, classEntity: {
+    slug: string;
+    edition?: string;
+} | null | undefined): {
+    slug: string;
+    childId: string;
+} | null;
+/**
+ * The level block to store BEFORE a Builder edit applies, or null for "no conversion" (spec §5.2 item 4, §5.5). The plugin's
+ * `setChoice` calls it for EVERY write with the edit's key and value (Gate 1 M-8), so the `feat` vocabulary stays here.
+ *
+ * Null when the key is neither `feat` nor `feat:`-prefixed, when the block is not a convertible legacy level
+ * ({@link convertibleLegacyAsi}), or when the class has no ASI feat ({@link resolveLegacyAsiFeat}). Else a NEW object:
+ * every key of `block` except `asi-or-feat`, `asi` and `feat:<childId>`, plus `feat: <the ASI slug>`, plus
+ * `feat:<childId>: <the legacy allocation>` UNLESS the edit is a SWITCH: `key === "feat"` with any value other than the
+ * ASI slug, so a pick of another feat (Gate 1 I-1, ruled option (a)) and the chip removal (null / undefined; final
+ * review, Review 3 m6, ruled) both count. A switch writes no `feat:<childId>` at all, so the legacy points and any
+ * stale child are dropped and the level's pick stays open (the new feat's own, or the removed ASI's), which is what
+ * today's orphan rule does for a switch; a chip removal is therefore not reversible, and re-picking the ASI feat after
+ * it starts open. The stepper and a re-pick of the ASI feat keep the full conversion, where the legacy allocation
+ * overwrites a stale child. Other keys at the level are kept untouched; the input is never mutated. An over-allocated
+ * legacy level is copied verbatim and then clamped by the feat's own rules when the sheet folds it (Gate 1 M-10).
+ */
+export declare function migrateLegacyAsiLevel(block: unknown, key: string, value: unknown, registry: FeatSearch, classEntity: {
+    slug: string;
+    edition?: string;
+} | null | undefined): Record<string, unknown> | null;
+export {};

package/dist/pc/pc.asi-flatten.js

@@ -0,0 +1,16 @@
+import {
+  convertibleLegacyAsi,
+  flattenAsiOrFeat,
+  legacyAsiBranch,
+  migrateLegacyAsiLevel,
+  resolveLegacyAsiFeat
+} from "../chunk-LBEXLN6I.js";
+import "../chunk-ZCTUYGNV.js";
+import "../chunk-WELIKLZF.js";
+export {
+  convertibleLegacyAsi,
+  flattenAsiOrFeat,
+  legacyAsiBranch,
+  migrateLegacyAsiLevel,
+  resolveLegacyAsiFeat
+};

package/dist/pc/pc.conditions.js

@@ -1,6 +1,6 @@
 import {
   computeConditionEffects
-} from "../chunk-R2ZV233X.js";
+} from "../chunk-MYY2C5MB.js";
 export {
   computeConditionEffects
 };

package/dist/pc/pc.containment.d.ts

@@ -0,0 +1,45 @@
+import type { EntityRegistry } from "@archivist-gg/core";
+import type { EquipmentEntry } from "./pc.types.js";
+/** I2a · containment (spec 2026-09-24-inv-i2a-containment-data-design.md §4). The equipment array stays FLAT; an entry
+ *  sits inside another through `in: <id>`. What counts as a container is the item's `container` data
+ *  (isContainerItem), never a name list. */
+export type ContainmentBreak = "equipped" | "missing" | "self" | "unresolved" | "not-container" | "cycle";
+export interface ContainmentView {
+    parentOf: ReadonlyArray<number | null>;
+    childrenOf: ReadonlyArray<ReadonlyArray<number>>;
+    isContainer: ReadonlyArray<boolean>;
+    ownerOfId: ReadonlyMap<string, number>;
+    duplicateIds: ReadonlyArray<number>;
+    broken: ReadonlyArray<{
+        index: number;
+        reason: ContainmentBreak;
+    }>;
+}
+export declare function nonEmptyRef(v: unknown): string | null;
+/** `container.holds_items` decides when present; otherwise a weight or item capacity, or weightless contents, make a
+ *  container. A pack_contents-only block (a pack) and a volume-only block (a liquid holder) are not containers. */
+export declare function isContainerItem(entity: unknown): boolean;
+export declare function idOwners(equipment: readonly EquipmentEntry[]): {
+    ownerOfId: Map<string, number>;
+    duplicateIds: number[];
+};
+export declare function entityOfEntry(entry: EquipmentEntry, registry: EntityRegistry | null): unknown;
+export declare function resolveContainment(equipment: readonly EquipmentEntry[], registry: EntityRegistry | null): ContainmentView;
+export type MoveRefusal = "out-of-range" | "equipped" | "self" | "descendant" | "unresolved" | "not-container";
+export type MoveCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: MoveRefusal;
+};
+export type MoveResult = {
+    ok: true;
+    changed: boolean;
+} | {
+    ok: false;
+    reason: MoveRefusal;
+};
+export declare function ensureEntryId(equipment: EquipmentEntry[], index: number, registry: EntityRegistry | null): string;
+export declare function canMoveInto(equipment: readonly EquipmentEntry[], index: number, target: number | null, registry: EntityRegistry | null): MoveCheck;
+export declare function moveInto(equipment: EquipmentEntry[], index: number, target: number | null, registry: EntityRegistry | null): MoveResult;
+export declare function repairContainment(equipment: EquipmentEntry[], registry: EntityRegistry | null): number;

package/dist/pc/pc.containment.js

@@ -0,0 +1,24 @@
+import {
+  canMoveInto,
+  ensureEntryId,
+  entityOfEntry,
+  idOwners,
+  isContainerItem,
+  moveInto,
+  nonEmptyRef,
+  repairContainment,
+  resolveContainment
+} from "../chunk-EJP263OP.js";
+import "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
+export {
+  canMoveInto,
+  ensureEntryId,
+  entityOfEntry,
+  idOwners,
+  isContainerItem,
+  moveInto,
+  nonEmptyRef,
+  repairContainment,
+  resolveContainment
+};

package/dist/pc/pc.decision-engine.d.ts

@@ -3,6 +3,7 @@ import type { ResolvedCharacter, ChoiceValue, FeatureSource } from "./pc.types.j
 import type { RegisteredEntity } from "@archivist-gg/core";
 import { type ProficiencyEntry } from "./pc.proficiency-grants.js";
 import { wikilinkTailSlug } from "../entities/slug.js";
+import { type RepeatableMember } from "./pc.infusions.js";
 export interface DecisionRegistry {
     search(query: string, entityType: string, limit: number): RegisteredEntity[];
     getByTypeAndSlug(entityType: string, slug: string): RegisteredEntity | undefined;
@@ -27,6 +28,8 @@ export interface ResolvedOption {
 /**
  * Status contract: over-selection (n > need) reports `resolved` — the engine
  * never reports an error for too many picks; the picker UI owns cap enforcement.
+ * A pick that FOLDS into proficiencies never over-selects, though: {@link capAtCount}
+ * keeps its first `count` stored values, in the ledger and the fold alike.
  * Likewise for ability-points `max_per`: the engine only sums total points
  * allocated, so per-ability caps are picker-enforced, not reflected here.
  */
@@ -88,6 +91,9 @@ export interface DecisionItem {
         id: string;
         anchorLevel: number;
     };
+    /** ART-a (spec §5.1, R20): present ONLY on a synthesized pool item whose pool offers a repeatable member: one entry per
+     *  such member, with its option rows resolved for the per-copy picker (visible candidates only, U-A). */
+    repeatable?: RepeatableMember[];
     /**
      * Populated only for the selected branch of a select-inline (the
      * revealed-on-selection rule): a child decision becomes visible once its
@@ -95,6 +101,9 @@ export interface DecisionItem {
      * status to "partial".
      */
     children?: DecisionItem[];
+    /** D2b-A (design §2.2 step 7): on a child of a pool item, the name of the member the choice belongs to ("Lessons of the
+     *  First Ones"), so the strip reads "Lessons of the First Ones · Origin feat". Absent everywhere else. */
+    parentLabel?: string;
 }
 export interface DecisionLedger {
     classes: Array<{
@@ -119,9 +128,9 @@ export interface DecisionContext {
 /** `wikilinkTailSlug` MOVED to `entities/slug.ts` in R4-G5 T1, beside `bareEntitySlug`, so `pc.pools.ts` can
  *  import it without importing this module (this module imports `pc.pools` for `strandedPicks`; the old
  *  direction would be a cycle). The re-export is KEPT because `@archivist-gg/dnd5e/pc/pc.decision-engine` is
- *  a published subpath with three plugin importers OF THIS SYMBOL (`components/passive/background-block.ts`,
- *  `components/builder/background-step.ts`, `components/builder/class-step.ts`, all under
- *  `packages/obsidian/src/modules/pc/`) plus this repo's `pc.resolver.ts` and
+ *  a published subpath with a plugin importer OF THIS SYMBOL (`components/builder/class-step.ts`, under
+ *  `packages/obsidian/src/modules/pc/`; the two background surfaces moved to the plugin's `refLabel`, which reads
+ *  `entities/slug` directly, on 2026-09-25) plus this repo's `pc.resolver.ts` and
  *  `tests/wikilink-tail-slug.test.ts`: a public
  *  surface, not a migration shim, so the standing "retire every shim" rule does not reach it (spec §17 names the
  *  re-export explicitly). */
@@ -129,6 +138,18 @@ export { wikilinkTailSlug };
 declare function matchesFilter(e: RegisteredEntity, where: EntityFilter, ownerBare: string): boolean;
 /** Test-only export of {@link matchesFilter} (Task B2). */
 export declare const __matchesFilterForTest: typeof matchesFilter;
+/** Map a starting-equipment category grant to a nested select-entity child (vocabulary on
+ *  {@link parseEquipmentCategory}). Weapons filter by weapon_category; armor by armor_category; `shield` is an armor
+ *  entity in the shield class; a tool category is a MUNDANE item of the category's `type` (magic instruments carry
+ *  `type: instrument` too).
+ *
+ *  An UNKNOWN category is never guessed. It used to fall through to `weapon_category: "simple"`, which is how the
+ *  PHB 2024 Bard's "Choose a musical instrument" listed Club, Dagger and Dart. It now yields `from: []`, the
+ *  engine's existing zero-option shape (an authored empty pool: the row stays open and the strip prints its
+ *  "No options available" line), and warns ONCE per distinct category. */
+declare function categoryToEntitySelect(category: string, id: string): Choice;
+/** Test-only export of {@link categoryToEntitySelect}. */
+export declare const __categoryToEntitySelectForTest: typeof categoryToEntitySelect;
 /** Walk every decision definition + persisted selection and collect chosen
  *  proficiencies. Pure; called by recalc.
  *