@archivist-gg/dnd5e 0.1.0

package/dist/pc/pc.decision-engine.js

@@ -0,0 +1,19 @@
+import {
+  __matchesFilterForTest,
+  bareEntitySlug,
+  buildDecisionLedger,
+  collectChosenAbilityPoints,
+  collectChosenProficiencies,
+  wikilinkTailSlug
+} from "../chunk-TJCNX6UZ.js";
+import "../chunk-BH6AMZVY.js";
+import "../chunk-JEYQU3JT.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  __matchesFilterForTest,
+  bareEntitySlug,
+  buildDecisionLedger,
+  collectChosenAbilityPoints,
+  collectChosenProficiencies,
+  wikilinkTailSlug
+};

package/dist/pc/pc.equipment.d.ts

@@ -0,0 +1,12 @@
+import type { EntityRegistry } from "@archivist-gg/core";
+import type { Ability } from "@archivist-gg/dnd5e";
+import type { AppliedBonuses, DerivedEquipment, ResolvedCharacter, ProficiencySet } from "./pc.types.js";
+interface ProficienciesForQuery {
+    armor: ProficiencySet;
+    weapons: ProficiencySet;
+    tools: ProficiencySet;
+}
+export declare function emptyAppliedBonuses(): AppliedBonuses;
+export declare function computeAppliedBonuses(resolved: ResolvedCharacter, _profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[]): AppliedBonuses;
+export declare function computeSlotsAndAttacks(resolved: ResolvedCharacter, mods: Record<Ability, number>, profs: ProficienciesForQuery, registry: EntityRegistry, warnings: string[], proficiencyBonus: number, weaponAbilityOverride?: Ability): DerivedEquipment;
+export {};

package/dist/pc/pc.equipment.js

@@ -0,0 +1,15 @@
+import {
+  computeAppliedBonuses,
+  computeSlotsAndAttacks,
+  emptyAppliedBonuses
+} from "../chunk-QQ5W2AZP.js";
+import "../chunk-UC4FE5X3.js";
+import "../chunk-LWFTHJIE.js";
+import "../chunk-DNAJRMNN.js";
+import "../chunk-DC74TZNA.js";
+import "../chunk-3TRGRSCH.js";
+export {
+  computeAppliedBonuses,
+  computeSlotsAndAttacks,
+  emptyAppliedBonuses
+};

package/dist/pc/pc.feature-effects.d.ts

