@archivist-gg/dnd5e 0.3.17 → 0.3.24

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

@@ -1,27 +1 @@
-import {
-  qualifiedGrantCovers
-} from "../chunk-3LWMFYKS.js";
-import "../chunk-YDGMBMYI.js";
-import {
-  normKey
-} from "../chunk-RLGQ5PZZ.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;