@archivist-gg/dnd5e 0.3.19 → 0.3.26

package/dist/pc/pc.proficiencies.js

@@ -1,156 +1 @@
-import {
-  qualifiedGrantCovers
-} from "../chunk-3LWMFYKS.js";
-import "../chunk-YDGMBMYI.js";
-import {
-  collectChosenProficiencies,
-  collectProficiencyGrants,
-  computeEffectiveProficiencies,
-  computeSuppressedProficiencies
-} from "../chunk-EJD47JHL.js";
-import "../chunk-2LULMQTF.js";
-import "../chunk-QA3YCOML.js";
-import "../chunk-64VNLMSG.js";
-import "../chunk-TOM66P2P.js";
-import "../chunk-KU3YLF6D.js";
-import {
-  normKey,
-  proficiencyKey,
-  proficiencyLabel,
-  toProfSlug,
-  weaponProfKey
-} from "../chunk-5JXFJ5AU.js";
-import "../chunk-RD2MID3M.js";
-import "../chunk-LICYHPI3.js";
-import "../chunk-PVCEA4HZ.js";
-import "../chunk-KSTV7J2U.js";
-import "../chunk-DPUJDOKV.js";
-import "../chunk-LBEXLN6I.js";
-import "../chunk-NXUY5XQN.js";
-import "../chunk-W6GC6OKK.js";
-import "../chunk-B3DP42OM.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-YHYTW5QA.js";
-import "../chunk-ZUQW5VBZ.js";
-import "../chunk-IHE6KVC3.js";
-import "../chunk-LHZXYFBU.js";
-import "../chunk-YBLDE5CG.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-CM5CWO4K.js";
-import "../chunk-4J6DS3EJ.js";
-import "../chunk-EVMUJYUD.js";
-import "../chunk-VTTA2ALZ.js";
-import "../chunk-ZCTUYGNV.js";
-import "../chunk-7Q2VPKCD.js";
-import "../chunk-ZDAEGJH4.js";
-import "../chunk-3TM34RSJ.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-import "../chunk-4U55VNC7.js";
-import "../chunk-UA5KS2PL.js";
-
-// src/pc/pc.proficiencies.ts
-function collectProficiencySources(resolved) {
-  const g = collectProficiencyGrants(resolved);
-  const chosen = collectChosenProficiencies(resolved);
-  return {
-    ...g,
-    chosenLanguages: chosen.languages,
-    chosenTools: chosen.tools,
-    chosenWeapons: chosen.weapons
-  };
-}
-function aggregateProficiencies(resolved) {
-  const { armor, weapons } = composeArmorWeapons(resolved);
-  const effective = computeEffectiveProficiencies(resolved);
-  return { armor: armor.kept, weapons: weapons.kept, tools: effective.tools, languages: effective.languages };
-}
-function proficiencyOverview(resolved, kind) {
-  if (kind === "armor" || kind === "weapons") {
-    const c = composeArmorWeapons(resolved)[kind];
-    return { effective: c.kept, removed: c.suppressed };
-  }
-  return { effective: computeEffectiveProficiencies(resolved)[kind], removed: computeSuppressedProficiencies(resolved)[kind] };
-}
-function weaponCoveredBy(effective, weapon) {
-  const cat = typeof weapon.category === "string" ? weapon.category : "";
-  const base = cat.split("-")[0];
-  return effective.find((e) => {
-    const key = weaponProfKey(e.value);
-    if ((key === "simple" || key === "martial") && key === base) return true;
-    if (cat && key === normKey(cat)) return true;
-    return qualifiedGrantCovers(e.value, weapon);
-  });
-}
-function composeArmorWeapons(resolved) {
-  const src = collectProficiencySources(resolved);
-  return {
-    // Walk order defines `sources` order (spec §4.1): class before feats, and
-    // for weapons the class `fixed` names before the class categories, matching
-    // the insertion order of the bucket this replaced, exactly.
-    //
-    // Effect buckets go LAST: first-seen wins the dedupe key, so an existing
-    // class or feat grant keeps its shipped spelling and label and the effect
-    // only appends its source name. Reordering these silently relabels rows.
-    //
-    // The chosen weapon PICKS are the second argument, so they are seeded after
-    // every grant bucket: a weapon both granted and picked stays ONE row that
-    // keeps origin `grant` and its granting source(s) (R4-G3b §7 F5 · the same
-    // grants-then-picks order computeEffectiveProficiencies uses for the
-    // language and tool buckets). Armor passes none.
-    armor: applyKindOverrides(resolved, "armor", composeGrantEntries([src.classArmor, src.featArmor, src.effectArmor])),
-    weapons: applyKindOverrides(
-      resolved,
-      "weapons",
-      composeGrantEntries([src.classWeaponFixed, src.classWeaponCategories, src.featWeapons, src.effectWeapons], src.chosenWeapons)
-    )
-  };
-}
-function applyKindOverrides(resolved, kind, entries) {
-  var _a, _b, _c, _d;
-  const ov = (_b = (_a = resolved.definition) == null ? void 0 : _a.overrides) == null ? void 0 : _b[kind];
-  const key = (v) => proficiencyKey(kind, v);
-  const all = [...entries];
-  for (const v of (_c = ov == null ? void 0 : ov.add) != null ? _c : []) {
-    if (!all.some((e) => key(e.value) === key(v))) all.push({ value: v, label: prettyName(v), sources: [], origin: "manual" });
-  }
-  const removes = new Set(((_d = ov == null ? void 0 : ov.remove) != null ? _d : []).map(key));
-  const byLabel = (a, b) => a.label < b.label ? -1 : a.label > b.label ? 1 : 0;
-  return {
-    kept: all.filter((e) => !removes.has(key(e.value))).sort(byLabel),
-    suppressed: all.filter((e) => removes.has(key(e.value))).sort(byLabel)
-  };
-}
-function composeGrantEntries(buckets, picks = []) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const bucket of buckets) {
-    for (const g of bucket) {
-      const key = toProfSlug(g.value);
-      const existing = byKey.get(key);
-      if (!existing) {
-        byKey.set(key, {
-          value: g.value,
-          label: prettyName(g.value),
-          sources: [g.source],
-          origin: "grant"
-        });
-        continue;
-      }
-      if (!existing.sources.includes(g.source)) existing.sources.push(g.source);
-    }
-  }
-  for (const v of picks) {
-    const k = toProfSlug(v);
-    if (!byKey.has(k)) byKey.set(k, { value: v, label: prettyName(v), sources: [], origin: "pick" });
-  }
-  return [...byKey.values()].sort((a, b) => a.label < b.label ? -1 : a.label > b.label ? 1 : 0);
-}
-function prettyName(slug) {
-  return proficiencyLabel(slug);
-}
-export {
-  aggregateProficiencies,
-  collectProficiencySources,
-  proficiencyOverview,
-  weaponCoveredBy
-};
+import{qualifiedGrantCovers}from"../chunk-T55DELVL.js";import"../chunk-SEOASDO4.js";import{collectChosenProficiencies,collectProficiencyGrants,computeEffectiveProficiencies,computeSuppressedProficiencies}from"../chunk-J5GL6FLP.js";import"../chunk-2EOGK6R6.js";import"../chunk-RQZCGXUZ.js";import"../chunk-GD7WRCNH.js";import"../chunk-FOLHTMSC.js";import"../chunk-4JEF3CET.js";import{normKey,proficiencyKey,proficiencyLabel,toProfSlug,weaponProfKey}from"../chunk-VTQ4RWEG.js";import"../chunk-J3RP5C7L.js";import"../chunk-WAUNLUFQ.js";import"../chunk-CEHL7PPC.js";import"../chunk-UBUKCRZ3.js";import"../chunk-KEXSF3CH.js";import"../chunk-PFQPP77Q.js";import"../chunk-QVWT67WA.js";import"../chunk-PKIMOVQG.js";import"../chunk-CMIEZQL4.js";import"../chunk-CSTAQQGX.js";import"../chunk-O776WL7O.js";import"../chunk-3LWOVRLA.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-4IAMSRHD.js";import"../chunk-3QQOATV3.js";import"../chunk-DZITM5AG.js";import"../chunk-PZ4L2EEG.js";import"../chunk-QMEKQTUT.js";import"../chunk-EAARMPCW.js";import"../chunk-CAPYNIGK.js";import"../chunk-63YJPWTM.js";import"../chunk-4KVVAENP.js";import"../chunk-7EL3GWWJ.js";import"../chunk-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";import"../chunk-S5UCI27C.js";import"../chunk-ZVL5FXXO.js";import"../chunk-I26FHSI6.js";function collectProficiencySources(resolved){const g=collectProficiencyGrants(resolved);const chosen=collectChosenProficiencies(resolved);return{...g,chosenLanguages:chosen.languages,chosenTools:chosen.tools,chosenWeapons:chosen.weapons}}function aggregateProficiencies(resolved){const{armor,weapons}=composeArmorWeapons(resolved);const effective=computeEffectiveProficiencies(resolved);return{armor:armor.kept,weapons:weapons.kept,tools:effective.tools,languages:effective.languages}}function proficiencyOverview(resolved,kind){if(kind==="armor"||kind==="weapons"){const c=composeArmorWeapons(resolved)[kind];return{effective:c.kept,removed:c.suppressed}}return{effective:computeEffectiveProficiencies(resolved)[kind],removed:computeSuppressedProficiencies(resolved)[kind]}}function weaponCoveredBy(effective,weapon){const cat=typeof weapon.category==="string"?weapon.category:"";const base=cat.split("-")[0];return effective.find(e=>{const key=weaponProfKey(e.value);if((key==="simple"||key==="martial")&&key===base)return true;if(cat&&key===normKey(cat))return true;return qualifiedGrantCovers(e.value,weapon)})}function composeArmorWeapons(resolved){const src=collectProficiencySources(resolved);return{armor:applyKindOverrides(resolved,"armor",composeGrantEntries([src.classArmor,src.featArmor,src.effectArmor])),weapons:applyKindOverrides(resolved,"weapons",composeGrantEntries([src.classWeaponFixed,src.classWeaponCategories,src.featWeapons,src.effectWeapons],src.chosenWeapons))}}function applyKindOverrides(resolved,kind,entries){var _a,_b,_c,_d;const ov=(_b=(_a=resolved.definition)==null?void 0:_a.overrides)==null?void 0:_b[kind];const key=v=>proficiencyKey(kind,v);const all=[...entries];for(const v of(_c=ov==null?void 0:ov.add)!=null?_c:[]){if(!all.some(e=>key(e.value)===key(v)))all.push({value:v,label:prettyName(v),sources:[],origin:"manual"})}const removes=new Set(((_d=ov==null?void 0:ov.remove)!=null?_d:[]).map(key));const byLabel=(a,b)=>a.label<b.label?-1:a.label>b.label?1:0;return{kept:all.filter(e=>!removes.has(key(e.value))).sort(byLabel),suppressed:all.filter(e=>removes.has(key(e.value))).sort(byLabel)}}function composeGrantEntries(buckets,picks=[]){const byKey=new Map;for(const bucket of buckets){for(const g of bucket){const key=toProfSlug(g.value);const existing=byKey.get(key);if(!existing){byKey.set(key,{value:g.value,label:prettyName(g.value),sources:[g.source],origin:"grant"});continue}if(!existing.sources.includes(g.source))existing.sources.push(g.source)}}for(const v of picks){const k=toProfSlug(v);if(!byKey.has(k))byKey.set(k,{value:v,label:prettyName(v),sources:[],origin:"pick"})}return[...byKey.values()].sort((a,b)=>a.label<b.label?-1:a.label>b.label?1:0)}function prettyName(slug){return proficiencyLabel(slug)}export{aggregateProficiencies,collectProficiencySources,proficiencyOverview,weaponCoveredBy};

