@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/pc/pc.defense-normalize.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Canonical key for a defense value (damage type or condition).
+ *
+ * Deliberately SIMPLER than `toProfSlug` (pc.proficiency-normalize.ts): damage types and conditions carry
+ * no apostrophes and no hyphens, so there is no U+2019 fold and no space-to-hyphen step. Do NOT reuse
+ * `normKey` · it token-sorts and singularizes for weapon display names and is actively wrong here.
+ *
+ * The whole point of this function is that ONE normalizer serves every reader and writer on the defenses
+ * path. Adding a second is the bug R4-P5 exists to remove.
+ */
+export declare function toDefenseSlug(s: string): string;

package/dist/pc/pc.defense-normalize.js

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

package/dist/pc/pc.equipment.d.ts

@@ -1,6 +1,7 @@
 import type { EntityRegistry } from "@archivist-gg/core";
 import type { Ability } from "@archivist-gg/dnd5e";
-import type { AppliedBonuses, DerivedEquipment, ResolvedCharacter, ProficiencySet } from "./pc.types.js";
+import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
+import type { AppliedBonuses, AttackRow, DerivedEquipment, ResolvedCharacter, ProficiencySet } from "./pc.types.js";
 import type { WeaponAbilityOverride } from "./pc.feature-effects.js";
 interface ProficienciesForQuery {
     armor: ProficiencySet;
@@ -9,5 +10,33 @@ interface ProficienciesForQuery {
 }
 export declare function emptyAppliedBonuses(): AppliedBonuses;
 export declare function computeAppliedBonuses(resolved: ResolvedCharacter, _profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[]): AppliedBonuses;
+/** The LIVE weapon-proficiency gate · the one the attack pipeline calls at
+ *  `computeAttacks` below. Exported for the overlay effect-slug guard
+ *  (`tests/srd-canonical/overlay-effect-slugs.test.ts`), which validates
+ *  authored `proficiency_type: weapon` values by asking this function whether
+ *  any SRD weapon comes out proficient. Note `pc.proficiency-query.ts`'s
+ *  `isProficientWithWeapon` is a near-twin with NO production callers · it
+ *  differs on the third arm (it compares only the base category, this one also
+ *  accepts the full hyphenated form), so guards wanting runtime fidelity must
+ *  use THIS one. */
+export declare function isWeaponSlugProficient(weapon: WeaponEntity, weaponSlug: string, profs: ProficienciesForQuery): boolean;
+/** The die and ability set an `unarmed-strike` effect (or its synthetic) resolved for this character (R4-G6b §5.1). */
+export interface UnarmedStrikeSpec {
+    dice?: string;
+    abilities?: Ability[];
+}
+/** The always-present Unarmed Strike row (R4-G6b §5.1): 1 + the modifier bludgeoning, 5 ft, always proficient. With a
+ *  DIE the damage string reproduces the OUTPUT of `buildAttackRow`'s `formatDice` (a closure over `dmgFlat` that cannot
+ *  be called): the flat part's `^\+0$` strip equals the whole-string `\+0$` strip for every modifier, so a die reads
+ *  `1d6-1`. With NO die the base is the number 1, and a signed suffix on a number is unevaluated arithmetic (`1-1`,
+ *  `1+3`), so the flat base prints EVALUATED and floored at 0: `String(Math.max(0, 1 + mod))` (R4-G7 T8 RIDER-10; the
+ *  user's Q-3 "1 + STR" is the formula, the evaluated number its display). The
+ *  ability is STR unless the spec lists others; the highest modifier wins and a LATER candidate wins a tie, so a
+ *  listed DEX beats STR on a tie (the shipped finesse idiom `mods.dex >= mods.str`). Called from recalc, which owns
+ *  the walk that produces `spec`; never from `computeAttacks`, so the row is present with or without a registry.
+ *  The `subLabel` is an ENGINE string, printed as it ships: the sheet humanizes a weapon's category tokens, and
+ *  this row carries no weapon, so `Unarmed` is capitalised here beside `Unarmed Strike`, `5 ft` and `bludgeoning`
+ *  rather than in a renderer (R4-G6b live rider R-1). */
+export declare function buildUnarmedRow(mods: Record<Ability, number>, proficiencyBonus: number, spec?: UnarmedStrikeSpec): AttackRow;
 export declare function computeSlotsAndAttacks(resolved: ResolvedCharacter, mods: Record<Ability, number>, profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[], proficiencyBonus: number, weaponAbilities?: WeaponAbilityOverride[], weaponMasteries?: string[]): DerivedEquipment;
 export {};

package/dist/pc/pc.equipment.js

@@ -1,16 +1,21 @@
 import {
+  buildUnarmedRow,
   computeAppliedBonuses,
   computeSlotsAndAttacks,
-  emptyAppliedBonuses
-} from "../chunk-EMOORSQ7.js";
-import "../chunk-353WXS6S.js";
-import "../chunk-N6N74K6X.js";
+  emptyAppliedBonuses,
+  isWeaponSlugProficient
+} from "../chunk-OSQFPGLM.js";
+import "../chunk-UIRMA5KM.js";
+import "../chunk-UBBKSYBY.js";
+import "../chunk-RLGQ5PZZ.js";
 import "../chunk-LWFTHJIE.js";
 import "../chunk-DNAJRMNN.js";
