@archivist-gg/dnd5e 0.3.1 → 0.3.4

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

@@ -3,7 +3,7 @@ import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
 import type { BackgroundEntity } from "@archivist-gg/dnd5e/background/background.types";
 import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
 import type { Ability } from "@archivist-gg/dnd5e";
-import type { Character, ChoiceValue, ResolvedCharacter, ResolvedClass, ResolvedFeature, ResolvedSpell } from "./pc.types.js";
+import type { Character, ChoiceValue, ResolvedCharacter, ResolvedClass, ResolvedFeature, ResolvedSpell, FeatVia } from "./pc.types.js";
 export interface ResolveResult {
     character: ResolvedCharacter;
     warnings: string[];
@@ -19,8 +19,19 @@ export declare function stripSlug(ref: string | null): string | null;
  * 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): {
+export declare function resolveOriginFeat(entities: EntityRegistry, originFeatRef: string | null | undefined, ownerSlug?: string | null): {
     feat: FeatEntity;
     display: string;
 } | null;
@@ -44,10 +55,17 @@ export declare function collectChosenWeaponMasteries(character: Character): {
     full: string[];
 };
 /**
- * Walks class.choices for `feat` entries and adds background feat slugs.
- * Returns bare slugs (no `[[ ]]`).
+ * 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 collectFeatSlugs(character: Character): string[];
+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
@@ -80,8 +98,16 @@ export declare function collectItemGrantedSpells(character: Character, ownAbilit
  * 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. A class-sourced copy owns a real DC via its `classSlug`, so it always
- * wins over a feat copy of the same slug; otherwise first-seen wins. Insertion order
+ * 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
@@ -101,4 +127,4 @@ export declare function collectChosenGrantedFeatures(character: Character, class
         data: Record<string, unknown>;
     } | undefined;
 }, race?: RaceEntity | null, background?: BackgroundEntity | null): ResolvedFeature[];
-export declare function collectResolvedFeatures(race: RaceEntity | null, classes: ResolvedClass[], background: BackgroundEntity | null, feats: FeatEntity[]): 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

@@ -3,29 +3,44 @@ import {
   collectChosenGrantedFeatures,
   collectChosenWeaponMasteries,
   collectFeatGrantedSpells,
-  collectFeatSlugs,
+  collectFeatPicks,
   collectItemGrantedSpells,
   collectResolvedFeatures,
   dedupeResolvedSpells,
   resolveOriginFeat,
   stripSlug
-} from "../chunk-TNUFPIXI.js";
-import "../chunk-7TEK5KK7.js";
-import "../chunk-6IRYTM5V.js";
-import "../chunk-5XUXXAQJ.js";
-import "../chunk-JEYQU3JT.js";
-import "../chunk-N6N74K6X.js";
-import "../chunk-4LZJXJJS.js";
-import "../chunk-LV4SNWZQ.js";
+} 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 "../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-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.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";
 export {
   PCResolver,
   collectChosenGrantedFeatures,
   collectChosenWeaponMasteries,
   collectFeatGrantedSpells,
-  collectFeatSlugs,
+  collectFeatPicks,
   collectItemGrantedSpells,
   collectResolvedFeatures,
   dedupeResolvedSpells,

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

@@ -4,7 +4,8 @@ import type { FormulaBindings } from "@archivist-gg/dnd5e/dnd/resource-formula";
  *  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
+ *  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. */
+ *  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,27 +1,29 @@
+import {
+  resourceLevelFor
+} from "../chunk-UXPGW4TI.js";
+import "../chunk-DPUJDOKV.js";
 import {
   numericColumnsAt
-} from "../chunk-5XUXXAQJ.js";
+} 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;
-  let classLevel = resolved.totalLevel;
+  const classLevel = resourceLevelFor(source, resolved);
   let table;
