@archivist-gg/dnd5e 0.1.0

package/dist/pc/pc.resolver.js

@@ -0,0 +1,267 @@
+import {
+  resolveAllPools
+} from "../chunk-6PXE7T7C.js";
+import {
+  normalizeKnownSpell,
+  resolveSpellcasting
+} from "../chunk-IXZXFFFW.js";
+import "../chunk-5XUXXAQJ.js";
+import "../chunk-TJCNX6UZ.js";
+import "../chunk-BH6AMZVY.js";
+import "../chunk-JEYQU3JT.js";
+import "../chunk-J2RYSZMQ.js";
+import "../chunk-NAEPSZAM.js";
+import "../chunk-WP2CX2JO.js";
+
+// src/pc/pc.resolver.ts
+var SLUG_RE = /^\[\[(.+?)\]\]$/;
+function stripSlug(ref) {
+  if (!ref) return null;
+  const m = ref.match(SLUG_RE);
+  return m ? m[1] : ref;
+}
+var PCResolver = class {
+  constructor(entities) {
+    this.entities = entities;
+  }
+  /** Exposed so recalc() can apply equipment bonuses (Pass A / Pass B). */
+  get registry() {
+    return this.entities;
+  }
+  resolve(character) {
+    var _a, _b, _c, _d, _e;
+    const warnings = [];
+    const lookup = (rawRef, type) => {
+      const slug = stripSlug(rawRef);
+      if (!slug) return null;
+      const reg = this.entities.getByTypeAndSlug(type, slug);
+      if (!reg) {
+        warnings.push(`Slug [[${slug}]] not found in compendium as ${type}.`);
+        return null;
+      }
+      const data = reg.data;
+      return data.slug == null ? { ...data, slug: reg.slug } : data;
+    };
+    const race = lookup(character.race, "race");
+    const background = lookup(character.background, "background");
+    const classes = character.class.map((c) => ({
+      entity: lookup(c.name, "class"),
+      level: c.level,
+      subclass: lookup(c.subclass, "subclass"),
+      choices: c.choices
+    }));
+    const featSlugs = collectFeatSlugs(character);
+    const feats = [];
+    for (const slug of featSlugs) {
+      const f = lookup(`[[${slug}]]`, "feat");
+      if (f) feats.push(f);
+    }
+    const totalLevel = classes.reduce((sum, c) => sum + c.level, 0);
+    const features = collectResolvedFeatures(race, classes, background, feats);
+    const extraFeatures = collectChosenGrantedFeatures(character, classes, this.entities, race, background);
+    features.push(...extraFeatures);
+    const primaryCasterSlug = (_a = classes.map((c, i) => c.entity && resolveSpellcasting(c) ? stripSlug(character.class[i].name) : null).find((slug) => slug != null)) != null ? _a : null;
+    const spells = [];
+    for (const raw of (_b = character.spells.known) != null ? _b : []) {
+      const n = normalizeKnownSpell(raw);
+      const reg = this.entities.getByTypeAndSlug("spell", n.slug);
+      if (!reg) {
+        warnings.push(`Spell [[${n.slug}]] not found in compendium.`);
+        continue;
+      }
+      const entity = reg.data;
+      const isCantrip = ((_c = entity.level) != null ? _c : 0) === 0;
+      const classSlug = (_d = n.classSlug) != null ? _d : primaryCasterSlug;
+      const prep = isCantrip || n.alwaysPrepared ? true : (_e = n.preparedFlag) != null ? _e : false;
+      spells.push({ entity, slug: n.slug, classSlug, source: n.source, prepared: prep, alwaysPrepared: n.alwaysPrepared });
+    }
+    const resolvedCharacter = {
+      definition: character,
+      race,
+      classes,
+      background,
+      feats,
+      totalLevel,
+      features,
+      spells,
+      pools: [],
+      state: character.state
+    };
+    resolvedCharacter.pools = resolveAllPools(resolvedCharacter, this.entities);
+    return { character: resolvedCharacter, warnings };
+  }
+};
+function collectFeatSlugs(character) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const c of character.class) {
+    for (const [, choiceBlock] of Object.entries(c.choices)) {
+      const feat = choiceBlock == null ? void 0 : choiceBlock.feat;
+      if (typeof feat === "string") {
+        const s = stripSlug(feat);
+        if (s) slugs.add(s);
+      }
+    }
+  }
+  return [...slugs];
+}
+function collectChosenGrantedFeatures(character, classes, registry, race = null, background = null) {
+  var _a, _b;
+  const out = [];
+  classes.forEach((c, i) => {
+    var _a2, _b2, _c, _d;
+    if (!c.entity) return;
+    const entity = c.entity;
+    const entry = character.class[i];
+    if (!entry) return;
+    for (const [lvlStr, atLevel] of Object.entries(entry.choices)) {
+      const lvl = Number(lvlStr);
+      if (!Number.isFinite(lvl) || lvl > entry.level) continue;
+      const features = (_b2 = ((_a2 = entity.features_by_level) != null ? _a2 : {})[lvl]) != null ? _b2 : [];
+      const subFeatures = c.subclass ? (_d = ((_c = c.subclass.features_by_level) != null ? _c : {})[lvl]) != null ? _d : [] : [];
+      for (const feature of [...features, ...subFeatures]) {
+        walkChoiceGrants(feature.choices, atLevel, (granted) => {
+          out.push({ feature: granted, source: { kind: "class", slug: entity.slug, level: lvl } });
+        }, registry);
+      }
+    }
+  });
+  const oc = (_a = character.origin_choices) != null ? _a : {};
+  const originAt = (ns) => {
+    const at = {};
+    for (const [key, val] of Object.entries(oc)) {
+      if (key.startsWith(`${ns}:`)) at[key.slice(ns.length + 1)] = val;
+    }
+    return at;
+  };
+  if (race) {
+    const atRace = originAt("race");
+    const emitRace = (granted) => {
+      out.push({ feature: granted, source: { kind: "race", slug: race.slug } });
+    };
+    walkChoiceGrants(race.choices, atRace, emitRace, registry);
+    for (const trait of (_b = race.traits) != null ? _b : []) {
+      walkChoiceGrants(trait.choices, atRace, emitRace, registry);
+    }
+  }
+  if (background) {
+    const atBg = originAt("background");
+    const emitBg = (granted) => {
+      out.push({ feature: granted, source: { kind: "background", slug: background.slug } });
+    };
+    walkChoiceGrants(background.choices, atBg, emitBg, registry);
+    if (background.feature) {
+      walkChoiceGrants(background.feature.choices, atBg, emitBg, registry);
+    }
+  }
+  return out;
+}
+function walkChoiceGrants(choices, atLevel, emit, registry) {
+  var _a, _b, _c, _d;
+  for (const ch of choices != null ? choices : []) {
+    const sel = atLevel[ch.id];
+    if (ch.kind === "select-entity" && ch.entity_type === "optional-feature") {
+      const slugs = Array.isArray(sel) ? sel : typeof sel === "string" ? [sel] : [];
+      for (const slug of slugs) {
+        const reg = registry.getByTypeAndSlug("optional-feature", (_a = stripSlug(String(slug))) != null ? _a : String(slug));
+        if (!reg) continue;
+        const d = reg.data;
+        emit({
+          id: (_b = d.slug) != null ? _b : String(slug),
+          name: (_c = d.name) != null ? _c : String(slug),
+          description: d.description,
+          effects: d.effects,
+          ...d.action_cost ? { action: d.action_cost } : {}
+        });
+      }
+    }
+    if (ch.kind === "select-inline") {
+      const branch = typeof sel === "string" ? ch.options.find((o) => o.value === sel) : void 0;
+      if ((_d = branch == null ? void 0 : branch.effects) == null ? void 0 : _d.length) {
+        emit({ id: `${ch.id}-${branch.value}`, name: branch.label, description: branch.description, effects: branch.effects });
+      }
+      if (branch == null ? void 0 : branch.choices) walkChoiceGrants(branch.choices, atLevel, emit, registry);
+    }
+  }
+}
+function collectResolvedFeatures(race, classes, background, feats) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const out = [];
+  for (const c of classes) {
+    if (!c.entity) continue;
+    const slug = c.entity.slug;
+    const byLevel = (_a = c.entity.features_by_level) != null ? _a : {};
+    for (const [lvlStr, feats0] of Object.entries(byLevel)) {
+      const lvl = parseInt(lvlStr, 10);
+      if (Number.isNaN(lvl) || lvl > c.level) continue;
+      for (const feat of feats0) {
+        out.push({ feature: feat, source: { kind: "class", slug, level: lvl } });
+      }
+    }
+    if ((_b = c.entity.resources) == null ? void 0 : _b.length) {
+      out.push({
+        feature: { name: c.entity.name, resources: c.entity.resources },
+        source: { kind: "class", slug, level: 1 }
+      });
+    }
+    if (c.subclass) {
+      const sSlug = c.subclass.slug;
+      const sByLevel = (_c = c.subclass.features_by_level) != null ? _c : {};
+      for (const [lvlStr, feats0] of Object.entries(sByLevel)) {
+        const lvl = parseInt(lvlStr, 10);
+        if (Number.isNaN(lvl) || lvl > c.level) continue;
+        for (const feat of feats0) {
+          out.push({ feature: feat, source: { kind: "subclass", slug: sSlug, level: lvl } });
+        }
+      }
+      if ((_d = c.subclass.resources) == null ? void 0 : _d.length) {
+        out.push({
+          feature: { name: c.subclass.name, resources: c.subclass.resources },
+          source: { kind: "subclass", slug: sSlug, level: 1 }
+        });
+      }
+    }
+  }
+  if (race) {
+    const traits = (_e = race.traits) != null ? _e : [];
+    for (const feat of traits) {
+      out.push({ feature: feat, source: { kind: "race", slug: race.slug } });
+    }
+  }
+  if (background) {
+    const bgFeature = background.feature;
+    if (bgFeature) {
+      out.push({ feature: bgFeature, source: { kind: "background", slug: background.slug } });
+    }
+  }
+  for (const feat of feats) {
+    const bundled = (_f = feat.features) != null ? _f : [];
+    const entityEffects = (_g = feat.effects) != null ? _g : [];
+    if (bundled.length > 0) {
+      bundled.forEach((f, i) => {
+        var _a2;
+        const feature = i === 0 && entityEffects.length > 0 ? { ...f, effects: [...(_a2 = f.effects) != null ? _a2 : [], ...entityEffects] } : f;
+        out.push({ feature, source: { kind: "feat", slug: feat.slug } });
+      });
+    } else {
+      const name = (_h = feat.name) != null ? _h : feat.slug;
+      const description = (_i = feat.description) != null ? _i : "";
+      out.push({
+        feature: {
+          name,
+          description,
+          ...feat.resources ? { resources: feat.resources } : {},
+          ...entityEffects.length > 0 ? { effects: entityEffects } : {}
+        },
+        source: { kind: "feat", slug: feat.slug }
+      });
+    }
+  }
+  return out;
+}
+export {
+  PCResolver,
+  collectChosenGrantedFeatures,
+  collectFeatSlugs,
+  collectResolvedFeatures,
+  stripSlug
+};

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