-import "../chunk-4LZJXJJS.js";
-import "../chunk-LV4SNWZQ.js";
+import "../chunk-WXWPK3LI.js";
+import "../chunk-6X4KUDMU.js";
 export {
+  buildUnarmedRow,
   computeAppliedBonuses,
   computeSlotsAndAttacks,
-  emptyAppliedBonuses
+  emptyAppliedBonuses,
+  isWeaponSlugProficient
 };

package/dist/pc/pc.feature-effects.d.ts

@@ -1,6 +1,6 @@
-import type { SenseType } from "@archivist-gg/dnd5e/types/feature-effect";
+import type { FeatureEffect, SenseType } from "@archivist-gg/dnd5e/types/feature-effect";
 import type { Ability } from "@archivist-gg/dnd5e";
-import type { DamageRider, ResolvedFeature, RollModifierEntry } from "./pc.types.js";
+import type { DamageRider, DefenseGrant, FeatureSource, ResolvedCharacter, ResolvedFeature, RollModifierEntry, SaveOutcomeEntry } from "./pc.types.js";
 /**
  * A melee-attack ability override from a `weapon-ability` effect. `weaponSlugs`
  * (bare, namespace-stripped) scopes the override to matching weapon types only;
@@ -35,27 +35,84 @@ export interface FeatureEffectTotals {
      * a "base speed becomes 60" feature). Max across all set effects; 0 = none.
      * recalc applies it as Math.max(set, race + additive bonuses) so it never
      * lowers an already-higher speed and is independent of the additive bonus.
+     * A `scales_at` progression resolves BEFORE the max, at the effect's own source level (R4-G7 §7.3).
      */
     speed_walk_set: number;
+    /** Flat ability-score bumps from `ability-score-increase` effects whose `abilities` is a FIXED LIST (the three level-20
+     *  capstones). `chosen` arms are the ASI SLOT's second encoding and MUST NOT fold (the synthesized feat decision pays
+     *  them; a flat fold double-counts). No cap: `max` is declared and unread (user ruling 2026-09-03). */
+    ability_bonus: Partial<Record<Ability, number>>;
     /** Max range per sense type granted by effects; 0 = none for that type. */
     senses: Record<SenseType, number>;
-    /** One term per ac-bonus effect, labeled with the owning feature's name. */
+    /** One term per ac-bonus effect, labeled with the owning feature's name. `condition` is the
+     *  effect's situational qualifier, carried verbatim onto the ACTerm and never evaluated. */
     ac_terms: {
         value: number;
         requires_armor: boolean;
         label: string;
+        condition?: string;
     }[];