-  if (source.kind === "class") {
-    const c = resolved.classes.find((c2) => {
-      var _a2;
-      return ((_a2 = c2.entity) == null ? void 0 : _a2.slug) === source.slug;
-    });
-    classLevel = (_a = c == null ? void 0 : c.level) != null ? _a : resolved.totalLevel;
-    table = (_b = c == null ? void 0 : c.entity) == null ? void 0 : _b.table;
-  } else if (source.kind === "subclass") {
-    const c = resolved.classes.find((c2) => {
-      var _a2;
-      return ((_a2 = c2.subclass) == null ? void 0 : _a2.slug) === source.slug;
-    });
-    classLevel = (_c = c == null ? void 0 : c.level) != null ? _c : resolved.totalLevel;
-    table = (_d = c == null ? void 0 : c.subclass) == null ? void 0 : _d.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,

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

@@ -0,0 +1,87 @@
+import type { FeatureSource, ResolvedCharacter, ResolvedFeature, ResolvedPool, 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";
+    featureId: string;
+    featureName: string;
+    source: FeatureSource;
+} | {
+    kind: "pool";
+    poolId: string;
+    poolLabel: string;
+    source: FeatureSource;
+};
+export type RecoveryKind = "uses" | "spell-slots";
+export type RecoveryFlavour = "rest" | "manual";
+export interface ResolvedRecovery {
+    entry: ResourceRecovery;
+    kind: RecoveryKind;
+    flavour: RecoveryFlavour;
+}
+export interface ResolvedResource {
+    id: string;
+    name: string;
+    reset: ResetTrigger;
+    maxFormula: string;
+    die?: ResourceDie;
+    scalesAt?: ResourceScaleStep[];
+    recovery?: ResolvedRecovery[];
+    owner: ResourceOwner;
+}
+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 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

@@ -0,0 +1,21 @@
+import {
+  poolSaveDC,
+  resolveFeatureResources,
+  resolveRecovery,
+  resolveResourceIndex,
+  resourceLevelFor
+} from "../chunk-UXPGW4TI.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 {
+  poolSaveDC,
+  resolveFeatureResources,
+  resolveRecovery,
+  resolveResourceIndex,
+  resourceLevelFor
+};

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