package/dist/pc/pc.proficiency-grants.d.ts

@@ -1,25 +1,12 @@
-import type { ResolvedCharacter } from "./pc.types.js";
+import type { ResolvedCharacter, FeatureSource } from "./pc.types.js";
 export type ProficiencyOrigin = "grant" | "pick" | "manual" | "custom";
 export interface ProficiencyEntry {
-    /** Canonical slug when the value lands on the domain vocabulary, else the raw string. Spec §3.3. */
     value: string;
-    /** Display form. Spec §3.3's first code block (languages/tools) or second (armor/weapons). */
     label: string;
-    /** EVERY granting entity's display name, in walk order: class, race,
-     *  background, feats, then feature EFFECTS last (R4-P3c · both composers order
-     *  the effect bucket last so a first-seen entity grant keeps its own label). */
     sources: string[];
     origin: ProficiencyOrigin;
-    /** R4-G4 §9: tool expertise rides the grant channel (the ONE channel the panel
-     *  and the modal read); the manual tri `overrides.tools.proficiency` (spec §9.3,
-     *  Tier B) is its second writer, applied in `computeEffectiveProficiencies`.
-     *  ABSENT rather than `false` on a plain entry. */
     expertise?: boolean;
 }
-/** One granted value plus the display name of the entity that granted it.
- *  `expertise` is present (and `true`) only when the granting effect authored it
- *  (R4-G4 §9.2), so a plain grant keeps the exact two-key shape every pre-phase
- *  reader was written against. */
 export interface ProficiencyGrant {
     value: string;
     source: string;
@@ -42,17 +29,6 @@ export interface ProficiencyGrants {
     effectTools: ProficiencyGrant[];
     effectLanguages: ProficiencyGrant[];
 }
-/** Every FIXED proficiency/language a character's entities grant, each paired
- *  with the display name of the entity that granted it. Walk order is
- *  class → race → background → feats, and that order defines `sources` ordering
- *  downstream (spec §4.1).
- *
- *  This module is a LEAF on purpose: it must import nothing from the decision
- *  engine module, so that the engine can import it without a cycle. NOT enforced
- *  by any test or lint rule · a previous comment claimed a grep guard that has
- *  never existed. It is a convention, and this phase adds a feature-effects
- *  import that is cycle-free by inspection, not by tooling.
- *  The walk returns raw `{value, source}` buckets and nothing else · no
- *  humanizing, no sorting, no dedupe. Label composition stays with the
- *  module-private `prettyName` in `pc.proficiencies.ts` (spec §7.1). */
+export declare const UNKNOWN_GRANT_SOURCE = "Unknown";
+export declare function grantSourceName(resolved: ResolvedCharacter, kind: FeatureSource["kind"], slug: string): string;
 export declare function collectProficiencyGrants(resolved: ResolvedCharacter): ProficiencyGrants;

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

@@ -1,43 +1,8 @@
-/** Normalized token-set key for matching class weapon DISPLAY names ("hand crossbows")
- *  against weapon-entity names ("Crossbow, hand"). EXACT equality on the key; verified
- *  collision-free across the SRD weapon set. Strip-"s" singularizer does not handle
- *  irregular plurals; no SRD weapon triggers that. */
 export declare const normKey: (s: string) => string;
-/** Canonical proficiency slug: lowercase, curly apostrophe folded to ASCII,
- *  whitespace collapsed to hyphens. Universally idempotent (one pass removes all
- *  whitespace) and the IDENTITY over ALL_SKILL_SLUGS / ALL_LANGUAGES / ALL_TOOLS,
- *  which are already canonical. The fold list is deliberately U+2019-only: no SRD
- *  tool name contains any other non-ASCII character. */
 export declare const toProfSlug: (s: string) => string;
-/** Apostrophe-safe title case: capitalizes only at start-of-string or after
- *  whitespace, never after `'` (so "smith's-tools" reads "Smith's Tools", not
- *  "Smith'S Tools"). Intentionally the same body as the plugin's humanizeSlug.
- *  The divergence that matters is one level up: prettyName is
- *  humanizeProficiency(toProfSlug(x)), and the U+2019 fold lives in toProfSlug.
- *  Do NOT "simplify" prettyName to a bare humanizer call · that reintroduces
- *  the duplicate-row defect (one proficiency rendering as two rows). */
 export declare const humanizeProficiency: (s: string) => string;
-/** The display label for one AUTHORED proficiency value that no vocabulary canonicalizes (R4-G7 T8 RIDER-14).
- *  The rule reads the value's SHAPE, never a word list:
- *  - a value with no whitespace is a slug ("thieves'-tools", "heavy"), and a phrase with no uppercase letter
- *    ("hand crossbows") carries no authored casing and shares its slug's `toProfSlug` key: both keep today's
- *    `humanizeProficiency(toProfSlug(raw))` (the fold and the apostrophe rule of the composition above);
- *  - a phrase that carries authored uppercase is PROSE ("Martial weapons that have the Light property",
- *    "... the 2H or H property") and prints as authored: U+2019 folded to ASCII, whitespace trimmed and collapsed,
- *    the first character capitalised, every other letter untouched. Title-casing it word by word lower-cased
- *    `2H` to `2h` and read "That Have The Light Property". */
 export declare const proficiencyLabel: (raw: string) => string;
-/** The four proficiency kinds the sheet lists and the D4 pickers edit, one picker per kind. */
 export type ProficiencyKind = "armor" | "weapons" | "tools" | "languages";
-/** D4 A: the key of a WEAPON proficiency value, so every spelling of one grant folds onto one key. A category reads
- *  `simple` or `martial` whatever its spelling ("martial", "Martial weapons"); anything else is keyed by
- *  {@link normKey}, the rule the live weapon gate (`isWeaponSlugProficient`) matches a weapon's name by, so
- *  "longswords", "Longsword" and "longsword" meet, and "hand-crossbow" meets "Hand Crossbows" and "Crossbow, hand". */
 export declare const weaponProfKey: (raw: string) => string;
-/** D4 A: the key of an ARMOR proficiency value: `light`, `medium`, `heavy`, `shield` whatever the spelling
- *  ("Heavy armor", "shields"). */
 export declare const armorProfKey: (raw: string) => string;
-/** D4 A: the one comparison key per kind, used by the engine's override readers and the plugin's writers alike, so a
- *  value the writer stores and the value the reader suppresses always meet. Languages and tools keep `toProfSlug`,
- *  unchanged. */
 export declare const proficiencyKey: (kind: ProficiencyKind, raw: string) => string;

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

@@ -1,18 +1 @@
-import {
-  armorProfKey,
-  humanizeProficiency,
-  normKey,
-  proficiencyKey,
-  proficiencyLabel,
-  toProfSlug,
-  weaponProfKey
-} from "../chunk-5JXFJ5AU.js";
-export {
-  armorProfKey,
-  humanizeProficiency,
-  normKey,
-  proficiencyKey,
-  proficiencyLabel,
-  toProfSlug,
-  weaponProfKey
-};
+import{armorProfKey,humanizeProficiency,normKey,proficiencyKey,proficiencyLabel,toProfSlug,weaponProfKey}from"../chunk-VTQ4RWEG.js";export{armorProfKey,humanizeProficiency,normKey,proficiencyKey,proficiencyLabel,toProfSlug,weaponProfKey};

package/dist/pc/pc.proficiency-query.d.ts

@@ -6,19 +6,6 @@ interface ProficienciesForQuery {
     weapons: ProficiencySet;
     tools: ProficiencySet;
 }
-/** NOT the live weapon gate · that is `isWeaponSlugProficient` in
- *  `pc.equipment.ts`, reached from `computeAttacks`. The two are near-twins,
- *  NOT aliases: that function's docblock records where their matching diverges,
- *  so anything asserting runtime behaviour must call it, not this one. */
 export declare function isProficientWithWeapon(weapon: WeaponEntity, profs: ProficienciesForQuery): boolean;
-/** No live armor gate exists at all · nothing in the product gates on armor
- *  proficiency today (`computeAppliedBonuses` takes `_profs` and ignores it),
- *  so this has no production caller either. Do NOT read that as "the
- *  `.specific` branch is dead": `normalizeArmorProf` in `pc.recalc.ts` routes
- *  an authored `armor: { specific: [...] }` block straight into it. No SRD
- *  entity uses that object form for armor yet, but `weapons:` and `tools:`
- *  already do in the same `proficiencies:` block, so it is one plausible
- *  keystroke away · and the function is published API besides. Trimming that
- *  branch could silently regress either. */
 export declare function isProficientWithArmor(armor: ArmorEntity, profs: ProficienciesForQuery): boolean;
 export {};

package/dist/pc/pc.proficiency-query.js

@@ -1,27 +1 @@
-import {
-  qualifiedGrantCovers
-} from "../chunk-3LWMFYKS.js";
-import "../chunk-YDGMBMYI.js";
-import {
-  normKey
-} from "../chunk-5JXFJ5AU.js";
-import "../chunk-ZCTUYGNV.js";
-
-// src/pc/pc.proficiency-query.ts
-function isProficientWithWeapon(weapon, profs) {
-  if (profs.weapons.specific.some((e) => e === weapon.slug || normKey(e) === normKey(weapon.name))) return true;
-  if (profs.weapons.specific.some((e) => qualifiedGrantCovers(e, weapon))) return true;
-  const baseCategory = weapon.category.split("-")[0];
-  return profs.weapons.categories.includes(baseCategory);
-}
-function isProficientWithArmor(armor, profs) {
-  if (profs.armor.specific.includes(armor.slug)) return true;
-  if (profs.armor.categories.includes(armor.category)) return true;
-  if (armor.category === "light" && (profs.armor.categories.includes("medium") || profs.armor.categories.includes("heavy"))) return true;
-  if (armor.category === "medium" && profs.armor.categories.includes("heavy")) return true;
-  return false;
-}
-export {
-  isProficientWithArmor,
-  isProficientWithWeapon
-};
+import{qualifiedGrantCovers}from"../chunk-T55DELVL.js";import"../chunk-SEOASDO4.js";import{normKey}from"../chunk-VTQ4RWEG.js";import"../chunk-63YJPWTM.js";function isProficientWithWeapon(weapon,profs){if(profs.weapons.specific.some(e=>e===weapon.slug||normKey(e)===normKey(weapon.name)))return true;if(profs.weapons.specific.some(e=>qualifiedGrantCovers(e,weapon)))return true;const baseCategory=weapon.category.split("-")[0];return profs.weapons.categories.includes(baseCategory)}function isProficientWithArmor(armor,profs){if(profs.armor.specific.includes(armor.slug))return true;if(profs.armor.categories.includes(armor.category))return true;if(armor.category==="light"&&(profs.armor.categories.includes("medium")||profs.armor.categories.includes("heavy")))return true;if(armor.category==="medium"&&profs.armor.categories.includes("heavy"))return true;return false}export{isProficientWithArmor,isProficientWithWeapon};

package/dist/pc/pc.recalc.d.ts

@@ -4,161 +4,37 @@ import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
 import type { EntityRegistry } from "@archivist-gg/core";
 import { type UnarmedStrikeSpec } from "./pc.equipment.js";
 import { type FeatureEffectTotals } from "./pc.feature-effects.js";
+import type { WeaponScope } from "../types/feature-effect.js";
 import type { ACTerm, AttackRow, DamageRider, DerivedStats, ProficiencySet, ResolvedCharacter, ResolvedClass, CharacterOverrides } from "./pc.types.js";
-/**
- * PHB "fixed average" value per hit die (per level beyond first). Called
- * "average" in the PHB but actually ceil((die + 1) / 2); equivalent to
- * Math.floor(die / 2) + 1 for even dice.
- *
- * d6 → 4, d8 → 5, d10 → 6, d12 → 7.
- */
 export declare function phbAverageForDie(hitDieStr: string): number;
-/** Extracts the integer size from "d8" / "d10" / 8 / 10. */
 export declare function parseDieSize(die: string | number | undefined | null): number | null;
-/**
- * Flattens RaceEntity.ability_score_increases into a partial ability→bonus map.
- * Fixed increases contribute their amount directly. Choice increases are ignored
- * here — they're expected to come through class.choices with a specific ability
- * selected, which computeAbilityScores handles separately.
- */
 export declare function flattenRaceAsi(race: RaceEntity | null): Partial<Record<Ability, number>>;
-/**
- * Sums the LEGACY class-level ASI-BRANCH allocations (`choices[lvl].asi`) per ability across every class: the path of an
- * L4/L8-style "Ability Score Increase or Feat" decision saved on the plain +2 ASI branch rather than a feat. Shared by
- * `computeAbilityScores`' fold and `abilityBonusBreakdown`'s `class` bucket so the two reads can never drift.
- *
- * The level gate is the ONE predicate `legacyAsiBranch` (pc.asi-flatten.ts, H234 H4(2)), shared with the Builder's ledger
- * alias and write path: a level whose `feat` is a string took the feat branch, and its `asi` is an orphan discarded since
- * R4-P4 Decision B (Volker.md drew FOUR points from one L4 when both folded). Disjoint from chosen-feat ability-points
- * (`choices[lvl]["feat:<id>"]`, collectClassFeatAbilityPoints) and from origin ability-points: no source double-counts.
- */
 export declare function collectClassAsiBranch(resolved: ResolvedCharacter): Partial<Record<Ability, number>>;
-/** Per-ability bonus provenance for the builder's obelisk captions:
- *  species = fixed race ASI + subrace fixed ASI + race ability-points choices;
- *  background = background ability-points choices;
- *  class = legacy class ASI-BRANCH allocations (the L4 asi-or-feat → asi path),
- *          MINUS any `asi` sharing a level with a string `feat` key, which
- *          collectClassAsiBranch discards as branch-switch residue (R4-P4 Dec. B),
- *          + the flat capstone fold when the caller threads the effect totals (R4-G3b §4);
- *  feat = class chosen-feat ability-points (the L4 asi-or-feat → feat path) +
- *         flat feat ability_bonuses (e.g. Athlete +1 STR). All already fold into
- *         computeAbilityScores totals, so the caption must account for them or a
- *         tile reads higher than the named sources explain (smoke r1/r5c). */
 export declare function abilityBonusBreakdown(resolved: ResolvedCharacter, featureEffects?: FeatureEffectTotals): Record<Ability, {
     species: number;
     background: number;
     class: number;
     feat: number;
 }>;
-/** Dice-only portion of PC max HP: first VALID level anywhere = max(die),
- *  every later valid level = PHB average. Skip rule identical to hpLevelCount. */
+export declare function fixedFeatAbilityIncrease(f: FeatEntity): Partial<Record<Ability, number>>;
 export declare function hitDiceAverageSum(classes: ResolvedClass[]): number;
-/** Count of levels that contribute to HP (valid class entries only). */
 export declare function hpLevelCount(classes: ResolvedClass[]): number;
-/**
- * PC-oriented multiclass HP.
- * - First class's first level: max(hit_die) + conMod.
- * - Every subsequent level (in any class): phbAverageForDie(thatLevel'sClass) + conMod.
- * CON mod contributes once per total level.
- * Decomposed (P5 T2) into hitDiceAverageSum (dice-only) + hpLevelCount (level count),
- * so a later popup can render the two components separately.
- */
 export declare function multiclassMaxHP(classes: ResolvedClass[], conMod: number): number;
-/** Does a damage rider reach this attack row (ART-c1 Task 9b, controller ruling 8)? A rider with no `scope` reaches
- *  every row (today's reach); a scoped one reaches a row when ANY of its words matches it: `melee` / `ranged` the
- *  row's `weaponCategory`, `unarmed` the engine's Unarmed Strike row, `finesse` / `thrown` the row's properties. */
-export declare function riderReachesRow(rider: DamageRider, row: AttackRow): boolean;
-/**
- * The BEST APPLICABLE unarmoured formula (R4-G7 T6a, spec §4): the plain 10 + DEX mod, against every
- * `unarmored-ac` effect that folds right now (its `base ?? 10` plus the modifier of every ability its
- * OWN `abilities` list names), highest total winning. A class feature carrying an "Unarmored
- * Defense"-style structured flag, or only the feature NAME (matched SILENTLY since R4-G6b §5.7), is the
- * FALLBACK for a document that authors no effect at all (Monk: +WIS; Barbarian: +CON). `warnings` is
- * retained for the exported signature and is no longer written to by this function or by
- * `unarmoredACBreakdown`.
- */
+export declare function riderReachesRow(rider: DamageRider, row: AttackRow, opts?: ScopeOpts): boolean;
+export interface ScopeOpts {
+    pactPicked?: boolean;
+}
+export declare function scopeReachesRow(scope: readonly WeaponScope[] | undefined, row: AttackRow, opts?: ScopeOpts): boolean;
 export declare function unarmoredAC(resolved: ResolvedCharacter, mods: Record<Ability, number>, warnings: string[]): number;
-/**
- * Same rule as `unarmoredAC` but also returns the WINNING formula's structured terms (its base, then one
- * term per ability its `abilities` list names, in that list's order) and whether that formula admits a
- * shield. Used by recalc to assemble a richer acBreakdown when no armor is equipped.
- *
- * `shieldBonus` is the equipped shield's contribution, read for the COMPARISON only: it is NOT part of
- * the returned `total` or `terms`, because the shield is one of the additive terms recalc merges on the
- * unarmoured path, and `shieldAllowed` is what tells that caller to keep it. A shield counts on a
- * candidate only where its effect declares `allow_shield === true` (absent is NOT true: the SRD Monk
- * omits the key and RAW allows the Monk no shield), and always on the plain 10 + DEX candidate, which is
- * unarmoured-with-a-shield. Both fallback arms keep the shipped answer, shield included.
- */
 export declare function unarmoredACBreakdown(resolved: ResolvedCharacter, mods: Record<Ability, number>, warnings: string[], shieldBonus?: number): {
     total: number;
     terms: ACTerm[];
     shieldAllowed: boolean;
 };
-/** R4-G6b §5.4: the die and ability set for the always-present Unarmed Strike row. Authored `unarmed-strike` effects
- *  first (a `{ column }` die is read from the GRANTING class's table at that class's level); then the SILENT synthetic:
- *  a class-sourced feature whose id slug `unarmedDieColumnFor` knows (`martial-arts`) with NO authored effect, on a
- *  class whose table carries that column with a dice value, contributes that die with DEX. The SHAPE is
- *  `decision-recognizer.ts`'s (a table-driven synthetic mirroring an overlay entry, retired when the data is
- *  authored: the G7 booking gives `overlay.schema.ts`'s class arm `effects` + `.strict()` and authors both Monks);
- *  the PLACEMENT is here because the builder ledger never feeds `derived.attacks`. Merge: the die with the highest
- *  average wins; the abilities are the union. Nothing writes onto a registry object. */
 export declare function resolveUnarmedStrike(resolved: ResolvedCharacter): UnarmedStrikeSpec;
-/** Initiative = DEX mod + Alert (+5 in 2014). Extendable via feat flags. */
 export declare function initiativeBonus(dexMod: number, feats: FeatEntity[], edition: "2014" | "2024"): number;
-/** Speed = race.speed.walk + flat bonuses from feats (e.g., Mobile +10). */
 export declare function speedFromRace(resolved: ResolvedCharacter): number;
-/**
- * Folds class-level CHOSEN-FEAT ability-points into per-ability totals.
- *
- * When the L4-style "asi or feat" decision resolves to a feat that carries
- * `ability-points` choices (e.g. Ability Score Improvement), the picker
- * persists the allocation under the namespaced key
- * `choices[lvl]["feat:" + choice.id]` (the engine's `buildItem` surfaces those
- * children; see pc.decision-engine.ts). This is disjoint from both the legacy
- * asi-BRANCH key (`choices[lvl].asi`) and origin ability-points, so no source
- * double-counts. The chosen feat entity is resolved from `resolved.feats`
- * (already looked up by the resolver) — no registry needed here.
- *
- * The L19 Epic Boon folds through this SAME path, but only as of R4-P4's re-key
- * (live in the SRD data from that phase's regeneration). This docblock earlier
- * cited it as an existing example, which it was not. EVERY reader OF THE FEAT
- * PICK keys on the LITERAL string `feat`, and there are FOUR of them, not the two
- * the R4-P4 spec §2.3 and task brief enumerate: this function (`block.feat`,
- * below), `collectFeatPicks` (pc.resolver.ts), `PCResolver.resolve`'s
- * feat-to-spell application pass, the two `collectFeatGrantedSpells` calls
- * (pc.resolver.ts), the one that makes a SPELL-granting boon work, and
- * `visitProficiencyChoices`' arm (A) (pc.decision-engine.ts, R4-G3b §8), which
- * reads `block.feat` to walk the chosen feat's own proficiency choices. Note the
- * qualifier: this is NOT a claim that every reader of a saved class choice block
- * keys on `feat`. Others read the very same block by OTHER keys ·
- * `collectClassAsiBranch` (above) reads the legacy `.asi` through
- * `legacyAsiBranch` (pc.asi-flatten.ts), while `resolvePool` (pc.pools.ts) and
- * `resolveChosenInline` (pc.resolver.ts) read by a DYNAMIC pool/choice id.
- * `legacyAsiBranch` also tests `block.feat`, but only to DETECT the feat branch
- * (R4-P4 Decision B), not to consume the pick. pc.decision-engine.ts's LEDGER
- * (`buildItem`) is NOT a reader: it reads generically by `choice.id`, which is
- * exactly why re-keying works at all; since H234 its class walk also SYNTHESIZES
- * a `feat` answer, the read-only alias for a level saved in the older ASI shape
- * (`legacyAsiReader`), which consumes no persisted `feat` key. srd-2024.yaml
- * authored the boon's pick `id: epic-boon`, so an L19 selection persisted under
- * `choices[19]["epic-boon"]`, which no reader looks at: the boon resolved to no
- * feat, granted no spells, and contributed no ability points at all. Re-keying
- * the authored pick to `id: feat` is what makes it fold. No persisted GRANDCHILD
- * key moved with it · pc.decision-engine.ts builds `feat:<childId>` off a
- * hardcoded prefix, independent of the parent choice's own id.
- *
- * Clamps defensively (per-ability max_per, then stops at the points total in
- * ABILITY_KEYS order), mirroring collectChosenAbilityPoints.
- */
 export declare function collectClassFeatAbilityPoints(resolved: ResolvedCharacter): Partial<Record<Ability, number>>;
-/**
- * Combines racial ASI (from race.ability_score_increases), feat ASI,
- * class-choice ASI (from classes[i].choices[lvl].asi), chosen-feat ASI
- * (from classes[i].choices[lvl]["feat:<id>"]), and user overrides.
- * Overrides win; ASI sources sum unconditionally. The flat capstone fold is added
- * in recalc's bonus loop, not here (R4-G3b §4).
- */
 export declare function computeAbilityScores(resolved: ResolvedCharacter, overrides: CharacterOverrides): Record<Ability, number>;
 export declare function computeProficiencies(resolved: ResolvedCharacter): {
     armor: ProficiencySet;
@@ -167,4 +43,5 @@ export declare function computeProficiencies(resolved: ResolvedCharacter): {
     languages: string[];
     saves: Ability[];
 };
+export declare const HAND_SET_HALF_SOURCE = "Set by you";
 export declare function recalc(resolved: ResolvedCharacter, registry?: EntityRegistry): DerivedStats;