-    resistances: string[];
-    condition_immunities: string[];
     /**
-     * skills are kebab-case lowercase slugs (matching skill slugs). armor/weapons
-     * are lowercase CATEGORY words ("heavy"/"shield", "simple"/"martial") — the
-     * same form class/race/feat grants use; recalc folds them into the matcher's
-     * `.categories` bucket, NOT `.specific` (which is per-item slugs). tools/languages
-     * keep their display spelling; saves are canonical ability keys.
+     * The four defense buckets a feature effect can grant, as DefenseGrant ENTRIES (R4-G3a §3.2.1).
+     * Deduped by value case-insensitively, first spelling wins, trimmed · exactly the contract
+     * `pushUnique` had when these were `string[]` · but the SECOND granting feature's NAME is merged
+     * into `sources` rather than discarded. `immunity` and `vulnerability` fold REGARDLESS of
+     * `condition` (following `resistance`: dropping a real immunity is worse than showing it
+     * unqualified); `immune-condition` keeps its `while` skip. Values stay in the AUTHORED spelling ·
+     * toDefenseSlug runs in pc.recalc.ts, where composeDefenseEntries turns these into DefenseEntry.
+     */
+    resistances: DefenseGrant[];
+    immunities: DefenseGrant[];
+    vulnerabilities: DefenseGrant[];
+    condition_immunities: DefenseGrant[];
+    /**
+     * skills, tools and languages are canonical slugs (toProfSlug: lowercase, U+2019
+     * folded to ASCII, whitespace collapsed to hyphens). armor and weapons entries
+     * are only `.toLowerCase()`d, NOT slugified, so an authored value keeps its
+     * spaces. recalc folds armor into armor.categories ONLY; it folds every weapons
+     * value into weapons.categories and additionally routes a non-category value
+     * into weapons.specific. saves are canonical ability keys, and are the one
+     * bucket a closed vocabulary genuinely guarantees: normalizeAbility returns null
+     * for anything else and the effect is dropped.
+     *
+     * What is INTENDED and what is ENFORCED differ here, and the gap is silent.
+     * INTENDED: skills/tools/languages land on ALL_SKILL_SLUGS / ALL_TOOLS /
+     * ALL_LANGUAGES, over which toProfSlug is the identity; armor values are
+     * CATEGORY words ("heavy"/"shield"); weapons values are a category word
+     * ("simple"/"martial", or an entity-level "martial-melee" form) or an authored
+     * weapon NAME. ENFORCED at runtime: nothing. feature-effect-schema's proficiency
+     * arm is `value: z.string().min(1)`, an OPEN string, and classifyProficiencyEffect
+     * does no membership test. The only guard is
+     * tests/srd-canonical/overlay-effect-slugs.test.ts, and it sees OVERLAY-AUTHORED
+     * data only · there skill/tool/language are checked against those three lists and
+     * weapon against the live gate, while armor and saving-throw are unchecked even
+     * there. Vault homebrew reaching this at runtime is checked by nothing.
+     *
+     * An off-vocabulary value does not crash and does not disappear · it becomes a
+     * value that can never coincide with the canonical one. Measured: an authored
+     * `{proficiency_type:"tool", value:"Playing Card Set"}` normalizes to
+     * "playing-card-set", which is NOT in ALL_TOOLS (that list carries the 2024
+     * spelling "playing-cards"). It still folds, and still renders as its own row
+     * labeled "Playing Card Set", but everything keyed on the canonical slug · the
+     * first-seen-wins dedupe in computeEffectiveProficiencies, an
+     * `overrides.tools.remove` suppression, the builder's already-satisfied
+     * exclusion · misses it, so the character ends up able to hold both.
+     *
+     * `skillExpertise` is NOT a seventh bucket · it is a SUBSET of `skills`, in the
+     * same canonical slug form, carrying the values whose effect set
+     * `expertise: true`. An expertise skill is pushed to BOTH, so every consumer
+     * that only knows about proficiency keeps working and recalc's `expSet` gains
+     * one source. SKILLS ONLY (spec §7.2): a tool or language effect carrying
+     * `expertise: true` folds as a plain proficiency and never lands here. It is
+     * not lost · since R4-G4 §9.2 the authored flag travels the GRANT channel
+     * instead (`EffectProficiencyGrant.expertise` -> `ProficiencyGrant.expertise`
+     * -> `ProficiencyEntry.expertise`), which is the channel the sheet panel and
+     * the proficiency modal read. Routing it here as well would put a value in the
+     * skill-expertise set that no skill key can ever match.
      */
     proficiencies: {
         skills: string[];
+        skillExpertise: string[];
         tools: string[];
         languages: string[];
         saves: Ability[];
@@ -78,6 +135,12 @@ export interface FeatureEffectTotals {
      * labeled with the owning feature's name.
      */
     rollModifiers: RollModifierEntry[];
+    /**
+     * Order-preserving list of `save-outcome` entries (R4-G3a §5.3), labeled with the owning
+     * feature's name. Pass-through (no dedupe/merge); `ability: "any"` becomes an ABSENT ability,
+     * which the save chip reads as "every save".
+     */
+    saveOutcomes: SaveOutcomeEntry[];
     /**
      * Lowest weapon-attack crit threshold (natural roll that scores a critical
      * hit) granted by `crit-range` effects. Folds via Math.min from init 20, so
@@ -86,10 +149,11 @@ export interface FeatureEffectTotals {
      */
     critRange: number;
     /**
-     * Max extra attacks per Attack action granted by `extra-attack` effects.
+     * Max EXTRA attacks per Attack action granted by `extra-attack` effects, never the total:
      * Non-stacking (D&D Extra Attack features don't stack): folds via Math.max
      * from init 0, so 0 = no extra attacks. recalc maps this onto
      * DerivedStats.attacksPerAction as `1 + extraAttack`.
+     * A `scales_at` progression resolves BEFORE the max, at the effect's own source level (R4-G7 §7.3).
      */
     extraAttack: number;
     /**
@@ -115,8 +179,158 @@ export declare function emptyFeatureEffectTotals(): FeatureEffectTotals;
  * is OFF by default, so callers passing no opts see activatable features fold to
  * nothing (correct — a buff is off until toggled). Non-activatable features fold
  * unconditionally regardless of opts.
+ *
+ * R4-G7 §7.3: `levelFor` answers "at what level does an effect from THIS source resolve", which is the rule
+ * `resourceLevelFor` (pc.resources.ts) already applies to a resource's own `scales_at`: the character's level
+ * in the granting class for a `class` source, the level in the class owning the subclass for a `subclass`
+ * source, the total level otherwise. Both production callers pass exactly that (dnd5e `pc.recalc.ts` and the
+ * plugin's builder `abilities-step.ts`); a caller that passes none leaves every `scales_at` unresolved and
+ * every effect at its BASE value, which is what a fixture with no character behind it should read.
  */
 export interface FeatureEffectsOpts {
     activeBuffs?: Set<string>;
+    levelFor?: (source: FeatureSource) => number;
 }
+/** Does this feature's effects fold right now? An activatable feature folds ONLY
+ *  while its id is in the active set; a buff is off until toggled. Shared by
+ *  computeFeatureEffects and the display-side proficiency collector so the fold
+ *  and the display can never disagree about boons (spec fence F3). */
+export declare function foldsNow(rf: ResolvedFeature, activeBuffs: Set<string>): boolean;
+/** The ONE assembly of everything whose effects fold: authored features plus
+ *  pool-granted and pool-selected boons, with the active-buff set.
+ *
+ *  Returning BOTH halves is load-bearing: a caller handed only the feature list
+ *  would drop activeBuffs and computeFeatureEffects would skip every activatable
+ *  boon · exactly the display/gate divergence this helper exists to close.
+ *
+ *  The guards defend against CAST-BUILT FIXTURES, not against the type: `features`,
+ *  `pools` and `state` are all non-optional on ResolvedCharacter, but `tests/` is
+ *  typechecked by nothing. Only fixtures that actually reach this function count,
+ *  and today that is THREE entry points: recalc, the display-side walk
+ *  (computeEffectiveProficiencies → collectProficiencyGrants), and this
+ *  function's own direct tests. All three guards are LIVE. Counts below were
+ *  measured by deleting each guard and running the suite · re-derive them the
+ *  same way rather than trusting the numbers, which drift as tests are added:
+ *    · `pools ?? []` is exercised by `emptyResolved()` in
+ *      tests/pc-recalc-feature-effects.test.ts, which omits pools and IS fed to
+ *      recalc, and by `dwarf()` in tests/pc-proficiency-effective.test.ts. This
+ *      guard predates the extraction; it was already here. Deleting it: 149 tests
+ *      red across 13 files.
+ *    · `state?.` is exercised by the "survives a cast-built fixture with no pools
+ *      and no state" case in tests/pc-feature-effects.test.ts, which calls this
+ *      function directly with `{ features: [...] } as never`, and again by
+ *      `dwarf()`. Deleting it: 11 red across 2 files.
+ *    · `features ?? []` is exercised by `dwarf()` in
+ *      tests/pc-proficiency-effective.test.ts, which omits `features` and reaches
+ *      here through the display walk. Deleting it: 7 red, all in that file.
+ *      ⚠️ This bullet used to read "NOT exercised today, and is the one kept
+ *      purely for the display-side callers". That was TRUE when written and was
+ *      falsified LATER IN THIS SAME PHASE by the tasks that wired the display
+ *      path, because nobody re-read it. A guard's own justification is the thing
+ *      most likely to go stale under you · re-run the deletion before restating
+ *      any of these three.
+ *  Do not "simplify" any of the three away. */
+export declare function assembleEffectFeatures(resolved: ResolvedCharacter): {
+    features: ResolvedFeature[];
+    activeBuffs: Set<string>;
+};
+/** Spec R4-G1a D2. Whether an effect changes the character it is written on. `subject` is absent on every SRD
+ *  effect (=== "self"); the converter emits "self" today and will emit other creatures later (Hound of Ill Omen
+ *  imposes disadvantage on a TARGET). A non-self effect never folds onto the PC: not here, not in
+ *  collectProficiencyEffectGrants, not in unarmoredACBreakdown, not in recalc's weapon-ability scan. Its FEATURE
+ *  still resolves and renders (it is not buildOnly); R4-G3a §4 gives it a row-local caption.
+ *
+ *  R4-G3a §4.4: a subject that is neither absent nor "self" warns ONCE per distinct subject string
+ *  (`warnOnce`, keyed on the subject). The converter's vocabulary here is open, so an unexpected
+ *  spelling ("Self", "target creature") silently stops folding today; the warning names it without
+ *  changing the answer. Never a refusal: the return value is unchanged. */
+export declare function foldsOnSelf(eff: {
+    subject?: string;
+}): boolean;
+/** The effects of a feature that fold on the character: every reader of `feature.effects` for a derived stat goes through this. */
+export declare function selfEffectsOf(f: {
+    effects?: FeatureEffect[];
+}): FeatureEffect[];
 export declare function computeFeatureEffects(features: ResolvedFeature[], opts?: FeatureEffectsOpts): FeatureEffectTotals;
+/** The ONE interpreter of `kind: "proficiency"` effects (spec fence F3).
+ *
+ *  Two consumers with different needs, so the return carries BOTH forms:
+ *  `applyEffect` pushes `value` (normalized) into FeatureEffectTotals, while the
+ *  display collector reads `raw` for armor/weapons · composeGrantEntries stores
+ *  the raw authored string as ProficiencyEntry.value (spec §4.8 #1) and computes
+ *  its dedupe key separately. Tools/languages read `value`.
+ *
+ *  `saves` is discriminated because FeatureEffectTotals.proficiencies.saves is
+ *  Ability[], not string[] (fence F1). A null return means "not a proficiency
+ *  effect, or an unresolvable ability".
+ *
+ *  `expertise` is REQUIRED and always a boolean, never absent: the authored key
+ *  is optional, so folding it here once means no consumer has to tell
+ *  `undefined` from `false`. It is reported for EVERY bucket · deciding that
+ *  only skills act on it belongs to the fold (spec §7.2), not to the
+ *  classification. */
+export type ProficiencyClassification = {
+    bucket: "skills" | "tools" | "languages" | "armor" | "weapons";
+    value: string;
+    raw: string;
+    expertise: boolean;
+} | {
+    bucket: "saves";
+    value: Ability;
+    raw: string;
+    expertise: boolean;
+};
+export declare function classifyProficiencyEffect(eff: FeatureEffect): ProficiencyClassification | null;
+/** One proficiency an effect grants, tagged with the source it came from.
+ *
+ *  BOTH forms are carried because the two display consumers need different ones
+ *  and, since the tool/language canonicalization landed, they no longer coincide:
+ *  armor/weapons read `raw` (composeGrantEntries stores the raw authored string
+ *  as ProficiencyEntry.value and keys its dedupe on toProfSlug separately), while
+ *  tools/languages read `value`, the canonical slug the effective-proficiency
+ *  matcher matches its vocabulary and suppressions on. Reaching for the wrong
+ *  field is silently wrong, not harmlessly identical.
+ *
+ *  `sourceSlug` is the source's slug VERBATIM (namespace and all), because the
+ *  consumer resolves it against the resolved character's entities to get a
+ *  display name. */
+export interface EffectProficiencyGrant {
+    value: string;
+    raw: string;
+    sourceKind: FeatureSource["kind"];
+    sourceSlug: string;
+    /**
+     * Set (to `true`) only when the granting effect carried `expertise: true`, and
+     * ABSENT otherwise, so a plain grant keeps the exact four-key shape the two
+     * display consumers already read. Reported for every bucket, unlike the fold,
+     * which routes skills only (spec §7.2). CONSUMED since R4-G4 §9.2 by
+     * `toGrants` in pc.proficiency-grants.ts, which spreads it onto
+     * `ProficiencyGrant` for every bucket; the tools display is the one reader
+     * today, and it reads this rather than re-deriving it from the raw effects.
+     */
+    expertise?: boolean;
+}
+export type EffectProficiencyGrants = Record<"skills" | "tools" | "languages" | "saves" | "armor" | "weapons", EffectProficiencyGrant[]>;
+/** Every proficiency an effect grants, tagged with the FeatureSource it came from.
+ *
+ *  Deliberately NOT deduped: composeGrantEntries collects distinct SOURCES per
+ *  value, so collapsing on value alone here would silently drop the second
+ *  granting entity and blank half the provenance.
+ *
+ *  `skills` and `saves` are collected because classifyProficiencyEffect's bucket
+ *  union has SIX members and this function indexes the record by it · drop either
+ *  key and `out[c.bucket].push(...)` is a type error, and a hand-built record
+ *  missing one crashes on the first such effect. They have NO display consumer:
+ *  effect-granted skills already reach the sheet via recalc's skill union and
+ *  saves via its save set, and the Proficiencies panel has only four rows. No
+ *  test asserts either bucket, and `toGrants` in pc.proficiency-grants.ts reads
+ *  only the other four. That is deliberate, not an oversight.
+ *
+ *  Reads the same three rules as the fold, and NOTHING else: foldsNow decides
+ *  what is active, selfEffectsOf decides whose numbers an effect changes and
+ *  classifyProficiencyEffect decides what a proficiency effect means (spec fence
+ *  F3), so the display can never disagree with the engine.
+ *
+ *  Reads only effects that fold on self (`selfEffectsOf`), the same predicate as
+ *  the fold, so a non-self proficiency is neither granted nor displayed. */
+export declare function collectProficiencyEffectGrants(features: ResolvedFeature[], activeBuffs: Set<string>): EffectProficiencyGrants;

package/dist/pc/pc.feature-effects.js

@@ -1,10 +1,26 @@
 import {
+  assembleEffectFeatures,
+  classifyProficiencyEffect,
+  collectProficiencyEffectGrants,
   computeFeatureEffects,
-  emptyFeatureEffectTotals
-} from "../chunk-AIRFC5NQ.js";
-import "../chunk-LV4SNWZQ.js";
-import "../chunk-WP2CX2JO.js";
+  emptyFeatureEffectTotals,
+  foldsNow,
+  foldsOnSelf,
+  selfEffectsOf
+} from "../chunk-JJ46T5XX.js";
+import "../chunk-TOM66P2P.js";
+import "../chunk-KU3YLF6D.js";
+import "../chunk-RLGQ5PZZ.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-6X4KUDMU.js";
+import "../chunk-WELIKLZF.js";
 export {
+  assembleEffectFeatures,
+  classifyProficiencyEffect,
+  collectProficiencyEffectGrants,
   computeFeatureEffects,
-  emptyFeatureEffectTotals
+  emptyFeatureEffectTotals,
+  foldsNow,
+  foldsOnSelf,
+  selfEffectsOf
 };

package/dist/pc/pc.parser.js

@@ -1,7 +1,7 @@
 import {
   characterSchema
-} from "../chunk-A4WENOUQ.js";
-import "../chunk-TZK36BU7.js";
+} from "../chunk-I2NDWFDD.js";
+import "../chunk-S7REMWW4.js";
 
 // src/pc/pc.parser.ts
 import * as yaml from "js-yaml";

