@archivist-gg/dnd5e 0.3.10 → 0.3.13

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

@@ -4,7 +4,7 @@ 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";
+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
@@ -23,19 +23,14 @@ export declare function parseDieSize(die: string | number | undefined | null): n
  */
 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. This is the path taken when an L4/L8-style
- * "Ability Score Increase or Feat" decision resolves to the plain +2 ASI branch
- * rather than a feat. Shared by both `computeAbilityScores`' fold and
- * `abilityBonusBreakdown`'s `class` bucket so the two reads can never drift.
+ * 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.
  *
- * Disjoint from chosen-feat ability-points (`choices[lvl]["feat:<id>"]`) and from
- * 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).
+ * 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:
@@ -69,6 +64,10 @@ export declare function hpLevelCount(classes: ResolvedClass[]): number;
  * 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
@@ -121,29 +120,33 @@ export declare function speedFromRace(resolved: ResolvedCharacter): number;
  * 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.
+ * 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.

package/dist/pc/pc.recalc.js

@@ -1,28 +1,18 @@
-import {
-  computeConditionEffects
-} from "../chunk-R2ZV233X.js";
 import {
   collectChosenAbilityPoints,
   collectChosenProficiencies
-} from "../chunk-HLQAFZKQ.js";
+} from "../chunk-QEO7LYTG.js";
+import "../chunk-2LULMQTF.js";
+import "../chunk-H5PTKYXL.js";
 import {
   resourceLevelFor
-} from "../chunk-4ISR76DH.js";
+} from "../chunk-KSTV7J2U.js";
 import {
   computeSpellLimits,
   deriveSpellSlots,
   effectiveSpellcastingAbility,
   resolveSpellcasting
 } from "../chunk-DPUJDOKV.js";
-import "../chunk-O4SRD3J5.js";
-import "../chunk-PP2UHLBA.js";
-import {
-  diceColumnAt,
-  unarmedDieColumnFor
-} from "../chunk-IUAAXXNO.js";
-import "../chunk-YHYTW5QA.js";
-import "../chunk-MI7P3NX3.js";
-import "../chunk-PVCEA4HZ.js";
 import {
   toDefenseSlug
 } from "../chunk-XJ2F2WO6.js";
@@ -31,31 +21,51 @@ import {
   computeAppliedBonuses,
   computeSlotsAndAttacks,
   emptyAppliedBonuses
-} from "../chunk-V373TRJE.js";
-import "../chunk-UIRMA5KM.js";
-import "../chunk-UBBKSYBY.js";
+} from "../chunk-Q5XTEYHD.js";
+import "../chunk-YDGMBMYI.js";
 import {
   assembleEffectFeatures,
   computeFeatureEffects,
   foldsNow,
   selfEffectsOf
-} from "../chunk-CBEKVAX4.js";
+} from "../chunk-4BZ47YJ4.js";
 import "../chunk-TOM66P2P.js";
 import "../chunk-KU3YLF6D.js";
 import "../chunk-RLGQ5PZZ.js";
-import "../chunk-LWFTHJIE.js";
-import "../chunk-DNAJRMNN.js";
+import "../chunk-T5GZBKIQ.js";
+import "../chunk-W6GC6OKK.js";
+import "../chunk-HJQNK3J5.js";
+import {
+  diceColumnAt,
+  unarmedDieColumnFor
+} from "../chunk-IUAAXXNO.js";
+import "../chunk-YHYTW5QA.js";
+import "../chunk-DPM6V7YX.js";
+import "../chunk-PVCEA4HZ.js";
+import {
+  legacyAsiBranch
+} from "../chunk-LBEXLN6I.js";
+import {
+  computeConditionEffects
+} from "../chunk-MYY2C5MB.js";
+import "../chunk-EJP263OP.js";
+import "../chunk-ZUQW5VBZ.js";
+import "../chunk-IHE6KVC3.js";
+import "../chunk-HHBD4SQ6.js";
+import "../chunk-A54HHCWW.js";
+import "../chunk-LHZXYFBU.js";
 import "../chunk-LVQLWRCU.js";