@@ -0,0 +1,10 @@
+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. */
+export declare function resourceBindings(resolved: ResolvedCharacter, derived: DerivedStats, source: FeatureSource): FormulaBindings;

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

@@ -0,0 +1,40 @@
+import {
+  numericColumnsAt
+} from "../chunk-5XUXXAQJ.js";
+
+// src/pc/pc.resource-seed.ts
+function resourceBindings(resolved, derived, source) {
+  var _a, _b, _c, _d;
+  let classLevel = resolved.totalLevel;
+  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;
+  }
+  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.rest.d.ts

@@ -0,0 +1,23 @@
+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" | `feature:${string}` | `item:${number}`;
+export interface RestCategory {
+    id: RestCategoryId;
+    label: string;
+    preview: string;
+}
+export interface RestPlan {
+    type: RestType;
+    categories: RestCategory[];
+    hdAvailable: Array<{
+        die: string;
+        remaining: number;
+    }>;
+    /** Internal: per-die HD-regain target captured at plan time so apply is idempotent. */
+    hdRegainDist?: Array<{
+        die: string;
+        targetUsed: number;
+    }>;
+}
+export declare function computeRestPlan(character: Character, resolved: ResolvedCharacter, derived: DerivedStats, registry: EntityRegistry | null, type: RestType): RestPlan;