package/dist/pc/pc.pools.d.ts

@@ -1,12 +1,20 @@
 import type { RegisteredEntity } from "@archivist-gg/core";
-import type { ResolvedCharacter, ResolvedClass, ResolvedPool } from "./pc.types.js";
+import type { ResolvedCharacter, ResolvedClass, ResolvedPool, ResolvedPoolEntry } from "./pc.types.js";
 import type { SelectionPool } from "@archivist-gg/dnd5e/types/selection-pool";
 import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
+import type { ResourceIndex } from "./pc.resources.js";
 /** Structural subset of EntityRegistry used here (lets tests pass a fake). */
 export interface PoolRegistry {
     search(query: string, entityType: string, limit: number): RegisteredEntity[];
     getByTypeAndSlug(entityType: string, slug: string): RegisteredEntity | undefined;
 }
 export declare function levelPrereqMax(d: OptionalFeatureEntity): number;
-export declare function resolvePool(rc: ResolvedClass, classIndex: number, pool: SelectionPool, registry: PoolRegistry): ResolvedPool;
-export declare function resolveAllPools(resolved: ResolvedCharacter, registry: PoolRegistry): ResolvedPool[];
+export declare function resolvePool(rc: ResolvedClass, classIndex: number, pool: SelectionPool, registry: PoolRegistry, index: ResourceIndex): ResolvedPool;
+export declare function resolveAllPools(resolved: ResolvedCharacter, registry: PoolRegistry, index: ResourceIndex): ResolvedPool[];
+/** The stored picks that survived resolution but are NOT in the collapsed `available` list, compared by FULL
+ *  slug: exactly the rule the plugin's `strandedSelections` used before T3 retires it (R4-G5 §3.2.3). Because
+ *  §9.2.3's resolution rewrites a collapsed twin to its survivor, only a GENUINE prerequisite-failing pick (the
+ *  one resolved by step 3 from the full scan) can land here, and it keeps its entity so the builder strip and the
+ *  sheet can both dress it "prerequisite unmet". A granted feature is already excluded from `selected`, so a
+ *  grant never appears here. Pure over the resolved pool: it reads nothing the resolver did not compute. */
+export declare function strandedPicks(pool: ResolvedPool): ResolvedPoolEntry[];