@@ -0,0 +1,95 @@
+import type { SenseType } from "@archivist-gg/dnd5e/types/feature-effect";
+import type { Ability } from "@archivist-gg/dnd5e";
+import type { ResolvedFeature, RollModifierEntry } from "./pc.types.js";
+/**
+ * Aggregated passive feature effects (effects-application engine).
+ * One pure scan over resolved.features[].feature.effects[]. Merge semantics
+ * mirror pc.conditions mergePartial: numbers add, each sense range takes max,
+ * lists union case-insensitively. apply-condition and damage-bonus are action/attack
+ * time and intentionally not aggregated; `while`-gated immune-condition
+ * entries are skipped entirely (conditional effects are a named deferral).
+ */
+export interface FeatureEffectTotals {
+    initiative_bonus: number;
+    hp_per_level_bonus: number;
+    speed_walk_bonus: number;
+    /**
+     * Absolute walk-speed FLOOR from `speed-bonus` effects with `set:true` (e.g.
+     * a "base speed becomes 60" feature). Max across all set effects; 0 = none.
+     * recalc applies it as Math.max(set, race + additive bonuses) so it never
+     * lowers an already-higher speed and is independent of the additive bonus.
+     */
+    speed_walk_set: number;
+    /** Max range per sense type granted by effects; 0 = none for that type. */
+    senses: Record<SenseType, number>;
+    /** One term per ac-bonus effect, labeled with the owning feature's name. */
+    ac_terms: {
+        value: number;
+        requires_armor: boolean;
+        label: string;
+    }[];
+    resistances: string[];
+    condition_immunities: string[];
+    /**
+     * skills are kebab-case lowercase slugs (matching skill slugs). armor/weapons
+     * are lowercase CATEGORY words ("heavy"/"shield", "simple"/"martial") — the
+     * same form class/race/feat grants use; recalc folds them into the matcher's
+     * `.categories` bucket, NOT `.specific` (which is per-item slugs). tools/languages
+     * keep their display spelling; saves are canonical ability keys.
+     */
+    proficiencies: {
+        skills: string[];
+        tools: string[];
+        languages: string[];
+        saves: Ability[];
+        armor: string[];
+        weapons: string[];
+    };
+    /**
+     * v1 global melee-attack ability override (Hexblade "Lies", etc.). The first
+     * `weapon-ability` effect with a concrete ability (not `"spellcasting"`) wins;
+     * `"spellcasting"` is resolved against the caster ability in recalc. `weapons`
+     * scope is parsed but ignored here (global override). null = no override.
+     */
+    weaponAbility: Ability | null;
+    /**
+     * Order-preserving list of structured advantage/disadvantage entries from
+     * `roll-modifier` effects. Pass-through (no dedupe/merge); each entry is
+     * labeled with the owning feature's name.
+     */
+    rollModifiers: RollModifierEntry[];
+    /**
+     * Lowest weapon-attack crit threshold (natural roll that scores a critical
+     * hit) granted by `crit-range` effects. Folds via Math.min from init 20, so
+     * 20 = no expansion. spell-only (`applies_to:"spell"`) entries do NOT lower
+     * it. recalc maps this onto each AttackRow as `critRange` only when < 20.
+     */
+    critRange: number;
+    /**
+     * Max extra attacks per Attack action granted by `extra-attack` effects.
+     * Non-stacking (D&D Extra Attack features don't stack): folds via Math.max
+     * from init 0, so 0 = no extra attacks. recalc maps this onto
+     * DerivedStats.attacksPerAction as `1 + extraAttack`.
+     */
+    extraAttack: number;
+    /**
+     * Order-preserving display-only captions surfaced from `reroll-damage` and
+     * `attack-rule` effects (e.g. "Reroll 2s", "No disadvantage firing in melee").
+     * recalc post-applies this list onto each AttackRow as `attackNotes` only when
+     * non-empty, so untouched attack rows keep `attackNotes: undefined`.
+     */
+    attackNotes: string[];
+}
+export declare function emptyFeatureEffectTotals(): FeatureEffectTotals;
+/**
+ * Optional fold inputs. `activeBuffs` is the set of currently-toggled buff
+ * ids/slugs (from Character.state.active_buffs + selected pool boons). An
+ * `activatable` feature's effects fold ONLY while its id is in this set; a buff
+ * is OFF by default, so callers passing no opts see activatable features fold to
+ * nothing (correct — a buff is off until toggled). Non-activatable features fold
+ * unconditionally regardless of opts.
+ */
+export interface FeatureEffectsOpts {
+    activeBuffs?: Set<string>;
+}
+export declare function computeFeatureEffects(features: ResolvedFeature[], opts?: FeatureEffectsOpts): FeatureEffectTotals;

package/dist/pc/pc.feature-effects.js

@@ -0,0 +1,9 @@
+import {
+  computeFeatureEffects,
+  emptyFeatureEffectTotals
+} from "../chunk-XURS6Q6Q.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  computeFeatureEffects,
+  emptyFeatureEffectTotals
+};

package/dist/pc/pc.formula-context.d.ts

@@ -0,0 +1,4 @@
+import type { EntityRegistry } from "@archivist-gg/core";
+import type { FormulaContext } from "@archivist-gg/dnd5e/types/formula-context";
+import type { DerivedStats, ResolvedCharacter } from "./pc.types.js";
+export declare function buildFormulaContext(resolved: ResolvedCharacter, derived: DerivedStats, registry: EntityRegistry): FormulaContext;

package/dist/pc/pc.formula-context.js

@@ -0,0 +1,11 @@
+// src/pc/pc.formula-context.ts
+function buildFormulaContext(resolved, derived, registry) {
+  return {
+    abilities: resolved.definition.abilities,
+    proficiencyBonus: derived.proficiencyBonus,
+    compendium: registry
+  };
+}
+export {
+  buildFormulaContext
+};

package/dist/pc/pc.parser.d.ts

