From 8ba38d893db2c1708a1c834e8da3875bc668d69c Mon Sep 17 00:00:00 2001
From: Nils Briggen <nilsbriggen@gmail.com>
Date: Tue, 9 Jun 2026 01:23:52 +0200
Subject: [PATCH] V2 Phase 3: combat rules automation (conditions, damage
 types, reminders)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Completes the deployable Phase 1-3 chunk: the combat tracker now runs the math.

- condition-effects engine: declarative CONDITION_EFFECTS_5E/PF2E table +
  deriveState(system, speed, conditions) → effective speed / advantage state /
  incapacitation / pf2e status penalty. Tracker shows effect badges
  ("Speed 0", "Disadv. attacks", "−2 status"); pure + 10 unit tests.
- damage types: applyDamage(c, amount, type?) consults snapshotted monster
  DamageDefenses (immune→0, resist→halve, vulnerable→double), back-compatible.
  Monster add snapshots damageDefenses; tracker shows a type picker only when a
  creature has typed defenses, and the log notes resisted/vulnerable amounts.
- concentration + death saves are surfaced as REMINDERS, never auto-rolled:
  damaging a concentrating PC logs "roll a DC N Con save…"; a downed PC's turn
  logs "make a death saving throw." The player rolls and resolves via the Drop
  button / death-save pips they already own. (Per user: no auto dice rolls —
  it removes the player from their character.)

Build + 271 unit tests green. Verified live: grapple → Speed 0 badge;
fire-immune creature shows the immune-labelled damage picker.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/features/combat/EncounterTracker.tsx   | 70 ++++++++++++++++-
 src/features/compendium/CompendiumPage.tsx |  4 +-
 src/features/compendium/registry.tsx       |  5 +-
 src/lib/combat/engine.test.ts              | 13 ++++
 src/lib/combat/engine.ts                   | 23 +++++-
 src/lib/mechanics/cast.ts                  |  5 ++
 src/lib/mechanics/conditionEffects.ts      | 70 +++++++++++++++++
 src/lib/mechanics/creatureState.test.ts    | 74 ++++++++++++++++++
 src/lib/mechanics/creatureState.ts         | 88 ++++++++++++++++++++++
 src/lib/mechanics/index.ts                 |  4 +-
 src/lib/schemas/encounter.ts               | 13 ++++
 tsconfig.app.tsbuildinfo                   |  2 +-
 12 files changed, 359 insertions(+), 12 deletions(-)
 create mode 100644 src/lib/mechanics/conditionEffects.ts
 create mode 100644 src/lib/mechanics/creatureState.test.ts
 create mode 100644 src/lib/mechanics/creatureState.ts

diff --git a/src/features/combat/EncounterTracker.tsx b/src/features/combat/EncounterTracker.tsx
index 6083a8a..27ef1b7 100644
--- a/src/features/combat/EncounterTracker.tsx
+++ b/src/features/combat/EncounterTracker.tsx
@@ -23,6 +23,7 @@ import { createRng } from '@/lib/rng';
 import { rollDice } from '@/lib/dice/notation';
 import { getSystem, getConditions, type SystemId } from '@/lib/rules';
 import { computeBudget, DIFFICULTY_COLOR } from '@/lib/combat/budget';
