Add Pathfinder 2e game system mode

Implements PF2e as an alternative game system alongside D&D 5e/5.5e.
Settings modal "Game System" selector switches conditions, bestiary,
stat block layout, and initiative calculation between systems.

- Valued conditions with increment/decrement UX (Clumsy 2, Frightened 3)
- 2,502 PF2e creatures from bundled search index (77 sources)
- PF2e stat block: level, traits, Perception, Fort/Ref/Will, ability mods
- Perception-based initiative rolling
- System-scoped source cache (D&D and PF2e sources don't collide)
- Backwards-compatible condition rehydration (ConditionId[] → ConditionEntry[])
- Difficulty indicator hidden in PF2e mode (excluded from MVP)

Closes dostulata/initiative#19

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

packages/domain/src/toggle-condition.ts

@@ -1,4 +1,4 @@
-import type { ConditionId } from "./conditions.js";
+import type { ConditionEntry, ConditionId } from "./conditions.js";
 import { CONDITION_DEFINITIONS, VALID_CONDITION_IDS } from "./conditions.js";
 import type { DomainEvent } from "./events.js";
 import {
@@ -14,11 +14,13 @@ export interface ToggleConditionSuccess {
 	readonly events: DomainEvent[];
 }
 
-export function toggleCondition(
-	encounter: Encounter,
-	combatantId: CombatantId,
-	conditionId: ConditionId,
-): ToggleConditionSuccess | DomainError {
+function sortByDefinitionOrder(entries: ConditionEntry[]): ConditionEntry[] {
+	const order = CONDITION_DEFINITIONS.map((d) => d.id);
+	entries.sort((a, b) => order.indexOf(a.id) - order.indexOf(b.id));
+	return entries;
+}
+
+function validateConditionId(conditionId: ConditionId): DomainError | null {
 	if (!VALID_CONDITION_IDS.has(conditionId)) {
 		return {
 			kind: "domain-error",
@@ -26,38 +28,157 @@ export function toggleCondition(
 			message: `Unknown condition "${conditionId}"`,
 		};
 	}
+	return null;
+}
+
+function applyConditions(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	newConditions: readonly ConditionEntry[] | undefined,
+): Encounter {
+	return {
+		combatants: encounter.combatants.map((c) =>
+			c.id === combatantId ? { ...c, conditions: newConditions } : c,
+		),
+		activeIndex: encounter.activeIndex,
+		roundNumber: encounter.roundNumber,
+	};
+}
+
+export function toggleCondition(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	conditionId: ConditionId,
+): ToggleConditionSuccess | DomainError {
+	const err = validateConditionId(conditionId);
+	if (err) return err;
 
 	const found = findCombatant(encounter, combatantId);
 	if (isDomainError(found)) return found;
 	const { combatant: target } = found;
 	const current = target.conditions ?? [];
-	const isActive = current.includes(conditionId);
+	const isActive = current.some((c) => c.id === conditionId);
 
-	let newConditions: readonly ConditionId[] | undefined;
+	let newConditions: readonly ConditionEntry[] | undefined;
 	let event: DomainEvent;
 
 	if (isActive) {
-		const filtered = current.filter((c) => c !== conditionId);
+		const filtered = current.filter((c) => c.id !== conditionId);
 		newConditions = filtered.length > 0 ? filtered : undefined;
 		event = { type: "ConditionRemoved", combatantId, condition: conditionId };
 	} else {
-		const added = [...current, conditionId];
-		const order = CONDITION_DEFINITIONS.map((d) => d.id);
-		added.sort((a, b) => order.indexOf(a) - order.indexOf(b));
+		const added = sortByDefinitionOrder([...current, { id: conditionId }]);
 		newConditions = added;
 		event = { type: "ConditionAdded", combatantId, condition: conditionId };
 	}
 
-	const updatedCombatants = encounter.combatants.map((c) =>
-		c.id === combatantId ? { ...c, conditions: newConditions } : c,
-	);
-
 	return {
-		encounter: {
-			combatants: updatedCombatants,
-			activeIndex: encounter.activeIndex,
-			roundNumber: encounter.roundNumber,
-		},
+		encounter: applyConditions(encounter, combatantId, newConditions),
 		events: [event],
 	};
 }
+
+export function setConditionValue(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	conditionId: ConditionId,
+	value: number,
+): ToggleConditionSuccess | DomainError {
+	const err = validateConditionId(conditionId);
+	if (err) return err;
+
+	const found = findCombatant(encounter, combatantId);
+	if (isDomainError(found)) return found;
+	const { combatant: target } = found;
+	const current = target.conditions ?? [];
+
+	if (value <= 0) {
+		const filtered = current.filter((c) => c.id !== conditionId);
+		const newConditions = filtered.length > 0 ? filtered : undefined;
+		return {
+			encounter: applyConditions(encounter, combatantId, newConditions),
+			events: [
+				{ type: "ConditionRemoved", combatantId, condition: conditionId },
+			],
+		};
+	}
+
+	const existing = current.find((c) => c.id === conditionId);
+	if (existing) {
+		const updated = current.map((c) =>
+			c.id === conditionId ? { ...c, value } : c,
+		);
+		return {
+			encounter: applyConditions(encounter, combatantId, updated),
+			events: [
+				{
+					type: "ConditionAdded",
+					combatantId,
+					condition: conditionId,
+					value,
+				},
+			],
+		};
+	}
+
+	const added = sortByDefinitionOrder([...current, { id: conditionId, value }]);
+	return {
+		encounter: applyConditions(encounter, combatantId, added),
+		events: [
+			{ type: "ConditionAdded", combatantId, condition: conditionId, value },
+		],
+	};
+}
+
+export function decrementCondition(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	conditionId: ConditionId,
+): ToggleConditionSuccess | DomainError {
+	const err = validateConditionId(conditionId);
+	if (err) return err;
+
+	const found = findCombatant(encounter, combatantId);
+	if (isDomainError(found)) return found;
+	const { combatant: target } = found;
+	const current = target.conditions ?? [];
+	const existing = current.find((c) => c.id === conditionId);
+
+	if (!existing) {
+		return {
+			kind: "domain-error",
+			code: "condition-not-active",
+			message: `Condition "${conditionId}" is not active`,
+		};
+	}
+
+	const newValue = (existing.value ?? 1) - 1;
+	if (newValue <= 0) {
+		const filtered = current.filter((c) => c.id !== conditionId);
+		return {
+			encounter: applyConditions(
+				encounter,
+				combatantId,
+				filtered.length > 0 ? filtered : undefined,
+			),
+			events: [
+				{ type: "ConditionRemoved", combatantId, condition: conditionId },
+			],
+		};
+	}
+
+	const updated = current.map((c) =>
+		c.id === conditionId ? { ...c, value: newValue } : c,
+	);
+	return {
+		encounter: applyConditions(encounter, combatantId, updated),
+		events: [
+			{
+				type: "ConditionAdded",
+				combatantId,
+				condition: conditionId,
+				value: newValue,
+			},
+		],
+	};
+}