@@ -0,0 +1,3 @@
+import type { ParseResult } from "@archivist-gg/core";
+import type { Character } from "./pc.types.js";
+export declare function parsePC(source: string): ParseResult<Character>;

package/dist/pc/pc.parser.js

@@ -0,0 +1,41 @@
+import {
+  characterSchema
+} from "../chunk-ZLG6FQFB.js";
+import "../chunk-TZK36BU7.js";
+
+// src/pc/pc.parser.ts
+import * as yaml from "js-yaml";
+function parsePC(source) {
+  let raw;
+  try {
+    raw = yaml.load(source);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { success: false, error: `YAML parse error: ${msg}` };
+  }
+  if (!raw || typeof raw !== "object") {
+    return { success: false, error: "Invalid YAML: expected an object" };
+  }
+  const result = characterSchema.safeParse(raw);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    const path = issue.path.length ? issue.path.join(".") : "(root)";
+    return { success: false, error: `${path}: ${issue.message}` };
+  }
+  const data = result.data;
+  const legacyState = data.state;
+  const legacyCurrency = legacyState.currency;
+  if (legacyCurrency && !data.currency) {
+    data.currency = legacyCurrency;
+  }
+  if (legacyCurrency) {
+    delete legacyState.currency;
+  }
+  if (legacyState.attuned_items) {
+    delete legacyState.attuned_items;
+  }
+  return { success: true, data };
+}
+export {
+  parsePC
+};

package/dist/pc/pc.pools.d.ts

@@ -0,0 +1,12 @@
+import type { RegisteredEntity } from "@archivist-gg/core";
+import type { ResolvedCharacter, ResolvedClass, ResolvedPool } from "./pc.types.js";
+import type { SelectionPool } from "@archivist-gg/dnd5e/types/selection-pool";
+import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
+/** Structural subset of EntityRegistry used here (lets tests pass a fake). */
+export interface PoolRegistry {
+    search(query: string, entityType: string, limit: number): RegisteredEntity[];
+    getByTypeAndSlug(entityType: string, slug: string): RegisteredEntity | undefined;
+}
+export declare function levelPrereqMax(d: OptionalFeatureEntity): number;
+export declare function resolvePool(rc: ResolvedClass, classIndex: number, pool: SelectionPool, registry: PoolRegistry): ResolvedPool;
+export declare function resolveAllPools(resolved: ResolvedCharacter, registry: PoolRegistry): ResolvedPool[];

package/dist/pc/pc.pools.js

@@ -0,0 +1,15 @@
+import {
+  levelPrereqMax,
+  resolveAllPools,
+  resolvePool
+} from "../chunk-6PXE7T7C.js";
+import "../chunk-5XUXXAQJ.js";
+import "../chunk-TJCNX6UZ.js";
+import "../chunk-BH6AMZVY.js";
+import "../chunk-JEYQU3JT.js";
+import "../chunk-WP2CX2JO.js";
+export {
+  levelPrereqMax,
+  resolveAllPools,
+  resolvePool
+};

package/dist/pc/pc.proficiencies.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedCharacter } from "./pc.types.js";
+export interface ProficiencyAggregate {
+    armor: string[];
+    weapons: string[];
+    tools: string[];
+    languages: string[];
+}
+export declare function aggregateProficiencies(resolved: ResolvedCharacter): ProficiencyAggregate;

package/dist/pc/pc.proficiencies.js