+import { deriveState, DAMAGE_TYPES, concentrationDC } from '@/lib/mechanics';
 import { useCharacters, useAllPcs } from '@/features/characters/hooks';
 import { useConditionGlossary } from './useConditionGlossary';
 import {
@@ -66,6 +67,36 @@ export function EncounterTracker({ encounter, campaign }: { encounter: Encounter
     if (prev) void encountersRepo.save(prev);
   };
 
+  /** The Character backing a PC/NPC combatant, if any (for cross-doc rules state). */
+  const pcCharacter = (combatant: Combatant): Character | undefined =>
+    combatant.kind !== 'monster' && combatant.characterId
+      ? [...allPcs, ...characters].find((ch) => ch.id === combatant.characterId)
+      : undefined;
+
+  /**
+   * After a concentrating PC takes damage, the app computes the Constitution
+   * save DC and surfaces it — but never rolls. The player rolls their own save
+   * and, on a failure, uses the Drop button on their sheet/panel. (Auto-rolling
+   * would take the moment away from the player.)
+   */
+  const noteConcentrationCheck = (combatant: Combatant, damage: number) => {
+    if (damage <= 0) return;
+    const ch = pcCharacter(combatant);
+    if (!ch?.concentration) return;
+    const dc = concentrationDC(damage);
+    void encountersRepo.mutate(encounter.id, (e) =>
+      logEvent(e, `${ch.name}: roll a DC ${dc} Constitution save or lose concentration on ${ch.concentration!.spellName}.`));
+  };
+
+  /** Advance the turn; remind (don't roll) when a downed PC's turn begins. */
+  const advanceTurn = () => {
+    mutate(nextTurn);
+    const upcoming = currentCombatant(nextTurn(encounter));
+    if (upcoming && upcoming.kind !== 'monster' && upcoming.hp.current <= 0 && pcCharacter(upcoming)) {
+      void encountersRepo.mutate(encounter.id, (e) => logEvent(e, `${upcoming.name} is down — make a death saving throw.`));
+    }
+  };
+
   const rollAllInitiative = () => {
     const rolls: Record<string, number> = {};
     for (const c of encounter.combatants) rolls[c.id] = rollDice('1d20', createRng()).total + c.initBonus;
@@ -148,7 +179,7 @@ export function EncounterTracker({ encounter, campaign }: { encounter: Encounter
               <Button variant="secondary" onClick={() => mutate(previousTurn)}>
                 <ChevronLeft size={15} aria-hidden /> Prev
               </Button>
-              <Button variant="primary" onClick={() => mutate(nextTurn)}>
+              <Button variant="primary" onClick={advanceTurn}>
                 Next turn <ChevronRight size={15} aria-hidden />
               </Button>
               <Button variant="ghost" className="text-danger" onClick={() => mutate(endEncounter)}>
@@ -185,7 +216,15 @@ export function EncounterTracker({ encounter, campaign }: { encounter: Encounter
               glossary={glossary}
               isCurrent={isActive && idx === encounter.turnIndex}
               onChange={(patch) => mutate((e) => updateCombatant(e, c.id, patch))}
-              onDamage={(amt) => mutate((e) => logEvent(updateCombatant(e, c.id, { hp: applyDamage(c, amt).hp }), `${c.name} takes ${amt} damage`))}
+              onDamage={(amt, type) => {
+                const after = applyDamage(c, amt, type);
+                const hpLoss = (c.hp.current - after.hp.current) + (c.hp.temp - after.hp.temp);
+                const note = hpLoss === amt
+                  ? `${c.name} takes ${amt}${type ? ` ${type}` : ''} damage`
+                  : `${c.name} takes ${hpLoss}${type ? ` ${type}` : ''} damage (${amt} before ${hpLoss < amt ? 'resistance' : 'vulnerability'})`;
+                mutate((e) => logEvent(updateCombatant(e, c.id, { hp: after.hp }), note));
+                noteConcentrationCheck(c, hpLoss);
+              }}
               onHeal={(amt) => mutate((e) => logEvent(updateCombatant(e, c.id, { hp: applyHealing(c, amt).hp }), `${c.name} heals ${amt}`))}
               onMove={(dir) => mutate((e) => moveCombatant(e, c.id, dir))}
               onRemove={() => mutate((e) => logEvent(removeCombatant(e, c.id), `${c.name} removed`))}
@@ -357,12 +396,16 @@ function CombatantRow({
   glossary: Map<string, string>;
   isCurrent: boolean;
   onChange: (patch: Partial<Combatant>) => void;
-  onDamage: (amt: number) => void;
+  onDamage: (amt: number, type?: string) => void;
   onHeal: (amt: number) => void;
   onMove: (dir: -1 | 1) => void;
   onRemove: () => void;
 }) {
   const [delta, setDelta] = useState(0);
+  const [dmgType, setDmgType] = useState('');
+  // Only show the damage-type picker when this creature actually has typed defenses.
+  const def = c.damageDefenses;
+  const hasDefenses = !!def && (def.resist.length > 0 || def.immune.length > 0 || def.vulnerable.length > 0);
   const dead = c.hp.current <= 0;
   const foe = c.kind === 'monster';
   const ratio = c.hp.max > 0 ? c.hp.current / c.hp.max : 0;
@@ -440,12 +483,31 @@ function CombatantRow({
               ))}
             </div>
           )}
+          {/* Mechanical consequences the conditions impose (enforced read-model). */}
+          {(() => {
+            const st = deriveState(system, 30, c.conditions);
+            return st.badges.length > 0 ? (
+              <div className="mt-1 flex flex-wrap gap-1" aria-label="Condition effects">
+                {st.badges.map((b) => (
+                  <span key={b} className="rounded border border-line bg-surface px-1.5 py-0.5 text-[10px] font-medium text-muted">{b}</span>
+                ))}
+              </div>
+            ) : null;
+          })()}
         </div>
 
         {/* HP controls */}
         <div className="flex items-center gap-1">
           <NumberField className="w-14" value={delta} min={0} onChange={setDelta} aria-label={`${c.name} HP amount`} />
-          <Button size="sm" variant="danger" disabled={delta <= 0} onClick={() => { onDamage(delta); setDelta(0); }} title="Apply damage">
+          {hasDefenses && (
+            <Select className="w-auto py-1 text-xs" value={dmgType} onChange={(e) => setDmgType(e.target.value)} aria-label={`${c.name} damage type`}>
+              <option value="">untyped</option>
+              {DAMAGE_TYPES.filter((t) => t !== 'untyped').map((t) => (
+                <option key={t} value={t}>{def!.immune.includes(t) ? `${t} (immune)` : def!.resist.includes(t) ? `${t} (resist)` : def!.vulnerable.includes(t) ? `${t} (vuln)` : t}</option>
+              ))}
+            </Select>
+          )}
+          <Button size="sm" variant="danger" disabled={delta <= 0} onClick={() => { onDamage(delta, dmgType || undefined); setDelta(0); }} title="Apply damage">
             <Sword size={14} aria-hidden /> Dmg
           </Button>
           <Button size="sm" variant="secondary" disabled={delta <= 0} onClick={() => { onHeal(delta); setDelta(0); }} title="Heal">
diff --git a/src/features/compendium/CompendiumPage.tsx b/src/features/compendium/CompendiumPage.tsx
index 704f87b..351f372 100644
--- a/src/features/compendium/CompendiumPage.tsx
+++ b/src/features/compendium/CompendiumPage.tsx
@@ -11,6 +11,7 @@ import { addCombatant } from '@/lib/combat/engine';
 import { charactersRepo, encountersRepo } from '@/lib/db/repositories';
 import { type Character, type InventoryItem, type SpellEntry, newSpellEntry } from '@/lib/schemas';
 import type { Spell, CompendiumEntry } from '@/lib/compendium/types';
+import type { CombatantDamageDefenses } from '@/lib/schemas/encounter';
 import { normalizeSpell5e, normalizeSpellPf2e } from '@/lib/mechanics';
 import { useUiStore } from '@/stores/uiStore';
 import { useActiveCampaign } from '@/features/campaigns/hooks';
@@ -295,7 +296,7 @@ function ActionBar({ children }: { children: React.ReactNode }) {
   );
 }
 
-function AddToCombat({ stats }: { stats: { name: string; ac: number; hp: number; initBonus: number; cr?: number; level?: number } }) {
+function AddToCombat({ stats }: { stats: { name: string; ac: number; hp: number; initBonus: number; cr?: number; level?: number; damageDefenses?: CombatantDamageDefenses } }) {
   const activeEncounterId = useUiStore((s) => s.activeEncounterId);
   const [msg, setMsg] = useState<string | null>(null);
 
@@ -312,6 +313,7 @@ function AddToCombat({ stats }: { stats: { name: string; ac: number; hp: number;
         conditions: [], notes: '',
         ...(stats.cr !== undefined ? { cr: stats.cr } : {}),
         ...(stats.level !== undefined ? { level: stats.level } : {}),
+        ...(stats.damageDefenses ? { damageDefenses: stats.damageDefenses } : {}),
       }),
     );
     setMsg(`Added to "${enc.name}" (init ${initiative}).`);
diff --git a/src/features/compendium/registry.tsx b/src/features/compendium/registry.tsx
index 5da4dd4..5ac9f0f 100644
--- a/src/features/compendium/registry.tsx
+++ b/src/features/compendium/registry.tsx
@@ -1,6 +1,8 @@
 import type { ReactNode } from 'react';
 import type { SystemId } from '@/lib/rules';
 import { abilityModifier } from '@/lib/rules';
+import { normalizeMonsterDefenses } from '@/lib/mechanics';
+import type { CombatantDamageDefenses } from '@/lib/schemas/encounter';
 import type { CompendiumEntry, Monster, Spell, MagicItem } from '@/lib/compendium/types';
 import {
   loadMonsters,
@@ -49,7 +51,7 @@ export interface CategoryDef {
   /** enables "add to character" for spells/items */
   linkAs?: 'spell' | 'item';
   /** enables "add to combat" for monsters/creatures */
-  toCombatant?: (e: Entry) => { name: string; ac: number; hp: number; initBonus: number; cr?: number; level?: number };
+  toCombatant?: (e: Entry) => { name: string; ac: number; hp: number; initBonus: number; cr?: number; level?: number; damageDefenses?: CombatantDamageDefenses };
   /** optional numeric sort axis (e.g. CR, spell level) in addition to name */
   numericSort?: { label: string; get: (e: Entry) => number };
 }
@@ -169,6 +171,7 @@ export const CATEGORIES: CategoryDef[] = [
         name: m.name, ac: m.armor_class ?? 10, hp: m.hit_points ?? 1,
         initBonus: abilityModifier(m.dexterity ?? 10),
         ...(m.cr !== undefined ? { cr: m.cr } : {}),
+        damageDefenses: normalizeMonsterDefenses(m),
       };
     },
     numericSort: { label: 'CR', get: (e) => Number(e.cr) },
diff --git a/src/lib/combat/engine.test.ts b/src/lib/combat/engine.test.ts
index 5d7a6b8..5c4f46a 100644
--- a/src/lib/combat/engine.test.ts
+++ b/src/lib/combat/engine.test.ts
@@ -161,6 +161,19 @@ describe('HP transitions', () => {
     expect(applyDamage(c, Number.NaN).hp.current).toBe(10);
     expect(applyHealing(c, -5).hp.current).toBe(10);
   });
+
+  it('applies typed-damage resistances when defenses are present', () => {
+    const base = { ...mk('a', 0, 20), damageDefenses: { resist: ['fire'], immune: ['poison'], vulnerable: ['cold'], conditionImmune: [], notes: [] } };
+    expect(applyDamage(base, 10, 'fire').hp.current).toBe(15); // resisted → 5
+    expect(applyDamage(base, 10, 'poison').hp.current).toBe(20); // immune → 0
+    expect(applyDamage(base, 10, 'cold').hp.current).toBe(0); // vulnerable → 20
+    expect(applyDamage(base, 10, 'acid').hp.current).toBe(10); // untracked type → full
+    expect(applyDamage(base, 10).hp.current).toBe(10); // no type → full (back-compat)
+  });
+
+  it('typeless damage is unchanged when no defenses are set', () => {
+    expect(applyDamage(mk('a', 0, 10), 4, 'fire').hp.current).toBe(6);
+  });
 });
 
 describe('endEncounter', () => {
diff --git a/src/lib/combat/engine.ts b/src/lib/combat/engine.ts
index 7bf0855..83c280c 100644
--- a/src/lib/combat/engine.ts
+++ b/src/lib/combat/engine.ts
@@ -207,11 +207,26 @@ export function moveCombatant(enc: Encounter, id: string, direction: -1 | 1): En
 
 // ---------------- HP transitions ----------------
 
-/** Apply damage: temporary HP absorbs first, then current (may go negative). */
-export function applyDamage(c: Combatant, amount: number): Combatant {
+/**
+ * Apply damage of an optional type. Resistances are consulted first (immune → 0,
+ * resistant → halved and rounded down, vulnerable → doubled), then temporary HP
+ * absorbs, then current HP (which may go negative). Passing no `type` reproduces
+ * the original typeless behaviour exactly.
+ */
+export function applyDamage(c: Combatant, amount: number, type?: string): Combatant {
   if (!Number.isFinite(amount) || amount <= 0) return c;
-  const absorbed = Math.min(c.hp.temp, amount);
-  const remaining = amount - absorbed;
+
+  let dmg = amount;
+  const def = c.damageDefenses;
+  if (type && def) {
+    if (def.immune.includes(type)) dmg = 0;
+    else if (def.vulnerable.includes(type)) dmg = amount * 2;
+    else if (def.resist.includes(type)) dmg = Math.floor(amount / 2);
+  }
+  if (dmg <= 0) return c; // fully resisted / immune — no change
+
+  const absorbed = Math.min(c.hp.temp, dmg);
+  const remaining = dmg - absorbed;
   return {
     ...c,
     hp: { ...c.hp, temp: c.hp.temp - absorbed, current: c.hp.current - remaining },
diff --git a/src/lib/mechanics/cast.ts b/src/lib/mechanics/cast.ts
index 79a9c40..e201b6e 100644
--- a/src/lib/mechanics/cast.ts
+++ b/src/lib/mechanics/cast.ts
@@ -59,3 +59,8 @@ export function castSpell(c: Character, spellId: string, atLevel?: number): Enfo
 export function dropConcentration(c: Character): Partial<Character> {
   return c.concentration ? { concentration: null } : {};
 }
+
+/** 5e Constitution save DC to maintain concentration after taking `damage`. */
+export function concentrationDC(damage: number): number {
+  return Math.max(10, Math.floor(damage / 2));
+}
diff --git a/src/lib/mechanics/conditionEffects.ts b/src/lib/mechanics/conditionEffects.ts
new file mode 100644
index 0000000..a06e39d
--- /dev/null
+++ b/src/lib/mechanics/conditionEffects.ts
@@ -0,0 +1,70 @@
+import type { SystemId } from '@/lib/rules';
+import type { AbilityKey, AdvState } from './types';
+
+/**
+ * The mechanical effect a condition imposes — a declarative table, never
+ * hardcoded `if`s in combat code. `deriveState` (creatureState.ts) folds these
+ * into a single query the tracker and dice roller ask.
+ */
+export interface ConditionEffect {
+  /** sets effective speed to 0 */
+  speedZero?: boolean;
+  /** this creature's attack rolls */
+  attackRolls?: AdvState;
+  /** attack rolls made AGAINST this creature */
+  attacksAgainst?: AdvState;
+  /** disadvantage on ability checks (5e) */
+  abilityChecks?: boolean;
+  /** per-ability save penalty (auto-fail dominates disadvantage) */
+  saves?: Partial<Record<AbilityKey, 'disadvantage' | 'auto-fail'>>;
+  /** cannot take actions or reactions */
+  incapacitated?: boolean;
+  /** pf2e: a numeric status penalty scaling with the condition's value */
+  statusPenalty?: boolean;
+}
+
+const ALL_PHYS: Partial<Record<AbilityKey, 'auto-fail'>> = { str: 'auto-fail', dex: 'auto-fail' };
+
+/** D&D 5e condition mechanics (keys lowercased to match stored names). */
+export const CONDITION_EFFECTS_5E: Record<string, ConditionEffect> = {
+  blinded: { attackRolls: 'disadvantage', attacksAgainst: 'advantage' },
+  frightened: { attackRolls: 'disadvantage', abilityChecks: true },
+  grappled: { speedZero: true },
+  incapacitated: { incapacitated: true },
+  invisible: { attackRolls: 'advantage', attacksAgainst: 'disadvantage' },
+  paralyzed: { incapacitated: true, speedZero: true, attacksAgainst: 'advantage', saves: ALL_PHYS },
+  petrified: { incapacitated: true, speedZero: true, attacksAgainst: 'advantage', saves: ALL_PHYS },
+  poisoned: { attackRolls: 'disadvantage', abilityChecks: true },
+  prone: { attackRolls: 'disadvantage', attacksAgainst: 'advantage' },
+  restrained: { speedZero: true, attackRolls: 'disadvantage', attacksAgainst: 'advantage', saves: { dex: 'disadvantage' } },
+  stunned: { incapacitated: true, speedZero: true, attacksAgainst: 'advantage', saves: ALL_PHYS },
+  unconscious: { incapacitated: true, speedZero: true, attacksAgainst: 'advantage', saves: ALL_PHYS },
+};
+
+/**
+ * Pathfinder 2e condition mechanics. PF2e uses flat numeric penalties rather
+ * than advantage/disadvantage; valued conditions (frightened N, clumsy N, …)
+ * contribute a status penalty aggregated by `deriveState`.
+ */
+export const CONDITION_EFFECTS_PF2E: Record<string, ConditionEffect> = {
+  blinded: { attacksAgainst: 'advantage' },
+  clumsy: { statusPenalty: true },
+  enfeebled: { statusPenalty: true },
+  frightened: { statusPenalty: true },
+  grabbed: { speedZero: true, attacksAgainst: 'advantage' },
+  immobilized: { speedZero: true },
+  paralyzed: { incapacitated: true, speedZero: true, attacksAgainst: 'advantage' },
+  petrified: { incapacitated: true, speedZero: true },
+  prone: { attacksAgainst: 'advantage' },
+  restrained: { speedZero: true, incapacitated: false, attacksAgainst: 'advantage' },
+  sickened: { statusPenalty: true },
+  slowed: { statusPenalty: true },
+  stunned: { incapacitated: true },
+  stupefied: { statusPenalty: true },
+  unconscious: { incapacitated: true, speedZero: true, attacksAgainst: 'advantage' },
+  'off-guard': { attacksAgainst: 'advantage' },
+};
+
+export function conditionEffects(system: SystemId): Record<string, ConditionEffect> {
+  return system === 'pf2e' ? CONDITION_EFFECTS_PF2E : CONDITION_EFFECTS_5E;
+}
diff --git a/src/lib/mechanics/creatureState.test.ts b/src/lib/mechanics/creatureState.test.ts
new file mode 100644
index 0000000..5b7c6c8
--- /dev/null
+++ b/src/lib/mechanics/creatureState.test.ts
@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { deriveState } from './creatureState';
+import { concentrationDC } from './cast';
+import type { Condition } from '@/lib/schemas/common';
+
+const cond = (name: string, value?: number): Condition => (value !== undefined ? { name, value } : { name });
+
+describe('deriveState (5e)', () => {
+  it('grappled zeroes speed', () => {
+    const s = deriveState('5e', 30, [cond('Grappled')]);
+    expect(s.speed).toBe(0);
+    expect(s.badges).toContain('Speed 0');
+  });
+
+  it('poisoned imposes disadvantage on attacks and ability checks', () => {
+    const s = deriveState('5e', 30, [cond('Poisoned')]);
+    expect(s.attackModifier).toBe('disadvantage');
+    expect(s.abilityCheckDisadvantage).toBe(true);
+  });
+
+  it('restrained: speed 0, disadv attacks, attacked with advantage, dex save disadvantage', () => {
+    const s = deriveState('5e', 30, [cond('Restrained')]);
+    expect(s.speed).toBe(0);
+    expect(s.attackModifier).toBe('disadvantage');
+    expect(s.attacksAgainstModifier).toBe('advantage');
+    expect(s.saveModifiers.dex).toBe('disadvantage');
+  });
+
+  it('paralyzed auto-fails str/dex saves and incapacitates', () => {
+    const s = deriveState('5e', 30, [cond('Paralyzed')]);
+    expect(s.incapacitated).toBe(true);
+    expect(s.saveModifiers.str).toBe('auto-fail');
+    expect(s.saveModifiers.dex).toBe('auto-fail');
+  });
+
+  it('opposing advantage and disadvantage cancel to normal', () => {
+    // invisible grants advantage to attack; poisoned imposes disadvantage → normal
+    const s = deriveState('5e', 30, [cond('Invisible'), cond('Poisoned')]);
+    expect(s.attackModifier).toBe('normal');
+  });
+
+  it('unknown/homebrew condition contributes nothing', () => {
+    const s = deriveState('5e', 30, [cond('Inspired by bards')]);
+    expect(s).toMatchObject({ speed: 30, attackModifier: 'normal', incapacitated: false });
+    expect(s.badges).toEqual([]);
+  });
+});
+
+describe('deriveState (pf2e)', () => {
+  it('frightened contributes a numeric status penalty equal to its value', () => {
+    const s = deriveState('pf2e', 25, [cond('Frightened', 2)]);
+    expect(s.statusPenalty).toBe(2);
+    expect(s.badges).toContain('−2 status');
+  });
+
+  it('status penalties do not stack — worst value wins', () => {
+    const s = deriveState('pf2e', 25, [cond('Frightened', 1), cond('Sickened', 3)]);
+    expect(s.statusPenalty).toBe(3);
+  });
+
+  it('grabbed zeroes speed and grants advantage to attackers', () => {
+    const s = deriveState('pf2e', 25, [cond('Grabbed')]);
+    expect(s.speed).toBe(0);
+    expect(s.attacksAgainstModifier).toBe('advantage');
+  });
+});
+
+describe('concentrationDC', () => {
+  it('is half the damage, floored, minimum 10', () => {
+    expect(concentrationDC(8)).toBe(10); // floor(4)=4 → min 10
+    expect(concentrationDC(22)).toBe(11);
+    expect(concentrationDC(40)).toBe(20);
+  });
+});
diff --git a/src/lib/mechanics/creatureState.ts b/src/lib/mechanics/creatureState.ts
new file mode 100644
index 0000000..2d55fac
--- /dev/null
+++ b/src/lib/mechanics/creatureState.ts
@@ -0,0 +1,88 @@
+import type { SystemId } from '@/lib/rules';
+import type { Condition } from '@/lib/schemas/common';
+import { conditionEffects } from './conditionEffects';
+import type { AbilityKey, AdvState } from './types';
+
+export interface MechanicalState {
+  /** effective speed after conditions (0 if any condition zeroes it) */
+  speed: number;
+  /** advantage state on THIS creature's attack rolls (5e) */
+  attackModifier: AdvState;
+  /** advantage state on attacks made AGAINST this creature (5e) */
+  attacksAgainstModifier: AdvState;
+  /** cannot take actions/reactions */
+  incapacitated: boolean;
+  /** per-ability save penalties (auto-fail dominates disadvantage) */
+  saveModifiers: Partial<Record<AbilityKey, 'disadvantage' | 'auto-fail'>>;
+  /** disadvantage on ability checks (5e) */
+  abilityCheckDisadvantage: boolean;
+  /** pf2e: aggregated numeric status penalty (worst single value, penalties don't stack) */
+  statusPenalty: number;
+  /** short human-readable badges for the UI, e.g. "Speed 0", "Disadv. attacks" */
+  badges: string[];
+}
+
+/** Combine two advantage states by the 5e rule: opposing sources cancel to normal. */
+function combineAdv(a: AdvState, b: AdvState): AdvState {
+  if (a === b) return a;
+  if (a === 'normal') return b;
+  if (b === 'normal') return a;
+  return 'normal'; // one advantage + one disadvantage cancel
+}
+
+/**
+ * Fold a creature's conditions into a single mechanical read-model. Pure and
+ * synchronous — combat, the dice roller, and the player view all call this
+ * (the player view ships the same table and derives effects locally from the
+ * broadcast condition names, so no derived state crosses the wire).
+ *
+ * Unknown / homebrew condition names contribute nothing (they remain visible
+ * labels), exactly as before.
+ */
+export function deriveState(system: SystemId, baseSpeed: number, conditions: Condition[]): MechanicalState {
+  const table = conditionEffects(system);
+  let speedZero = false;
+  let attackModifier: AdvState = 'normal';
+  let attacksAgainstModifier: AdvState = 'normal';
+  let incapacitated = false;
+  let abilityCheckDisadvantage = false;
+  let statusPenalty = 0;
+  const saveModifiers: Partial<Record<AbilityKey, 'disadvantage' | 'auto-fail'>> = {};
+
+  for (const cond of conditions) {
+    const eff = table[cond.name.trim().toLowerCase()];
+    if (!eff) continue;
+    if (eff.speedZero) speedZero = true;
+    if (eff.incapacitated) incapacitated = true;
+    if (eff.abilityChecks) abilityCheckDisadvantage = true;
+    if (eff.attackRolls) attackModifier = combineAdv(attackModifier, eff.attackRolls);
+    if (eff.attacksAgainst) attacksAgainstModifier = combineAdv(attacksAgainstModifier, eff.attacksAgainst);
+    if (eff.saves) {
+      for (const [ability, level] of Object.entries(eff.saves) as [AbilityKey, 'disadvantage' | 'auto-fail'][]) {
+        // auto-fail dominates disadvantage
+        if (level === 'auto-fail' || saveModifiers[ability] === undefined) saveModifiers[ability] = level;
+      }
+    }
+    // pf2e: status penalties don't stack — take the worst single value.
+    if (eff.statusPenalty && cond.value !== undefined) statusPenalty = Math.max(statusPenalty, cond.value);
+  }
+
+  const badges: string[] = [];
+  if (speedZero) badges.push('Speed 0');
+  if (incapacitated) badges.push('Incapacitated');
+  if (attackModifier === 'disadvantage') badges.push('Disadv. attacks');
+  if (attackModifier === 'advantage') badges.push('Adv. attacks');
+  if (attacksAgainstModifier === 'advantage') badges.push('Attacked w/ adv.');
+  if (statusPenalty > 0) badges.push(`−${statusPenalty} status`);
+
+  return {
+    speed: speedZero ? 0 : baseSpeed,
+    attackModifier,
+    attacksAgainstModifier,
+    incapacitated,
+    saveModifiers,
+    abilityCheckDisadvantage,
+    statusPenalty,
+    badges,
+  };
+}
diff --git a/src/lib/mechanics/index.ts b/src/lib/mechanics/index.ts
index 8b1218e..f8e2c56 100644
--- a/src/lib/mechanics/index.ts
+++ b/src/lib/mechanics/index.ts
@@ -15,9 +15,11 @@ export type { EnforceResult } from './result';
 export { normalizeSpell5e, normalizeSpellPf2e } from './normalize/spell';
 export { normalizeArmor5e } from './normalize/armor';
 export { normalizeMonsterDefenses } from './normalize/monsterDefenses';
-export { castSpell, dropConcentration } from './cast';
+export { castSpell, dropConcentration, concentrationDC } from './cast';
 export { spendResource, regainResource } from './resources';
 export { rollDeathSave, type DeathSaveOutcome } from './deathSaves';
+export { conditionEffects, CONDITION_EFFECTS_5E, CONDITION_EFFECTS_PF2E, type ConditionEffect } from './conditionEffects';
+export { deriveState, type MechanicalState } from './creatureState';
 
 let spellMechCache: Map<string, SpellMechanics> | null = null;
 let armorMechCache: Map<string, ArmorMechanics> | null = null;
diff --git a/src/lib/schemas/encounter.ts b/src/lib/schemas/encounter.ts
index f13e912..64adcb6 100644
--- a/src/lib/schemas/encounter.ts
+++ b/src/lib/schemas/encounter.ts
@@ -3,6 +3,17 @@ import { conditionSchema, hpSchema, int } from './common';
 
 export const combatantKindSchema = z.enum(['pc', 'npc', 'monster']);
 
+/** Damage/condition defenses snapshotted from the bestiary at add time, so the
+ *  combat engine can apply resistances without an async compendium load. */
+export const damageDefensesSchema = z.object({
+  resist: z.array(z.string()).default([]),
+  immune: z.array(z.string()).default([]),
+  vulnerable: z.array(z.string()).default([]),
+  conditionImmune: z.array(z.string()).default([]),
+  notes: z.array(z.string()).default([]),
+});
+export type CombatantDamageDefenses = z.infer<typeof damageDefensesSchema>;
+
 export const combatantSchema = z.object({
   id: z.string(),
   name: z.string().min(1).max(120),
@@ -19,6 +30,8 @@ export const combatantSchema = z.object({
   hp: hpSchema,
   conditions: z.array(conditionSchema).default([]),
   notes: z.string().max(2000).default(''),
+  /** damage resistances/immunities snapshotted from the bestiary, if known */
+  damageDefenses: damageDefensesSchema.optional(),
   /** 5e challenge rating (for difficulty budget), if known */
   cr: z.number().finite().nonnegative().optional(),
   /** PF2e creature level (for difficulty budget), if known */
diff --git a/tsconfig.app.tsbuildinfo b/tsconfig.app.tsbuildinfo
index 694fb85..6fe8aec 100644
--- a/tsconfig.app.tsbuildinfo
+++ b/tsconfig.app.tsbuildinfo
@@ -1 +1 @@
-{"root":["./src/main.tsx","./src/router.tsx","./src/vite-env.d.ts","./src/app/RootLayout.tsx","./src/components/CommandPalette.tsx","./src/components/ui/Button.tsx","./src/components/ui/Codex.tsx","./src/components/ui/ErrorBoundary.tsx","./src/components/ui/Input.tsx","./src/components/ui/Modal.tsx","./src/components/ui/NumberField.tsx","./src/components/ui/Page.tsx","./src/components/ui/RollTray.tsx","./src/features/assistant/AssistantPage.tsx","./src/features/assistant/CampaignInsights.tsx","./src/features/assistant/EncounterTipCard.tsx","./src/features/assistant/NpcGenCard.tsx","./src/features/assistant/SessionPrepCard.tsx","./src/features/assistant/useEncounterAdvisor.ts","./src/features/assistant/useLevelUpAdvisor.ts","./src/features/campaigns/CampaignsPage.tsx","./src/features/campaigns/hooks.ts","./src/features/characters/CharacterSheet.tsx","./src/features/characters/CharacterSheetPage.tsx","./src/features/characters/CharactersPage.tsx","./src/features/characters/hooks.ts","./src/features/characters/builder/CreationWizard.tsx","./src/features/characters/sheet/AbilityGenModal.tsx","./src/features/characters/sheet/AttacksSection.tsx","./src/features/characters/sheet/DefensesSection.tsx","./src/features/characters/sheet/InventorySection.tsx","./src/features/characters/sheet/LevelUpAdvisor.tsx","./src/features/characters/sheet/LevelUpModal.tsx","./src/features/characters/sheet/ResourcesSection.tsx","./src/features/characters/sheet/SpellcastingSection.tsx","./src/features/characters/sheet/common.tsx","./src/features/cloud/useCloudAutosave.ts","./src/features/combat/CombatPage.tsx","./src/features/combat/EncounterTracker.tsx","./src/features/combat/hooks.ts","./src/features/combat/useConditionGlossary.ts","./src/features/compendium/CompendiumPage.tsx","./src/features/compendium/MonsterDetail.tsx","./src/features/compendium/details.tsx","./src/features/compendium/registry.test.ts","./src/features/compendium/registry.tsx","./src/features/dice/DicePage.tsx","./src/features/play/HandoutControl.tsx","./src/features/play/PlayerConnection.tsx","./src/features/play/SessionControl.tsx","./src/features/play/SessionSidebar.tsx","./src/features/play/usePlayerConnection.ts","./src/features/play/useSessionBroadcaster.ts","./src/features/player/ActionGuide.tsx","./src/features/player/MyCharacterPanel.tsx","./src/features/player/PlayerBoards.tsx","./src/features/player/PlayerMapView.tsx","./src/features/player/PlayerSetupPage.tsx","./src/features/player/PlayerViewPage.tsx","./src/features/player/RollFeed.tsx","./src/features/player/SeatClaimScreen.tsx","./src/features/settings/AssistantSettings.tsx","./src/features/settings/CloudCampaigns.tsx","./src/features/settings/SettingsPage.tsx","./src/features/world/CalendarPage.tsx","./src/features/world/DashboardPage.tsx","./src/features/world/HomebrewPage.tsx","./src/features/world/MapsPage.tsx","./src/features/world/NotesPage.tsx","./src/features/world/NpcsPage.tsx","./src/features/world/QuestsPage.tsx","./src/features/world/homebrew.ts","./src/features/world/hooks.ts","./src/features/world/map/MapCanvas.tsx","./src/features/world/map/MapEditor.tsx","./src/features/world/map/TokenPalette.test.ts","./src/features/world/map/TokenPalette.tsx","./src/features/world/map/tokens.ts","./src/lib/cn.ts","./src/lib/format.ts","./src/lib/ids.ts","./src/lib/rng.ts","./src/lib/sample.ts","./src/lib/useDebouncedCallback.ts","./src/lib/useRoll.ts","./src/lib/wikilinks.test.ts","./src/lib/wikilinks.ts","./src/lib/assistant/actions.ts","./src/lib/assistant/advisors.test.ts","./src/lib/assistant/advisors.ts","./src/lib/assistant/builder.ts","./src/lib/assistant/context.test.ts","./src/lib/assistant/context.ts","./src/lib/assistant/encounter.ts","./src/lib/assistant/levelup.test.ts","./src/lib/assistant/levelup.ts","./src/lib/assistant/patterns.test.ts","./src/lib/assistant/patterns.ts","./src/lib/assistant/prompts.test.ts","./src/lib/assistant/prompts.ts","./src/lib/assistant/session.ts","./src/lib/cloud/campaigns.ts","./src/lib/cloud/client.ts","./src/lib/combat/budget.test.ts","./src/lib/combat/budget.ts","./src/lib/combat/engine.test.ts","./src/lib/combat/engine.ts","./src/lib/combat/playerProjection.test.ts","./src/lib/combat/playerProjection.ts","./src/lib/compendium/index.ts","./src/lib/compendium/types.ts","./src/lib/db/db.ts","./src/lib/db/repositories.test.ts","./src/lib/db/repositories.ts","./src/lib/dice/check.test.ts","./src/lib/dice/check.ts","./src/lib/dice/notation.test.ts","./src/lib/dice/notation.ts","./src/lib/img/resize.test.ts","./src/lib/img/resize.ts","./src/lib/io/backup.test.ts","./src/lib/io/backup.ts","./src/lib/io/character.test.ts","./src/lib/io/character.ts","./src/lib/io/file.ts","./src/lib/io/pathbuilder.test.ts","./src/lib/io/pathbuilder.ts","./src/lib/llm/client.test.ts","./src/lib/llm/client.ts","./src/lib/llm/types.ts","./src/lib/map/distance.ts","./src/lib/map/fog.ts","./src/lib/map/grid.ts","./src/lib/map/index.ts","./src/lib/map/map.test.ts","./src/lib/map/projection.test.ts","./src/lib/map/projection.ts","./src/lib/map/shapes.ts","./src/lib/map/types.ts","./src/lib/map/viewport.test.ts","./src/lib/map/viewport.ts","./src/lib/map/vision.test.ts","./src/lib/map/vision.ts","./src/lib/mechanics/cast.ts","./src/lib/mechanics/deathSaves.ts","./src/lib/mechanics/enforce.test.ts","./src/lib/mechanics/index.ts","./src/lib/mechanics/resources.ts","./src/lib/mechanics/result.ts","./src/lib/mechanics/types.ts","./src/lib/mechanics/normalize/armor.ts","./src/lib/mechanics/normalize/monsterDefenses.ts","./src/lib/mechanics/normalize/normalize.test.ts","./src/lib/mechanics/normalize/spell.ts","./src/lib/rules/abilities.ts","./src/lib/rules/abilityGen.test.ts","./src/lib/rules/abilityGen.ts","./src/lib/rules/conditions.ts","./src/lib/rules/depth.test.ts","./src/lib/rules/index.ts","./src/lib/rules/progression.test.ts","./src/lib/rules/progression.ts","./src/lib/rules/rest.ts","./src/lib/rules/rules.test.ts","./src/lib/rules/types.ts","./src/lib/rules/dnd5e/index.ts","./src/lib/rules/dnd5e/progression.ts","./src/lib/rules/dnd5e/skills.ts","./src/lib/rules/pf2e/index.ts","./src/lib/rules/pf2e/progression.ts","./src/lib/rules/pf2e/skills.ts","./src/lib/ruleset/normalize.test.ts","./src/lib/ruleset/normalize.ts","./src/lib/schemas/campaign.ts","./src/lib/schemas/character.ts","./src/lib/schemas/common.ts","./src/lib/schemas/dice.ts","./src/lib/schemas/encounter.ts","./src/lib/schemas/index.ts","./src/lib/schemas/sessionLog.ts","./src/lib/schemas/world.ts","./src/lib/sync/index.ts","./src/lib/sync/messages.test.ts","./src/lib/sync/messages.ts","./src/lib/sync/playerLink.test.ts","./src/lib/sync/playerLink.ts","./src/lib/sync/snapshot.ts","./src/lib/sync/wsSync.ts","./src/lib/vtt/uvtt.test.ts","./src/lib/vtt/uvtt.ts","./src/stores/assistantStore.ts","./src/stores/macroStore.ts","./src/stores/playerSessionStore.ts","./src/stores/rollStore.ts","./src/stores/sessionStore.ts","./src/stores/uiStore.ts","./vitest.setup.ts"],"version":"5.9.3"}
\ No newline at end of file
+{"root":["./src/main.tsx","./src/router.tsx","./src/vite-env.d.ts","./src/app/RootLayout.tsx","./src/components/CommandPalette.tsx","./src/components/ui/Button.tsx","./src/components/ui/Codex.tsx","./src/components/ui/ErrorBoundary.tsx","./src/components/ui/Input.tsx","./src/components/ui/Modal.tsx","./src/components/ui/NumberField.tsx","./src/components/ui/Page.tsx","./src/components/ui/RollTray.tsx","./src/features/assistant/AssistantPage.tsx","./src/features/assistant/CampaignInsights.tsx","./src/features/assistant/EncounterTipCard.tsx","./src/features/assistant/NpcGenCard.tsx","./src/features/assistant/SessionPrepCard.tsx","./src/features/assistant/useEncounterAdvisor.ts","./src/features/assistant/useLevelUpAdvisor.ts","./src/features/campaigns/CampaignsPage.tsx","./src/features/campaigns/hooks.ts","./src/features/characters/CharacterSheet.tsx","./src/features/characters/CharacterSheetPage.tsx","./src/features/characters/CharactersPage.tsx","./src/features/characters/hooks.ts","./src/features/characters/builder/CreationWizard.tsx","./src/features/characters/sheet/AbilityGenModal.tsx","./src/features/characters/sheet/AttacksSection.tsx","./src/features/characters/sheet/DefensesSection.tsx","./src/features/characters/sheet/InventorySection.tsx","./src/features/characters/sheet/LevelUpAdvisor.tsx","./src/features/characters/sheet/LevelUpModal.tsx","./src/features/characters/sheet/ResourcesSection.tsx","./src/features/characters/sheet/SpellcastingSection.tsx","./src/features/characters/sheet/common.tsx","./src/features/cloud/useCloudAutosave.ts","./src/features/combat/CombatPage.tsx","./src/features/combat/EncounterTracker.tsx","./src/features/combat/hooks.ts","./src/features/combat/useConditionGlossary.ts","./src/features/compendium/CompendiumPage.tsx","./src/features/compendium/MonsterDetail.tsx","./src/features/compendium/details.tsx","./src/features/compendium/registry.test.ts","./src/features/compendium/registry.tsx","./src/features/dice/DicePage.tsx","./src/features/play/HandoutControl.tsx","./src/features/play/PlayerConnection.tsx","./src/features/play/SessionControl.tsx","./src/features/play/SessionSidebar.tsx","./src/features/play/usePlayerConnection.ts","./src/features/play/useSessionBroadcaster.ts","./src/features/player/ActionGuide.tsx","./src/features/player/MyCharacterPanel.tsx","./src/features/player/PlayerBoards.tsx","./src/features/player/PlayerMapView.tsx","./src/features/player/PlayerSetupPage.tsx","./src/features/player/PlayerViewPage.tsx","./src/features/player/RollFeed.tsx","./src/features/player/SeatClaimScreen.tsx","./src/features/settings/AssistantSettings.tsx","./src/features/settings/CloudCampaigns.tsx","./src/features/settings/SettingsPage.tsx","./src/features/world/CalendarPage.tsx","./src/features/world/DashboardPage.tsx","./src/features/world/HomebrewPage.tsx","./src/features/world/MapsPage.tsx","./src/features/world/NotesPage.tsx","./src/features/world/NpcsPage.tsx","./src/features/world/QuestsPage.tsx","./src/features/world/homebrew.ts","./src/features/world/hooks.ts","./src/features/world/map/MapCanvas.tsx","./src/features/world/map/MapEditor.tsx","./src/features/world/map/TokenPalette.test.ts","./src/features/world/map/TokenPalette.tsx","./src/features/world/map/tokens.ts","./src/lib/cn.ts","./src/lib/format.ts","./src/lib/ids.ts","./src/lib/rng.ts","./src/lib/sample.ts","./src/lib/useDebouncedCallback.ts","./src/lib/useRoll.ts","./src/lib/wikilinks.test.ts","./src/lib/wikilinks.ts","./src/lib/assistant/actions.ts","./src/lib/assistant/advisors.test.ts","./src/lib/assistant/advisors.ts","./src/lib/assistant/builder.ts","./src/lib/assistant/context.test.ts","./src/lib/assistant/context.ts","./src/lib/assistant/encounter.ts","./src/lib/assistant/levelup.test.ts","./src/lib/assistant/levelup.ts","./src/lib/assistant/patterns.test.ts","./src/lib/assistant/patterns.ts","./src/lib/assistant/prompts.test.ts","./src/lib/assistant/prompts.ts","./src/lib/assistant/session.ts","./src/lib/cloud/campaigns.ts","./src/lib/cloud/client.ts","./src/lib/combat/budget.test.ts","./src/lib/combat/budget.ts","./src/lib/combat/engine.test.ts","./src/lib/combat/engine.ts","./src/lib/combat/playerProjection.test.ts","./src/lib/combat/playerProjection.ts","./src/lib/compendium/index.ts","./src/lib/compendium/types.ts","./src/lib/db/db.ts","./src/lib/db/repositories.test.ts","./src/lib/db/repositories.ts","./src/lib/dice/check.test.ts","./src/lib/dice/check.ts","./src/lib/dice/notation.test.ts","./src/lib/dice/notation.ts","./src/lib/img/resize.test.ts","./src/lib/img/resize.ts","./src/lib/io/backup.test.ts","./src/lib/io/backup.ts","./src/lib/io/character.test.ts","./src/lib/io/character.ts","./src/lib/io/file.ts","./src/lib/io/pathbuilder.test.ts","./src/lib/io/pathbuilder.ts","./src/lib/llm/client.test.ts","./src/lib/llm/client.ts","./src/lib/llm/types.ts","./src/lib/map/distance.ts","./src/lib/map/fog.ts","./src/lib/map/grid.ts","./src/lib/map/index.ts","./src/lib/map/map.test.ts","./src/lib/map/projection.test.ts","./src/lib/map/projection.ts","./src/lib/map/shapes.ts","./src/lib/map/types.ts","./src/lib/map/viewport.test.ts","./src/lib/map/viewport.ts","./src/lib/map/vision.test.ts","./src/lib/map/vision.ts","./src/lib/mechanics/cast.ts","./src/lib/mechanics/conditionEffects.ts","./src/lib/mechanics/creatureState.test.ts","./src/lib/mechanics/creatureState.ts","./src/lib/mechanics/deathSaves.ts","./src/lib/mechanics/enforce.test.ts","./src/lib/mechanics/index.ts","./src/lib/mechanics/resources.ts","./src/lib/mechanics/result.ts","./src/lib/mechanics/types.ts","./src/lib/mechanics/normalize/armor.ts","./src/lib/mechanics/normalize/monsterDefenses.ts","./src/lib/mechanics/normalize/normalize.test.ts","./src/lib/mechanics/normalize/spell.ts","./src/lib/rules/abilities.ts","./src/lib/rules/abilityGen.test.ts","./src/lib/rules/abilityGen.ts","./src/lib/rules/conditions.ts","./src/lib/rules/depth.test.ts","./src/lib/rules/index.ts","./src/lib/rules/progression.test.ts","./src/lib/rules/progression.ts","./src/lib/rules/rest.ts","./src/lib/rules/rules.test.ts","./src/lib/rules/types.ts","./src/lib/rules/dnd5e/index.ts","./src/lib/rules/dnd5e/progression.ts","./src/lib/rules/dnd5e/skills.ts","./src/lib/rules/pf2e/index.ts","./src/lib/rules/pf2e/progression.ts","./src/lib/rules/pf2e/skills.ts","./src/lib/ruleset/normalize.test.ts","./src/lib/ruleset/normalize.ts","./src/lib/schemas/campaign.ts","./src/lib/schemas/character.ts","./src/lib/schemas/common.ts","./src/lib/schemas/dice.ts","./src/lib/schemas/encounter.ts","./src/lib/schemas/index.ts","./src/lib/schemas/sessionLog.ts","./src/lib/schemas/world.ts","./src/lib/sync/index.ts","./src/lib/sync/messages.test.ts","./src/lib/sync/messages.ts","./src/lib/sync/playerLink.test.ts","./src/lib/sync/playerLink.ts","./src/lib/sync/snapshot.ts","./src/lib/sync/wsSync.ts","./src/lib/vtt/uvtt.test.ts","./src/lib/vtt/uvtt.ts","./src/stores/assistantStore.ts","./src/stores/macroStore.ts","./src/stores/playerSessionStore.ts","./src/stores/rollStore.ts","./src/stores/sessionStore.ts","./src/stores/uiStore.ts","./vitest.setup.ts"],"version":"5.9.3"}
\ No newline at end of file