@archivist-gg/dnd5e 0.3.17 → 0.3.24

package/dist/pc/pc.resolver.d.ts

@@ -10,28 +10,6 @@ export interface ResolveResult {
     warnings: string[];
 }
 export declare function stripSlug(ref: string | null): string | null;
-/**
- * Resolve a background's `origin_feat` wikilink into a real FeatEntity + a display
- * name, using ONLY the EntityRegistry (no DOM). Lifted from the builder's
- * background-step so the resolver pipeline and the builder share ONE resolution
- * (R2-m7, [[always-retire-shims-edit-all]]). Handles both path-style refs
- * ("[[SRD 2024/Feats/Alert]]") and bare-slug refs ("[[my-feat]]"), plus the 2024
- * parenthetical-variant refs ("[[SRD 2024/Feats/Magic Initiate (Cleric)]]") that
- * resolve to the BASE feat ("magic-initiate") while keeping the full variant
- * string as the display name. Returns null when the ref is empty or resolves to no
- * feat (an unresolvable ref folds nothing into the pipeline).
- *
- * R4-G4 §8: this is a SEVEN-TIER cascade, first hit wins, and the granting
- * BACKGROUND's slug arrives as `ownerSlug` so the compendium-scoped tiers can read
- * its prefix. It replaces the old two-tier "exact slug, else FIRST tail match"
- * lookup, whose two defects were measured on the shipped corpora: a tail match on a
- * DIFFERENT real feat pre-empted the parenthetical strip (PHB 2024
- * "Magic Initiate; Cleric", tail `magic-initiate-cleric`, beat SRD 2024
- * "Magic Initiate" for every 2024 Acolyte / Sage, order-independently), and where
- * several same-NAMED feats exist the registry order decided which one won
- * (`EntityRegistry.search` sorts by lowercased name, so equal names fall through to
- * insertion order).
- */
 export declare function resolveOriginFeat(entities: EntityRegistry, originFeatRef: string | null | undefined, ownerSlug?: string | null): {
     feat: FeatEntity;
     display: string;
@@ -39,107 +17,25 @@ export declare function resolveOriginFeat(entities: EntityRegistry, originFeatRe
 export declare class PCResolver {
     private readonly entities;
     constructor(entities: EntityRegistry);
-    /** Exposed so recalc() can apply equipment bonuses (Pass A / Pass B). */
     get registry(): EntityRegistry;
     resolve(character: Character): ResolveResult;
 }
-/**
- * 2024 Weapon Mastery: unions the persisted `weapon-mastery` picks across every
- * class/level `ClassEntry.choices[level]["weapon-mastery"]`. Returns both the
- * ORIGINAL full picked slugs (`full` — used for exact-match display-name lookup)
- * and their BARE-normalized form (`bare` — e.g. "srd-2024_greatsword" →
- * "greatsword"), each de-duplicated in first-seen order. Bare-authored picks
- * normalize to themselves. Non-string / non-array picks are ignored.
- */
 export declare function collectChosenWeaponMasteries(character: Character): {
     bare: string[];
     full: string[];
 };
-/**
- * R4-G7 T8 RIDER-23 · every `choices[<level>].feat` pick with the slot it was taken at: the index of its class entry and
- * the level key as a number (`null` when the key is not an integer). De-duplicated by slug in first-seen order (class
- * entries in order, level keys ascending as `Object.entries` yields integer keys), so a feat picked twice keeps its FIRST
- * slot. Slugs are bare (no `[[ ]]`). The resolver's one walk of class.choices for `feat` entries: the slug-only wrapper that
- * mapped it had no production caller after RIDER-23 and was retired in wave D fix round 1.
- */
 export declare function collectFeatPicks(character: Character): {
     slug: string;
     classIndex: number;
     level: number | null;
 }[];
-/**
- * Feat→spell application (3d). Walks a feat's OWN `choices` to find its spell
- * picks and turns each into a ResolvedSpell. A feat's spells sit behind a
- * `spell-list` select-inline whose CHOSEN branch nests `select-entity{spell}`
- * picks; the chosen spellcasting ability comes from the feat's
- * `spellcasting-ability` select-inline. `read(childId)` yields the persisted pick
- * for a child choice id (origin feat: `origin_choices["background:feat:<id>"]`;
- * class-slot feat: `choices[lvl]["feat:<id>"]`). Unresolvable spell slugs warn and
- * are skipped, mirroring the known-spell loop. classSlug stays null: a feat spell
- * is not owned by a class for DC/ability; the carried `ability` drives its casting.
- */
 export declare function collectFeatGrantedSpells(feat: FeatEntity, read: (childId: string) => ChoiceValue | undefined, entities: EntityRegistry, warnings: string[]): ResolvedSpell[];
-/**
- * Item→spell application (P4-T3). Walks the character's equipment for entries whose
- * resolved item is a spell scroll (carries the T1 `scroll_level` marker) AND names a
- * chosen spell via `overrides.spell`, turning each into a
- * ResolvedSpell{ source:"item", classSlug:null, prepared:true, alwaysPrepared:true }.
- * The casting `ability` is the character's OWN spellcasting ability when they have
- * one (`ownAbility`, the first caster class's ability), else the per-instance
- * `overrides.spell_ability`, else undefined (a no-ability scroll is left ability-less:
- * the plugin surfaces it without a DC; an ability is NEVER fabricated here).
- * `entryIndex` records the originating equipment index so the segmented dedupe keeps
- * two scrolls of one spell (and a scroll of a class-known spell) as their own rows.
- * Unresolvable spell slugs warn and are skipped, mirroring the known-spell + feat loops.
- * In-memory only: no KnownSpellObject{source:"item"} is injected (its strict schema
- * omits `ability`).
- */
 export declare function collectItemGrantedSpells(character: Character, ownAbility: Ability | null, entities: EntityRegistry, warnings: string[]): ResolvedSpell[];
-/**
- * Collapses duplicate resolved spells (3d Minor #2 carry-forward + P4-T3 segmented
- * dedupe). A spell can be emitted more than once: it may be BOTH in
- * `character.spells.known` AND a feat pick, or a feat may be taken as both origin +
- * class-slot, or an `additional_spells` grant (R4-G3b §5) may name a spell the character
- * already knows. A class-sourced copy owns a real DC via its `classSlug`, so it always
- * wins over a feat copy of the same slug; otherwise the FIRST-SEEN copy holds the slot.
- * Which copy holds the slot is not the whole answer, though: `alwaysPrepared` is OR-merged
- * onto the winner in BOTH collision orders (R4-G3b §5.2.8), so a hand-added Bless that a
- * subclass later grants stops counting against the prepared limit instead of counting
- * forever. `persisted` crosses the merge as well, in both orders (fix 1b): removability is
- * MEMBERSHIP in `character.spells.known`, so the flag belongs to the SLUG, not to whichever
- * copy won. Nothing else crosses: the winner keeps its own `source` / `classSlug` /
- * `entryIndex`. Insertion order
- * is preserved (a later class copy replaces an earlier feat copy in place), so the
- * Spells section never renders duplicate rows while a legitimately class-known copy is
- * never lost. Item-source spells carry INSTANCE identity: they key by
- * `slug + "#" + entryIndex`, so two scrolls of one spell stay two rows and a scroll of
- * a class-known spell keeps its OWN item row, never collapsing into / being collapsed
- * by a class/feat copy. The class/feat slug-only merge is unchanged.
- */
 export declare function dedupeResolvedSpells(spells: ResolvedSpell[]): ResolvedSpell[];
-/** Selected select-entity values (optional-features) and selected inline
- *  options carrying effects[] become synthesized resolved features (SP2 Plan 3 §9).
- *  The actions/resources engines consume these synthesized features, and the
- *  effects-application pass (pc.feature-effects.ts → recalc) consumes their
- *  effects[]. Scope: class/subclass level choices, plus race/background origin
- *  choices (origin_choices keys are namespaced "race:<id>" / "background:<id>"). */
 export declare function collectChosenGrantedFeatures(character: Character, classes: ResolvedClass[], registry: {
     getByTypeAndSlug(type: string, slug: string): {
         data: Record<string, unknown>;
     } | undefined;
 }, race?: RaceEntity | null, background?: BackgroundEntity | null, memberSites?: PoolMemberSite[]): ResolvedFeature[];
-/**
- * `character.additional_features` → ResolvedFeatures (the DM-grant path).
- *
- * Deliberately NOT routed through `walkChoiceGrants`: that converter emits
- * `{id, name, description, effects, action}` and DROPS `uses`, which is correct there because a pool
- * pick's tracker is built separately by `resolveResourceIndex`'s pools loop. A campaign grant has no
- * pool, so nothing would ever build its tracker — the feature would render as a card with no counter.
- * This walk therefore converts `uses` into the feature's own `resources[]`, which
- * `resolveFeatureResources` already indexes, and the grant gets a tracker with no pool involved.
- *
- * A prose `uses.max` (the 4 shipped carriers that have one) yields no resource rather than a broken
- * tracker, matching the pools loop's rule; the feature still renders.
- */
 export declare function collectAdditionalFeatures(character: Character, entities: EntityRegistry, warnings: string[]): ResolvedFeature[];
 export declare function collectResolvedFeatures(race: RaceEntity | null, classes: ResolvedClass[], background: BackgroundEntity | null, feats: FeatEntity[], featVia?: ReadonlyMap<string, FeatVia>): ResolvedFeature[];

package/dist/pc/pc.resolver.js

@@ -1,59 +1 @@
-import {
-  PCResolver,
-  collectAdditionalFeatures,
-  collectChosenGrantedFeatures,
-  collectChosenWeaponMasteries,
-  collectFeatGrantedSpells,
-  collectFeatPicks,
-  collectItemGrantedSpells,
-  collectResolvedFeatures,
-  dedupeResolvedSpells,
-  resolveOriginFeat,
-  stripSlug
-} from "../chunk-ONTGZR5T.js";
-import "../chunk-2LULMQTF.js";
-import "../chunk-H5PTKYXL.js";
-import "../chunk-TULQ4FFX.js";
-import "../chunk-TOM66P2P.js";
-import "../chunk-KU3YLF6D.js";
-import "../chunk-HTYMW5CH.js";
-import "../chunk-KSTV7J2U.js";
-import "../chunk-DPUJDOKV.js";
-import "../chunk-LBEXLN6I.js";
-import "../chunk-RLGQ5PZZ.js";
-import "../chunk-3VZZDKRA.js";
-import "../chunk-W6GC6OKK.js";
-import "../chunk-B3DP42OM.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-YHYTW5QA.js";
-import "../chunk-VRV3NNTA.js";
-import "../chunk-PVCEA4HZ.js";
-import "../chunk-IHE6KVC3.js";
-import "../chunk-LHZXYFBU.js";
-import "../chunk-YBLDE5CG.js";
-import "../chunk-ZUQW5VBZ.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-CM5CWO4K.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";
-export {
-  PCResolver,
-  collectAdditionalFeatures,
-  collectChosenGrantedFeatures,
-  collectChosenWeaponMasteries,
-  collectFeatGrantedSpells,
-  collectFeatPicks,
-  collectItemGrantedSpells,
-  collectResolvedFeatures,
-  dedupeResolvedSpells,
-  resolveOriginFeat,
-  stripSlug
-};
+import{PCResolver,collectAdditionalFeatures,collectChosenGrantedFeatures,collectChosenWeaponMasteries,collectFeatGrantedSpells,collectFeatPicks,collectItemGrantedSpells,collectResolvedFeatures,dedupeResolvedSpells,resolveOriginFeat,stripSlug}from"../chunk-IGVRLGLM.js";import"../chunk-2EOGK6R6.js";import"../chunk-RQZCGXUZ.js";import"../chunk-PQAVMK3T.js";import"../chunk-HCK6IUB3.js";import"../chunk-FOLHTMSC.js";import"../chunk-4JEF3CET.js";import"../chunk-VTQ4RWEG.js";import"../chunk-QBA757AU.js";import"../chunk-A7H6LX47.js";import"../chunk-UBUKCRZ3.js";import"../chunk-PZUPZBTN.js";import"../chunk-NI364WV7.js";import"../chunk-QVWT67WA.js";import"../chunk-DY6FVAGA.js";import"../chunk-CMIEZQL4.js";import"../chunk-BGX36NPE.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-6IC53O3Q.js";import"../chunk-I26FHSI6.js";export{PCResolver,collectAdditionalFeatures,collectChosenGrantedFeatures,collectChosenWeaponMasteries,collectFeatGrantedSpells,collectFeatPicks,collectItemGrantedSpells,collectResolvedFeatures,dedupeResolvedSpells,resolveOriginFeat,stripSlug};

package/dist/pc/pc.resource-seed.d.ts

@@ -1,11 +1,3 @@
 import type { ResolvedCharacter, DerivedStats, FeatureSource } from "./pc.types.js";
 import type { FormulaBindings } from "@archivist-gg/dnd5e/dnd/resource-formula";
-/** Build the DSL bindings for a resource granted via `source`. `class_level`
- *  is the character's level in the granting class; for a `subclass` source it
- *  is the level in the class that OWNS that subclass, and it falls back to the
- *  total level for race/background/feat sources (or when the class isn't found).
- *  Also binds `columns` · the numeric values of that (sub)class's table row at
- *  `class_level` (empty when there is no table/row), backing the `column('Name')`
- *  accessor in the DSL. Ability mods come from the final (post-bonus) derived mods.
- *  `class_level` comes from `resourceLevelFor` (pc.resources.ts), the one derivation. */
 export declare function resourceBindings(resolved: ResolvedCharacter, derived: DerivedStats, source: FeatureSource): FormulaBindings;

package/dist/pc/pc.resource-seed.js

@@ -1,42 +1 @@
-import {
-  resourceLevelFor
-} from "../chunk-KSTV7J2U.js";
-import "../chunk-DPUJDOKV.js";
-import {
-  numericColumnsAt
-} from "../chunk-IUAAXXNO.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-EVMUJYUD.js";
-import "../chunk-VTTA2ALZ.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-
-// src/pc/pc.resource-seed.ts
-function resourceBindings(resolved, derived, source) {
-  var _a, _b, _c, _d;
-  const classLevel = resourceLevelFor(source, resolved);
-  let table;
-  if (source.kind === "class") table = (_b = (_a = resolved.classes.find((c) => {
-    var _a2;
-    return ((_a2 = c.entity) == null ? void 0 : _a2.slug) === source.slug;
-  })) == null ? void 0 : _a.entity) == null ? void 0 : _b.table;
-  else if (source.kind === "subclass") table = (_d = (_c = resolved.classes.find((c) => {
-    var _a2;
-    return ((_a2 = c.subclass) == null ? void 0 : _a2.slug) === source.slug;
-  })) == null ? void 0 : _c.subclass) == null ? void 0 : _d.table;
-  return {
-    level: resolved.totalLevel,
-    class_level: classLevel,
-    prof: derived.proficiencyBonus,
-    str_mod: derived.mods.str,
-    dex_mod: derived.mods.dex,
-    con_mod: derived.mods.con,
-    int_mod: derived.mods.int,
-    wis_mod: derived.mods.wis,
-    cha_mod: derived.mods.cha,
-    columns: numericColumnsAt(table, classLevel)
-  };
-}
-export {
-  resourceBindings
-};
+import{resourceLevelFor}from"../chunk-PZUPZBTN.js";import"../chunk-NI364WV7.js";import"../chunk-DY6FVAGA.js";import"../chunk-CMIEZQL4.js";import{numericColumnsAt}from"../chunk-BGX36NPE.js";import"../chunk-O776WL7O.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-4IAMSRHD.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-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";function resourceBindings(resolved,derived,source){var _a,_b,_c,_d;const classLevel=resourceLevelFor(source,resolved);let table;if(source.kind==="class")table=(_b=(_a=resolved.classes.find(c=>{var _a2;return((_a2=c.entity)==null?void 0:_a2.slug)===source.slug}))==null?void 0:_a.entity)==null?void 0:_b.table;else if(source.kind==="subclass")table=(_d=(_c=resolved.classes.find(c=>{var _a2;return((_a2=c.subclass)==null?void 0:_a2.slug)===source.slug}))==null?void 0:_c.subclass)==null?void 0:_d.table;return{level:resolved.totalLevel,class_level:classLevel,prof:derived.proficiencyBonus,str_mod:derived.mods.str,dex_mod:derived.mods.dex,con_mod:derived.mods.con,int_mod:derived.mods.int,wis_mod:derived.mods.wis,cha_mod:derived.mods.cha,columns:numericColumnsAt(table,classLevel)}}export{resourceBindings};

package/dist/pc/pc.resources.d.ts

@@ -1,27 +1,5 @@
 import type { FeatureSource, ResolvedCharacter, ResolvedFeature, ResolvedPool, ResolvedPoolEntry, DerivedStats } from "./pc.types.js";
 import type { ResourceRecovery, ResourceDie, ResourceScaleStep, ResetTrigger } from "../types/resource.js";
-/** The level a resource granted via `source` scales against (R4-G4 §6.2.4, ONE derivation): the
- *  character's level in the granting class; for a `subclass` source the level in the class that OWNS
- *  that subclass; the total level for race / background / feat sources, or when the class is not found.
- *  `resourceBindings` (pc.resource-seed.ts) binds `class_level` through this function, and R4-G4 T3
- *  (§6.2.4 / §6.2.5) routed the plugin's three former TOTAL-level reads through it too, so
- *  `class_level`, `scales_at` and the die can no longer disagree. T4 added a fourth read, the die label
- *  of `renderSpendControl`, and T5 a fifth, the die label of the pool tab's dice head.
- *
- *  The units, re-measured 2026-09-06 on the SHIPPED plugin tree with
- *  `grep -rn "resourceLevelFor(" packages/obsidian/src`, which returns FOUR lines: FIVE READS reach
- *  this function through FOUR call EXPRESSIONS living in FOUR functions across FOUR files. The
- *  expressions are the plugin SEED (`seedFeatureUses` in `pc.resource-seed.ts`, for the level it hands
- *  `resolveMaxCountAt`), the module-private `resourceLevel(id, ctx)` helper of
- *  `components/actions/feature-rows.ts` (which resolves the owner from `resolved.resources` and falls
- *  back to the total level when there is none), `renderSpendControl`
- *  (`components/actions/spend-control.ts`) and `renderPoolHead` (`components/pool-tab.ts`). The count
- *  of READS is one higher than the count of expressions because `resourceLevel` serves TWO
- *  `resolveScalingDie` die labels, one in `renderCardResource` and one in `formatFeatureAttackNote`:
- *  so THREE of the five reads call this function directly (the seed, the spend control, the pool head)
- *  and TWO reach it through `resourceLevel`. Each render-time reader passes the owner its index entry
- *  already carries, so a die label and the tracker beside it read the same level. So a
- *  Barbarian 5 / Fighter 5 reads the level-5 Rage count, not the level-10 one. */
 export declare function resourceLevelFor(source: FeatureSource, resolved: ResolvedCharacter): number;
 export type ResourceOwner = {
     kind: "feature";
@@ -50,49 +28,13 @@ export interface ResolvedResource {
     scalesAt?: ResourceScaleStep[];
     recovery?: ResolvedRecovery[];
     owner: ResourceOwner;
-    /** Which control draws this resource — the declaring note's `rendering_hint`, carried verbatim and
-     *  never interpreted here. The renderer owns the hint → component table; the engine only delivers the
-     *  string, so adding a component is a change in ONE table and adding a resource is no code at all. */
     renderingHint?: string;
-    /** `band` = also drawn in the header strip. Absent = the Resources tab alone. */
     surface?: "band" | "tab";
+    equivalentIds?: readonly string[];
 }
 export type ResourceIndex = ReadonlyMap<string, ResolvedResource>;
-/** KIND first (the schema key; absent = `uses`, UR2), FLAVOUR second (`action` / `reset`): a
- *  `spell-slots` entry is ALWAYS manual (the slot picker), whatever its action / reset say; a `uses`
- *  entry is a rest restore when its `reset` is `short-rest` or `long-rest` AND it carries no `action`,
- *  else manual (R4-G4 §7.2, invariant 12). The other rest-shaped triggers (`either`, `dawn`, `dusk`)
- *  read manual here: §7.1's partition of the 33 shipped entries has no carrier among them, and §15
- *  keeps the reset VOCABULARY of the rest arm deferred to G8.
- *
- *  BOTH arms it routes are LANDED as of R4-G4 T7, and its CALLERS are counted here rather than its
- *  grep hits, because a docblock that names the function moves its own grep count. Measured
- *  2026-09-05 on both trees: dnd5e has exactly ONE caller, `toResolvedResource` below, which STAMPS
- *  the kind and the flavour onto every entry of every indexed resource, so `pushPartialRecoveries`
- *  (pc.rest.ts) reads that stamp to emit the rest arm's partial category and never calls this
- *  function itself; the plugin has exactly ONE, `renderRecoveryAction` (blocks/feature-card.ts),
- *  which calls it directly and picks the card's arm from the KIND, then the FLAVOUR
- *  (`grep -rn "resolveRecovery" packages/obsidian/src` returns THREE lines there: the import, that
- *  call and one docblock mention). */
 export declare function resolveRecovery(entry: ResourceRecovery): ResolvedRecovery;
-/** ONE walk over `features[].feature.resources` (the walk `findResourceById` used to do per call). The
- *  owner is the DECLARING feature; a duplicate id keeps the FIRST declaration (seeding keeps its own
- *  max-of-maxes merge). Reads the features array ONLY. `name` falls back to the owning feature's name,
- *  the rule `findResourceById` carried, for resources synthesised from older fixtures that omit it. */
 export declare function resolveFeatureResources(features: ReadonlyArray<ResolvedFeature>): ResourceIndex;
-/** The resource id a pool pick's own tracker uses (spec §5.2): a repeatable copy keys by its pick key, every other pick by its slug.
- *  A repeatable (non-item-bound) copy keys its tracker by its KEY, so two copies are two trackers; `param != null` keeps a cast
- *  fixture without the field on the slug. ONE rule for both sides: dnd5e seeds by it and the plugin's pick tracker reads by it
- *  (ART-c1, R-3 c). */
 export declare function pickResourceId(entry: Pick<ResolvedPoolEntry, "slug" | "key" | "param">): string;
-/** The full index: the feature resources (`resolveFeatureResources`) plus the pool picks' own
- *  `uses` (R4-G4 §12, LANDED at T7b). A pure function of `resolved.features` and `resolved.pools`,
- *  each guarded `?? []` because the cast fixtures behind the rest suites in both repos carry
- *  neither; `computeRestPlan` derives it per call and never reads `resolved.resources`, the
- *  resolver stores it on `resolved.resources` after pools resolve, and the resolver suite pins the
- *  stored index equal to a fresh derivation. */
 export declare function resolveResourceIndex(resolved: ResolvedCharacter): ResourceIndex;
-/** 8 + prof + mod(ability) when the pool's owning class's subclass carries `spellcasting.ability` AND
- *  `resolveSpellcasting` returns null for that class (no caster profile: the Four Elements shape); null
- *  otherwise. Reads `subclass.spellcasting.ability` and NEVER `dc_formula` (R4-G4 §11.2). */
 export declare function poolSaveDC(resolved: ResolvedCharacter, derived: DerivedStats, pool: ResolvedPool): number | null;

package/dist/pc/pc.resources.js

@@ -1,23 +1 @@
-import {
-  pickResourceId,
-  poolSaveDC,
-  resolveFeatureResources,
-  resolveRecovery,
-  resolveResourceIndex,
-  resourceLevelFor
-} from "../chunk-KSTV7J2U.js";
-import "../chunk-DPUJDOKV.js";
-import "../chunk-IUAAXXNO.js";
-import "../chunk-LVQLWRCU.js";
-import "../chunk-EVMUJYUD.js";
-import "../chunk-VTTA2ALZ.js";
-import "../chunk-PDJSUH24.js";
-import "../chunk-WELIKLZF.js";
-export {
-  pickResourceId,
-  poolSaveDC,
-  resolveFeatureResources,
-  resolveRecovery,
-  resolveResourceIndex,
-  resourceLevelFor
-};
+import{pickResourceId,poolSaveDC,resolveFeatureResources,resolveRecovery,resolveResourceIndex,resourceLevelFor}from"../chunk-PZUPZBTN.js";import"../chunk-NI364WV7.js";import"../chunk-DY6FVAGA.js";import"../chunk-CMIEZQL4.js";import"../chunk-BGX36NPE.js";import"../chunk-O776WL7O.js";import"../chunk-DVUXUIPV.js";import"../chunk-YGH7S5ZF.js";import"../chunk-4IAMSRHD.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-BREHZNTL.js";import"../chunk-7FPQJDFD.js";import"../chunk-EVT7MGAC.js";export{pickResourceId,poolSaveDC,resolveFeatureResources,resolveRecovery,resolveResourceIndex,resourceLevelFor};

package/dist/pc/pc.rest.d.ts

@@ -2,23 +2,12 @@ import type { EntityRegistry } from "@archivist-gg/core";
 import type { ResetTrigger } from "../types/resource.js";
 import type { Character, DerivedStats, EquipmentEntryState, ResolvedCharacter } from "./pc.types.js";
 export type RestType = "short" | "long";
-export type RestCategoryId = "hp-to-max" | "hd-regain" | "spell-slots" | "pact-slots" | "exhaustion" | "hp-modifier-reset" | `feature:${string}` | `item:${number}`
-/** R4-G5 §4.4.2: END an active buff whose carrier declares a structured `duration`. The tail is the STORED
- *  `state.active_buffs` key (a class feature's `id` or a pool entry's resolved `slug`). Emitted by
- *  `pushBuffEnds` below and read by the plugin's `applyRestResets`, whose `buff:` arm removes that key
- *  from `state.active_buffs`. That arm is the plugin half of R4-G5 Task 6: this type is the task's
- *  dnd5e hard edge and is committed first. */
- | `buff:${string}`;
+export type RestCategoryId = "hp-to-max" | "hd-regain" | "spell-slots" | "pact-slots" | "exhaustion" | "hp-modifier-reset" | `feature:${string}` | `item:${number}` | `buff:${string}`;
 export interface RestCategory {
     id: RestCategoryId;
     label: string;
     preview: string;
-    /** R4-G4 §7.2.2: a PARTIAL restore from a `recovery[]` entry of kind `uses` and flavour `rest` (N uses, or "all"),
-     *  emitted only when the resource's own `reset` does not already fire at this rest. Absent = the own reset (to 0). */
     restore?: number | "all";
-    /** ART-c1 Task 9c (S-4, controller ruling 10): an `item:` category's recharge, the amount its rule restores ("1d6+1",
-     *  "3", "all") and the charges before the rest. The sheet's rest dialog rolls a DICE amount once when it opens and the
-     *  rest applies `min(max, current + n)`; this plan stays pure and rolls nothing. */
     recharge?: {
         amount: string;
         current: number;
@@ -32,21 +21,13 @@ export interface RestPlan {
         die: string;
         remaining: number;
     }>;
-    /** Internal: per-die HD-regain target captured at plan time so apply is idempotent. */
     hdRegainDist?: Array<{
         die: string;
         targetUsed: number;
     }>;
 }
-/** The persisted item-charge recovery vocabulary (`pc.schema.ts` `equipmentEntryStateSchema.recovery.reset`). */
 export type ItemRecoveryReset = NonNullable<EquipmentEntryState["recovery"]>["reset"];
-/** Every reset a counter can carry: a feature resource's `ResetTrigger` or an item's recovery reset. The two
- *  vocabularies share only `dawn`, which means the same thing in both. */
 export type AnyReset = ResetTrigger | ItemRecoveryReset;
-/** The earliest rest that restores `reset` in full, or `null` when none does. A value outside both vocabularies (raw
- *  note data reaches here unvalidated) is restored by no rest: an OWN-property lookup, so a prototype key such as
- *  `constructor` is not a reset either. */
 export declare function earliestRestoringRest(reset: AnyReset): RestType | null;
-/** Whether a rest of `type` restores `reset` in full: the earliest rest that restores it is no longer than `type`. */
 export declare function restRestores(type: RestType, reset: AnyReset): boolean;
 export declare function computeRestPlan(character: Character, resolved: ResolvedCharacter, derived: DerivedStats, registry: EntityRegistry | null, type: RestType): RestPlan;