package/dist/pc/pc.rest.js

@@ -0,0 +1,128 @@
+// src/pc/pc.rest.ts
+function resolveItemName(entry, registry) {
+  var _a;
+  if (!registry) return void 0;
+  const ref = entry.item.match(/^\[\[(.+?)\]\]$/);
+  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 };
+    }
+  }
+  return void 0;
+}
+function computeRestPlan(character, resolved, derived, registry, type) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const cats = [];
+  let hdRegainDist;
+  const pact = character.state.spell_slots_pact;
+  if (pact && pact.used > 0) {
+    cats.push({ id: "pact-slots", label: "Pact Magic Slots", preview: "all reset" });
+  }
+  if (type === "long") {
+    if (character.state.hp.current < derived.hp.max) {
+      cats.push({
+        id: "hp-to-max",
+        label: "Hit Points",
+        preview: `${character.state.hp.current} \u2192 ${derived.hp.max}`
+      });
+    }
+    if (character.state.exhaustion > 0) {
+      cats.push({
+        id: "exhaustion",
+        label: "Exhaustion",
+        preview: `${character.state.exhaustion} \u2192 ${character.state.exhaustion - 1}`
+      });
+    }
+    const slotsUsed = Object.values((_a = character.state.spell_slots) != null ? _a : {}).reduce((s, slot) => {
+      var _a2;
+      return s + ((_a2 = slot.used) != null ? _a2 : 0);
+    }, 0);
+    if (slotsUsed > 0) {
+      cats.push({ id: "spell-slots", label: "Spell Slots", preview: "all reset" });
+    }
+    const totalLevel = (_b = resolved.totalLevel) != null ? _b : 0;
+    const regainBudget = Math.max(1, Math.floor(totalLevel / 2));
+    const pools = Object.entries((_c = character.state.hit_dice) != null ? _c : {}).map(([die, hd]) => ({ die, used: hd.used, total: hd.total })).filter((p) => p.used > 0).sort((a, b) => b.used - a.used);
+    if (pools.length > 0) {
+      let left = regainBudget;
+      const dist = [];
+      for (const p of pools) {
+        if (left === 0) break;
+        const give = Math.min(p.used, left);
+        if (give > 0) dist.push({ die: p.die, give, targetUsed: p.used - give });
+        left -= give;
+      }
+      const totalGive = dist.reduce((s, d) => s + d.give, 0);
+      if (totalGive > 0) {
+        const detail = dist.map((d) => `${d.die}: +${d.give}`).join(", ");
+        cats.push({
+          id: "hd-regain",
+          label: "Hit Dice",
+          preview: `+${totalGive} (${detail})`
+        });
+        hdRegainDist = dist.map((d) => ({ die: d.die, targetUsed: d.targetUsed }));
+      }
+    }
+    for (const [key, fu] of Object.entries((_d = character.state.feature_uses) != null ? _d : {})) {
+      if (fu.used <= 0) continue;
+      const res = findResourceById(resolved, key);
+      const reset = (_e = res == null ? void 0 : res.reset) != null ? _e : "long-rest";
+      if (reset !== "short-rest" && reset !== "long-rest" && reset !== "dawn" && reset !== "dusk") continue;
+      cats.push({
+        id: `feature:${key}`,
+        label: (_f = res == null ? void 0 : res.label) != null ? _f : key,
+        preview: `${fu.used}/${fu.max} restored`
+      });
+    }
+    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;
+      if (!rec || !charges) return;
+      if (charges.current >= charges.max) return;
+      if (rec.reset !== "short" && rec.reset !== "long" && rec.reset !== "dawn") 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}`
+      });
+    });
+  }
+  if (type === "short") {
+    for (const [key, fu] of Object.entries((_g = character.state.feature_uses) != null ? _g : {})) {
+      if (fu.used <= 0) continue;
+      const res = findResourceById(resolved, key);
+      if (((_h = res == null ? void 0 : res.reset) != null ? _h : "long-rest") !== "short-rest") continue;
+      cats.push({
+        id: `feature:${key}`,
+        label: (_i = res == null ? void 0 : res.label) != null ? _i : key,
+        preview: `${fu.used}/${fu.max} restored`
+      });
+    }
+    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;
+      if (!rec || !charges) return;
+      if (charges.current >= charges.max) return;
+      if (rec.reset !== "short") 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}`
+      });
+    });
+  }
+  const hdAvailable = type === "short" ? Object.entries((_j = character.state.hit_dice) != null ? _j : {}).filter(([, hd]) => hd.used < hd.total).map(([die, hd]) => ({ die, remaining: hd.total - hd.used })) : [];
+  return { type, categories: cats, hdAvailable, hdRegainDist };
+}
+export {
+  computeRestPlan
+};