-import "../chunk-WXWPK3LI.js";
-import "../chunk-6X4KUDMU.js";
+import "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
 import "../chunk-YBLDE5CG.js";
 import {
   evaluateMaxFormula,
   isValidMaxFormula
 } from "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
-import "../chunk-OZP6JFGT.js";
-import "../chunk-VQAXTIBW.js";
+import "../chunk-XY6X2APM.js";
+import "../chunk-ZDAEGJH4.js";
+import "../chunk-3TM34RSJ.js";
 import {
   abilityModifier,
   attackBonus,
@@ -124,13 +134,11 @@ function collectClassAsiBranch(resolved) {
   var _a;
   const out = {};
   for (const c of resolved.classes) {
-    for (const [, choice] of Object.entries(c.choices)) {
-      const block = choice;
-      if (typeof (block == null ? void 0 : block.feat) === "string") continue;
-      const asi = block == null ? void 0 : block.asi;
-      if (!asi) continue;
+    for (const choice of Object.values(c.choices)) {
+      const alloc = legacyAsiBranch(choice);
+      if (!alloc) continue;
       for (const ab of ABILITY_KEYS) {
-        const v = asi[ab];
+        const v = alloc[ab];
         if (typeof v === "number") out[ab] = ((_a = out[ab]) != null ? _a : 0) + v;
       }
     }
@@ -205,6 +213,24 @@ function resolveDamageRider(rider, rowDamageType, bindings) {
   }
   return out;
 }
+function riderReachesRow(rider, row) {
+  var _a;
+  if (!((_a = rider.scope) == null ? void 0 : _a.length)) return true;
+  return rider.scope.some((word) => {
+    switch (word) {
+      case "weapon":
+        return true;
+      case "unarmed":
+        return row.unarmed === true;
+      case "melee":
+      case "ranged":
+        return row.weaponCategory === word;
+      case "finesse":
+      case "thrown":
+        return row.properties.includes(word);
+    }
+  });
+}
 function unarmoredAC(resolved, mods, warnings) {
   return unarmoredACBreakdown(resolved, mods, warnings).total;
 }
@@ -634,7 +660,8 @@ function recalc(resolved, registry) {
     skills[skillKey] = {
       bonus,
       proficiency: tri,
-      ability: ab
+      ability: ab,
+      ...halfProfBest ? { halfProficiency: { source: halfProfBest.source, amount: halfProfBest.amount } } : {}
     };
   }
   const passives = {
@@ -862,7 +889,7 @@ function recalc(resolved, registry) {
     // attackNotes: reroll-damage / attack-rule captions, only when non-empty.
     attacks: attackRows.map((a) => {
       var _a2;
-      const riders = [...(_a2 = a.damageRiders) != null ? _a2 : [], ...featureEffects.damageBonuses].map((r) => resolveDamageRider(r, a.damageType, riderBindings));
+      const riders = [...(_a2 = a.damageRiders) != null ? _a2 : [], ...featureEffects.damageBonuses.filter((r) => riderReachesRow(r, a))].map((r) => resolveDamageRider(r, a.damageType, riderBindings));
       return {
         ...a,
         toHit: a.toHit + conditionEffects.d20_test_penalty,
@@ -895,6 +922,7 @@ export {
   phbAverageForDie,
   recalc,
   resolveUnarmedStrike,
+  riderReachesRow,
   speedFromRace,
   unarmoredAC,
   unarmoredACBreakdown

package/dist/pc/pc.resolver.js

@@ -10,28 +10,35 @@ import {
   dedupeResolvedSpells,
   resolveOriginFeat,
   stripSlug
-} from "../chunk-HLQAFZKQ.js";
-import "../chunk-4ISR76DH.js";
+} from "../chunk-QEO7LYTG.js";
+import "../chunk-2LULMQTF.js";
+import "../chunk-H5PTKYXL.js";
+import "../chunk-KSTV7J2U.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-CBEKVAX4.js";
+import "../chunk-4BZ47YJ4.js";
 import "../chunk-TOM66P2P.js";
 import "../chunk-KU3YLF6D.js";
 import "../chunk-RLGQ5PZZ.js";
+import "../chunk-T5GZBKIQ.js";
+import "../chunk-W6GC6OKK.js";
+import "../chunk-HJQNK3J5.js";
+import "../chunk-IUAAXXNO.js";
+import "../chunk-YHYTW5QA.js";
+import "../chunk-DPM6V7YX.js";
+import "../chunk-PVCEA4HZ.js";
+import "../chunk-LBEXLN6I.js";
+import "../chunk-ZUQW5VBZ.js";
+import "../chunk-IHE6KVC3.js";
+import "../chunk-LHZXYFBU.js";
 import "../chunk-LVQLWRCU.js";
-import "../chunk-WXWPK3LI.js";
-import "../chunk-6X4KUDMU.js";
+import "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
 import "../chunk-YBLDE5CG.js";
 import "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
-import "../chunk-OZP6JFGT.js";
-import "../chunk-VQAXTIBW.js";
+import "../chunk-XY6X2APM.js";
+import "../chunk-ZDAEGJH4.js";
+import "../chunk-3TM34RSJ.js";
 import "../chunk-PDJSUH24.js";
 import "../chunk-WELIKLZF.js";
 import "../chunk-4U55VNC7.js";

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

@@ -1,6 +1,6 @@
 import {
   resourceLevelFor
-} from "../chunk-4ISR76DH.js";
+} from "../chunk-KSTV7J2U.js";
 import "../chunk-DPUJDOKV.js";
 import {
   numericColumnsAt

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

@@ -1,4 +1,4 @@
-import type { FeatureSource, ResolvedCharacter, ResolvedFeature, ResolvedPool, DerivedStats } from "./pc.types.js";
+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
@@ -80,6 +80,11 @@ export declare function resolveRecovery(entry: ResourceRecovery): ResolvedRecove
  *  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

package/dist/pc/pc.resources.js

@@ -1,10 +1,11 @@
 import {
+  pickResourceId,
   poolSaveDC,
   resolveFeatureResources,
   resolveRecovery,
   resolveResourceIndex,
   resourceLevelFor
-} from "../chunk-4ISR76DH.js";
+} from "../chunk-KSTV7J2U.js";
 import "../chunk-DPUJDOKV.js";
 import "../chunk-IUAAXXNO.js";
 import "../chunk-LVQLWRCU.js";
@@ -13,6 +14,7 @@ import "../chunk-VTTA2ALZ.js";
 import "../chunk-PDJSUH24.js";
 import "../chunk-WELIKLZF.js";
 export {
+  pickResourceId,
   poolSaveDC,
   resolveFeatureResources,
   resolveRecovery,

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

@@ -1,5 +1,6 @@
 import type { EntityRegistry } from "@archivist-gg/core";
-import type { Character, DerivedStats, ResolvedCharacter } from "./pc.types.js";
+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
@@ -15,6 +16,14 @@ export interface RestCategory {
     /** 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;
+        max: number;
+    };
 }
 export interface RestPlan {
     type: RestType;
@@ -29,4 +38,15 @@ export interface RestPlan {
         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;

package/dist/pc/pc.rest.js

@@ -1,11 +1,23 @@
 import {
   resolveResourceIndex
-} from "../chunk-4ISR76DH.js";
+} from "../chunk-KSTV7J2U.js";
 import "../chunk-DPUJDOKV.js";
+import {
+  effectiveItemCharges,
+  effectiveItemRecovery
+} from "../chunk-T5GZBKIQ.js";
+import "../chunk-W6GC6OKK.js";
+import "../chunk-HJQNK3J5.js";
 import "../chunk-IUAAXXNO.js";
+import "../chunk-ZUQW5VBZ.js";
+import "../chunk-IHE6KVC3.js";
+import "../chunk-LHZXYFBU.js";
 import "../chunk-LVQLWRCU.js";
+import "../chunk-CM5CWO4K.js";
+import "../chunk-ZCTUYGNV.js";
 import "../chunk-EVMUJYUD.js";
 import "../chunk-VTTA2ALZ.js";
+import "../chunk-3TM34RSJ.js";
 import "../chunk-PDJSUH24.js";
 import "../chunk-WELIKLZF.js";
 
@@ -17,18 +29,35 @@ function resolveItemName(entry, registry) {
   const slug = ref ? ref[1] : entry.item;
   return (_a = registry.getBySlug(slug)) == null ? void 0 : _a.name;
 }
-var FIRES_AT = {
-  long: /* @__PURE__ */ new Set(["short-rest", "long-rest", "either", "dawn", "dusk"]),
-  short: /* @__PURE__ */ new Set(["short-rest", "either"])
+var RESTORED_BY = {
+  "short-rest": "short",
+  either: "short",
+  short: "short",
+  "long-rest": "long",
+  long: "long",
+  dawn: "long",
+  dusk: "long",
+  turn: null,
+  round: null,
+  custom: null,
+  special: null
 };
+var REST_SPAN = { short: 1, long: 2 };
+function earliestRestoringRest(reset) {
+  return Object.prototype.hasOwnProperty.call(RESTORED_BY, reset) ? RESTORED_BY[reset] : null;
+}
+function restRestores(type, reset) {
+  const earliest = earliestRestoringRest(reset);
+  return earliest !== null && REST_SPAN[earliest] <= REST_SPAN[type];
+}
 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 (restRestores(type, res.reset)) continue;
+    const entry = res.recovery.find((r) => r.kind === "uses" && r.flavour === "rest" && restRestores(type, r.entry.reset));
     if (!entry) continue;
     const amount = entry.entry.amount;
     const restore = amount === "all" ? "all" : typeof amount === "number" ? amount : Number(amount);
@@ -132,8 +161,7 @@ function computeRestPlan(character, resolved, derived, registry, type) {
       const bankedRolls = banked ? banked.filter((v) => v > 0).length : 0;
       if (fu.used <= 0 && bankedRolls <= 0) continue;
       const res = index.get(key);
-      const reset = (_h = res == null ? void 0 : res.reset) != null ? _h : "long-rest";
-      if (reset !== "short-rest" && reset !== "long-rest" && reset !== "either" && reset !== "dawn" && reset !== "dusk") continue;
+      if (!restRestores("long", (_h = res == null ? void 0 : res.reset) != null ? _h : "long-rest")) continue;
       const rollsNote = bankedRolls > 0 ? ` \xB7 ${bankedRolls} roll${bankedRolls === 1 ? "" : "s"} cleared` : "";
       cats.push({
         id: `feature:${key}`,
@@ -144,16 +172,18 @@ function computeRestPlan(character, resolved, derived, registry, type) {
     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;
-      const charges = (_b2 = entry.state) == null ? void 0 : _b2.charges;
+      const view = (_b2 = (_a2 = resolved.infusions) == null ? void 0 : _a2.views.get(idx)) != null ? _b2 : null;
+      const rec = effectiveItemRecovery(entry, registry, view);
+      const charges = effectiveItemCharges(entry, registry, view);
       if (!rec || !charges) return;
       if (charges.current >= charges.max) return;
-      if (rec.reset !== "short" && rec.reset !== "long" && rec.reset !== "dawn") return;
+      if (!restRestores("long", rec.reset)) return;
       const label = (_e2 = (_d2 = (_c2 = entry.overrides) == null ? void 0 : _c2.name) != null ? _d2 : resolveItemName(entry, registry)) != null ? _e2 : entry.item;
       cats.push({
         id: `item:${idx}`,
         label,
-        preview: `${charges.current} \u2192 ${charges.max}`
+        preview: `${charges.current} \u2192 ${charges.max}`,
+        recharge: { amount: rec.amount, current: charges.current, max: charges.max }
       });
     });
   }
@@ -163,8 +193,7 @@ function computeRestPlan(character, resolved, derived, registry, type) {
       const bankedRolls = banked ? banked.filter((v) => v > 0).length : 0;
       if (fu.used <= 0 && bankedRolls <= 0) continue;
       const res = index.get(key);
-      const r = (_l = res == null ? void 0 : res.reset) != null ? _l : "long-rest";
-      if (r !== "short-rest" && r !== "either") continue;
+      if (!restRestores("short", (_l = res == null ? void 0 : res.reset) != null ? _l : "long-rest")) continue;
       const rollsNote = bankedRolls > 0 ? ` \xB7 ${bankedRolls} roll${bankedRolls === 1 ? "" : "s"} cleared` : "";
       cats.push({
         id: `feature:${key}`,
@@ -175,16 +204,18 @@ function computeRestPlan(character, resolved, derived, registry, type) {
     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;
-      const charges = (_b2 = entry.state) == null ? void 0 : _b2.charges;
+      const view = (_b2 = (_a2 = resolved.infusions) == null ? void 0 : _a2.views.get(idx)) != null ? _b2 : null;
+      const rec = effectiveItemRecovery(entry, registry, view);
+      const charges = effectiveItemCharges(entry, registry, view);
       if (!rec || !charges) return;
       if (charges.current >= charges.max) return;
-      if (rec.reset !== "short") return;
+      if (!restRestores("short", rec.reset)) return;
       const label = (_e2 = (_d2 = (_c2 = entry.overrides) == null ? void 0 : _c2.name) != null ? _d2 : resolveItemName(entry, registry)) != null ? _e2 : entry.item;
       cats.push({
         id: `item:${idx}`,
         label,
-        preview: `${charges.current} \u2192 ${charges.max}`
+        preview: `${charges.current} \u2192 ${charges.max}`,
+        recharge: { amount: rec.amount, current: charges.current, max: charges.max }
       });
     });
   }
@@ -193,5 +224,7 @@ function computeRestPlan(character, resolved, derived, registry, type) {
   return { type, categories: cats, hdAvailable, hdRegainDist };
 }
 export {
-  computeRestPlan
+  computeRestPlan,
+  earliestRestoringRest,
+  restRestores
 };

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

@@ -275,6 +275,20 @@ export declare const characterSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strict>>;
         granted_by: z.ZodOptional<z.ZodString>;
+        id: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        in: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        infusion: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                infused: "infused";
+                created: "created";
+            }>;
+            by: z.ZodString;
+            seq: z.ZodNumber;
+            choice: z.ZodOptional<z.ZodString>;
+            charges: z.ZodOptional<z.ZodObject<{
+                current: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     overrides: z.ZodDefault<z.ZodObject<{
         scores: z.ZodOptional<z.ZodRecord<z.ZodEnum<{

package/dist/pc/pc.schema.js

@@ -1,7 +1,7 @@
 import {
   characterOverridesShape,
   characterSchema
-} from "../chunk-PZCE7DJM.js";
+} from "../chunk-UE6LKRXQ.js";
 import "../chunk-S7REMWW4.js";
 export {
   characterOverridesShape,

package/dist/pc/pc.slotting.d.ts

@@ -2,7 +2,7 @@ import type { EntityRegistry } from "@archivist-gg/core";
 import type { ItemEntity } from "@archivist-gg/dnd5e/item/item.types";
 import type { ArmorEntity } from "@archivist-gg/dnd5e/armor/armor.types";
 import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
-import type { SlotKey } from "./pc.types.js";
+import type { EquipmentEntry, SlotKey } from "./pc.types.js";
 export declare function isItemEntity(e: unknown): e is ItemEntity;
 export declare function isWeaponEntity(e: unknown): e is WeaponEntity;
 export declare function isArmorEntity(e: unknown): e is ArmorEntity;
@@ -13,10 +13,43 @@ export declare function resolveEntityForEntry(item: string, registry: EntityRegi
     entity: ArmorEntity | WeaponEntity | ItemEntity | null;
     entityType: string | null;
 };
-/** Is this armor a shield? Robust to SRD-2024 data where the Shield entity
- *  carries `category: "heavy"` rather than `"shield"`. */
+/** Is this armor a shield? By category, slug or name: the SRD Shield is category "shield" (dnd5e 0.3.13), but
+ *  imported or hand-authored data (and the SRD bundle before 0.3.13) may carry category "heavy". */
 export declare function isShieldArmor(armor: ArmorEntity): boolean;
 /** The ArmorEntity whose `ac` block governs a slot: the entity itself when armor,
  *  or — for a magic item whose `base_item` points at armor — the resolved base. */
 export declare function effectiveArmor(entity: ArmorEntity | WeaponEntity | ItemEntity | null | undefined, registry: EntityRegistry): ArmorEntity | null;
+/** The WeaponEntity whose attack and two-handed rules govern a slot (H234 H2, spec §3.2): the entity itself when it is a
+ *  weapon, or, for a magic item whose `base_item` resolves to a weapon, that base. ONE hop, exactly like
+ *  {@link effectiveArmor}: a base that is itself an item is not followed (measured at Gate 0: 108 item-to-item bases, 0
+ *  cycles, 0 ending at a two-handed weapon; a later multi-hop needs a visited set). Null for armor, a wondrous item, an
+ *  unresolved slug, or a base that does not resolve to a weapon. */
+export declare function effectiveWeapon(entity: ArmorEntity | WeaponEntity | ItemEntity | null | undefined, registry: EntityRegistry): WeaponEntity | null;
+/** THE two-handed rule (H234 H2, spec §3.2), read by `computeAC`'s shield gate, the `wielding_two_handed` condition and
+ *  the plugin's equip conflicts:
+ *  1-2. an entity whose OWN `properties` is a non-empty list: that list decides, whatever its base (resolved, unresolved or
+ *       absent). The same precedence as the attack row, whose magic `propertiesOverride` replaces the base list, so the
+ *       Weapons table's property chips and the two-handed rules cannot disagree;
+ *  3.   an item with no own properties: its base weapon's, through {@link effectiveWeapon} (needs a registry);
+ *  4-6. anything else (no base, an unresolved or non-weapon base, no registry, null): not two-handed, as before.
+ *  A property entry may be a conditional object; the test is the literal "two_handed". */
+export declare function isTwoHandedWeapon(entity: ArmorEntity | WeaponEntity | ItemEntity | null | undefined, registry?: EntityRegistry | null): boolean;
+/** An armour's own Armor Class term: its `base` plus its `flat` (raw vault data omits `flat`, so it reads 0). ONE rule
+ *  for the armour and shield terms `computeAC` adds (pc.equipment.ts) and for the AC an entry shows
+ *  (`effectiveItemArmorClass`, pc.entry-overrides.ts), both read through {@link slotAcTerms}. */
+export declare function armorAcTerm(armor: ArmorEntity): number;
+/** The Armor Class ONE worn armour or shield entry adds by itself, as the two terms a breakdown lists apart: its armour's
+ *  own term ({@link armorAcTerm}; null when the entry resolves to no armour) and the entry's `overrides.ac_bonus` (0 when
+ *  absent, or not a number in raw vault data). ONE rule for `computeAC`'s armour and shield slots (pc.equipment.ts) and
+ *  the AC an entry shows (`effectiveItemArmorClass`, pc.entry-overrides.ts), which wrote "armour term + entry ac_bonus"
+ *  three times, held equal only by a test (T17, carried from rider EF's review). The item's own `bonuses.ac` is not a
+ *  slot term: the engine reads it attunement-gated and per condition, so it stays with each consumer. */
+export declare function slotAcTerms(armor: ArmorEntity, entry: EquipmentEntry | undefined): {
+    armor: number;
+    override: number;
+};
+export declare function slotAcTerms(armor: ArmorEntity | null, entry: EquipmentEntry | undefined): {
+    armor: number | null;
+    override: number;
+};
 export declare function defaultSlotForType(entityType: string | null, entity: ArmorEntity | WeaponEntity | ItemEntity | null, registry: EntityRegistry): SlotKey | null;