@archivist-gg/dnd5e 0.3.0 → 0.3.4

package/dist/pc/pc.proficiencies.js

@@ -1,47 +1,99 @@
+import {
+  collectChosenProficiencies,
+  collectProficiencyGrants,
+  computeEffectiveProficiencies
+} from "../chunk-XQCSGNXE.js";
+import "../chunk-UXPGW4TI.js";
+import "../chunk-DPUJDOKV.js";
+import "../chunk-O4SRD3J5.js";
+import "../chunk-PP2UHLBA.js";
+import "../chunk-IUAAXXNO.js";
+import "../chunk-YHYTW5QA.js";
+import "../chunk-MI7P3NX3.js";
+import "../chunk-PVCEA4HZ.js";
+import "../chunk-UBBKSYBY.js";
+import "../chunk-JJ46T5XX.js";
+import "../chunk-TOM66P2P.js";
+import "../chunk-KU3YLF6D.js";
+import {
+  proficiencyLabel,
+  toProfSlug
+} from "../chunk-RLGQ5PZZ.js";
+import "../chunk-LVQLWRCU.js";
+import "../chunk-WXWPK3LI.js";
+import "../chunk-6X4KUDMU.js";
+import "../chunk-YBLDE5CG.js";
+import "../chunk-EVMUJYUD.js";
+import "../chunk-VTTA2ALZ.js";
+import "../chunk-OZP6JFGT.js";
+import "../chunk-VQAXTIBW.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) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-  const armor = /* @__PURE__ */ new Set();
-  const weapons = /* @__PURE__ */ new Set();
-  const tools = /* @__PURE__ */ new Set();
-  const languages = /* @__PURE__ */ new Set();
-  for (const c of resolved.classes) {
-    const prof = (_a = c.entity) == null ? void 0 : _a.proficiencies;
-    if (!prof) continue;
-    for (const a of (_b = prof.armor) != null ? _b : []) armor.add(prettyName(a));
-    if ((_c = prof.weapons) == null ? void 0 : _c.fixed) for (const w of prof.weapons.fixed) weapons.add(prettyName(w));
-    if ((_d = prof.weapons) == null ? void 0 : _d.categories) for (const w of prof.weapons.categories) weapons.add(prettyName(w));
-    if ((_e = prof.tools) == null ? void 0 : _e.fixed) for (const t of prof.tools.fixed) tools.add(prettyName(t));
-  }
-  const raceLangs = (_f = resolved.race) == null ? void 0 : _f.languages;
-  if (raceLangs == null ? void 0 : raceLangs.fixed) for (const l of raceLangs.fixed) languages.add(prettyName(l));
-  const bg = resolved.background;
-  if (bg) {
-    for (const entry of (_g = bg.tool_proficiencies) != null ? _g : []) {
-      if (entry.kind === "fixed") for (const t of entry.items) tools.add(prettyName(t));
-    }
-    for (const entry of (_h = bg.language_proficiencies) != null ? _h : []) {
-      if (entry.kind === "fixed") for (const l of entry.languages) languages.add(prettyName(l));
+  const src = collectProficiencySources(resolved);
+  const effective = computeEffectiveProficiencies(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: composeGrantEntries([src.classArmor, src.featArmor, src.effectArmor]),
+    weapons: composeGrantEntries([src.classWeaponFixed, src.classWeaponCategories, src.featWeapons, src.effectWeapons], src.chosenWeapons),
+    tools: effective.tools,
+    languages: effective.languages
+  };
+}
+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 f of resolved.feats) {
-    const grants = f.proficiencies;
-    if (!grants) continue;
-    for (const a of (_i = grants.armor) != null ? _i : []) armor.add(prettyName(a));
-    for (const w of (_j = grants.weapons) != null ? _j : []) weapons.add(prettyName(w));
-    for (const t of (_k = grants.tools) != null ? _k : []) tools.add(prettyName(t));
-    for (const l of (_l = grants.languages) != null ? _l : []) languages.add(prettyName(l));
+  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 {
-    armor: [...armor].sort(),
-    weapons: [...weapons].sort(),
-    tools: [...tools].sort(),
-    languages: [...languages].sort()
-  };
+  return [...byKey.values()].sort((a, b) => a.label < b.label ? -1 : a.label > b.label ? 1 : 0);
 }
 function prettyName(slug) {
-  return slug.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  return proficiencyLabel(slug);
 }
 export {
-  aggregateProficiencies
+  aggregateProficiencies,
+  collectProficiencySources
 };

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