package/dist/pc/pc.pools.js

@@ -1,20 +1,16 @@
 import {
   levelPrereqMax,
   resolveAllPools,
-  resolvePool
-} from "../chunk-5MZSB6OM.js";
-import "../chunk-BH6AMZVY.js";
-import "../chunk-M2EMFD6S.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-JEYQU3JT.js";
-import "../chunk-N6N74K6X.js";
-import "../chunk-4LZJXJJS.js";
-import "../chunk-LV4SNWZQ.js";
-import "../chunk-VTTA2ALZ.js";
-import "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+  resolvePool,
+  strandedPicks
+} from "../chunk-O4SRD3J5.js";
+import "../chunk-PP2UHLBA.js";
+import "../chunk-IUAAXXNO.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-6X4KUDMU.js";
 export {
   levelPrereqMax,
   resolveAllPools,
-  resolvePool
+  resolvePool,
+  strandedPicks
 };

package/dist/pc/pc.proficiencies.d.ts

@@ -1,8 +1,64 @@
 import type { ResolvedCharacter } from "./pc.types.js";
+import { type ProficiencyEntry, type ProficiencyGrant } from "./pc.proficiency-grants.js";
+/** Re-exported for the plugin: both types are DECLARED in the leaf so that
+ *  pc.decision-engine can reference them without importing this module, which
+ *  would close a cycle (spec §4.3). */
+export type { ProficiencyEntry, ProficiencyOrigin } from "./pc.proficiency-grants.js";
+/** Every bucket carries provenance (spec §7.1). `languages`/`tools` ARE
+ *  {@link computeEffectiveProficiencies}' output, unmodified · `armor`/`weapons`
+ *  are composed below from the raw grant walk, because they have no vocabulary
+ *  constant to canonicalize against (spec §3.3's second rule) · and for `weapons`
+ *  that grant walk is followed by the chosen `select-entity{weapon}` picks
+ *  (R4-G3b §7 F5), which land with origin `pick`. */
 export interface ProficiencyAggregate {
-    armor: string[];
-    weapons: string[];
-    tools: string[];
-    languages: string[];
+    armor: ProficiencyEntry[];
+    weapons: ProficiencyEntry[];
+    tools: ProficiencyEntry[];
+    languages: ProficiencyEntry[];
 }