@@ -1,11 +1,20 @@
 import type { EntityRegistry } from "@archivist-gg/core";
 import type { Character, DerivedStats, 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}`;
+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 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";
 }
 export interface RestPlan {
     type: RestType;

package/dist/pc/pc.rest.js

@@ -1,3 +1,14 @@
+import {
+  resolveResourceIndex
+} from "../chunk-UXPGW4TI.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";
+
 // src/pc/pc.rest.ts
 function resolveItemName(entry, registry) {
   var _a;
@@ -6,19 +17,58 @@ function resolveItemName(entry, registry) {
   const slug = ref ? ref[1] : entry.item;
   return (_a = registry.getBySlug(slug)) == null ? void 0 : _a.name;
 }
-function findResourceById(resolved, id) {
-  var _a, _b, _c;
-  for (const rf of (_a = resolved.features) != null ? _a : []) {
-    for (const r of (_b = rf.feature.resources) != null ? _b : []) {
-      if (r.id === id) return { label: (_c = r.name) != null ? _c : rf.feature.name, reset: r.reset };
+var FIRES_AT = {
+  long: /* @__PURE__ */ new Set(["short-rest", "long-rest", "either", "dawn", "dusk"]),
+  short: /* @__PURE__ */ new Set(["short-rest", "either"])
+};
+function pushPartialRecoveries(cats, character, index, type) {
+  var _a, _b;
+  for (const [key, fu] of Object.entries((_a = character.state.feature_uses) != null ? _a : {})) {
+    if (fu.used <= 0) continue;
+    const res = index.get(key);
+    if (!((_b = res == null ? void 0 : res.recovery) == null ? void 0 : _b.length)) continue;
+    if (FIRES_AT[type].has(res.reset)) continue;
+    const entry = res.recovery.find((r) => r.kind === "uses" && r.flavour === "rest" && FIRES_AT[type].has(r.entry.reset));
+    if (!entry) continue;
+    const amount = entry.entry.amount;
+    const restore = amount === "all" ? "all" : typeof amount === "number" ? amount : Number(amount);
+    if (restore !== "all" && !Number.isFinite(restore)) continue;
+    const n = restore === "all" ? fu.used : Math.min(fu.used, restore);
+    cats.push({ id: `feature:${key}`, label: res.name, preview: `${n} of ${fu.used} used restored`, restore });
+  }
+}
+function pushBuffEnds(cats, character, resolved) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const structured = (d) => !!d && typeof d === "object";
+  for (const key of (_a = character.state.active_buffs) != null ? _a : []) {
+    let found = false;
+    let name = key;
+    for (const rf of (_b = resolved.features) != null ? _b : []) {
+      if (rf.feature.id === key && structured(rf.feature.duration)) {
+        found = true;
+        name = (_c = rf.feature.name) != null ? _c : key;
+        break;
+      }
+    }
+    if (!found) {
+      for (const pool of (_d = resolved.pools) != null ? _d : []) {
+        const entry = [...(_e = pool.selected) != null ? _e : [], ...(_f = pool.grants) != null ? _f : []].find((e) => e.slug === key);
+        if (entry && structured(entry.entity.duration)) {
+          found = true;
+          name = (_g = entry.entity.name) != null ? _g : key;
+          break;
+        }
+      }
     }
+    if (!found) continue;
+    cats.push({ id: `buff:${key}`, label: `End ${name}`, preview: "active \u2192 ended" });
   }
-  return void 0;
 }
 function computeRestPlan(character, resolved, derived, registry, type) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
   const cats = [];
   let hdRegainDist;
+  const index = resolveResourceIndex(resolved);
   const pact = character.state.spell_slots_pact;
   if (pact && pact.used > 0) {
     cats.push({ id: "pact-slots", label: "Pact Magic Slots", preview: "all reset" });
@@ -79,15 +129,16 @@ function computeRestPlan(character, resolved, derived, registry, type) {
     }
     for (const [key, fu] of Object.entries((_f = character.state.feature_uses) != null ? _f : {})) {
       if (fu.used <= 0) continue;
-      const res = findResourceById(resolved, key);
+      const res = index.get(key);
       const reset = (_g = res == null ? void 0 : res.reset) != null ? _g : "long-rest";
-      if (reset !== "short-rest" && reset !== "long-rest" && reset !== "dawn" && reset !== "dusk") continue;
+      if (reset !== "short-rest" && reset !== "long-rest" && reset !== "either" && reset !== "dawn" && reset !== "dusk") continue;
       cats.push({
         id: `feature:${key}`,
-        label: (_h = res == null ? void 0 : res.label) != null ? _h : key,
+        label: (_h = res == null ? void 0 : res.name) != null ? _h : key,
         preview: `${fu.used}/${fu.max} restored`
       });
     }
+    pushPartialRecoveries(cats, character, index, "long");
     character.equipment.forEach((entry, idx) => {
       var _a2, _b2, _c2, _d2, _e2;
       const rec = (_a2 = entry.state) == null ? void 0 : _a2.recovery;
@@ -106,14 +157,16 @@ function computeRestPlan(character, resolved, derived, registry, type) {
   if (type === "short") {
     for (const [key, fu] of Object.entries((_i = character.state.feature_uses) != null ? _i : {})) {
       if (fu.used <= 0) continue;
-      const res = findResourceById(resolved, key);
-      if (((_j = res == null ? void 0 : res.reset) != null ? _j : "long-rest") !== "short-rest") continue;
+      const res = index.get(key);
+      const r = (_j = res == null ? void 0 : res.reset) != null ? _j : "long-rest";
+      if (r !== "short-rest" && r !== "either") continue;
       cats.push({
         id: `feature:${key}`,
-        label: (_k = res == null ? void 0 : res.label) != null ? _k : key,
+        label: (_k = res == null ? void 0 : res.name) != null ? _k : key,
         preview: `${fu.used}/${fu.max} restored`
       });
     }
+    pushPartialRecoveries(cats, character, index, "short");
     character.equipment.forEach((entry, idx) => {
       var _a2, _b2, _c2, _d2, _e2;
       const rec = (_a2 = entry.state) == null ? void 0 : _a2.recovery;
@@ -129,6 +182,7 @@ function computeRestPlan(character, resolved, derived, registry, type) {
       });
     });
   }
+  pushBuffEnds(cats, character, resolved);
   const hdAvailable = type === "short" ? Object.entries((_l = character.state.hit_dice) != null ? _l : {}).filter(([, hd]) => hd.used < hd.total).map(([die, hd]) => ({ die, remaining: hd.total - hd.used })) : [];
   return { type, categories: cats, hdAvailable, hdRegainDist };
 }

package/dist/pc/pc.schema.d.ts

@@ -1,4 +1,113 @@
 import { z } from "zod";
+export declare const characterOverridesShape: z.ZodObject<{
+    scores: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }> & z.core.$partial, z.ZodNumber>>;
+    saves: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }> & z.core.$partial, z.ZodObject<{
+        bonus: z.ZodOptional<z.ZodNumber>;
+        proficient: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    skills: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        acrobatics: "acrobatics";
+        "animal-handling": "animal-handling";
+        arcana: "arcana";
+        athletics: "athletics";
+        deception: "deception";
+        history: "history";
+        insight: "insight";
+        intimidation: "intimidation";
+        investigation: "investigation";
+        medicine: "medicine";
+        nature: "nature";
+        perception: "perception";
+        performance: "performance";
+        persuasion: "persuasion";
+        religion: "religion";
+        "sleight-of-hand": "sleight-of-hand";
+        stealth: "stealth";
+        survival: "survival";
+    }> & z.core.$partial, z.ZodObject<{
+        bonus: z.ZodNumber;
+        proficiency: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            expertise: "expertise";
+            proficient: "proficient";
+        }>>;
+    }, z.core.$strip>>>;
+    passives: z.ZodOptional<z.ZodObject<{
+        perception: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        investigation: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        insight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    hp: z.ZodOptional<z.ZodObject<{
+        max: z.ZodOptional<z.ZodNumber>;
+        rolled: z.ZodOptional<z.ZodNumber>;
+        modifier: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    ac: z.ZodOptional<z.ZodNumber>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    initiative: z.ZodOptional<z.ZodNumber>;
+    spellcasting_ability_by_class: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>>;
+    spellcasting_ability: z.ZodOptional<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>;
+    spell_slots: z.ZodOptional<z.ZodRecord<z.ZodCoercedNumber<unknown>, z.ZodNumber>>;
+    attunement_limit: z.ZodOptional<z.ZodNumber>;
+    languages: z.ZodOptional<z.ZodObject<{
+        add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    tools: z.ZodOptional<z.ZodObject<{
+        add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        proficiency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            none: "none";
+            expertise: "expertise";
+            proficient: "proficient";
+        }>>>;
+    }, z.core.$strip>>;
+    defenses: z.ZodOptional<z.ZodObject<{
+        resistances: z.ZodOptional<z.ZodObject<{
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        immunities: z.ZodOptional<z.ZodObject<{
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        vulnerabilities: z.ZodOptional<z.ZodObject<{
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        condition_immunities: z.ZodOptional<z.ZodObject<{
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The overrides key set as a type. Paired with `keyof CharacterOverrides` by the compile-time parity
+ *  assertion in pc.types.ts, which is what actually stops a one-sided addition. */
+export type CharacterOverridesSchemaKeys = keyof z.infer<typeof characterOverridesShape>;
 export declare const characterSchema: z.ZodObject<{
     name: z.ZodString;
     edition: z.ZodEnum<{
@@ -27,10 +136,10 @@ export declare const characterSchema: z.ZodObject<{
         cha: z.ZodNumber;
     }, z.core.$strip>;
     ability_method: z.ZodEnum<{
+        rolled: "rolled";
         "standard-array": "standard-array";
         "point-buy": "point-buy";
         "archivist-point-buy": "archivist-point-buy";
-        rolled: "rolled";
         manual: "manual";
     }>;
     builder_rolls: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -87,8 +196,8 @@ export declare const characterSchema: z.ZodObject<{
             class: z.ZodOptional<z.ZodString>;
             source: z.ZodOptional<z.ZodEnum<{
                 domain: "domain";
-                race: "race";
                 item: "item";
+                race: "race";
                 class: "class";
                 feat: "feat";
             }>>;
@@ -210,8 +319,8 @@ export declare const characterSchema: z.ZodObject<{
             bonus: z.ZodNumber;
             proficiency: z.ZodOptional<z.ZodEnum<{
                 none: "none";
-                proficient: "proficient";
                 expertise: "expertise";
+                proficient: "proficient";
             }>>;
         }, z.core.$strip>>>;
         passives: z.ZodOptional<z.ZodObject<{
@@ -245,6 +354,33 @@ export declare const characterSchema: z.ZodObject<{
         }>>;
         spell_slots: z.ZodOptional<z.ZodRecord<z.ZodCoercedNumber<unknown>, z.ZodNumber>>;
         attunement_limit: z.ZodOptional<z.ZodNumber>;
+        languages: z.ZodOptional<z.ZodObject<{
+            add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        tools: z.ZodOptional<z.ZodObject<{
+            add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            proficiency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                none: "none";
+                expertise: "expertise";
+                proficient: "proficient";
+            }>>>;
+        }, z.core.$strip>>;
+        defenses: z.ZodOptional<z.ZodObject<{
+            resistances: z.ZodOptional<z.ZodObject<{
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            immunities: z.ZodOptional<z.ZodObject<{
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            vulnerabilities: z.ZodOptional<z.ZodObject<{
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            condition_immunities: z.ZodOptional<z.ZodObject<{
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     currency: z.ZodOptional<z.ZodObject<{
         cp: z.ZodNumber;

package/dist/pc/pc.schema.js

@@ -1,7 +1,9 @@
 import {
+  characterOverridesShape,
   characterSchema
-} from "../chunk-TN6ZLTNU.js";
-import "../chunk-TZK36BU7.js";
+} from "../chunk-I2NDWFDD.js";
+import "../chunk-S7REMWW4.js";
 export {
+  characterOverridesShape,
   characterSchema
 };