@@ -0,0 +1,58 @@
+import type { ResolvedCharacter } 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;
+    expertise?: boolean;
+}
+export interface ProficiencyGrants {
+    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[];
+}
+/** 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 function collectProficiencyGrants(resolved: ResolvedCharacter): ProficiencyGrants;

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

@@ -0,0 +1,29 @@
+/** 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;

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

@@ -0,0 +1,12 @@
+import {
+  humanizeProficiency,
+  normKey,
+  proficiencyLabel,
+  toProfSlug
+} from "../chunk-RLGQ5PZZ.js";
+export {
+  humanizeProficiency,
+  normKey,
+  proficiencyLabel,
+  toProfSlug
+};

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

@@ -6,6 +6,19 @@ 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,6 +1,10 @@
+import {
+  normKey
+} from "../chunk-RLGQ5PZZ.js";
+
 // src/pc/pc.proficiency-query.ts
 function isProficientWithWeapon(weapon, profs) {
-  if (profs.weapons.specific.includes(weapon.slug)) return true;
+  if (profs.weapons.specific.some((e) => e === weapon.slug || normKey(e) === normKey(weapon.name))) return true;
   const baseCategory = weapon.category.split("-")[0];
   return profs.weapons.categories.includes(baseCategory);
 }

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

@@ -2,6 +2,8 @@ import type { Ability } from "@archivist-gg/dnd5e";
 import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
 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 { ACTerm, DerivedStats, ProficiencySet, ResolvedCharacter, ResolvedClass, CharacterOverrides } from "./pc.types.js";
 /**
  * PHB "fixed average" value per hit die (per level beyond first). Called
@@ -28,18 +30,26 @@ export declare function flattenRaceAsi(race: RaceEntity | null): Partial<Record<
  * `abilityBonusBreakdown`'s `class` bucket so the two reads can never drift.
  *
  * Disjoint from chosen-feat ability-points (`choices[lvl]["feat:<id>"]`) and from
- * origin ability-points — no source double-counts.
+ * origin ability-points · no source double-counts.
+ *
+ * Since R4-P4 Decision B an `asi` that SHARES a level with a string `feat` key is
+ * discarded as an orphan rather than folded: that level took the feat branch, and
+ * the `asi` beside it is residue the picker never cleared on a branch switch.
+ * Folding both paid the same slot twice (Volker.md drew FOUR points from one L4).
  */
 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);
+ *  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): Record<Ability, {
+export declare function abilityBonusBreakdown(resolved: ResolvedCharacter, featureEffects?: FeatureEffectTotals): Record<Ability, {
     species: number;
     background: number;
     class: number;
@@ -60,21 +70,41 @@ export declare function hpLevelCount(classes: ResolvedClass[]): number;
  */
 export declare function multiclassMaxHP(classes: ResolvedClass[], conMod: number): number;
 /**
- * Default AC = 10 + DEX mod. If any class's features include an
- * "Unarmored Defense"–style feature with a structured flag, applies the
- * variant (Monk: +WIS; Barbarian: +CON). Falls back to feature-name
- * regex matching with a warning pushed onto `warnings`.
+ * 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 unarmoredAC(resolved: ResolvedCharacter, mods: Record<Ability, number>, warnings: string[]): number;
 /**
- * Same logic as `unarmoredAC` but also returns a structured breakdown of the
- * contributing terms (Base 10, DEX, optional class unarmored defense ability).
- * Used by recalc to assemble a richer acBreakdown when no armor is equipped.
+ * 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[]): {
+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). */
@@ -83,14 +113,38 @@ 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 epic Boons),
- * the picker persists the allocation under the namespaced key
+ * `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 THREE of them, not
+ * the two the R4-P4 spec §2.3 and task brief enumerate: this function
+ * (`block.feat`, below), `collectFeatPicks` (pc.resolver.ts) and
+ * `PCResolver.resolve`'s feat-to-spell application pass, the two
+ * `collectFeatGrantedSpells` calls (pc.resolver.ts), the one that
+ * makes a SPELL-granting boon work. 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 literal
+ * `.asi`, while `resolvePool` (pc.pools.ts) and `resolveChosenInline`
+ * (pc.resolver.ts) read by a DYNAMIC pool/choice id. As of R4-P4 Decision B
+ * `collectClassAsiBranch` also tests `block.feat`, but only to DETECT the feat
+ * branch, not to consume the pick. pc.decision-engine.ts is NOT a fourth:
+ * it reads generically by `choice.id`, which is exactly why re-keying works at
+ * all. 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.
  */
@@ -99,7 +153,8 @@ export declare function collectClassFeatAbilityPoints(resolved: ResolvedCharacte
  * 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.
+ * 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): {