+/** Normalized intermediate of every proficiency/language source the DISPLAY path
+ *  reads, in one place. Among the ENTITY branches only the class one is a live
+ *  proficiency source today (race/bg/feat `.proficiencies` object fields do not
+ *  exist on those entities); race languages, bg tool/lang, and feat grants read
+ *  their real fields, and the four `effect*` buckets carry what a feature's
+ *  `kind: "proficiency"` effects grant · that is the live path a 2014 race trait
+ *  actually uses (R4-P3c). Chosen picks come from the single decision walk in
+ *  pc.decision-engine so display can never diverge from the persisted picks.
+ *
+ *  Every grant bucket carries `{value, source}` rather than a bare value: the
+ *  walk holds the granting entity and the aggregate needs it to fill
+ *  `ProficiencyEntry.sources` for armor and weapons (spec §7.1). The
+ *  language/tool grant buckets are still surfaced here for completeness, but
+ *  the aggregate no longer reads them · languages and tools come from
+ *  computeEffectiveProficiencies, which does its own grant walk so that
+ *  suppressions and manual adds can never be skipped by a second composer.
+ *
+ *  These names are RE-DECLARED by hand rather than inherited: this interface
+ *  does not `extends ProficiencyGrants`, so a bucket added to the grant walk
+ *  stays invisible here until it is added here too. `collectProficiencySources`
+ *  spreads the grants object, so an undeclared bucket still flows at RUNTIME ·
+ *  the compiler is the only thing that notices, and only where the field is
+ *  read. Nothing iterates these objects with Object.keys/values/entries, so a
+ *  declaration gap is inert rather than corrupting; it is still a gap. */
+export interface ProficiencySources {
+    classArmor: ProficiencyGrant[];
+    classWeaponFixed: ProficiencyGrant[];
+    classWeaponCategories: ProficiencyGrant[];
+    classToolFixed: ProficiencyGrant[];
+    raceLangFixed: ProficiencyGrant[];
+    bgToolFixed: ProficiencyGrant[];
+    bgLangFixed: ProficiencyGrant[];
+    featArmor: ProficiencyGrant[];
+    featWeapons: ProficiencyGrant[];
+    featTools: ProficiencyGrant[];
+    featLanguages: ProficiencyGrant[];
+    effectArmor: ProficiencyGrant[];
+    effectWeapons: ProficiencyGrant[];
+    effectTools: ProficiencyGrant[];
+    effectLanguages: ProficiencyGrant[];
+    chosenLanguages: string[];
+    chosenTools: string[];
+    chosenWeapons: string[];
+}
+export declare function collectProficiencySources(resolved: ResolvedCharacter): ProficiencySources;
 export declare function aggregateProficiencies(resolved: ResolvedCharacter): ProficiencyAggregate;