@@ -0,0 +1,47 @@
+// src/pc/pc.proficiencies.ts
+function aggregateProficiencies(resolved) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const armor = /* @__PURE__ */ new Set();
+  const weapons = /* @__PURE__ */ new Set();
+  const tools = /* @__PURE__ */ new Set();
+  const languages = /* @__PURE__ */ new Set();
+  for (const c of resolved.classes) {
+    const prof = (_a = c.entity) == null ? void 0 : _a.proficiencies;
+    if (!prof) continue;
+    for (const a of (_b = prof.armor) != null ? _b : []) armor.add(prettyName(a));
+    if ((_c = prof.weapons) == null ? void 0 : _c.fixed) for (const w of prof.weapons.fixed) weapons.add(prettyName(w));
+    if ((_d = prof.weapons) == null ? void 0 : _d.categories) for (const w of prof.weapons.categories) weapons.add(prettyName(w));
+    if ((_e = prof.tools) == null ? void 0 : _e.fixed) for (const t of prof.tools.fixed) tools.add(prettyName(t));
+  }
+  const raceLangs = (_f = resolved.race) == null ? void 0 : _f.languages;
+  if (raceLangs == null ? void 0 : raceLangs.fixed) for (const l of raceLangs.fixed) languages.add(prettyName(l));
+  const bg = resolved.background;
+  if (bg) {
+    for (const entry of (_g = bg.tool_proficiencies) != null ? _g : []) {
+      if (entry.kind === "fixed") for (const t of entry.items) tools.add(prettyName(t));
+    }
+    for (const entry of (_h = bg.language_proficiencies) != null ? _h : []) {
+      if (entry.kind === "fixed") for (const l of entry.languages) languages.add(prettyName(l));
+    }
+  }
+  for (const f of resolved.feats) {
+    const grants = f.proficiencies;
+    if (!grants) continue;
+    for (const a of (_i = grants.armor) != null ? _i : []) armor.add(prettyName(a));
+    for (const w of (_j = grants.weapons) != null ? _j : []) weapons.add(prettyName(w));
+    for (const t of (_k = grants.tools) != null ? _k : []) tools.add(prettyName(t));
+    for (const l of (_l = grants.languages) != null ? _l : []) languages.add(prettyName(l));
+  }
+  return {
+    armor: [...armor].sort(),
+    weapons: [...weapons].sort(),
+    tools: [...tools].sort(),
+    languages: [...languages].sort()
+  };
+}
+function prettyName(slug) {
+  return slug.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+export {
+  aggregateProficiencies
+};

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

@@ -0,0 +1,11 @@
+import type { ArmorEntity } from "@archivist-gg/dnd5e/armor/armor.types";
+import type { WeaponEntity } from "@archivist-gg/dnd5e/weapon/weapon.types";
+import type { ProficiencySet } from "./pc.types.js";
+interface ProficienciesForQuery {
+    armor: ProficiencySet;
+    weapons: ProficiencySet;
+    tools: ProficiencySet;
+}
+export declare function isProficientWithWeapon(weapon: WeaponEntity, profs: ProficienciesForQuery): boolean;
+export declare function isProficientWithArmor(armor: ArmorEntity, profs: ProficienciesForQuery): boolean;
+export {};

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

@@ -0,0 +1,17 @@
+// src/pc/pc.proficiency-query.ts
+function isProficientWithWeapon(weapon, profs) {
+  if (profs.weapons.specific.includes(weapon.slug)) return true;
+  const baseCategory = weapon.category.split("-")[0];
+  return profs.weapons.categories.includes(baseCategory);
+}
+function isProficientWithArmor(armor, profs) {
+  if (profs.armor.specific.includes(armor.slug)) return true;
+  if (profs.armor.categories.includes(armor.category)) return true;
+  if (armor.category === "light" && (profs.armor.categories.includes("medium") || profs.armor.categories.includes("heavy"))) return true;
+  if (armor.category === "medium" && profs.armor.categories.includes("heavy")) return true;
+  return false;
+}
+export {
+  isProficientWithArmor,
+  isProficientWithWeapon
+};

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

@@ -0,0 +1,105 @@
+import type { Ability } from "@archivist-gg/dnd5e";
+import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
+import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
+import type { EntityRegistry } from "@archivist-gg/core";
+import type { ACTerm, 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
+ * Math.floor(die / 2) + 1 for even dice.
+ *
+ * d6 → 4, d8 → 5, d10 → 6, d12 → 7.
+ */
+export declare function phbAverageForDie(hitDieStr: string): number;
+/** Extracts the integer size from "d8" / "d10" / 8 / 10. */
+export declare function parseDieSize(die: string | number | undefined | null): number | null;
+/**
+ * Flattens RaceEntity.ability_score_increases into a partial ability→bonus map.
+ * Fixed increases contribute their amount directly. Choice increases are ignored
+ * here — they're expected to come through class.choices with a specific ability
+ * selected, which computeAbilityScores handles separately.
+ */
+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.
+ *
+ * Disjoint from chosen-feat ability-points (`choices[lvl]["feat:<id>"]`) 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:
+ *  species = fixed race ASI + subrace fixed ASI + race ability-points choices;
+ *  background = background ability-points choices;
+ *  class = legacy class ASI-BRANCH allocations (the L4 asi-or-feat → asi path);
+ *  feat = class chosen-feat ability-points (the L4 asi-or-feat → feat path) +
+ *         flat feat ability_bonuses (e.g. Athlete +1 STR). All already fold into
+ *         computeAbilityScores totals, so the caption must account for them or a
+ *         tile reads higher than the named sources explain (smoke r1/r5c). */
+export declare function abilityBonusBreakdown(resolved: ResolvedCharacter): Record<Ability, {
+    species: number;
+    background: number;
+    class: number;
+    feat: number;
+}>;
+/**
+ * PC-oriented multiclass HP.
+ * - First class's first level: max(hit_die) + conMod.
+ * - Every subsequent level (in any class): phbAverageForDie(thatLevel'sClass) + conMod.
+ * CON mod contributes once per total level.
+ */
+export declare function multiclassMaxHP(classes: ResolvedClass[], conMod: number): number;
+/**
+ * Default AC = 10 + DEX mod. If any class's features include an
+ * "Unarmored Defense"–style feature with a structured flag, applies the
+ * variant (Monk: +WIS; Barbarian: +CON). Falls back to feature-name
+ * regex matching with a warning pushed onto `warnings`.
+ */
+export declare function unarmoredAC(resolved: ResolvedCharacter, mods: Record<Ability, number>, warnings: string[]): number;
+/**
+ * Same logic as `unarmoredAC` but also returns a structured breakdown of the
+ * contributing terms (Base 10, DEX, optional class unarmored defense ability).
+ * Used by recalc to assemble a richer acBreakdown when no armor is equipped.
+ */
+export declare function unarmoredACBreakdown(resolved: ResolvedCharacter, mods: Record<Ability, number>, warnings: string[]): {
+    total: number;
+    terms: ACTerm[];
+};
+/** Initiative = DEX mod + Alert (+5 in 2014). Extendable via feat flags. */
+export declare function initiativeBonus(dexMod: number, feats: FeatEntity[], edition: "2014" | "2024"): number;
+/** Speed = race.speed.walk + flat bonuses from feats (e.g., Mobile +10). */
+export declare function speedFromRace(resolved: ResolvedCharacter): number;
+/**
+ * Folds class-level CHOSEN-FEAT ability-points into per-ability totals.
+ *
+ * When the L4-style "asi or feat" decision resolves to a feat that carries
+ * `ability-points` choices (e.g. Ability Score Improvement, the epic Boons),
+ * the picker persists the allocation under the namespaced key
+ * `choices[lvl]["feat:" + choice.id]` (the engine's `buildItem` surfaces those
+ * children; see pc.decision-engine.ts). This is disjoint from both the legacy
+ * asi-BRANCH key (`choices[lvl].asi`) and origin ability-points, so no source
+ * double-counts. The chosen feat entity is resolved from `resolved.feats`
+ * (already looked up by the resolver) — no registry needed here.
+ *
+ * Clamps defensively (per-ability max_per, then stops at the points total in
+ * ABILITY_KEYS order), mirroring collectChosenAbilityPoints.
+ */
+export declare function collectClassFeatAbilityPoints(resolved: ResolvedCharacter): Partial<Record<Ability, number>>;
+/**
+ * Combines racial ASI (from race.ability_score_increases), feat ASI,
+ * class-choice ASI (from classes[i].choices[lvl].asi), chosen-feat ASI
+ * (from classes[i].choices[lvl]["feat:<id>"]), and user overrides.
+ * Overrides win; ASI sources sum unconditionally.
+ */
+export declare function computeAbilityScores(resolved: ResolvedCharacter, overrides: CharacterOverrides): Record<Ability, number>;
+export declare function computeProficiencies(resolved: ResolvedCharacter): {
+    armor: ProficiencySet;
+    weapons: ProficiencySet;
+    tools: ProficiencySet;
+    languages: string[];
+    saves: Ability[];
+};
+export declare function recalc(resolved: ResolvedCharacter, registry?: EntityRegistry): DerivedStats;