Fix "undefined" in PF2e stat block weaknesses/resistances

Some PF2e creatures (e.g. Giant Mining Bee) have qualitative
weaknesses without a numeric amount, causing "undefined" to
render in the stat block. Handle missing amounts gracefully.

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

apps/web/package.json

@@ -29,6 +29,6 @@
 		"@vitejs/plugin-react": "^6.0.1",
 		"jsdom": "^29.0.1",
 		"tailwindcss": "^4.2.2",
-		"vite": "^8.0.1"
+		"vite": "^8.0.5"
 	}
 }

apps/web/src/__tests__/adapters/in-memory-adapters.ts

@@ -1,5 +1,5 @@
 import {
-	type Creature,
+	type AnyCreature,
 	type CreatureId,
 	EMPTY_UNDO_REDO_STATE,
 	type Encounter,
@@ -12,10 +12,10 @@ export function createTestAdapters(options?: {
 	encounter?: Encounter | null;
 	undoRedoState?: UndoRedoState;
 	playerCharacters?: PlayerCharacter[];
-	creatures?: Map<CreatureId, Creature>;
+	creatures?: Map<CreatureId, AnyCreature>;
 	sources?: Map<
 		string,
-		{ displayName: string; creatures: Creature[]; cachedAt: number }
+		{ displayName: string; creatures: AnyCreature[]; cachedAt: number }
 	>;
 }): Adapters {
 	let storedEncounter = options?.encounter ?? null;
@@ -25,7 +25,7 @@ export function createTestAdapters(options?: {
 		options?.sources ??
 		new Map<
 			string,
-			{ displayName: string; creatures: Creature[]; cachedAt: number }
+			{ displayName: string; creatures: AnyCreature[]; cachedAt: number }
 		>();
 
 	// Pre-populate sourceStore from creatures map if provided
@@ -33,7 +33,7 @@ export function createTestAdapters(options?: {
 		// No-op: creatures are accessed directly from the map
 	}
 
-	const creatureMap = options?.creatures ?? new Map<CreatureId, Creature>();
+	const creatureMap = options?.creatures ?? new Map<CreatureId, AnyCreature>();
 
 	return {
 		encounterPersistence: {
@@ -55,8 +55,9 @@ export function createTestAdapters(options?: {
 			},
 		},
 		bestiaryCache: {
-			cacheSource(sourceCode, displayName, creatures) {
+			cacheSource(system, sourceCode, displayName, creatures) {
-				sourceStore.set(sourceCode, {
+				const key = `${system}:${sourceCode}`;
+				sourceStore.set(key, {
 					displayName,
 					creatures,
 					cachedAt: Date.now(),
@@ -66,21 +67,25 @@ export function createTestAdapters(options?: {
 				}
 				return Promise.resolve();
 			},
-			isSourceCached(sourceCode) {
+			isSourceCached(system, sourceCode) {
-				return Promise.resolve(sourceStore.has(sourceCode));
+				return Promise.resolve(sourceStore.has(`${system}:${sourceCode}`));
 			},
-			getCachedSources() {
+			getCachedSources(system) {
 				return Promise.resolve(
-					[...sourceStore.entries()].map(([sourceCode, info]) => ({
+					[...sourceStore.entries()]
-						sourceCode,
+						.filter(([key]) => !system || key.startsWith(`${system}:`))
+						.map(([key, info]) => ({
+							sourceCode: key.includes(":")
+								? key.slice(key.indexOf(":") + 1)
+								: key,
 							displayName: info.displayName,
 							creatureCount: info.creatures.length,
 							cachedAt: info.cachedAt,
 						})),
 				);
 			},
-			clearSource(sourceCode) {
+			clearSource(system, sourceCode) {
-				sourceStore.delete(sourceCode);
+				sourceStore.delete(`${system}:${sourceCode}`);
 				return Promise.resolve();
 			},
 			clearAll() {
@@ -104,5 +109,12 @@ export function createTestAdapters(options?: {
 			},
 			getSourceDisplayName: (sourceCode) => sourceCode,
 		},
+		pf2eBestiaryIndex: {
+			loadIndex: () => ({ sources: {}, creatures: [] }),
+			getAllSourceCodes: () => [],
+			getDefaultFetchUrl: (sourceCode) =>
+				`https://example.com/creatures-${sourceCode.toLowerCase()}.json`,
+			getSourceDisplayName: (sourceCode) => sourceCode,
+		},
 	};
 }

apps/web/src/adapters/__tests__/bestiary-cache-fallback.test.ts

@@ -46,17 +46,17 @@ describe("bestiary-cache fallback (IndexedDB unavailable)", () => {
 
 	it("cacheSource falls back to in-memory store", async () => {
 		const creatures = [makeCreature("mm:goblin", "Goblin")];
-		await cacheSource("MM", "Monster Manual", creatures);
+		await cacheSource("dnd", "MM", "Monster Manual", creatures);
 
-		expect(await isSourceCached("MM")).toBe(true);
+		expect(await isSourceCached("dnd", "MM")).toBe(true);
 	});
 
 	it("isSourceCached returns false for uncached source", async () => {
-		expect(await isSourceCached("XGE")).toBe(false);
+		expect(await isSourceCached("dnd", "XGE")).toBe(false);
 	});
 
 	it("getCachedSources returns sources from in-memory store", async () => {
-		await cacheSource("MM", "Monster Manual", [
+		await cacheSource("dnd", "MM", "Monster Manual", [
 			makeCreature("mm:goblin", "Goblin"),
 		]);
 
@@ -68,7 +68,7 @@ describe("bestiary-cache fallback (IndexedDB unavailable)", () => {
 
 	it("loadAllCachedCreatures assembles creatures from in-memory store", async () => {
 		const goblin = makeCreature("mm:goblin", "Goblin");
-		await cacheSource("MM", "Monster Manual", [goblin]);
+		await cacheSource("dnd", "MM", "Monster Manual", [goblin]);
 
 		const map = await loadAllCachedCreatures();
 		expect(map.size).toBe(1);
@@ -76,17 +76,17 @@ describe("bestiary-cache fallback (IndexedDB unavailable)", () => {
 	});
 
 	it("clearSource removes a single source from in-memory store", async () => {
-		await cacheSource("MM", "Monster Manual", []);
+		await cacheSource("dnd", "MM", "Monster Manual", []);
-		await cacheSource("VGM", "Volo's Guide", []);
+		await cacheSource("dnd", "VGM", "Volo's Guide", []);
 
-		await clearSource("MM");
+		await clearSource("dnd", "MM");
 
-		expect(await isSourceCached("MM")).toBe(false);
+		expect(await isSourceCached("dnd", "MM")).toBe(false);
-		expect(await isSourceCached("VGM")).toBe(true);
+		expect(await isSourceCached("dnd", "VGM")).toBe(true);
 	});
 
 	it("clearAll removes all data from in-memory store", async () => {
-		await cacheSource("MM", "Monster Manual", []);
+		await cacheSource("dnd", "MM", "Monster Manual", []);
 		await clearAll();
 
 		const sources = await getCachedSources();

apps/web/src/adapters/__tests__/bestiary-cache.test.ts

@@ -69,17 +69,17 @@ describe("bestiary-cache", () => {
 	describe("cacheSource", () => {
 		it("stores creatures and metadata", async () => {
 			const creatures = [makeCreature("mm:goblin", "Goblin")];
-			await cacheSource("MM", "Monster Manual", creatures);
+			await cacheSource("dnd", "MM", "Monster Manual", creatures);
 
-			expect(fakeStore.has("MM")).toBe(true);
+			expect(fakeStore.has("dnd:MM")).toBe(true);
-			const record = fakeStore.get("MM") as {
+			const record = fakeStore.get("dnd:MM") as {
 				sourceCode: string;
 				displayName: string;
 				creatures: Creature[];
 				creatureCount: number;
 				cachedAt: number;
 			};
-			expect(record.sourceCode).toBe("MM");
+			expect(record.sourceCode).toBe("dnd:MM");
 			expect(record.displayName).toBe("Monster Manual");
 			expect(record.creatures).toHaveLength(1);
 			expect(record.creatureCount).toBe(1);
@@ -89,12 +89,12 @@ describe("bestiary-cache", () => {
 
 	describe("isSourceCached", () => {
 		it("returns false for uncached source", async () => {
-			expect(await isSourceCached("XGE")).toBe(false);
+			expect(await isSourceCached("dnd", "XGE")).toBe(false);
 		});
 
 		it("returns true after caching", async () => {
-			await cacheSource("MM", "Monster Manual", []);
+			await cacheSource("dnd", "MM", "Monster Manual", []);
-			expect(await isSourceCached("MM")).toBe(true);
+			expect(await isSourceCached("dnd", "MM")).toBe(true);
 		});
 	});
 
@@ -105,11 +105,11 @@ describe("bestiary-cache", () => {
 		});
 
 		it("returns source info with creature counts", async () => {
-			await cacheSource("MM", "Monster Manual", [
+			await cacheSource("dnd", "MM", "Monster Manual", [
 				makeCreature("mm:goblin", "Goblin"),
 				makeCreature("mm:orc", "Orc"),
 			]);
-			await cacheSource("VGM", "Volo's Guide", [
+			await cacheSource("dnd", "VGM", "Volo's Guide", [
 				makeCreature("vgm:flind", "Flind"),
 			]);
 
@@ -137,8 +137,8 @@ describe("bestiary-cache", () => {
 			const orc = makeCreature("mm:orc", "Orc");
 			const flind = makeCreature("vgm:flind", "Flind");
 
-			await cacheSource("MM", "Monster Manual", [goblin, orc]);
+			await cacheSource("dnd", "MM", "Monster Manual", [goblin, orc]);
-			await cacheSource("VGM", "Volo's Guide", [flind]);
+			await cacheSource("dnd", "VGM", "Volo's Guide", [flind]);
 
 			const map = await loadAllCachedCreatures();
 			expect(map.size).toBe(3);
@@ -150,20 +150,20 @@ describe("bestiary-cache", () => {
 
 	describe("clearSource", () => {
 		it("removes a single source", async () => {
-			await cacheSource("MM", "Monster Manual", []);
+			await cacheSource("dnd", "MM", "Monster Manual", []);
-			await cacheSource("VGM", "Volo's Guide", []);
+			await cacheSource("dnd", "VGM", "Volo's Guide", []);
 
-			await clearSource("MM");
+			await clearSource("dnd", "MM");
 
-			expect(await isSourceCached("MM")).toBe(false);
+			expect(await isSourceCached("dnd", "MM")).toBe(false);
-			expect(await isSourceCached("VGM")).toBe(true);
+			expect(await isSourceCached("dnd", "VGM")).toBe(true);
 		});
 	});
 
 	describe("clearAll", () => {
 		it("removes all cached data", async () => {
-			await cacheSource("MM", "Monster Manual", []);
+			await cacheSource("dnd", "MM", "Monster Manual", []);
-			await cacheSource("VGM", "Volo's Guide", []);
+			await cacheSource("dnd", "VGM", "Volo's Guide", []);
 
 			await clearAll();
 

apps/web/src/adapters/__tests__/pf2e-bestiary-adapter.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { normalizePf2eBestiary } from "../pf2e-bestiary-adapter.js";
+
+function minimalCreature(defenses?: Record<string, unknown>) {
+	return {
+		name: "Test Creature",
+		source: "TST",
+		defenses,
+	};
+}
+
+describe("normalizePf2eBestiary", () => {
+	describe("weaknesses formatting", () => {
+		it("formats weakness with numeric amount", () => {
+			const [creature] = normalizePf2eBestiary({
+				creature: [
+					minimalCreature({
+						weaknesses: [{ name: "fire", amount: 5 }],
+					}),
+				],
+			});
+			expect(creature.weaknesses).toBe("Fire 5");
+		});
+
+		it("formats weakness without amount (qualitative)", () => {
+			const [creature] = normalizePf2eBestiary({
+				creature: [
+					minimalCreature({
+						weaknesses: [{ name: "smoke susceptibility" }],
+					}),
+				],
+			});
+			expect(creature.weaknesses).toBe("Smoke susceptibility");
+		});
+
+		it("formats weakness with note and amount", () => {
+			const [creature] = normalizePf2eBestiary({
+				creature: [
+					minimalCreature({
+						weaknesses: [
+							{ name: "cold iron", amount: 5, note: "except daggers" },
+						],
+					}),
+				],
+			});
+			expect(creature.weaknesses).toBe("Cold iron 5 (except daggers)");
+		});
+
+		it("formats weakness with note but no amount", () => {
+			const [creature] = normalizePf2eBestiary({
+				creature: [
+					minimalCreature({
+						weaknesses: [{ name: "smoke susceptibility", note: "see below" }],
+					}),
+				],
+			});
+			expect(creature.weaknesses).toBe("Smoke susceptibility (see below)");
+		});
+
+		it("returns undefined when no weaknesses", () => {
+			const [creature] = normalizePf2eBestiary({
+				creature: [minimalCreature({})],
+			});
+			expect(creature.weaknesses).toBeUndefined();
+		});
+	});
+
+	describe("resistances formatting", () => {
+		it("formats resistance without amount", () => {
+			const [creature] = normalizePf2eBestiary({
+				creature: [
+					minimalCreature({
+						resistances: [{ name: "physical" }],
+					}),
+				],
+			});
+			expect(creature.resistances).toBe("Physical");
+		});
+
+		it("formats resistance with amount", () => {
+			const [creature] = normalizePf2eBestiary({
+				creature: [
+					minimalCreature({
+						resistances: [{ name: "fire", amount: 10 }],
+					}),
+				],
+			});
+			expect(creature.resistances).toBe("Fire 10");
+		});
+	});
+});

apps/web/src/adapters/__tests__/pf2e-bestiary-index-adapter.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import {
+	getAllPf2eSourceCodes,
+	getDefaultPf2eFetchUrl,
+	getPf2eSourceDisplayName,
+	loadPf2eBestiaryIndex,
+} from "../pf2e-bestiary-index-adapter.js";
+
+describe("loadPf2eBestiaryIndex", () => {
+	it("returns an object with sources and creatures", () => {
+		const index = loadPf2eBestiaryIndex();
+		expect(index.sources).toBeDefined();
+		expect(index.creatures).toBeDefined();
+		expect(Array.isArray(index.creatures)).toBe(true);
+	});
+
+	it("creatures have the expected PF2e shape", () => {
+		const index = loadPf2eBestiaryIndex();
+		expect(index.creatures.length).toBeGreaterThan(0);
+		const first = index.creatures[0];
+		expect(first).toHaveProperty("name");
+		expect(first).toHaveProperty("source");
+		expect(first).toHaveProperty("level");
+		expect(first).toHaveProperty("ac");
+		expect(first).toHaveProperty("hp");
+		expect(first).toHaveProperty("perception");
+		expect(first).toHaveProperty("size");
+		expect(first).toHaveProperty("type");
+	});
+
+	it("contains a substantial number of creatures", () => {
+		const index = loadPf2eBestiaryIndex();
+		expect(index.creatures.length).toBeGreaterThan(2000);
+	});
+
+	it("returns the same cached instance on subsequent calls", () => {
+		const a = loadPf2eBestiaryIndex();
+		const b = loadPf2eBestiaryIndex();
+		expect(a).toBe(b);
+	});
+});
+
+describe("getAllPf2eSourceCodes", () => {
+	it("returns all keys from the index sources", () => {
+		const codes = getAllPf2eSourceCodes();
+		const index = loadPf2eBestiaryIndex();
+		expect(codes).toEqual(Object.keys(index.sources));
+	});
+});
+
+describe("getDefaultPf2eFetchUrl", () => {
+	it("returns Pf2eTools GitHub URL with lowercase source code", () => {
+		const url = getDefaultPf2eFetchUrl("B1");
+		expect(url).toBe(
+			"https://raw.githubusercontent.com/Pf2eToolsOrg/Pf2eTools/dev/data/bestiary/creatures-b1.json",
+		);
+	});
+});
+
+describe("getPf2eSourceDisplayName", () => {
+	it("returns display name for a known source", () => {
+		expect(getPf2eSourceDisplayName("B1")).toBe("Bestiary");
+	});
+
+	it("falls back to source code for unknown source", () => {
+		expect(getPf2eSourceDisplayName("UNKNOWN")).toBe("UNKNOWN");
+	});
+});

apps/web/src/adapters/bestiary-cache.ts

@@ -1,23 +1,25 @@
-import type { Creature, CreatureId } from "@initiative/domain";
+import type { AnyCreature, CreatureId } from "@initiative/domain";
 import { type IDBPDatabase, openDB } from "idb";
 
 const DB_NAME = "initiative-bestiary";
 const STORE_NAME = "sources";
-const DB_VERSION = 3;
+const DB_VERSION = 4;
 
 interface CachedSourceInfo {
 	readonly sourceCode: string;
 	readonly displayName: string;
 	readonly creatureCount: number;
 	readonly cachedAt: number;
+	readonly system?: string;
 }
 
 interface CachedSourceRecord {
 	sourceCode: string;
 	displayName: string;
-	creatures: Creature[];
+	creatures: AnyCreature[];
 	cachedAt: number;
 	creatureCount: number;
+	system?: string;
 }
 
 let db: IDBPDatabase | null = null;
@@ -26,6 +28,10 @@ let dbFailed = false;
 // In-memory fallback when IndexedDB is unavailable
 const memoryStore = new Map<string, CachedSourceRecord>();
 
+function scopedKey(system: string, sourceCode: string): string {
+	return `${system}:${sourceCode}`;
+}
+
 async function getDb(): Promise<IDBPDatabase | null> {
 	if (db) return db;
 	if (dbFailed) return null;
@@ -58,60 +64,77 @@ async function getDb(): Promise<IDBPDatabase | null> {
 }
 
 export async function cacheSource(
+	system: string,
 	sourceCode: string,
 	displayName: string,
-	creatures: Creature[],
+	creatures: AnyCreature[],
 ): Promise<void> {
+	const key = scopedKey(system, sourceCode);
 	const record: CachedSourceRecord = {
-		sourceCode,
+		sourceCode: key,
 		displayName,
 		creatures,
 		cachedAt: Date.now(),
 		creatureCount: creatures.length,
+		system,
 	};
 
 	const database = await getDb();
 	if (database) {
 		await database.put(STORE_NAME, record);
 	} else {
-		memoryStore.set(sourceCode, record);
+		memoryStore.set(key, record);
 	}
 }
 
-export async function isSourceCached(sourceCode: string): Promise<boolean> {
+export async function isSourceCached(
+	system: string,
+	sourceCode: string,
+): Promise<boolean> {
+	const key = scopedKey(system, sourceCode);
 	const database = await getDb();
 	if (database) {
-		const record = await database.get(STORE_NAME, sourceCode);
+		const record = await database.get(STORE_NAME, key);
 		return record !== undefined;
 	}
-	return memoryStore.has(sourceCode);
+	return memoryStore.has(key);
 }
 
-export async function getCachedSources(): Promise<CachedSourceInfo[]> {
+export async function getCachedSources(
+	system?: string,
+): Promise<CachedSourceInfo[]> {
 	const database = await getDb();
+	let records: CachedSourceRecord[];
 	if (database) {
-		const all: CachedSourceRecord[] = await database.getAll(STORE_NAME);
+		records = await database.getAll(STORE_NAME);
-		return all.map((r) => ({
-			sourceCode: r.sourceCode,
-			displayName: r.displayName,
-			creatureCount: r.creatureCount,
-			cachedAt: r.cachedAt,
-		}));
-	}
-	return [...memoryStore.values()].map((r) => ({
-		sourceCode: r.sourceCode,
-		displayName: r.displayName,
-		creatureCount: r.creatureCount,
-		cachedAt: r.cachedAt,
-	}));
-}
-
-export async function clearSource(sourceCode: string): Promise<void> {
-	const database = await getDb();
-	if (database) {
-		await database.delete(STORE_NAME, sourceCode);
 	} else {
-		memoryStore.delete(sourceCode);
+		records = [...memoryStore.values()];
+	}
+
+	const filtered = system
+		? records.filter((r) => r.system === system)
+		: records;
+	return filtered.map((r) => ({
+		sourceCode: r.system
+			? r.sourceCode.slice(r.system.length + 1)
+			: r.sourceCode,
+		displayName: r.displayName,
+		creatureCount: r.creatureCount,
+		cachedAt: r.cachedAt,
+		system: r.system,
+	}));
+}
+
+export async function clearSource(
+	system: string,
+	sourceCode: string,
+): Promise<void> {
+	const key = scopedKey(system, sourceCode);
+	const database = await getDb();
+	if (database) {
+		await database.delete(STORE_NAME, key);
+	} else {
+		memoryStore.delete(key);
 	}
 }
 
@@ -125,9 +148,9 @@ export async function clearAll(): Promise<void> {
 }
 
 export async function loadAllCachedCreatures(): Promise<
-	Map<CreatureId, Creature>
+	Map<CreatureId, AnyCreature>
 > {
-	const map = new Map<CreatureId, Creature>();
+	const map = new Map<CreatureId, AnyCreature>();
 	const database = await getDb();
 
 	let records: CachedSourceRecord[];

apps/web/src/adapters/pf2e-bestiary-adapter.ts

@@ -0,0 +1,338 @@
+import type {
+	CreatureId,
+	Pf2eCreature,
+	TraitBlock,
+	TraitSegment,
+} from "@initiative/domain";
+import { creatureId } from "@initiative/domain";
+import { stripTags } from "./strip-tags.js";
+
+// -- Raw Pf2eTools types (minimal, for parsing) --
+
+interface RawPf2eCreature {
+	name: string;
+	source: string;
+	level?: number;
+	traits?: string[];
+	perception?: { std?: number };
+	senses?: { name?: string; type?: string }[];
+	languages?: { languages?: string[] };
+	skills?: Record<string, { std?: number }>;
+	abilityMods?: Record<string, number>;
+	items?: string[];
+	defenses?: RawDefenses;
+	speed?: Record<string, number | { number: number }>;
+	attacks?: RawAttack[];
+	abilities?: {
+		top?: RawAbility[];
+		mid?: RawAbility[];
+		bot?: RawAbility[];
+	};
+	_copy?: unknown;
+}
+
+interface RawDefenses {
+	ac?: Record<string, unknown>;
+	savingThrows?: {
+		fort?: { std?: number };
+		ref?: { std?: number };
+		will?: { std?: number };
+	};
+	hp?: { hp?: number }[];
+	immunities?: (string | { name: string })[];
+	resistances?: { amount?: number; name: string; note?: string }[];
+	weaknesses?: { amount?: number; name: string; note?: string }[];
+}
+
+interface RawAbility {
+	name?: string;
+	entries?: RawEntry[];
+}
+
+interface RawAttack {
+	range?: string;
+	name: string;
+	attack?: number;
+	traits?: string[];
+	damage?: string;
+}
+
+type RawEntry = string | RawEntryObject;
+
+interface RawEntryObject {
+	type?: string;
+	items?: (string | { name?: string; entry?: string })[];
+	entries?: RawEntry[];
+}
+
+// -- Module state --
+
+let sourceDisplayNames: Record<string, string> = {};
+
+export function setPf2eSourceDisplayNames(names: Record<string, string>): void {
+	sourceDisplayNames = names;
+}
+
+// -- Helpers --
+
+function capitalize(s: string): string {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+function makeCreatureId(source: string, name: string): CreatureId {
+	const slug = name
+		.toLowerCase()
+		.replaceAll(/[^a-z0-9]+/g, "-")
+		.replaceAll(/(^-|-$)/g, "");
+	return creatureId(`${source.toLowerCase()}:${slug}`);
+}
+
+function formatSpeed(
+	speed: Record<string, number | { number: number }> | undefined,
+): string {
+	if (!speed) return "";
+	const parts: string[] = [];
+	for (const [mode, value] of Object.entries(speed)) {
+		if (typeof value === "number") {
+			parts.push(
+				mode === "walk" ? `${value} feet` : `${capitalize(mode)} ${value} feet`,
+			);
+		} else if (typeof value === "object" && "number" in value) {
+			parts.push(
+				mode === "walk"
+					? `${value.number} feet`
+					: `${capitalize(mode)} ${value.number} feet`,
+			);
+		}
+	}
+	return parts.join(", ");
+}
+
+function formatSkills(
+	skills: Record<string, { std?: number }> | undefined,
+): string | undefined {
+	if (!skills) return undefined;
+	const parts = Object.entries(skills)
+		.map(([name, val]) => `${capitalize(name)} +${val.std ?? 0}`)
+		.sort();
+	return parts.length > 0 ? parts.join(", ") : undefined;
+}
+
+function formatSenses(
+	senses: readonly { name?: string; type?: string }[] | undefined,
+): string | undefined {
+	if (!senses || senses.length === 0) return undefined;
+	return senses
+		.map((s) => {
+			const label = s.name ?? s.type ?? "";
+			return label ? capitalize(label) : "";
+		})
+		.filter(Boolean)
+		.join(", ");
+}
+
+function formatLanguages(
+	languages: { languages?: string[] } | undefined,
+): string | undefined {
+	if (!languages?.languages || languages.languages.length === 0)
+		return undefined;
+	return languages.languages.map(capitalize).join(", ");
+}
+
+function formatImmunities(
+	immunities: readonly (string | { name: string })[] | undefined,
+): string | undefined {
+	if (!immunities || immunities.length === 0) return undefined;
+	return immunities
+		.map((i) => capitalize(typeof i === "string" ? i : i.name))
+		.join(", ");
+}
+
+function formatResistances(
+	resistances:
+		| readonly { amount?: number; name: string; note?: string }[]
+		| undefined,
+): string | undefined {
+	if (!resistances || resistances.length === 0) return undefined;
+	return resistances
+		.map((r) => {
+			const base =
+				r.amount == null
+					? capitalize(r.name)
+					: `${capitalize(r.name)} ${r.amount}`;
+			return r.note ? `${base} (${r.note})` : base;
+		})
+		.join(", ");
+}
+
+function formatWeaknesses(
+	weaknesses:
+		| readonly { amount?: number; name: string; note?: string }[]
+		| undefined,
+): string | undefined {
+	if (!weaknesses || weaknesses.length === 0) return undefined;
+	return weaknesses
+		.map((w) => {
+			const base =
+				w.amount == null
+					? capitalize(w.name)
+					: `${capitalize(w.name)} ${w.amount}`;
+			return w.note ? `${base} (${w.note})` : base;
+		})
+		.join(", ");
+}
+
+// -- Entry parsing --
+
+function segmentizeEntries(entries: unknown): TraitSegment[] {
+	if (!Array.isArray(entries)) return [];
+	const segments: TraitSegment[] = [];
+	for (const entry of entries) {
+		if (typeof entry === "string") {
+			segments.push({ type: "text", value: stripTags(entry) });
+		} else if (typeof entry === "object" && entry !== null) {
+			const obj = entry as RawEntryObject;
+			if (obj.type === "list" && Array.isArray(obj.items)) {
+				segments.push({
+					type: "list",
+					items: obj.items.map((item) => {
+						if (typeof item === "string") {
+							return { text: stripTags(item) };
+						}
+						return { label: item.name, text: stripTags(item.entry ?? "") };
+					}),
+				});
+			} else if (Array.isArray(obj.entries)) {
+				segments.push(...segmentizeEntries(obj.entries));
+			}
+		}
+	}
+	return segments;
+}
+
+function formatAffliction(a: Record<string, unknown>): TraitSegment[] {
+	const parts: string[] = [];
+	if (a.note) parts.push(stripTags(String(a.note)));
+	if (a.DC) parts.push(`DC ${a.DC}`);
+	if (a.savingThrow) parts.push(String(a.savingThrow));
+	const stages = a.stages as
+		| { stage: number; entry: string; duration: string }[]
+		| undefined;
+	if (stages) {
+		for (const s of stages) {
+			parts.push(`Stage ${s.stage}: ${stripTags(s.entry)} (${s.duration})`);
+		}
+	}
+	return parts.length > 0 ? [{ type: "text", value: parts.join("; ") }] : [];
+}
+
+function normalizeAbilities(
+	abilities: readonly RawAbility[] | undefined,
+): TraitBlock[] | undefined {
+	if (!abilities || abilities.length === 0) return undefined;
+	return abilities
+		.filter((a) => a.name)
+		.map((a) => {
+			const raw = a as Record<string, unknown>;
+			return {
+				name: stripTags(a.name as string),
+				segments: Array.isArray(a.entries)
+					? segmentizeEntries(a.entries)
+					: formatAffliction(raw),
+			};
+		});
+}
+
+function normalizeAttacks(
+	attacks: readonly RawAttack[] | undefined,
+): TraitBlock[] | undefined {
+	if (!attacks || attacks.length === 0) return undefined;
+	return attacks.map((a) => {
+		const parts: string[] = [];
+		if (a.range) parts.push(a.range);
+		const attackMod = a.attack == null ? "" : ` +${a.attack}`;
+		const traits =
+			a.traits && a.traits.length > 0
+				? ` (${a.traits.map((t) => stripTags(t)).join(", ")})`
+				: "";
+		const damage = a.damage ? `, ${stripTags(a.damage)}` : "";
+		return {
+			name: capitalize(stripTags(a.name)),
+			segments: [
+				{
+					type: "text" as const,
+					value: `${parts.join(" ")}${attackMod}${traits}${damage}`,
+				},
+			],
+		};
+	});
+}
+
+// -- Defenses extraction --
+
+function extractDefenses(defenses: RawDefenses | undefined) {
+	const acRecord = defenses?.ac ?? {};
+	const acStd = (acRecord.std as number | undefined) ?? 0;
+	const acEntries = Object.entries(acRecord).filter(([k]) => k !== "std");
+	return {
+		ac: acStd,
+		acConditional:
+			acEntries.length > 0
+				? acEntries.map(([k, v]) => `${v} ${k}`).join(", ")
+				: undefined,
+		saveFort: defenses?.savingThrows?.fort?.std ?? 0,
+		saveRef: defenses?.savingThrows?.ref?.std ?? 0,
+		saveWill: defenses?.savingThrows?.will?.std ?? 0,
+		hp: defenses?.hp?.[0]?.hp ?? 0,
+		immunities: formatImmunities(defenses?.immunities),
+		resistances: formatResistances(defenses?.resistances),
+		weaknesses: formatWeaknesses(defenses?.weaknesses),
+	};
+}
+
+// -- Main normalization --
+
+function normalizeCreature(raw: RawPf2eCreature): Pf2eCreature {
+	const source = raw.source ?? "";
+	const defenses = extractDefenses(raw.defenses);
+	const mods = raw.abilityMods ?? {};
+
+	return {
+		system: "pf2e",
+		id: makeCreatureId(source, raw.name),
+		name: raw.name,
+		source,
+		sourceDisplayName: sourceDisplayNames[source] ?? source,
+		level: raw.level ?? 0,
+		traits: raw.traits ?? [],
+		perception: raw.perception?.std ?? 0,
+		senses: formatSenses(raw.senses),
+		languages: formatLanguages(raw.languages),
+		skills: formatSkills(raw.skills),
+		abilityMods: {
+			str: mods.str ?? 0,
+			dex: mods.dex ?? 0,
+			con: mods.con ?? 0,
+			int: mods.int ?? 0,
+			wis: mods.wis ?? 0,
+			cha: mods.cha ?? 0,
+		},
+		...defenses,
+		speed: formatSpeed(raw.speed),
+		attacks: normalizeAttacks(raw.attacks),
+		abilitiesTop: normalizeAbilities(raw.abilities?.top),
+		abilitiesMid: normalizeAbilities(raw.abilities?.mid),
+		abilitiesBot: normalizeAbilities(raw.abilities?.bot),
+	};
+}
+
+export function normalizePf2eBestiary(raw: {
+	creature: unknown[];
+}): Pf2eCreature[] {
+	return (raw.creature ?? [])
+		.filter((c: unknown) => {
+			const obj = c as { _copy?: unknown };
+			return !obj._copy;
+		})
+		.map((c) => normalizeCreature(c as RawPf2eCreature));
+}

apps/web/src/adapters/pf2e-bestiary-index-adapter.ts

@@ -0,0 +1,70 @@
+import type {
+	Pf2eBestiaryIndex,
+	Pf2eBestiaryIndexEntry,
+} from "@initiative/domain";
+
+import rawIndex from "../../../../data/bestiary/pf2e-index.json";
+
+interface CompactCreature {
+	readonly n: string;
+	readonly s: string;
+	readonly lv: number;
+	readonly ac: number;
+	readonly hp: number;
+	readonly pc: number;
+	readonly sz: string;
+	readonly tp: string;
+}
+
+interface CompactIndex {
+	readonly sources: Record<string, string>;
+	readonly creatures: readonly CompactCreature[];
+}
+
+function mapCreature(c: CompactCreature): Pf2eBestiaryIndexEntry {
+	return {
+		name: c.n,
+		source: c.s,
+		level: c.lv,
+		ac: c.ac,
+		hp: c.hp,
+		perception: c.pc,
+		size: c.sz,
+		type: c.tp,
+	};
+}
+
+let cachedIndex: Pf2eBestiaryIndex | undefined;
+
+export function loadPf2eBestiaryIndex(): Pf2eBestiaryIndex {
+	if (cachedIndex) return cachedIndex;
+
+	const compact = rawIndex as unknown as CompactIndex;
+	cachedIndex = {
+		sources: compact.sources,
+		creatures: compact.creatures.map(mapCreature),
+	};
+	return cachedIndex;
+}
+
+export function getAllPf2eSourceCodes(): string[] {
+	const index = loadPf2eBestiaryIndex();
+	return Object.keys(index.sources);
+}
+
+export function getDefaultPf2eFetchUrl(
+	sourceCode: string,
+	baseUrl?: string,
+): string {
+	const filename = `creatures-${sourceCode.toLowerCase()}.json`;
+	if (baseUrl !== undefined) {
+		const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+		return `${normalized}${filename}`;
+	}
+	return `https://raw.githubusercontent.com/Pf2eToolsOrg/Pf2eTools/dev/data/bestiary/${filename}`;
+}
+
+export function getPf2eSourceDisplayName(sourceCode: string): string {
+	const index = loadPf2eBestiaryIndex();
+	return index.sources[sourceCode] ?? sourceCode;
+}

apps/web/src/adapters/ports.ts

@@ -1,8 +1,9 @@
 import type {
+	AnyCreature,
 	BestiaryIndex,
-	Creature,
 	CreatureId,
 	Encounter,
+	Pf2eBestiaryIndex,
 	PlayerCharacter,
 	UndoRedoState,
 } from "@initiative/domain";
@@ -31,15 +32,16 @@ export interface CachedSourceInfo {
 
 export interface BestiaryCachePort {
 	cacheSource(
+		system: string,
 		sourceCode: string,
 		displayName: string,
-		creatures: Creature[],
+		creatures: AnyCreature[],
 	): Promise<void>;
-	isSourceCached(sourceCode: string): Promise<boolean>;
+	isSourceCached(system: string, sourceCode: string): Promise<boolean>;
-	getCachedSources(): Promise<CachedSourceInfo[]>;
+	getCachedSources(system?: string): Promise<CachedSourceInfo[]>;
-	clearSource(sourceCode: string): Promise<void>;
+	clearSource(system: string, sourceCode: string): Promise<void>;
 	clearAll(): Promise<void>;
-	loadAllCachedCreatures(): Promise<Map<CreatureId, Creature>>;
+	loadAllCachedCreatures(): Promise<Map<CreatureId, AnyCreature>>;
 }
 
 export interface BestiaryIndexPort {
@@ -48,3 +50,10 @@ export interface BestiaryIndexPort {
 	getDefaultFetchUrl(sourceCode: string, baseUrl?: string): string;
 	getSourceDisplayName(sourceCode: string): string;
 }
+
+export interface Pf2eBestiaryIndexPort {
+	loadIndex(): Pf2eBestiaryIndex;
+	getAllSourceCodes(): string[];
+	getDefaultFetchUrl(sourceCode: string, baseUrl?: string): string;
+	getSourceDisplayName(sourceCode: string): string;
+}

apps/web/src/adapters/production-adapters.ts

@@ -13,6 +13,7 @@ import {
 } from "../persistence/undo-redo-storage.js";
 import * as bestiaryCache from "./bestiary-cache.js";
 import * as bestiaryIndex from "./bestiary-index-adapter.js";
+import * as pf2eBestiaryIndex from "./pf2e-bestiary-index-adapter.js";
 
 export const productionAdapters: Adapters = {
 	encounterPersistence: {
@@ -41,4 +42,10 @@ export const productionAdapters: Adapters = {
 		getDefaultFetchUrl: bestiaryIndex.getDefaultFetchUrl,
 		getSourceDisplayName: bestiaryIndex.getSourceDisplayName,
 	},
+	pf2eBestiaryIndex: {
+		loadIndex: pf2eBestiaryIndex.loadPf2eBestiaryIndex,
+		getAllSourceCodes: pf2eBestiaryIndex.getAllPf2eSourceCodes,
+		getDefaultFetchUrl: pf2eBestiaryIndex.getDefaultPf2eFetchUrl,
+		getSourceDisplayName: pf2eBestiaryIndex.getPf2eSourceDisplayName,
+	},
 };

apps/web/src/components/__tests__/bulk-import-prompt.test.tsx

@@ -6,6 +6,7 @@ import userEvent from "@testing-library/user-event";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { createTestAdapters } from "../../__tests__/adapters/in-memory-adapters.js";
 import { AdapterProvider } from "../../contexts/adapter-context.js";
+import { RulesEditionProvider } from "../../contexts/rules-edition-context.js";
 import { BulkImportPrompt } from "../bulk-import-prompt.js";
 
 const THREE_SOURCES_REGEX = /3 sources/;
@@ -68,9 +69,11 @@ function createAdaptersWithSources() {
 function renderWithAdapters() {
 	const adapters = createAdaptersWithSources();
 	return render(
+		<RulesEditionProvider>
 			<AdapterProvider adapters={adapters}>
 				<BulkImportPrompt />
-		</AdapterProvider>,
+			</AdapterProvider>
+		</RulesEditionProvider>,
 	);
 }
 

apps/web/src/components/__tests__/condition-picker.test.tsx

@@ -1,7 +1,11 @@
 // @vitest-environment jsdom
 import "@testing-library/jest-dom/vitest";
 
-import { CONDITION_DEFINITIONS, type ConditionId } from "@initiative/domain";
+import {
+	type ConditionEntry,
+	type ConditionId,
+	getConditionsForEdition,
+} from "@initiative/domain";
 import { cleanup, render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { createRef, type RefObject } from "react";
@@ -13,12 +17,14 @@ afterEach(cleanup);
 
 function renderPicker(
 	overrides: Partial<{
-		activeConditions: readonly ConditionId[];
+		activeConditions: readonly ConditionEntry[];
 		onToggle: (conditionId: ConditionId) => void;
+		onSetValue: (conditionId: ConditionId, value: number) => void;
 		onClose: () => void;
 	}> = {},
 ) {
 	const onToggle = overrides.onToggle ?? vi.fn();
+	const onSetValue = overrides.onSetValue ?? vi.fn();
 	const onClose = overrides.onClose ?? vi.fn();
 	const anchorRef = createRef<HTMLElement>() as RefObject<HTMLElement>;
 	const anchor = document.createElement("div");
@@ -30,25 +36,27 @@ function renderPicker(
 				anchorRef={anchorRef}
 				activeConditions={overrides.activeConditions ?? []}
 				onToggle={onToggle}
+				onSetValue={onSetValue}
 				onClose={onClose}
 			/>
 		</RulesEditionProvider>,
 	);
-	return { ...result, onToggle, onClose };
+	return { ...result, onToggle, onSetValue, onClose };
 }
 
 describe("ConditionPicker", () => {
-	it("renders all condition definitions from domain", () => {
+	it("renders edition-specific conditions from domain", () => {
 		renderPicker();
-		for (const def of CONDITION_DEFINITIONS) {
+		const editionConditions = getConditionsForEdition("5.5e");
+		for (const def of editionConditions) {
 			expect(screen.getByText(def.label)).toBeInTheDocument();
 		}
 	});
 
 	it("active conditions are visually distinguished", () => {
-		renderPicker({ activeConditions: ["blinded"] });
+		renderPicker({ activeConditions: [{ id: "blinded" }] });
-		const blindedButton = screen.getByText("Blinded").closest("button");
+		const row = screen.getByText("Blinded").closest("div[class]");
-		expect(blindedButton?.className).toContain("bg-card/50");
+		expect(row?.className).toContain("bg-card/50");
 	});
 
 	it("clicking a condition calls onToggle with that condition's ID", async () => {
@@ -65,7 +73,7 @@ describe("ConditionPicker", () => {
 	});
 
 	it("active condition labels use foreground color", () => {
-		renderPicker({ activeConditions: ["charmed"] });
+		renderPicker({ activeConditions: [{ id: "charmed" }] });
 		const label = screen.getByText("Charmed");
 		expect(label.className).toContain("text-foreground");
 	});

apps/web/src/components/__tests__/condition-tags.test.tsx

@@ -1,5 +1,5 @@
 // @vitest-environment jsdom
-import type { ConditionId } from "@initiative/domain";
+import type { ConditionEntry } from "@initiative/domain";
 import { cleanup, render, screen } from "@testing-library/react";
 import { userEvent } from "@testing-library/user-event";
 import { afterEach, describe, expect, it, vi } from "vitest";
@@ -14,6 +14,7 @@ function renderTags(props: Partial<Parameters<typeof ConditionTags>[0]> = {}) {
 			<ConditionTags
 				conditions={props.conditions}
 				onRemove={props.onRemove ?? (() => {})}
+				onDecrement={props.onDecrement ?? (() => {})}
 				onOpenPicker={props.onOpenPicker ?? (() => {})}
 			/>
 		</RulesEditionProvider>,
@@ -28,7 +29,7 @@ describe("ConditionTags", () => {
 	});
 
 	it("renders a button per condition", () => {
-		const conditions: ConditionId[] = ["blinded", "prone"];
+		const conditions: ConditionEntry[] = [{ id: "blinded" }, { id: "prone" }];
 		renderTags({ conditions });
 		expect(
 			screen.getByRole("button", { name: "Remove Blinded" }),
@@ -39,7 +40,7 @@ describe("ConditionTags", () => {
 	it("calls onRemove with condition id when clicked", async () => {
 		const onRemove = vi.fn();
 		renderTags({
-			conditions: ["blinded"] as ConditionId[],
+			conditions: [{ id: "blinded" }] as ConditionEntry[],
 			onRemove,
 		});
 
@@ -66,4 +67,37 @@ describe("ConditionTags", () => {
 		// Only add button
 		expect(screen.getByRole("button", { name: "Add condition" })).toBeDefined();
 	});
+
+	it("displays value badge for valued conditions", () => {
+		renderTags({ conditions: [{ id: "frightened", value: 3 }] });
+		expect(screen.getByText("3")).toBeDefined();
+	});
+
+	it("calls onDecrement for valued condition click", async () => {
+		const onDecrement = vi.fn();
+		renderTags({
+			conditions: [{ id: "frightened", value: 2 }],
+			onDecrement,
+		});
+
+		await userEvent.click(
+			screen.getByRole("button", { name: "Remove Frightened" }),
+		);
+
+		expect(onDecrement).toHaveBeenCalledWith("frightened");
+	});
+
+	it("calls onRemove for non-valued condition click", async () => {
+		const onRemove = vi.fn();
+		renderTags({
+			conditions: [{ id: "blinded" }],
+			onRemove,
+		});
+
+		await userEvent.click(
+			screen.getByRole("button", { name: "Remove Blinded" }),
+		);
+
+		expect(onRemove).toHaveBeenCalledWith("blinded");
+	});
 });

apps/web/src/components/__tests__/settings-modal.test.tsx

@@ -37,15 +37,18 @@ function renderModal(open = true) {
 }
 
 describe("SettingsModal", () => {
-	it("renders edition section with 'Rules Edition' label", () => {
+	it("renders game system section with all three options", () => {
 		renderModal();
-		expect(screen.getByText("Rules Edition")).toBeInTheDocument();
+		expect(screen.getByText("Game System")).toBeInTheDocument();
 		expect(
 			screen.getByRole("button", { name: "5e (2014)" }),
 		).toBeInTheDocument();
 		expect(
 			screen.getByRole("button", { name: "5.5e (2024)" }),
 		).toBeInTheDocument();
+		expect(
+			screen.getByRole("button", { name: "Pathfinder 2e" }),
+		).toBeInTheDocument();
 	});
 
 	it("renders theme toggle buttons", () => {

apps/web/src/components/__tests__/source-fetch-prompt.test.tsx

@@ -6,6 +6,7 @@ import userEvent from "@testing-library/user-event";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { createTestAdapters } from "../../__tests__/adapters/in-memory-adapters.js";
 import { AdapterProvider } from "../../contexts/adapter-context.js";
+import { RulesEditionProvider } from "../../contexts/rules-edition-context.js";
 import { SourceFetchPrompt } from "../source-fetch-prompt.js";
 
 const MONSTER_MANUAL_REGEX = /Monster Manual/;
@@ -36,12 +37,14 @@ function renderPrompt(sourceCode = "MM") {
 			code === "MM" ? "Monster Manual" : code,
 	};
 	const result = render(
+		<RulesEditionProvider>
 			<AdapterProvider adapters={adapters}>
 				<SourceFetchPrompt
 					sourceCode={sourceCode}
 					onSourceLoaded={onSourceLoaded}
 				/>
-		</AdapterProvider>,
+			</AdapterProvider>
+		</RulesEditionProvider>,
 	);
 	return { ...result, onSourceLoaded };
 }

apps/web/src/components/__tests__/source-manager.test.tsx

@@ -36,7 +36,7 @@ function renderWithSources(sources: CachedSourceInfo[] = []) {
 	adapters.bestiaryCache = {
 		...adapters.bestiaryCache,
 		getCachedSources: () => Promise.resolve(currentSources),
-		clearSource(sourceCode) {
+		clearSource(_system, sourceCode) {
 			currentSources = currentSources.filter(
 				(s) => s.sourceCode !== sourceCode,
 			);

apps/web/src/components/__tests__/stat-block.test.tsx

@@ -5,7 +5,7 @@ import type { Creature } from "@initiative/domain";
 import { creatureId } from "@initiative/domain";
 import { cleanup, render, screen } from "@testing-library/react";
 import { afterEach, describe, expect, it } from "vitest";
-import { StatBlock } from "../stat-block.js";
+import { DndStatBlock as StatBlock } from "../dnd-stat-block.js";
 
 afterEach(cleanup);
 

apps/web/src/components/bulk-import-prompt.tsx

@@ -3,23 +3,30 @@ import { useId, useState } from "react";
 import { useAdapters } from "../contexts/adapter-context.js";
 import { useBestiaryContext } from "../contexts/bestiary-context.js";
 import { useBulkImportContext } from "../contexts/bulk-import-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 import { useSidePanelContext } from "../contexts/side-panel-context.js";
 import { Button } from "./ui/button.js";
 import { Input } from "./ui/input.js";
 
-const DEFAULT_BASE_URL =
+const DND_BASE_URL =
 	"https://raw.githubusercontent.com/5etools-mirror-3/5etools-src/main/data/bestiary/";
 
+const PF2E_BASE_URL =
+	"https://raw.githubusercontent.com/Pf2eToolsOrg/Pf2eTools/dev/data/bestiary/";
+
 export function BulkImportPrompt() {
-	const { bestiaryIndex } = useAdapters();
+	const { bestiaryIndex, pf2eBestiaryIndex } = useAdapters();
 	const { fetchAndCacheSource, isSourceCached, refreshCache } =
 		useBestiaryContext();
 	const { state: importState, startImport, reset } = useBulkImportContext();
 	const { dismissPanel } = useSidePanelContext();
+	const { edition } = useRulesEditionContext();
 
-	const [baseUrl, setBaseUrl] = useState(DEFAULT_BASE_URL);
+	const indexPort = edition === "pf2e" ? pf2eBestiaryIndex : bestiaryIndex;
+	const defaultUrl = edition === "pf2e" ? PF2E_BASE_URL : DND_BASE_URL;
+	const [baseUrl, setBaseUrl] = useState(defaultUrl);
 	const baseUrlId = useId();
-	const totalSources = bestiaryIndex.getAllSourceCodes().length;
+	const totalSources = indexPort.getAllSourceCodes().length;
 
 	const handleStart = (url: string) => {
 		startImport(url, fetchAndCacheSource, isSourceCached, refreshCache);

apps/web/src/components/combatant-row.tsx

@@ -1,6 +1,6 @@
 import {
 	type CombatantId,
-	type ConditionId,
+	type ConditionEntry,
 	type CreatureId,
 	deriveHpStatus,
 	type PlayerIcon,
@@ -31,7 +31,7 @@ interface Combatant {
 	readonly currentHp?: number;
 	readonly tempHp?: number;
 	readonly ac?: number;
-	readonly conditions?: readonly ConditionId[];
+	readonly conditions?: readonly ConditionEntry[];
 	readonly isConcentrating?: boolean;
 	readonly color?: string;
 	readonly icon?: string;
@@ -448,6 +448,8 @@ export function CombatantRow({
 		setTempHp,
 		setAc,
 		toggleCondition,
+		setConditionValue,
+		decrementCondition,
 		toggleConcentration,
 	} = useEncounterContext();
 	const { selectedCreatureId, showCreature, toggleCollapse } =
@@ -585,6 +587,7 @@ export function CombatantRow({
 						<ConditionTags
 							conditions={combatant.conditions}
 							onRemove={(conditionId) => toggleCondition(id, conditionId)}
+							onDecrement={(conditionId) => decrementCondition(id, conditionId)}
 							onOpenPicker={() => setPickerOpen((prev) => !prev)}
 						/>
 					</div>
@@ -593,6 +596,9 @@ export function CombatantRow({
 							anchorRef={conditionAnchorRef}
 							activeConditions={combatant.conditions}
 							onToggle={(conditionId) => toggleCondition(id, conditionId)}
+							onSetValue={(conditionId, value) =>
+								setConditionValue(id, conditionId, value)
+							}
 							onClose={() => setPickerOpen(false)}
 						/>
 					)}

apps/web/src/components/condition-picker.tsx

@@ -1,8 +1,10 @@
 import {
+	type ConditionEntry,
 	type ConditionId,
 	getConditionDescription,
 	getConditionsForEdition,
 } from "@initiative/domain";
+import { Check, Minus, Plus } from "lucide-react";
 import { useLayoutEffect, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
@@ -16,8 +18,9 @@ import { Tooltip } from "./ui/tooltip.js";
 
 interface ConditionPickerProps {
 	anchorRef: React.RefObject<HTMLElement | null>;
-	activeConditions: readonly ConditionId[] | undefined;
+	activeConditions: readonly ConditionEntry[] | undefined;
 	onToggle: (conditionId: ConditionId) => void;
+	onSetValue: (conditionId: ConditionId, value: number) => void;
 	onClose: () => void;
 }
 
@@ -25,6 +28,7 @@ export function ConditionPicker({
 	anchorRef,
 	activeConditions,
 	onToggle,
+	onSetValue,
 	onClose,
 }: Readonly<ConditionPickerProps>) {
 	const ref = useRef<HTMLDivElement>(null);
@@ -34,6 +38,11 @@ export function ConditionPicker({
 		maxHeight: number;
 	} | null>(null);
 
+	const [editing, setEditing] = useState<{
+		id: ConditionId;
+		value: number;
+	} | null>(null);
+
 	useLayoutEffect(() => {
 		const anchor = anchorRef.current;
 		const el = ref.current;
@@ -59,7 +68,9 @@ export function ConditionPicker({
 
 	const { edition } = useRulesEditionContext();
 	const conditions = getConditionsForEdition(edition);
-	const active = new Set(activeConditions ?? []);
+	const activeMap = new Map(
+		(activeConditions ?? []).map((e) => [e.id, e.value]),
+	);
 
 	return createPortal(
 		<div
@@ -74,35 +85,112 @@ export function ConditionPicker({
 			{conditions.map((def) => {
 				const Icon = CONDITION_ICON_MAP[def.iconName];
 				if (!Icon) return null;
-				const isActive = active.has(def.id);
+				const isActive = activeMap.has(def.id);
+				const activeValue = activeMap.get(def.id);
+				const isEditing = editing?.id === def.id;
 				const colorClass =
 					CONDITION_COLOR_CLASSES[def.color] ?? "text-muted-foreground";
+
+				const handleClick = () => {
+					if (def.valued && edition === "pf2e") {
+						const current = activeMap.get(def.id);
+						setEditing({
+							id: def.id,
+							value: current ?? 1,
+						});
+					} else {
+						onToggle(def.id);
+					}
+				};
+
 				return (
 					<Tooltip
 						key={def.id}
 						content={getConditionDescription(def, edition)}
 						className="block"
+					>
+						<div
+							className={cn(
+								"flex w-full items-center gap-2 rounded px-2 py-1 text-sm transition-colors",
+								(isActive || isEditing) && "bg-card/50",
+							)}
 						>
 							<button
 								type="button"
-							className={cn(
+								className="flex flex-1 items-center gap-2"
-								"flex w-full items-center gap-2 rounded px-2 py-1 text-sm transition-colors hover:bg-hover-neutral-bg",
+								onClick={handleClick}
-								isActive && "bg-card/50",
-							)}
-							onClick={() => onToggle(def.id)}
 							>
 								<Icon
 									size={14}
-								className={isActive ? colorClass : "text-muted-foreground"}
+									className={
+										isActive || isEditing ? colorClass : "text-muted-foreground"
+									}
 								/>
 								<span
 									className={
-									isActive ? "text-foreground" : "text-muted-foreground"
+										isActive || isEditing
+											? "text-foreground"
+											: "text-muted-foreground"
 									}
 								>
 									{def.label}
 								</span>
 							</button>
+							{isActive && def.valued && edition === "pf2e" && !isEditing && (
+								<span className="min-w-5 rounded-full bg-accent px-1.5 py-0.5 text-center font-medium text-primary-foreground text-xs">
+									{activeValue}
+								</span>
+							)}
+							{isEditing && (
+								<div className="flex items-center gap-0.5">
+									<button
+										type="button"
+										className="rounded p-0.5 text-foreground hover:bg-accent/40"
+										onMouseDown={(e) => e.preventDefault()}
+										onClick={(e) => {
+											e.stopPropagation();
+											if (editing.value > 1) {
+												setEditing({
+													...editing,
+													value: editing.value - 1,
+												});
+											}
+										}}
+									>
+										<Minus className="h-3 w-3" />
+									</button>
+									<span className="min-w-5 rounded-full bg-accent px-1.5 py-0.5 text-center font-medium text-primary-foreground text-xs">
+										{editing.value}
+									</span>
+									<button
+										type="button"
+										className="rounded p-0.5 text-foreground hover:bg-accent/40"
+										onMouseDown={(e) => e.preventDefault()}
+										onClick={(e) => {
+											e.stopPropagation();
+											setEditing({
+												...editing,
+												value: editing.value + 1,
+											});
+										}}
+									>
+										<Plus className="h-3 w-3" />
+									</button>
+									<button
+										type="button"
+										className="ml-0.5 rounded p-0.5 text-foreground hover:bg-accent/40"
+										onMouseDown={(e) => e.preventDefault()}
+										onClick={(e) => {
+											e.stopPropagation();
+											onSetValue(editing.id, editing.value);
+											setEditing(null);
+										}}
+									>
+										<Check className="h-3.5 w-3.5" />
+									</button>
+								</div>
+							)}
+						</div>
 					</Tooltip>
 				);
 			})}

apps/web/src/components/condition-styles.ts

@@ -1,42 +1,74 @@
 import type { LucideIcon } from "lucide-react";
 import {
+	Anchor,
 	ArrowDown,
 	Ban,
 	BatteryLow,
+	BrainCog,
+	CircleHelp,
+	CloudFog,
+	Drama,
 	Droplet,
+	Droplets,
 	EarOff,
+	Eye,
 	EyeOff,
+	Footprints,
 	Gem,
 	Ghost,
 	Hand,
 	Heart,
+	HeartCrack,
+	HeartPulse,
 	Link,
 	Moon,
+	PersonStanding,
 	ShieldMinus,
+	ShieldOff,
 	Siren,
+	Skull,
 	Snail,
 	Sparkles,
+	Sun,
+	TrendingDown,
+	Zap,
 	ZapOff,
 } from "lucide-react";
 
 export const CONDITION_ICON_MAP: Record<string, LucideIcon> = {
-	EyeOff,
+	Anchor,
-	Heart,
-	EarOff,
-	BatteryLow,
-	Siren,
-	Hand,
-	Ban,
-	Ghost,
-	ZapOff,
-	Gem,
-	Droplet,
 	ArrowDown,
+	Ban,
+	BatteryLow,
+	BrainCog,
+	CircleHelp,
+	CloudFog,
+	Drama,
+	Droplet,
+	Droplets,
+	EarOff,
+	Eye,
+	EyeOff,
+	Footprints,
+	Gem,
+	Ghost,
+	Hand,
+	Heart,
+	HeartCrack,
+	HeartPulse,
 	Link,
+	Moon,
+	PersonStanding,
 	ShieldMinus,
+	ShieldOff,
+	Siren,
+	Skull,
 	Snail,
 	Sparkles,
-	Moon,
+	Sun,
+	TrendingDown,
+	Zap,
+	ZapOff,
 };
 
 export const CONDITION_COLOR_CLASSES: Record<string, string> = {
@@ -51,4 +83,5 @@ export const CONDITION_COLOR_CLASSES: Record<string, string> = {
 	green: "text-green-400",
 	indigo: "text-indigo-400",
 	sky: "text-sky-400",
+	red: "text-red-400",
 };

apps/web/src/components/condition-tags.tsx

@@ -1,5 +1,6 @@
 import {
 	CONDITION_DEFINITIONS,
+	type ConditionEntry,
 	type ConditionId,
 	getConditionDescription,
 } from "@initiative/domain";
@@ -13,44 +14,57 @@ import {
 import { Tooltip } from "./ui/tooltip.js";
 
 interface ConditionTagsProps {
-	conditions: readonly ConditionId[] | undefined;
+	conditions: readonly ConditionEntry[] | undefined;
 	onRemove: (conditionId: ConditionId) => void;
+	onDecrement: (conditionId: ConditionId) => void;
 	onOpenPicker: () => void;
 }
 
 export function ConditionTags({
 	conditions,
 	onRemove,
+	onDecrement,
 	onOpenPicker,
 }: Readonly<ConditionTagsProps>) {
 	const { edition } = useRulesEditionContext();
 	return (
 		<div className="flex flex-wrap items-center gap-0.5">
-			{conditions?.map((condId) => {
+			{conditions?.map((entry) => {
-				const def = CONDITION_DEFINITIONS.find((d) => d.id === condId);
+				const def = CONDITION_DEFINITIONS.find((d) => d.id === entry.id);
 				if (!def) return null;
 				const Icon = CONDITION_ICON_MAP[def.iconName];
 				if (!Icon) return null;
 				const colorClass =
 					CONDITION_COLOR_CLASSES[def.color] ?? "text-muted-foreground";
+				const tooltipLabel =
+					entry.value === undefined ? def.label : `${def.label} ${entry.value}`;
 				return (
 					<Tooltip
-						key={condId}
+						key={entry.id}
-						content={`${def.label}:\n${getConditionDescription(def, edition)}`}
+						content={`${tooltipLabel}:\n${getConditionDescription(def, edition)}`}
 					>
 						<button
 							type="button"
 							aria-label={`Remove ${def.label}`}
 							className={cn(
-								"inline-flex items-center rounded p-0.5 transition-colors hover:bg-hover-neutral-bg",
+								"inline-flex items-center gap-0.5 rounded p-0.5 transition-colors hover:bg-hover-neutral-bg",
 								colorClass,
 							)}
 							onClick={(e) => {
 								e.stopPropagation();
-								onRemove(condId);
+								if (entry.value === undefined) {
+									onRemove(entry.id);
+								} else {
+									onDecrement(entry.id);
+								}
 							}}
 						>
 							<Icon size={14} />
+							{entry.value !== undefined && (
+								<span className="font-medium text-xs leading-none">
+									{entry.value}
+								</span>
+							)}
 						</button>
 					</Tooltip>
 				);

apps/web/src/components/difficulty-breakdown-panel.tsx

@@ -11,9 +11,8 @@ import {
 import { CrPicker } from "./cr-picker.js";
 import { Button } from "./ui/button.js";
 
-const TIER_LABEL_MAP: Record<
+const TIER_LABEL_MAP: Partial<
-	RulesEdition,
+	Record<RulesEdition, Record<DifficultyTier, { label: string; color: string }>>
-	Record<DifficultyTier, { label: string; color: string }>
 > = {
 	"5.5e": {
 		0: { label: "Trivial", color: "text-muted-foreground" },
@@ -117,7 +116,9 @@ export function DifficultyBreakdownPanel({ onClose }: { onClose: () => void }) {
 	const breakdown = useDifficultyBreakdown();
 	if (!breakdown) return null;
 
-	const tierConfig = TIER_LABEL_MAP[edition][breakdown.tier];
+	const tierLabels = TIER_LABEL_MAP[edition];
+	if (!tierLabels) return null;
+	const tierConfig = tierLabels[breakdown.tier];
 
 	const handleToggle = (entry: BreakdownCombatant) => {
 		const newSide = entry.side === "party" ? "enemy" : "party";

apps/web/src/components/dnd-stat-block.tsx

@@ -1,10 +1,16 @@
-import type { Creature, TraitBlock, TraitSegment } from "@initiative/domain";
+import type { Creature } from "@initiative/domain";
 import {
 	calculateInitiative,
 	formatInitiativeModifier,
 } from "@initiative/domain";
+import {
+	PropertyLine,
+	SectionDivider,
+	TraitEntry,
+	TraitSection,
+} from "./stat-block-parts.js";
 
-interface StatBlockProps {
+interface DndStatBlockProps {
 	creature: Creature;
 }
 
@@ -13,96 +19,7 @@ function abilityMod(score: number): string {
 	return mod >= 0 ? `+${mod}` : `${mod}`;
 }
 
-function PropertyLine({
+export function DndStatBlock({ creature }: Readonly<DndStatBlockProps>) {
-	label,
-	value,
-}: Readonly<{
-	label: string;
-	value: string | undefined;
-}>) {
-	if (!value) return null;
-	return (
-		<div className="text-sm">
-			<span className="font-semibold">{label}</span> {value}
-		</div>
-	);
-}
-
-function SectionDivider() {
-	return (
-		<div className="my-2 h-px bg-gradient-to-r from-stat-divider-from via-stat-divider-via to-transparent" />
-	);
-}
-
-function segmentKey(seg: TraitSegment): string {
-	return seg.type === "text"
-		? seg.value.slice(0, 40)
-		: seg.items.map((i) => i.label ?? i.text.slice(0, 20)).join(",");
-}
-
-function TraitSegments({
-	segments,
-}: Readonly<{ segments: readonly TraitSegment[] }>) {
-	return (
-		<>
-			{segments.map((seg, i) => {
-				if (seg.type === "text") {
-					return (
-						<span key={segmentKey(seg)}>
-							{i === 0 ? ` ${seg.value}` : seg.value}
-						</span>
-					);
-				}
-				return (
-					<div key={segmentKey(seg)} className="mt-1 space-y-0.5">
-						{seg.items.map((item) => (
-							<p key={item.label ?? item.text}>
-								{item.label != null && (
-									<span className="font-semibold">{item.label}. </span>
-								)}
-								{item.text}
-							</p>
-						))}
-					</div>
-				);
-			})}
-		</>
-	);
-}
-
-function TraitEntry({ trait }: Readonly<{ trait: TraitBlock }>) {
-	return (
-		<div className="text-sm">
-			<span className="font-semibold italic">{trait.name}.</span>
-			<TraitSegments segments={trait.segments} />
-		</div>
-	);
-}
-
-function TraitSection({
-	entries,
-	heading,
-}: Readonly<{
-	entries: readonly TraitBlock[] | undefined;
-	heading?: string;
-}>) {
-	if (!entries || entries.length === 0) return null;
-	return (
-		<>
-			<SectionDivider />
-			{heading ? (
-				<h3 className="font-bold text-base text-stat-heading">{heading}</h3>
-			) : null}
-			<div className="space-y-2">
-				{entries.map((e) => (
-					<TraitEntry key={e.name} trait={e} />
-				))}
-			</div>
-		</>
-	);
-}
-
-export function StatBlock({ creature }: Readonly<StatBlockProps>) {
 	const abilities = [
 		{ label: "STR", score: creature.abilities.str },
 		{ label: "DEX", score: creature.abilities.dex },

apps/web/src/components/pf2e-stat-block.tsx

@@ -0,0 +1,143 @@
+import type { Pf2eCreature } from "@initiative/domain";
+import { formatInitiativeModifier } from "@initiative/domain";
+import {
+	PropertyLine,
+	SectionDivider,
+	TraitSection,
+} from "./stat-block-parts.js";
+
+interface Pf2eStatBlockProps {
+	creature: Pf2eCreature;
+}
+
+const ALIGNMENTS = new Set([
+	"lg",
+	"ng",
+	"cg",
+	"ln",
+	"n",
+	"cn",
+	"le",
+	"ne",
+	"ce",
+]);
+
+function capitalize(s: string): string {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+function displayTraits(traits: readonly string[]): string[] {
+	return traits.filter((t) => !ALIGNMENTS.has(t)).map(capitalize);
+}
+
+function formatMod(mod: number): string {
+	return mod >= 0 ? `+${mod}` : `${mod}`;
+}
+
+export function Pf2eStatBlock({ creature }: Readonly<Pf2eStatBlockProps>) {
+	const abilityEntries = [
+		{ label: "Str", mod: creature.abilityMods.str },
+		{ label: "Dex", mod: creature.abilityMods.dex },
+		{ label: "Con", mod: creature.abilityMods.con },
+		{ label: "Int", mod: creature.abilityMods.int },
+		{ label: "Wis", mod: creature.abilityMods.wis },
+		{ label: "Cha", mod: creature.abilityMods.cha },
+	];
+
+	return (
+		<div className="space-y-1 text-foreground">
+			{/* Header */}
+			<div>
+				<div className="flex items-baseline justify-between gap-2">
+					<h2 className="font-bold text-stat-heading text-xl">
+						{creature.name}
+					</h2>
+					<span className="shrink-0 font-semibold text-sm">
+						Level {creature.level}
+					</span>
+				</div>
+				<div className="mt-1 flex flex-wrap gap-1">
+					{displayTraits(creature.traits).map((trait) => (
+						<span
+							key={trait}
+							className="rounded border border-border bg-card px-1.5 py-0.5 text-foreground text-xs"
+						>
+							{trait}
+						</span>
+					))}
+				</div>
+				<p className="mt-1 text-muted-foreground text-xs">
+					{creature.sourceDisplayName}
+				</p>
+			</div>
+
+			<SectionDivider />
+
+			{/* Perception, Languages, Skills */}
+			<div className="space-y-0.5 text-sm">
+				<div>
+					<span className="font-semibold">Perception</span>{" "}
+					{formatInitiativeModifier(creature.perception)}
+					{creature.senses ? `; ${creature.senses}` : ""}
+				</div>
+				<PropertyLine label="Languages" value={creature.languages} />
+				<PropertyLine label="Skills" value={creature.skills} />
+			</div>
+
+			{/* Ability Modifiers */}
+			<div className="grid grid-cols-6 gap-1 text-center text-sm">
+				{abilityEntries.map((a) => (
+					<div key={a.label}>
+						<div className="font-semibold text-muted-foreground text-xs">
+							{a.label}
+						</div>
+						<div>{formatMod(a.mod)}</div>
+					</div>
+				))}
+			</div>
+
+			<PropertyLine label="Items" value={creature.items} />
+
+			{/* Top abilities (before defenses) */}
+			<TraitSection entries={creature.abilitiesTop} />
+
+			<SectionDivider />
+
+			{/* Defenses */}
+			<div className="space-y-0.5 text-sm">
+				<div>
+					<span className="font-semibold">AC</span> {creature.ac}
+					{creature.acConditional ? ` (${creature.acConditional})` : ""};{" "}
+					<span className="font-semibold">Fort</span>{" "}
+					{formatMod(creature.saveFort)},{" "}
+					<span className="font-semibold">Ref</span>{" "}
+					{formatMod(creature.saveRef)},{" "}
+					<span className="font-semibold">Will</span>{" "}
+					{formatMod(creature.saveWill)}
+				</div>
+				<div>
+					<span className="font-semibold">HP</span> {creature.hp}
+				</div>
+				<PropertyLine label="Immunities" value={creature.immunities} />
+				<PropertyLine label="Resistances" value={creature.resistances} />
+				<PropertyLine label="Weaknesses" value={creature.weaknesses} />
+			</div>
+
+			{/* Mid abilities (reactions, auras) */}
+			<TraitSection entries={creature.abilitiesMid} />
+
+			<SectionDivider />
+
+			{/* Speed */}
+			<div className="text-sm">
+				<span className="font-semibold">Speed</span> {creature.speed}
+			</div>
+
+			{/* Attacks */}
+			<TraitSection entries={creature.attacks} />
+
+			{/* Bottom abilities (active abilities) */}
+			<TraitSection entries={creature.abilitiesBot} />
+		</div>
+	);
+}

apps/web/src/components/settings-modal.tsx

@@ -13,6 +13,7 @@ interface SettingsModalProps {
 const EDITION_OPTIONS: { value: RulesEdition; label: string }[] = [
 	{ value: "5e", label: "5e (2014)" },
 	{ value: "5.5e", label: "5.5e (2024)" },
+	{ value: "pf2e", label: "Pathfinder 2e" },
 ];
 
 const THEME_OPTIONS: {
@@ -36,7 +37,7 @@ export function SettingsModal({ open, onClose }: Readonly<SettingsModalProps>) {
 			<div className="flex flex-col gap-5">
 				<div>
 					<span className="mb-2 block font-medium text-muted-foreground text-sm">
-						Rules Edition
+						Game System
 					</span>
 					<div className="flex gap-1">
 						{EDITION_OPTIONS.map((opt) => (

apps/web/src/components/source-fetch-prompt.tsx

@@ -2,6 +2,7 @@ import { Download, Loader2, Upload } from "lucide-react";
 import { useId, useRef, useState } from "react";
 import { useAdapters } from "../contexts/adapter-context.js";
 import { useBestiaryContext } from "../contexts/bestiary-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 import { Button } from "./ui/button.js";
 import { Input } from "./ui/input.js";
 
@@ -14,11 +15,13 @@ export function SourceFetchPrompt({
 	sourceCode,
 	onSourceLoaded,
 }: Readonly<SourceFetchPromptProps>) {
-	const { bestiaryIndex } = useAdapters();
+	const { bestiaryIndex, pf2eBestiaryIndex } = useAdapters();
 	const { fetchAndCacheSource, uploadAndCacheSource } = useBestiaryContext();
-	const sourceDisplayName = bestiaryIndex.getSourceDisplayName(sourceCode);
+	const { edition } = useRulesEditionContext();
+	const indexPort = edition === "pf2e" ? pf2eBestiaryIndex : bestiaryIndex;
+	const sourceDisplayName = indexPort.getSourceDisplayName(sourceCode);
 	const [url, setUrl] = useState(() =>
-		bestiaryIndex.getDefaultFetchUrl(sourceCode),
+		indexPort.getDefaultFetchUrl(sourceCode),
 	);
 	const [status, setStatus] = useState<"idle" | "fetching" | "error">("idle");
 	const [error, setError] = useState<string>("");

apps/web/src/components/source-manager.tsx

@@ -9,12 +9,15 @@ import {
 import type { CachedSourceInfo } from "../adapters/ports.js";
 import { useAdapters } from "../contexts/adapter-context.js";
 import { useBestiaryContext } from "../contexts/bestiary-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 import { Button } from "./ui/button.js";
 import { Input } from "./ui/input.js";
 
 export function SourceManager() {
 	const { bestiaryCache } = useAdapters();
 	const { refreshCache } = useBestiaryContext();
+	const { edition } = useRulesEditionContext();
+	const system = edition === "pf2e" ? "pf2e" : "dnd";
 	const [sources, setSources] = useState<CachedSourceInfo[]>([]);
 	const [filter, setFilter] = useState("");
 	const [optimisticSources, applyOptimistic] = useOptimistic(
@@ -29,9 +32,9 @@ export function SourceManager() {
 	);
 
 	const loadSources = useCallback(async () => {
-		const cached = await bestiaryCache.getCachedSources();
+		const cached = await bestiaryCache.getCachedSources(system);
 		setSources(cached);
-	}, [bestiaryCache]);
+	}, [bestiaryCache, system]);
 
 	useEffect(() => {
 		void loadSources();
@@ -39,7 +42,7 @@ export function SourceManager() {
 
 	const handleClearSource = async (sourceCode: string) => {
 		applyOptimistic({ type: "remove", sourceCode });
-		await bestiaryCache.clearSource(sourceCode);
+		await bestiaryCache.clearSource(system, sourceCode);
 		await loadSources();
 		void refreshCache();
 	};

apps/web/src/components/stat-block-panel.tsx

@@ -1,4 +1,4 @@
-import type { CreatureId } from "@initiative/domain";
+import type { Creature, CreatureId } from "@initiative/domain";
 import { PanelRightClose, Pin, PinOff } from "lucide-react";
 import type { ReactNode } from "react";
 import { useEffect, useState } from "react";
@@ -7,9 +7,10 @@ import { useSidePanelContext } from "../contexts/side-panel-context.js";
 import { useSwipeToDismiss } from "../hooks/use-swipe-to-dismiss.js";
 import { cn } from "../lib/utils.js";
 import { BulkImportPrompt } from "./bulk-import-prompt.js";
+import { DndStatBlock } from "./dnd-stat-block.js";
+import { Pf2eStatBlock } from "./pf2e-stat-block.js";
 import { SourceFetchPrompt } from "./source-fetch-prompt.js";
 import { SourceManager } from "./source-manager.js";
-import { StatBlock } from "./stat-block.js";
 import { Button } from "./ui/button.js";
 
 interface StatBlockPanelProps {
@@ -307,7 +308,10 @@ export function StatBlockPanel({
 		}
 
 		if (creature) {
-			return <StatBlock creature={creature} />;
+			if ("system" in creature && creature.system === "pf2e") {
+				return <Pf2eStatBlock creature={creature} />;
+			}
+			return <DndStatBlock creature={creature as Creature} />;
 		}
 
 		if (needsFetch && sourceCode) {

apps/web/src/components/stat-block-parts.tsx

@@ -0,0 +1,90 @@
+import type { TraitBlock, TraitSegment } from "@initiative/domain";
+
+export function PropertyLine({
+	label,
+	value,
+}: Readonly<{
+	label: string;
+	value: string | undefined;
+}>) {
+	if (!value) return null;
+	return (
+		<div className="text-sm">
+			<span className="font-semibold">{label}</span> {value}
+		</div>
+	);
+}
+
+export function SectionDivider() {
+	return (
+		<div className="my-2 h-px bg-gradient-to-r from-stat-divider-from via-stat-divider-via to-transparent" />
+	);
+}
+
+function segmentKey(seg: TraitSegment): string {
+	return seg.type === "text"
+		? seg.value.slice(0, 40)
+		: seg.items.map((i) => i.label ?? i.text.slice(0, 20)).join(",");
+}
+
+function TraitSegments({
+	segments,
+}: Readonly<{ segments: readonly TraitSegment[] }>) {
+	return (
+		<>
+			{segments.map((seg, i) => {
+				if (seg.type === "text") {
+					return (
+						<span key={segmentKey(seg)}>
+							{i === 0 ? ` ${seg.value}` : seg.value}
+						</span>
+					);
+				}
+				return (
+					<div key={segmentKey(seg)} className="mt-1 space-y-0.5">
+						{seg.items.map((item) => (
+							<p key={item.label ?? item.text}>
+								{item.label != null && (
+									<span className="font-semibold">{item.label}. </span>
+								)}
+								{item.text}
+							</p>
+						))}
+					</div>
+				);
+			})}
+		</>
+	);
+}
+
+export function TraitEntry({ trait }: Readonly<{ trait: TraitBlock }>) {
+	return (
+		<div className="text-sm">
+			<span className="font-semibold italic">{trait.name}.</span>
+			<TraitSegments segments={trait.segments} />
+		</div>
+	);
+}
+
+export function TraitSection({
+	entries,
+	heading,
+}: Readonly<{
+	entries: readonly TraitBlock[] | undefined;
+	heading?: string;
+}>) {
+	if (!entries || entries.length === 0) return null;
+	return (
+		<>
+			<SectionDivider />
+			{heading ? (
+				<h3 className="font-bold text-base text-stat-heading">{heading}</h3>
+			) : null}
+			<div className="space-y-2">
+				{entries.map((e) => (
+					<TraitEntry key={e.name} trait={e} />
+				))}
+			</div>
+		</>
+	);
+}

apps/web/src/contexts/adapter-context.tsx

@@ -3,6 +3,7 @@ import type {
 	BestiaryCachePort,
 	BestiaryIndexPort,
 	EncounterPersistence,
+	Pf2eBestiaryIndexPort,
 	PlayerCharacterPersistence,
 	UndoRedoPersistence,
 } from "../adapters/ports.js";
@@ -13,6 +14,7 @@ export interface Adapters {
 	playerCharacterPersistence: PlayerCharacterPersistence;
 	bestiaryCache: BestiaryCachePort;
 	bestiaryIndex: BestiaryIndexPort;
+	pf2eBestiaryIndex: Pf2eBestiaryIndexPort;
 }
 
 const AdapterContext = createContext<Adapters | null>(null);

apps/web/src/hooks/__tests__/encounter-reducer.test.ts

@@ -1,8 +1,4 @@
-import type {
+import type { ConditionId, PlayerCharacter } from "@initiative/domain";
-	BestiaryIndexEntry,
-	ConditionId,
-	PlayerCharacter,
-} from "@initiative/domain";
 import {
 	combatantId,
 	createEncounter,
@@ -11,6 +7,7 @@ import {
 	playerCharacterId,
 } from "@initiative/domain";
 import { describe, expect, it } from "vitest";
+import type { SearchResult } from "../use-bestiary.js";
 import { type EncounterState, encounterReducer } from "../use-encounter.js";
 
 function emptyState(): EncounterState {
@@ -45,9 +42,11 @@ function stateWithHp(name: string, maxHp: number): EncounterState {
 	});
 }
 
-const BESTIARY_ENTRY: BestiaryIndexEntry = {
+const BESTIARY_ENTRY: SearchResult = {
+	system: "dnd",
 	name: "Goblin",
 	source: "MM",
+	sourceDisplayName: "Monster Manual",
 	ac: 15,
 	hp: 7,
 	dex: 14,
@@ -57,6 +56,19 @@ const BESTIARY_ENTRY: BestiaryIndexEntry = {
 	type: "humanoid",
 };
 
+const PF2E_BESTIARY_ENTRY: SearchResult = {
+	system: "pf2e",
+	name: "Goblin Warrior",
+	source: "B1",
+	sourceDisplayName: "Bestiary",
+	level: -1,
+	ac: 16,
+	hp: 6,
+	perception: 5,
+	size: "small",
+	type: "humanoid",
+};
+
 describe("encounterReducer", () => {
 	describe("add-combatant", () => {
 		it("adds a combatant and pushes undo", () => {
@@ -236,7 +248,9 @@ describe("encounterReducer", () => {
 				conditionId: "blinded" as ConditionId,
 			});
 
-			expect(next.encounter.combatants[0].conditions).toContain("blinded");
+			expect(next.encounter.combatants[0].conditions).toContainEqual({
+				id: "blinded",
+			});
 		});
 
 		it("toggles concentration", () => {
@@ -327,6 +341,19 @@ describe("encounterReducer", () => {
 			expect(names).toContain("Goblin 1");
 			expect(names).toContain("Goblin 2");
 		});
+
+		it("adds PF2e creature with HP, AC, and creatureId", () => {
+			const next = encounterReducer(emptyState(), {
+				type: "add-from-bestiary",
+				entry: PF2E_BESTIARY_ENTRY,
+			});
+
+			const c = next.encounter.combatants[0];
+			expect(c.name).toBe("Goblin Warrior");
+			expect(c.maxHp).toBe(6);
+			expect(c.ac).toBe(16);
+			expect(c.creatureId).toBe("b1:goblin-warrior");
+		});
 	});
 
 	describe("add-multiple-from-bestiary", () => {

apps/web/src/hooks/__tests__/use-encounter.test.tsx

@@ -1,11 +1,12 @@
 // @vitest-environment jsdom
-import type { BestiaryIndexEntry, PlayerCharacter } from "@initiative/domain";
+import type { PlayerCharacter } from "@initiative/domain";
 import { combatantId, creatureId, playerCharacterId } from "@initiative/domain";
 import { act, renderHook } from "@testing-library/react";
 import type { ReactNode } from "react";
 import { beforeAll, describe, expect, it, vi } from "vitest";
 import { createTestAdapters } from "../../__tests__/adapters/in-memory-adapters.js";
 import { AllProviders } from "../../__tests__/test-providers.js";
+import type { SearchResult } from "../use-bestiary.js";
 import { useEncounter } from "../use-encounter.js";
 
 beforeAll(() => {
@@ -152,9 +153,11 @@ describe("useEncounter", () => {
 		expect(result.current.canRollAllInitiative).toBe(false);
 
 		// Add from bestiary to get a creature combatant
-		const entry: BestiaryIndexEntry = {
+		const entry: SearchResult = {
+			system: "dnd",
 			name: "Goblin",
 			source: "MM",
+			sourceDisplayName: "Monster Manual",
 			ac: 15,
 			hp: 7,
 			dex: 14,
@@ -175,9 +178,11 @@ describe("useEncounter", () => {
 	it("addFromBestiary adds combatant with HP, AC, creatureId", () => {
 		const { result } = renderHook(() => useEncounter(), { wrapper });
 
-		const entry: BestiaryIndexEntry = {
+		const entry: SearchResult = {
+			system: "dnd",
 			name: "Goblin",
 			source: "MM",
+			sourceDisplayName: "Monster Manual",
 			ac: 15,
 			hp: 7,
 			dex: 14,
@@ -202,9 +207,11 @@ describe("useEncounter", () => {
 	it("addFromBestiary auto-numbers duplicate names", () => {
 		const { result } = renderHook(() => useEncounter(), { wrapper });
 
-		const entry: BestiaryIndexEntry = {
+		const entry: SearchResult = {
+			system: "dnd",
 			name: "Goblin",
 			source: "MM",
+			sourceDisplayName: "Monster Manual",
 			ac: 15,
 			hp: 7,
 			dex: 14,

apps/web/src/hooks/__tests__/use-rules-edition.test.ts

@@ -1,9 +1,10 @@
 // @vitest-environment jsdom
 import { act, renderHook } from "@testing-library/react";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { useRulesEdition } from "../use-rules-edition.js";
 
-const STORAGE_KEY = "initiative:rules-edition";
+const STORAGE_KEY = "initiative:game-system";
+const OLD_STORAGE_KEY = "initiative:rules-edition";
 
 describe("useRulesEdition", () => {
 	afterEach(() => {
@@ -11,6 +12,7 @@ describe("useRulesEdition", () => {
 		const { result } = renderHook(() => useRulesEdition());
 		act(() => result.current.setEdition("5.5e"));
 		localStorage.removeItem(STORAGE_KEY);
+		localStorage.removeItem(OLD_STORAGE_KEY);
 	});
 
 	it("defaults to 5.5e", () => {
@@ -42,4 +44,31 @@ describe("useRulesEdition", () => {
 
 		expect(r2.current.edition).toBe("5e");
 	});
+
+	it("accepts pf2e as a valid game system", () => {
+		const { result } = renderHook(() => useRulesEdition());
+
+		act(() => result.current.setEdition("pf2e"));
+
+		expect(result.current.edition).toBe("pf2e");
+		expect(localStorage.getItem(STORAGE_KEY)).toBe("pf2e");
+	});
+
+	it("migrates from old storage key on fresh module load", async () => {
+		// Set up old key before re-importing the module
+		localStorage.setItem(OLD_STORAGE_KEY, "5e");
+		localStorage.removeItem(STORAGE_KEY);
+
+		// Force a fresh module so loadEdition() re-runs at init time
+		vi.resetModules();
+		const { useRulesEdition: freshHook } = await import(
+			"../use-rules-edition.js"
+		);
+
+		const { result } = renderHook(() => freshHook());
+
+		expect(result.current.edition).toBe("5e");
+		expect(localStorage.getItem(STORAGE_KEY)).toBe("5e");
+		expect(localStorage.getItem(OLD_STORAGE_KEY)).toBeNull();
+	});
 });

apps/web/src/hooks/use-bestiary.ts

@@ -1,22 +1,34 @@
 import type {
+	AnyCreature,
 	BestiaryIndexEntry,
-	Creature,
 	CreatureId,
+	Pf2eBestiaryIndexEntry,
 } from "@initiative/domain";
 import { useCallback, useEffect, useState } from "react";
 import {
 	normalizeBestiary,
 	setSourceDisplayNames,
 } from "../adapters/bestiary-adapter.js";
+import {
+	normalizePf2eBestiary,
+	setPf2eSourceDisplayNames,
+} from "../adapters/pf2e-bestiary-adapter.js";
 import { useAdapters } from "../contexts/adapter-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 
-export interface SearchResult extends BestiaryIndexEntry {
+export type SearchResult =
+	| (BestiaryIndexEntry & {
+			readonly system: "dnd";
 			readonly sourceDisplayName: string;
-}
+	  })
+	| (Pf2eBestiaryIndexEntry & {
+			readonly system: "pf2e";
+			readonly sourceDisplayName: string;
+	  });
 
 interface BestiaryHook {
 	search: (query: string) => SearchResult[];
-	getCreature: (id: CreatureId) => Creature | undefined;
+	getCreature: (id: CreatureId) => AnyCreature | undefined;
 	isLoaded: boolean;
 	isSourceCached: (sourceCode: string) => Promise<boolean>;
 	fetchAndCacheSource: (sourceCode: string, url: string) => Promise<void>;
@@ -28,28 +40,47 @@ interface BestiaryHook {
 }
 
 export function useBestiary(): BestiaryHook {
-	const { bestiaryCache, bestiaryIndex } = useAdapters();
+	const { bestiaryCache, bestiaryIndex, pf2eBestiaryIndex } = useAdapters();
+	const { edition } = useRulesEditionContext();
 	const [isLoaded, setIsLoaded] = useState(false);
 	const [creatureMap, setCreatureMap] = useState(
-		() => new Map<CreatureId, Creature>(),
+		() => new Map<CreatureId, AnyCreature>(),
 	);
 
 	useEffect(() => {
 		const index = bestiaryIndex.loadIndex();
 		setSourceDisplayNames(index.sources as Record<string, string>);
-		if (index.creatures.length > 0) {
+
+		const pf2eIndex = pf2eBestiaryIndex.loadIndex();
+		setPf2eSourceDisplayNames(pf2eIndex.sources as Record<string, string>);
+
+		if (index.creatures.length > 0 || pf2eIndex.creatures.length > 0) {
 			setIsLoaded(true);
 		}
 
 		void bestiaryCache.loadAllCachedCreatures().then((map) => {
 			setCreatureMap(map);
 		});
-	}, [bestiaryCache, bestiaryIndex]);
+	}, [bestiaryCache, bestiaryIndex, pf2eBestiaryIndex]);
 
 	const search = useCallback(
 		(query: string): SearchResult[] => {
 			if (query.length < 2) return [];
 			const lower = query.toLowerCase();
+
+			if (edition === "pf2e") {
+				const index = pf2eBestiaryIndex.loadIndex();
+				return index.creatures
+					.filter((c) => c.name.toLowerCase().includes(lower))
+					.sort((a, b) => a.name.localeCompare(b.name))
+					.slice(0, 10)
+					.map((c) => ({
+						...c,
+						system: "pf2e" as const,
+						sourceDisplayName: pf2eBestiaryIndex.getSourceDisplayName(c.source),
+					}));
+			}
+
 			const index = bestiaryIndex.loadIndex();
 			return index.creatures
 				.filter((c) => c.name.toLowerCase().includes(lower))
@@ -57,24 +88,27 @@ export function useBestiary(): BestiaryHook {
 				.slice(0, 10)
 				.map((c) => ({
 					...c,
+					system: "dnd" as const,
 					sourceDisplayName: bestiaryIndex.getSourceDisplayName(c.source),
 				}));
 		},
-		[bestiaryIndex],
+		[bestiaryIndex, pf2eBestiaryIndex, edition],
 	);
 
 	const getCreature = useCallback(
-		(id: CreatureId): Creature | undefined => {
+		(id: CreatureId): AnyCreature | undefined => {
 			return creatureMap.get(id);
 		},
 		[creatureMap],
 	);
 
+	const system = edition === "pf2e" ? "pf2e" : "dnd";
+
 	const isSourceCachedFn = useCallback(
 		(sourceCode: string): Promise<boolean> => {
-			return bestiaryCache.isSourceCached(sourceCode);
+			return bestiaryCache.isSourceCached(system, sourceCode);
 		},
-		[bestiaryCache],
+		[bestiaryCache, system],
 	);
 
 	const fetchAndCacheSource = useCallback(
@@ -86,9 +120,20 @@ export function useBestiary(): BestiaryHook {
 				);
 			}
 			const json = await response.json();
-			const creatures = normalizeBestiary(json);
+			const creatures =
-			const displayName = bestiaryIndex.getSourceDisplayName(sourceCode);
+				edition === "pf2e"
-			await bestiaryCache.cacheSource(sourceCode, displayName, creatures);
+					? normalizePf2eBestiary(json)
+					: normalizeBestiary(json);
+			const displayName =
+				edition === "pf2e"
+					? pf2eBestiaryIndex.getSourceDisplayName(sourceCode)
+					: bestiaryIndex.getSourceDisplayName(sourceCode);
+			await bestiaryCache.cacheSource(
+				system,
+				sourceCode,
+				displayName,
+				creatures,
+			);
 			setCreatureMap((prev) => {
 				const next = new Map(prev);
 				for (const c of creatures) {
@@ -97,15 +142,27 @@ export function useBestiary(): BestiaryHook {
 				return next;
 			});
 		},
-		[bestiaryCache, bestiaryIndex],
+		[bestiaryCache, bestiaryIndex, pf2eBestiaryIndex, edition, system],
 	);
 
 	const uploadAndCacheSource = useCallback(
 		async (sourceCode: string, jsonData: unknown): Promise<void> => {
-			// biome-ignore lint/suspicious/noExplicitAny: raw JSON shape varies
+			const creatures =
-			const creatures = normalizeBestiary(jsonData as any);
+				edition === "pf2e"
-			const displayName = bestiaryIndex.getSourceDisplayName(sourceCode);
+					? normalizePf2eBestiary(jsonData as { creature: unknown[] })
-			await bestiaryCache.cacheSource(sourceCode, displayName, creatures);
+					: normalizeBestiary(
+							jsonData as Parameters<typeof normalizeBestiary>[0],
+						);
+			const displayName =
+				edition === "pf2e"
+					? pf2eBestiaryIndex.getSourceDisplayName(sourceCode)
+					: bestiaryIndex.getSourceDisplayName(sourceCode);
+			await bestiaryCache.cacheSource(
+				system,
+				sourceCode,
+				displayName,
+				creatures,
+			);
 			setCreatureMap((prev) => {
 				const next = new Map(prev);
 				for (const c of creatures) {
@@ -114,7 +171,7 @@ export function useBestiary(): BestiaryHook {
 				return next;
 			});
 		},
-		[bestiaryCache, bestiaryIndex],
+		[bestiaryCache, bestiaryIndex, pf2eBestiaryIndex, edition, system],
 	);
 
 	const refreshCache = useCallback(async (): Promise<void> => {

apps/web/src/hooks/use-bulk-import.ts

@@ -1,5 +1,6 @@
 import { useCallback, useRef, useState } from "react";
 import { useAdapters } from "../contexts/adapter-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 
 const BATCH_SIZE = 6;
 
@@ -29,7 +30,9 @@ interface BulkImportHook {
 }
 
 export function useBulkImport(): BulkImportHook {
-	const { bestiaryIndex } = useAdapters();
+	const { bestiaryIndex, pf2eBestiaryIndex } = useAdapters();
+	const { edition } = useRulesEditionContext();
+	const indexPort = edition === "pf2e" ? pf2eBestiaryIndex : bestiaryIndex;
 	const [state, setState] = useState<BulkImportState>(IDLE_STATE);
 	const countersRef = useRef({ completed: 0, failed: 0 });
 
@@ -40,7 +43,7 @@ export function useBulkImport(): BulkImportHook {
 			isSourceCached: (sourceCode: string) => Promise<boolean>,
 			refreshCache: () => Promise<void>,
 		) => {
-			const allCodes = bestiaryIndex.getAllSourceCodes();
+			const allCodes = indexPort.getAllSourceCodes();
 			const total = allCodes.length;
 
 			countersRef.current = { completed: 0, failed: 0 };
@@ -81,7 +84,7 @@ export function useBulkImport(): BulkImportHook {
 						chain.then(() =>
 							Promise.allSettled(
 								batch.map(async ({ code }) => {
-									const url = bestiaryIndex.getDefaultFetchUrl(code, baseUrl);
+									const url = indexPort.getDefaultFetchUrl(code, baseUrl);
 									try {
 										await fetchAndCacheSource(code, url);
 										countersRef.current.completed++;
@@ -115,7 +118,7 @@ export function useBulkImport(): BulkImportHook {
 				});
 			})();
 		},
-		[bestiaryIndex],
+		[indexPort],
 	);
 
 	const reset = useCallback(() => {

apps/web/src/hooks/use-difficulty-breakdown.ts

@@ -64,7 +64,7 @@ export function useDifficultyBreakdown(): DifficultyBreakdown | null {
 }
 
 type CreatureInfo = {
-	cr: string;
+	cr?: string;
 	source: string;
 	sourceDisplayName: string;
 };
@@ -87,10 +87,11 @@ function buildBreakdownEntry(
 		};
 	}
 	if (creature) {
+		const cr = creature.cr ?? null;
 		return {
 			combatant: c,
-			cr: creature.cr,
+			cr,
-			xp: crToXp(creature.cr),
+			xp: cr ? crToXp(cr) : null,
 			source: creature.sourceDisplayName ?? creature.source,
 			editable: false,
 			side,
@@ -132,7 +133,7 @@ function resolveCr(
 	getCreature: (id: CreatureId) => CreatureInfo | undefined,
 ): { cr: string | null; creature: CreatureInfo | undefined } {
 	const creature = c.creatureId ? getCreature(c.creatureId) : undefined;
-	const cr = creature ? creature.cr : (c.cr ?? null);
+	const cr = creature?.cr ?? c.cr ?? null;
 	return { cr, creature };
 }
 

apps/web/src/hooks/use-difficulty.ts

@@ -1,4 +1,5 @@
 import type {
+	AnyCreature,
 	Combatant,
 	CombatantDescriptor,
 	CreatureId,
@@ -20,7 +21,7 @@ export function resolveSide(c: Combatant): "party" | "enemy" {
 function buildDescriptors(
 	combatants: readonly Combatant[],
 	characters: readonly PlayerCharacter[],
-	getCreature: (id: CreatureId) => { cr: string } | undefined,
+	getCreature: (id: CreatureId) => AnyCreature | undefined,
 ): CombatantDescriptor[] {
 	const descriptors: CombatantDescriptor[] = [];
 	for (const c of combatants) {
@@ -28,9 +29,10 @@ function buildDescriptors(
 		const level = c.playerCharacterId
 			? characters.find((p) => p.id === c.playerCharacterId)?.level
 			: undefined;
-		const cr = c.creatureId
+		const creature = c.creatureId ? getCreature(c.creatureId) : undefined;
-			? getCreature(c.creatureId)?.cr
+		const creatureCr =
-			: (c.cr ?? undefined);
+			creature && !("system" in creature) ? creature.cr : undefined;
+		const cr = creatureCr ?? c.cr ?? undefined;
 
 		if (level !== undefined || cr !== undefined) {
 			descriptors.push({ level, cr, side });
@@ -46,6 +48,8 @@ export function useDifficulty(): DifficultyResult | null {
 	const { edition } = useRulesEditionContext();
 
 	return useMemo(() => {
+		if (edition === "pf2e") return null;
+
 		const descriptors = buildDescriptors(
 			encounter.combatants,
 			characters,

apps/web/src/hooks/use-encounter.ts

@@ -4,11 +4,13 @@ import {
 	adjustHpUseCase,
 	advanceTurnUseCase,
 	clearEncounterUseCase,
+	decrementConditionUseCase,
 	editCombatantUseCase,
 	redoUseCase,
 	removeCombatantUseCase,
 	retreatTurnUseCase,
 	setAcUseCase,
+	setConditionValueUseCase,
 	setCrUseCase,
 	setHpUseCase,
 	setInitiativeUseCase,
@@ -19,7 +21,6 @@ import {
 	undoUseCase,
 } from "@initiative/application";
 import type {
-	BestiaryIndexEntry,
 	CombatantId,
 	CombatantInit,
 	ConditionId,
@@ -40,6 +41,7 @@ import {
 } from "@initiative/domain";
 import { useCallback, useEffect, useReducer, useRef } from "react";
 import { useAdapters } from "../contexts/adapter-context.js";
+import type { SearchResult } from "./use-bestiary.js";
 
 // -- Types --
 
@@ -61,14 +63,25 @@ type EncounterAction =
 			id: CombatantId;
 			conditionId: ConditionId;
 	  }
+	| {
+			type: "set-condition-value";
+			id: CombatantId;
+			conditionId: ConditionId;
+			value: number;
+	  }
+	| {
+			type: "decrement-condition";
+			id: CombatantId;
+			conditionId: ConditionId;
+	  }
 	| { type: "toggle-concentration"; id: CombatantId }
 	| { type: "clear-encounter" }
 	| { type: "undo" }
 	| { type: "redo" }
-	| { type: "add-from-bestiary"; entry: BestiaryIndexEntry }
+	| { type: "add-from-bestiary"; entry: SearchResult }
 	| {
 			type: "add-multiple-from-bestiary";
-			entry: BestiaryIndexEntry;
+			entry: SearchResult;
 			count: number;
 	  }
 	| { type: "add-from-player-character"; pc: PlayerCharacter }
@@ -156,7 +169,7 @@ function resolveAndRename(store: EncounterStore, name: string): string {
 
 function addOneFromBestiary(
 	store: EncounterStore,
-	entry: BestiaryIndexEntry,
+	entry: SearchResult,
 	nextId: number,
 ): {
 	cId: CreatureId;
@@ -215,7 +228,7 @@ function handleUndoRedo(
 
 function handleAddFromBestiary(
 	state: EncounterState,
-	entry: BestiaryIndexEntry,
+	entry: SearchResult,
 	count: number,
 ): EncounterState {
 	const { store, getEncounter } = makeStoreFromState(state);
@@ -325,6 +338,8 @@ function dispatchEncounterAction(
 		| { type: "set-cr" }
 		| { type: "set-side" }
 		| { type: "toggle-condition" }
+		| { type: "set-condition-value" }
+		| { type: "decrement-condition" }
 		| { type: "toggle-concentration" }
 	>,
 ): EncounterState {
@@ -373,6 +388,17 @@ function dispatchEncounterAction(
 		case "toggle-condition":
 			result = toggleConditionUseCase(store, action.id, action.conditionId);
 			break;
+		case "set-condition-value":
+			result = setConditionValueUseCase(
+				store,
+				action.id,
+				action.conditionId,
+				action.value,
+			);
+			break;
+		case "decrement-condition":
+			result = decrementConditionUseCase(store, action.id, action.conditionId);
+			break;
 		case "toggle-concentration":
 			result = toggleConcentrationUseCase(store, action.id);
 			break;
@@ -522,6 +548,16 @@ export function useEncounter() {
 				dispatch({ type: "toggle-condition", id, conditionId }),
 			[],
 		),
+		setConditionValue: useCallback(
+			(id: CombatantId, conditionId: ConditionId, value: number) =>
+				dispatch({ type: "set-condition-value", id, conditionId, value }),
+			[],
+		),
+		decrementCondition: useCallback(
+			(id: CombatantId, conditionId: ConditionId) =>
+				dispatch({ type: "decrement-condition", id, conditionId }),
+			[],
+		),
 		toggleConcentration: useCallback(
 			(id: CombatantId) => dispatch({ type: "toggle-concentration", id }),
 			[],
@@ -530,15 +566,12 @@ export function useEncounter() {
 			() => dispatch({ type: "clear-encounter" }),
 			[],
 		),
-		addFromBestiary: useCallback(
+		addFromBestiary: useCallback((entry: SearchResult): CreatureId | null => {
-			(entry: BestiaryIndexEntry): CreatureId | null => {
 			dispatch({ type: "add-from-bestiary", entry });
 			return null;
-			},
+		}, []),
-			[],
-		),
 		addMultipleFromBestiary: useCallback(
-			(entry: BestiaryIndexEntry, count: number): CreatureId | null => {
+			(entry: SearchResult, count: number): CreatureId | null => {
 				dispatch({
 					type: "add-multiple-from-bestiary",
 					entry,

apps/web/src/hooks/use-rules-edition.ts

@@ -1,7 +1,8 @@
 import type { RulesEdition } from "@initiative/domain";
 import { useCallback, useSyncExternalStore } from "react";
 
-const STORAGE_KEY = "initiative:rules-edition";
+const STORAGE_KEY = "initiative:game-system";
+const OLD_STORAGE_KEY = "initiative:rules-edition";
 
 const listeners = new Set<() => void>();
 let currentEdition: RulesEdition = loadEdition();
@@ -9,7 +10,14 @@ let currentEdition: RulesEdition = loadEdition();
 function loadEdition(): RulesEdition {
 	try {
 		const raw = localStorage.getItem(STORAGE_KEY);
-		if (raw === "5e" || raw === "5.5e") return raw;
+		if (raw === "5e" || raw === "5.5e" || raw === "pf2e") return raw;
+		// Migrate from old key
+		const old = localStorage.getItem(OLD_STORAGE_KEY);
+		if (old === "5e" || old === "5.5e") {
+			localStorage.setItem(STORAGE_KEY, old);
+			localStorage.removeItem(OLD_STORAGE_KEY);
+			return old;
+		}
 	} catch {
 		// storage unavailable
 	}

packages/application/src/__tests__/use-cases.test.ts

@@ -292,9 +292,9 @@ describe("toggleConditionUseCase", () => {
 		);
 
 		expect(isDomainError(result)).toBe(false);
-		expect(requireSaved(store.saved).combatants[0].conditions).toContain(
+		expect(requireSaved(store.saved).combatants[0].conditions).toContainEqual({
-			"blinded",
+			id: "blinded",
-		);
+		});
 	});
 
 	it("returns domain error for unknown combatant", () => {

packages/application/src/creature-initiative-modifier.ts

@@ -0,0 +1,21 @@
+import {
+	type AnyCreature,
+	calculateInitiative,
+	calculatePf2eInitiative,
+} from "@initiative/domain";
+
+export function creatureInitiativeModifier(creature: AnyCreature): number {
+	if ("system" in creature && creature.system === "pf2e") {
+		return calculatePf2eInitiative(creature.perception).modifier;
+	}
+	const c = creature as {
+		abilities: { dex: number };
+		cr: string;
+		initiativeProficiency: number;
+	};
+	return calculateInitiative({
+		dexScore: c.abilities.dex,
+		cr: c.cr,
+		initiativeProficiency: c.initiativeProficiency,
+	}).modifier;
+}

packages/application/src/decrement-condition-use-case.ts

@@ -0,0 +1,19 @@
+import {
+	type CombatantId,
+	type ConditionId,
+	type DomainError,
+	type DomainEvent,
+	decrementCondition,
+} from "@initiative/domain";
+import type { EncounterStore } from "./ports.js";
+import { runEncounterAction } from "./run-encounter-action.js";
+
+export function decrementConditionUseCase(
+	store: EncounterStore,
+	combatantId: CombatantId,
+	conditionId: ConditionId,
+): DomainEvent[] | DomainError {
+	return runEncounterAction(store, (encounter) =>
+		decrementCondition(encounter, combatantId, conditionId),
+	);
+}

packages/application/src/index.ts

@@ -3,6 +3,7 @@ export { adjustHpUseCase } from "./adjust-hp-use-case.js";
 export { advanceTurnUseCase } from "./advance-turn-use-case.js";
 export { clearEncounterUseCase } from "./clear-encounter-use-case.js";
 export { createPlayerCharacterUseCase } from "./create-player-character-use-case.js";
+export { decrementConditionUseCase } from "./decrement-condition-use-case.js";
 export { deletePlayerCharacterUseCase } from "./delete-player-character-use-case.js";
 export { editCombatantUseCase } from "./edit-combatant-use-case.js";
 export { editPlayerCharacterUseCase } from "./edit-player-character-use-case.js";
@@ -21,6 +22,7 @@ export {
 } from "./roll-all-initiative-use-case.js";
 export { rollInitiativeUseCase } from "./roll-initiative-use-case.js";
 export { setAcUseCase } from "./set-ac-use-case.js";
+export { setConditionValueUseCase } from "./set-condition-value-use-case.js";
 export { setCrUseCase } from "./set-cr-use-case.js";
 export { setHpUseCase } from "./set-hp-use-case.js";
 export { setInitiativeUseCase } from "./set-initiative-use-case.js";

packages/application/src/ports.ts

@@ -1,5 +1,5 @@
 import type {
-	Creature,
+	AnyCreature,
 	CreatureId,
 	Encounter,
 	PlayerCharacter,
@@ -12,7 +12,7 @@ export interface EncounterStore {
 }
 
 export interface BestiarySourceCache {
-	getCreature(creatureId: CreatureId): Creature | undefined;
+	getCreature(creatureId: CreatureId): AnyCreature | undefined;
 	isSourceCached(sourceCode: string): boolean;
 }
 

packages/application/src/roll-all-initiative-use-case.ts

@@ -1,7 +1,6 @@
 import {
-	type Creature,
+	type AnyCreature,
 	type CreatureId,
-	calculateInitiative,
 	type DomainError,
 	type DomainEvent,
 	isDomainError,
@@ -10,6 +9,7 @@ import {
 	selectRoll,
 	setInitiative,
 } from "@initiative/domain";
+import { creatureInitiativeModifier } from "./creature-initiative-modifier.js";
 import type { EncounterStore } from "./ports.js";
 
 export interface RollAllResult {
@@ -20,7 +20,7 @@ export interface RollAllResult {
 export function rollAllInitiativeUseCase(
 	store: EncounterStore,
 	rollDice: () => number,
-	getCreature: (id: CreatureId) => Creature | undefined,
+	getCreature: (id: CreatureId) => AnyCreature | undefined,
 	mode: RollMode = "normal",
 ): RollAllResult | DomainError {
 	let encounter = store.get();
@@ -37,11 +37,7 @@ export function rollAllInitiativeUseCase(
 			continue;
 		}
 
-		const { modifier } = calculateInitiative({
+		const modifier = creatureInitiativeModifier(creature);
-			dexScore: creature.abilities.dex,
-			cr: creature.cr,
-			initiativeProficiency: creature.initiativeProficiency,
-		});
 		const roll1 = rollDice();
 		const effectiveRoll =
 			mode === "normal" ? roll1 : selectRoll(roll1, rollDice(), mode);

packages/application/src/roll-initiative-use-case.ts

@@ -1,8 +1,7 @@
 import {
+	type AnyCreature,
 	type CombatantId,
-	type Creature,
 	type CreatureId,
-	calculateInitiative,
 	type DomainError,
 	type DomainEvent,
 	isDomainError,
@@ -11,13 +10,14 @@ import {
 	selectRoll,
 	setInitiative,
 } from "@initiative/domain";
+import { creatureInitiativeModifier } from "./creature-initiative-modifier.js";
 import type { EncounterStore } from "./ports.js";
 
 export function rollInitiativeUseCase(
 	store: EncounterStore,
 	combatantId: CombatantId,
 	diceRolls: readonly [number, ...number[]],
-	getCreature: (id: CreatureId) => Creature | undefined,
+	getCreature: (id: CreatureId) => AnyCreature | undefined,
 	mode: RollMode = "normal",
 ): DomainEvent[] | DomainError {
 	const encounter = store.get();
@@ -48,11 +48,7 @@ export function rollInitiativeUseCase(
 		};
 	}
 
-	const { modifier } = calculateInitiative({
+	const modifier = creatureInitiativeModifier(creature);
-		dexScore: creature.abilities.dex,
-		cr: creature.cr,
-		initiativeProficiency: creature.initiativeProficiency,
-	});
 	const effectiveRoll =
 		mode === "normal"
 			? diceRolls[0]

packages/application/src/set-condition-value-use-case.ts

@@ -0,0 +1,20 @@
+import {
+	type CombatantId,
+	type ConditionId,
+	type DomainError,
+	type DomainEvent,
+	setConditionValue,
+} from "@initiative/domain";
+import type { EncounterStore } from "./ports.js";
+import { runEncounterAction } from "./run-encounter-action.js";
+
+export function setConditionValueUseCase(
+	store: EncounterStore,
+	combatantId: CombatantId,
+	conditionId: ConditionId,
+	value: number,
+): DomainEvent[] | DomainError {
+	return runEncounterAction(store, (encounter) =>
+		setConditionValue(encounter, combatantId, conditionId, value),
+	);
+}

packages/domain/src/__tests__/clear-encounter.test.ts

@@ -54,7 +54,7 @@ describe("clearEncounter", () => {
 					maxHp: 50,
 					currentHp: 30,
 					ac: 18,
-					conditions: ["blinded", "poisoned"],
+					conditions: [{ id: "blinded" }, { id: "poisoned" }],
 					isConcentrating: true,
 				},
 				{
@@ -63,7 +63,7 @@ describe("clearEncounter", () => {
 					maxHp: 25,
 					currentHp: 0,
 					ac: 12,
-					conditions: ["unconscious"],
+					conditions: [{ id: "unconscious" }],
 				},
 			],
 			activeIndex: 0,

packages/domain/src/__tests__/conditions.test.ts

@@ -26,25 +26,40 @@ describe("getConditionDescription", () => {
 		);
 	});
 
-	it("universal conditions have both descriptions", () => {
+	it("returns pf2e description when edition is pf2e", () => {
-		const universal = CONDITION_DEFINITIONS.filter(
+		const blinded = findCondition("blinded");
-			(d) => d.edition === undefined,
+		expect(getConditionDescription(blinded, "pf2e")).toBe(
+			blinded.descriptionPf2e,
 		);
-		expect(universal.length).toBeGreaterThan(0);
+	});
-		for (const def of universal) {
+
-			expect(def.description).toBeTruthy();
+	it("falls back to default description for pf2e when no pf2e text", () => {
-			expect(def.description5e).toBeTruthy();
+		const paralyzed = findCondition("paralyzed");
+		expect(getConditionDescription(paralyzed, "pf2e")).toBe(
+			paralyzed.descriptionPf2e,
+		);
+	});
+
+	it("shared D&D conditions have both description and description5e", () => {
+		const sharedDndConditions = CONDITION_DEFINITIONS.filter(
+			(d) =>
+				d.systems === undefined ||
+				(d.systems.includes("5e") && d.systems.includes("5.5e")),
+		);
+		for (const def of sharedDndConditions) {
+			expect(def.description, `${def.id} missing description`).toBeTruthy();
+			expect(def.description5e, `${def.id} missing description5e`).toBeTruthy();
 		}
 	});
 
-	it("edition-specific conditions have their edition description", () => {
+	it("system-specific conditions use the systems field", () => {
 		const sapped = findCondition("sapped");
 		expect(sapped.description).toBeTruthy();
-		expect(sapped.edition).toBe("5.5e");
+		expect(sapped.systems).toContain("5.5e");
 
 		const slowed = findCondition("slowed");
 		expect(slowed.description).toBeTruthy();
-		expect(slowed.edition).toBe("5.5e");
+		expect(slowed.systems).toContain("5.5e");
 	});
 
 	it("conditions with identical rules share the same text", () => {
@@ -79,4 +94,34 @@ describe("getConditionsForEdition", () => {
 		expect(ids5e).toContain("blinded");
 		expect(ids55e).toContain("blinded");
 	});
+
+	it("returns PF2e conditions for pf2e edition", () => {
+		const conditions = getConditionsForEdition("pf2e");
+		const ids = conditions.map((d) => d.id);
+		expect(ids).toContain("clumsy");
+		expect(ids).toContain("drained");
+		expect(ids).toContain("off-guard");
+		expect(ids).toContain("sickened");
+		expect(ids).not.toContain("charmed");
+		expect(ids).not.toContain("exhaustion");
+		expect(ids).not.toContain("grappled");
+	});
+
+	it("returns D&D conditions for 5.5e", () => {
+		const conditions = getConditionsForEdition("5.5e");
+		const ids = conditions.map((d) => d.id);
+		expect(ids).toContain("charmed");
+		expect(ids).toContain("exhaustion");
+		expect(ids).not.toContain("clumsy");
+		expect(ids).not.toContain("off-guard");
+	});
+
+	it("shared conditions appear in both D&D and PF2e", () => {
+		const dndIds = getConditionsForEdition("5.5e").map((d) => d.id);
+		const pf2eIds = getConditionsForEdition("pf2e").map((d) => d.id);
+		expect(dndIds).toContain("blinded");
+		expect(pf2eIds).toContain("blinded");
+		expect(dndIds).toContain("prone");
+		expect(pf2eIds).toContain("prone");
+	});
 });

packages/domain/src/__tests__/initiative.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import {
 	calculateInitiative,
+	calculatePf2eInitiative,
 	formatInitiativeModifier,
 } from "../initiative.js";
 
@@ -93,6 +94,26 @@ describe("calculateInitiative", () => {
 	});
 });
 
+describe("calculatePf2eInitiative", () => {
+	it("returns perception as both modifier and passive", () => {
+		const result = calculatePf2eInitiative(11);
+		expect(result.modifier).toBe(11);
+		expect(result.passive).toBe(11);
+	});
+
+	it("handles zero perception", () => {
+		const result = calculatePf2eInitiative(0);
+		expect(result.modifier).toBe(0);
+		expect(result.passive).toBe(0);
+	});
+
+	it("handles negative perception", () => {
+		const result = calculatePf2eInitiative(-2);
+		expect(result.modifier).toBe(-2);
+		expect(result.passive).toBe(-2);
+	});
+});
+
 describe("formatInitiativeModifier", () => {
 	it("formats positive modifier with plus sign", () => {
 		expect(formatInitiativeModifier(7)).toBe("+7");

packages/domain/src/__tests__/rehydrate-combatant.test.ts

@@ -35,7 +35,7 @@ describe("rehydrateCombatant", () => {
 			expect(result?.maxHp).toBe(7);
 			expect(result?.currentHp).toBe(5);
 			expect(result?.tempHp).toBe(3);
-			expect(result?.conditions).toEqual(["poisoned"]);
+			expect(result?.conditions).toEqual([{ id: "poisoned" }]);
 			expect(result?.isConcentrating).toBe(true);
 			expect(result?.creatureId).toBe("creature-goblin");
 			expect(result?.color).toBe("red");
@@ -165,7 +165,45 @@ describe("rehydrateCombatant", () => {
 				...minimalCombatant(),
 				conditions: ["poisoned", "fake", "blinded"],
 			});
-			expect(result?.conditions).toEqual(["poisoned", "blinded"]);
+			expect(result?.conditions).toEqual([
+				{ id: "poisoned" },
+				{ id: "blinded" },
+			]);
+		});
+
+		it("converts old bare string format to ConditionEntry", () => {
+			const result = rehydrateCombatant({
+				...minimalCombatant(),
+				conditions: ["blinded", "prone"],
+			});
+			expect(result?.conditions).toEqual([{ id: "blinded" }, { id: "prone" }]);
+		});
+
+		it("passes through new ConditionEntry format with values", () => {
+			const result = rehydrateCombatant({
+				...minimalCombatant(),
+				conditions: [{ id: "blinded" }, { id: "frightened", value: 2 }],
+			});
+			expect(result?.conditions).toEqual([
+				{ id: "blinded" },
+				{ id: "frightened", value: 2 },
+			]);
+		});
+
+		it("handles mixed old and new format entries", () => {
+			const result = rehydrateCombatant({
+				...minimalCombatant(),
+				conditions: ["blinded", { id: "prone" }],
+			});
+			expect(result?.conditions).toEqual([{ id: "blinded" }, { id: "prone" }]);
+		});
+
+		it("drops ConditionEntry with invalid value", () => {
+			const result = rehydrateCombatant({
+				...minimalCombatant(),
+				conditions: [{ id: "blinded", value: -1 }],
+			});
+			expect(result?.conditions).toEqual([{ id: "blinded" }]);
 		});
 
 		it("drops invalid color — keeps combatant", () => {

packages/domain/src/__tests__/toggle-condition.test.ts

@@ -1,14 +1,18 @@
 import { describe, expect, it } from "vitest";
-import type { ConditionId } from "../conditions.js";
+import type { ConditionEntry, ConditionId } from "../conditions.js";
 import { CONDITION_DEFINITIONS } from "../conditions.js";
-import { toggleCondition } from "../toggle-condition.js";
+import {
+	decrementCondition,
+	setConditionValue,
+	toggleCondition,
+} from "../toggle-condition.js";
 import type { Combatant, Encounter } from "../types.js";
 import { combatantId, isDomainError } from "../types.js";
 import { expectDomainError } from "./test-helpers.js";
 
 function makeCombatant(
 	name: string,
-	conditions?: readonly ConditionId[],
+	conditions?: readonly ConditionEntry[],
 ): Combatant {
 	return conditions
 		? { id: combatantId(name), name, conditions }
@@ -32,7 +36,7 @@ describe("toggleCondition", () => {
 		const e = enc([makeCombatant("A")]);
 		const { encounter, events } = success(e, "A", "blinded");
 
-		expect(encounter.combatants[0].conditions).toEqual(["blinded"]);
+		expect(encounter.combatants[0].conditions).toEqual([{ id: "blinded" }]);
 		expect(events).toEqual([
 			{
 				type: "ConditionAdded",
@@ -43,7 +47,7 @@ describe("toggleCondition", () => {
 	});
 
 	it("removes a condition when already present", () => {
-		const e = enc([makeCombatant("A", ["blinded"])]);
+		const e = enc([makeCombatant("A", [{ id: "blinded" }])]);
 		const { encounter, events } = success(e, "A", "blinded");
 
 		expect(encounter.combatants[0].conditions).toBeUndefined();
@@ -57,14 +61,17 @@ describe("toggleCondition", () => {
 	});
 
 	it("maintains definition order when adding conditions", () => {
-		const e = enc([makeCombatant("A", ["poisoned"])]);
+		const e = enc([makeCombatant("A", [{ id: "poisoned" }])]);
 		const { encounter } = success(e, "A", "blinded");
 
-		expect(encounter.combatants[0].conditions).toEqual(["blinded", "poisoned"]);
+		expect(encounter.combatants[0].conditions).toEqual([
+			{ id: "blinded" },
+			{ id: "poisoned" },
+		]);
 	});
 
 	it("prevents duplicate conditions", () => {
-		const e = enc([makeCombatant("A", ["blinded"])]);
+		const e = enc([makeCombatant("A", [{ id: "blinded" }])]);
 		// Toggling blinded again removes it, not duplicates
 		const { encounter } = success(e, "A", "blinded");
 		expect(encounter.combatants[0].conditions).toBeUndefined();
@@ -96,7 +103,7 @@ describe("toggleCondition", () => {
 	});
 
 	it("normalizes empty array to undefined on removal", () => {
-		const e = enc([makeCombatant("A", ["charmed"])]);
+		const e = enc([makeCombatant("A", [{ id: "charmed" }])]);
 		const { encounter } = success(e, "A", "charmed");
 
 		expect(encounter.combatants[0].conditions).toBeUndefined();
@@ -110,6 +117,91 @@ describe("toggleCondition", () => {
 			const result = success(e, "A", cond);
 			e = result.encounter;
 		}
-		expect(e.combatants[0].conditions).toEqual(order);
+		expect(e.combatants[0].conditions).toEqual(order.map((id) => ({ id })));
+	});
+});
+
+describe("setConditionValue", () => {
+	it("adds a valued condition at the specified value", () => {
+		const e = enc([makeCombatant("A")]);
+		const result = setConditionValue(e, combatantId("A"), "frightened", 2);
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toEqual([
+			{ id: "frightened", value: 2 },
+		]);
+		expect(result.events).toEqual([
+			{
+				type: "ConditionAdded",
+				combatantId: combatantId("A"),
+				condition: "frightened",
+				value: 2,
+			},
+		]);
+	});
+
+	it("updates the value of an existing condition", () => {
+		const e = enc([makeCombatant("A", [{ id: "frightened", value: 1 }])]);
+		const result = setConditionValue(e, combatantId("A"), "frightened", 3);
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toEqual([
+			{ id: "frightened", value: 3 },
+		]);
+	});
+
+	it("removes condition when value is 0", () => {
+		const e = enc([makeCombatant("A", [{ id: "frightened", value: 2 }])]);
+		const result = setConditionValue(e, combatantId("A"), "frightened", 0);
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toBeUndefined();
+		expect(result.events[0].type).toBe("ConditionRemoved");
+	});
+
+	it("rejects unknown condition", () => {
+		const e = enc([makeCombatant("A")]);
+		const result = setConditionValue(
+			e,
+			combatantId("A"),
+			"flying" as ConditionId,
+			1,
+		);
+		expectDomainError(result, "unknown-condition");
+	});
+});
+
+describe("decrementCondition", () => {
+	it("decrements value by 1", () => {
+		const e = enc([makeCombatant("A", [{ id: "frightened", value: 3 }])]);
+		const result = decrementCondition(e, combatantId("A"), "frightened");
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toEqual([
+			{ id: "frightened", value: 2 },
+		]);
+	});
+
+	it("removes condition when value reaches 0", () => {
+		const e = enc([makeCombatant("A", [{ id: "frightened", value: 1 }])]);
+		const result = decrementCondition(e, combatantId("A"), "frightened");
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toBeUndefined();
+		expect(result.events[0].type).toBe("ConditionRemoved");
+	});
+
+	it("removes non-valued condition (value undefined treated as 1)", () => {
+		const e = enc([makeCombatant("A", [{ id: "blinded" }])]);
+		const result = decrementCondition(e, combatantId("A"), "blinded");
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toBeUndefined();
+	});
+
+	it("returns error for inactive condition", () => {
+		const e = enc([makeCombatant("A")]);
+		const result = decrementCondition(e, combatantId("A"), "frightened");
+		expectDomainError(result, "condition-not-active");
 	});
 });

packages/domain/src/conditions.ts

@@ -1,21 +1,48 @@
 export type ConditionId =
 	| "blinded"
 	| "charmed"
+	| "clumsy"
+	| "concealed"
+	| "confused"
+	| "controlled"
+	| "dazzled"
 	| "deafened"
+	| "doomed"
+	| "drained"
+	| "dying"
+	| "enfeebled"
 	| "exhaustion"
+	| "fascinated"
+	| "fatigued"
+	| "fleeing"
 	| "frightened"
+	| "grabbed"
 	| "grappled"
+	| "hidden"
+	| "immobilized"
 	| "incapacitated"
 	| "invisible"
+	| "off-guard"
 	| "paralyzed"
 	| "petrified"
 	| "poisoned"
 	| "prone"
+	| "quickened"
 	| "restrained"
 	| "sapped"
+	| "sickened"
 	| "slowed"
+	| "slowed-pf2e"
 	| "stunned"
-	| "unconscious";
+	| "stupefied"
+	| "unconscious"
+	| "undetected"
+	| "wounded";
+
+export interface ConditionEntry {
+	readonly id: ConditionId;
+	readonly value?: number;
+}
 
 import type { RulesEdition } from "./rules-edition.js";
 
@@ -24,20 +51,24 @@ export interface ConditionDefinition {
 	readonly label: string;
 	readonly description: string;
 	readonly description5e: string;
+	readonly descriptionPf2e?: string;
 	readonly iconName: string;
 	readonly color: string;
-	/** When set, the condition only appears in this edition's picker. */
+	/** When set, the condition only appears in these systems' pickers. */
-	readonly edition?: RulesEdition;
+	readonly systems?: readonly RulesEdition[];
+	readonly valued?: boolean;
 }
 
 export function getConditionDescription(
 	def: ConditionDefinition,
 	edition: RulesEdition,
 ): string {
+	if (edition === "pf2e" && def.descriptionPf2e) return def.descriptionPf2e;
 	return edition === "5e" ? def.description5e : def.description;
 }
 
 export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
+	// ── Shared conditions (D&D + PF2e) ──
 	{
 		id: "blinded",
 		label: "Blinded",
@@ -45,6 +76,8 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Can't see. Auto-fail sight checks. Attacks have Disadvantage; attacks against have Advantage.",
 		description5e:
 			"Can't see. Auto-fail sight checks. Attacks have Disadvantage; attacks against have Advantage.",
+		descriptionPf2e:
+			"Can't see. All terrain is difficult terrain. –4 status penalty to Perception checks involving sight. Immune to visual effects. Auto-fail checks requiring sight. Off-guard.",
 		iconName: "EyeOff",
 		color: "neutral",
 	},
@@ -57,12 +90,15 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Can't attack or target the charmer with harmful abilities. Charmer has Advantage on social checks.",
 		iconName: "Heart",
 		color: "pink",
+		systems: ["5e", "5.5e"],
 	},
 	{
 		id: "deafened",
 		label: "Deafened",
 		description: "Can't hear. Auto-fail hearing checks.",
 		description5e: "Can't hear. Auto-fail hearing checks.",
+		descriptionPf2e:
+			"Can't hear. –2 status penalty to Perception checks and Initiative. Auto-fail hearing checks. Immune to auditory effects.",
 		iconName: "EarOff",
 		color: "neutral",
 	},
@@ -75,6 +111,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"L1: Disadvantage on ability checks\nL2: Speed halved\nL3: Disadvantage on attacks and saves\nL4: HP max halved\nL5: Speed 0\nL6: Death\nLong rest removes 1 level.",
 		iconName: "BatteryLow",
 		color: "amber",
+		systems: ["5e", "5.5e"],
 	},
 	{
 		id: "frightened",
@@ -83,8 +120,11 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Disadvantage on ability checks and attacks while source of fear is in line of sight. Can't willingly move closer to the source.",
 		description5e:
 			"Disadvantage on ability checks and attacks while source of fear is in line of sight. Can't willingly move closer to the source.",
+		descriptionPf2e:
+			"–X status penalty to all checks and DCs (X = value). Can't willingly approach the source.",
 		iconName: "Siren",
 		color: "orange",
+		valued: true,
 	},
 	{
 		id: "grappled",
@@ -95,6 +135,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Speed 0. Ends if grappler is Incapacitated or moved out of reach.",
 		iconName: "Hand",
 		color: "neutral",
+		systems: ["5e", "5.5e"],
 	},
 	{
 		id: "incapacitated",
@@ -104,6 +145,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 		description5e: "Can't take Actions or Reactions.",
 		iconName: "Ban",
 		color: "gray",
+		systems: ["5e", "5.5e"],
 	},
 	{
 		id: "invisible",
@@ -112,6 +154,8 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Can't be seen. Advantage on Initiative. Not affected by effects requiring sight (unless caster sees you). Attacks have Advantage; attacks against have Disadvantage.",
 		description5e:
 			"Impossible to see without magic or special sense. Heavily Obscured. Attacks have Advantage; attacks against have Disadvantage.",
+		descriptionPf2e:
+			"Can't be seen except by special senses. Undetected to everyone. Can't be targeted except by effects that don't require sight.",
 		iconName: "Ghost",
 		color: "violet",
 	},
@@ -122,6 +166,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Incapacitated. Can't move or speak. Auto-fail Str/Dex saves. Attacks against have Advantage. Hits within 5 ft. are critical.",
 		description5e:
 			"Incapacitated. Can't move or speak. Auto-fail Str/Dex saves. Attacks against have Advantage. Hits within 5 ft. are critical.",
+		descriptionPf2e: "Can't act. Off-guard. –4 status penalty to AC.",
 		iconName: "ZapOff",
 		color: "yellow",
 	},
@@ -132,6 +177,8 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Turned to stone. Weight \u00D710. Incapacitated. Can't move or speak. Attacks against have Advantage. Auto-fail Str/Dex saves. Resistant to all damage. Immune to poison and disease.",
 		description5e:
 			"Turned to stone. Weight \u00D710. Incapacitated. Can't move or speak. Attacks against have Advantage. Auto-fail Str/Dex saves. Resistant to all damage. Immune to poison and disease.",
+		descriptionPf2e:
+			"Can't act. Can't sense anything. AC = 9. Hardness 8. Immune to most effects.",
 		iconName: "Gem",
 		color: "slate",
 	},
@@ -142,6 +189,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 		description5e: "Disadvantage on attack rolls and ability checks.",
 		iconName: "Droplet",
 		color: "green",
+		systems: ["5e", "5.5e"],
 	},
 	{
 		id: "prone",
@@ -150,6 +198,8 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Can only crawl (costs extra movement). Disadvantage on attacks. Attacks within 5 ft. have Advantage; ranged attacks have Disadvantage. Standing up costs half movement.",
 		description5e:
 			"Can only crawl (costs extra movement). Disadvantage on attacks. Attacks within 5 ft. have Advantage; ranged attacks have Disadvantage. Standing up costs half movement.",
+		descriptionPf2e:
+			"Off-guard. –2 circumstance penalty to attack rolls. Only movement is Crawl and Stand. +1 circumstance bonus to AC vs. ranged attacks, –2 vs. melee.",
 		iconName: "ArrowDown",
 		color: "neutral",
 	},
@@ -160,6 +210,8 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Speed is 0. Attacks have Disadvantage. Attacks against have Advantage. Disadvantage on Dex saves.",
 		description5e:
 			"Speed is 0. Attacks have Disadvantage. Attacks against have Advantage. Disadvantage on Dex saves.",
+		descriptionPf2e:
+			"Off-guard. Immobilized. Can't use any actions with the attack trait except to attempt to Escape.",
 		iconName: "Link",
 		color: "neutral",
 	},
@@ -171,7 +223,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 		description5e: "",
 		iconName: "ShieldMinus",
 		color: "amber",
-		edition: "5.5e",
+		systems: ["5.5e"],
 	},
 	{
 		id: "slowed",
@@ -181,7 +233,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 		description5e: "",
 		iconName: "Snail",
 		color: "sky",
-		edition: "5.5e",
+		systems: ["5.5e"],
 	},
 	{
 		id: "stunned",
@@ -190,8 +242,11 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Incapacitated (can't act or speak). Auto-fail Str/Dex saves. Attacks against have Advantage.",
 		description5e:
 			"Incapacitated. Can't move. Can speak only falteringly. Auto-fail Str/Dex saves. Attacks against have Advantage.",
+		descriptionPf2e:
+			"Can't act. –X value to actions per turn while the value counts down.",
 		iconName: "Sparkles",
 		color: "yellow",
+		valued: true,
 	},
 	{
 		id: "unconscious",
@@ -200,9 +255,261 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 			"Incapacitated. Speed 0. Can't move or speak. Unaware of surroundings. Drops held items, falls Prone. Auto-fail Str/Dex saves. Attacks against have Advantage. Hits within 5 ft. are critical.",
 		description5e:
 			"Incapacitated. Speed 0. Can't move or speak. Unaware of surroundings. Drops held items, falls Prone. Auto-fail Str/Dex saves. Attacks against have Advantage. Hits within 5 ft. are critical.",
+		descriptionPf2e:
+			"Can't act. Off-guard. –4 status penalty to AC. –3 to Perception. Fall prone, drop items.",
 		iconName: "Moon",
 		color: "indigo",
 	},
+	// ── PF2e-only conditions ──
+	{
+		id: "clumsy",
+		label: "Clumsy",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"–X status penalty to Dex-based checks and DCs, including AC, Reflex saves, and ranged attack rolls.",
+		iconName: "Footprints",
+		color: "amber",
+		systems: ["pf2e"],
+		valued: true,
+	},
+	{
+		id: "concealed",
+		label: "Concealed",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"DC 5 flat check for targeted attacks. Doesn't change which creatures can see you.",
+		iconName: "CloudFog",
+		color: "slate",
+		systems: ["pf2e"],
+	},
+	{
+		id: "confused",
+		label: "Confused",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Off-guard. Can't Delay, Ready, or use reactions. GM determines targets randomly. Flat check DC 11 to act normally each turn.",
+		iconName: "CircleHelp",
+		color: "pink",
+		systems: ["pf2e"],
+	},
+	{
+		id: "controlled",
+		label: "Controlled",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Another creature determines your actions. You gain no actions of your own.",
+		iconName: "Drama",
+		color: "pink",
+		systems: ["pf2e"],
+	},
+	{
+		id: "dazzled",
+		label: "Dazzled",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"All creatures and objects are concealed to you. DC 5 flat check for targeted attacks requiring sight.",
+		iconName: "Sun",
+		color: "yellow",
+		systems: ["pf2e"],
+	},
+	{
+		id: "doomed",
+		label: "Doomed",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Die at dying X (where X = 4 – doomed value instead of dying 4). Decreases by 1 on full night's rest.",
+		iconName: "Skull",
+		color: "red",
+		systems: ["pf2e"],
+		valued: true,
+	},
+	{
+		id: "drained",
+		label: "Drained",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"–X status penalty to Con-based checks and DCs. Lose X × Hit Die in max HP. Decreases by 1 on full night's rest.",
+		iconName: "Droplets",
+		color: "red",
+		systems: ["pf2e"],
+		valued: true,
+	},
+	{
+		id: "dying",
+		label: "Dying",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Unconscious. Make recovery checks at start of turn. At dying 4 (or 4 – doomed), you die.",
+		iconName: "HeartPulse",
+		color: "red",
+		systems: ["pf2e"],
+		valued: true,
+	},
+	{
+		id: "enfeebled",
+		label: "Enfeebled",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"–X status penalty to Str-based rolls, including melee attack and damage rolls.",
+		iconName: "TrendingDown",
+		color: "amber",
+		systems: ["pf2e"],
+		valued: true,
+	},
+	{
+		id: "fascinated",
+		label: "Fascinated",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"–2 status penalty to all checks. Can't use hostile actions. Ends if hostile action is used against you.",
+		iconName: "Eye",
+		color: "violet",
+		systems: ["pf2e"],
+	},
+	{
+		id: "fatigued",
+		label: "Fatigued",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"–1 status penalty to AC and saves. Can't use exploration activities while traveling. Recover after a full night's rest.",
+		iconName: "BatteryLow",
+		color: "amber",
+		systems: ["pf2e"],
+	},
+	{
+		id: "fleeing",
+		label: "Fleeing",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Must spend actions to move away from the source. Can't Delay or Ready.",
+		iconName: "PersonStanding",
+		color: "orange",
+		systems: ["pf2e"],
+	},
+	{
+		id: "grabbed",
+		label: "Grabbed",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Immobilized. Off-guard. Can't use actions with the move trait unless to Break Grapple.",
+		iconName: "Hand",
+		color: "neutral",
+		systems: ["pf2e"],
+	},
+	{
+		id: "hidden",
+		label: "Hidden",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Known location but can't be seen. DC 11 flat check to target. Can use Seek to find.",
+		iconName: "EyeOff",
+		color: "slate",
+		systems: ["pf2e"],
+	},
+	{
+		id: "immobilized",
+		label: "Immobilized",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Can't use any action with the move trait to change position.",
+		iconName: "Anchor",
+		color: "neutral",
+		systems: ["pf2e"],
+	},
+	{
+		id: "off-guard",
+		label: "Off-Guard",
+		description: "",
+		description5e: "",
+		descriptionPf2e: "–2 circumstance penalty to AC. (Formerly flat-footed.)",
+		iconName: "ShieldOff",
+		color: "amber",
+		systems: ["pf2e"],
+	},
+	{
+		id: "quickened",
+		label: "Quickened",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Gain 1 extra action at the start of your turn each round (limited uses specified by the effect).",
+		iconName: "Zap",
+		color: "green",
+		systems: ["pf2e"],
+	},
+	{
+		id: "sickened",
+		label: "Sickened",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"–X status penalty to all checks and DCs. Can't willingly ingest anything. Reduce by retching (Fortitude save).",
+		iconName: "Droplet",
+		color: "green",
+		systems: ["pf2e"],
+		valued: true,
+	},
+	{
+		id: "slowed-pf2e",
+		label: "Slowed",
+		description: "",
+		description5e: "",
+		descriptionPf2e: "Lose X actions at the start of your turn each round.",
+		iconName: "Snail",
+		color: "sky",
+		systems: ["pf2e"],
+		valued: true,
+	},
+	{
+		id: "stupefied",
+		label: "Stupefied",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"–X status penalty to Int/Wis/Cha-based checks and DCs, including spell attack rolls and spell DCs. DC 5 + X flat check to cast spells or lose the spell.",
+		iconName: "BrainCog",
+		color: "violet",
+		systems: ["pf2e"],
+		valued: true,
+	},
+	{
+		id: "undetected",
+		label: "Undetected",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Location unknown. Must pick a square to target; DC 11 flat check. Attacker is off-guard against your attacks.",
+		iconName: "Ghost",
+		color: "violet",
+		systems: ["pf2e"],
+	},
+	{
+		id: "wounded",
+		label: "Wounded",
+		description: "",
+		description5e: "",
+		descriptionPf2e:
+			"Next time you gain dying, add wounded value to dying value. Wounded 1 when you recover from dying; increases if already wounded.",
+		iconName: "HeartCrack",
+		color: "red",
+		systems: ["pf2e"],
+		valued: true,
+	},
 ] as const;
 
 export const VALID_CONDITION_IDS: ReadonlySet<string> = new Set(
@@ -213,6 +520,6 @@ export function getConditionsForEdition(
 	edition: RulesEdition,
 ): readonly ConditionDefinition[] {
 	return CONDITION_DEFINITIONS.filter(
-		(d) => d.edition === undefined || d.edition === edition,
+		(d) => d.systems === undefined || d.systems.includes(edition),
 	);
 }

packages/domain/src/creature-types.ts

@@ -101,6 +101,62 @@ export interface BestiaryIndex {
 	readonly creatures: readonly BestiaryIndexEntry[];
 }
 
+export interface Pf2eCreature {
+	readonly system: "pf2e";
+	readonly id: CreatureId;
+	readonly name: string;
+	readonly source: string;
+	readonly sourceDisplayName: string;
+	readonly level: number;
+	readonly traits: readonly string[];
+	readonly perception: number;
+	readonly senses?: string;
+	readonly languages?: string;
+	readonly skills?: string;
+	readonly abilityMods: {
+		readonly str: number;
+		readonly dex: number;
+		readonly con: number;
+		readonly int: number;
+		readonly wis: number;
+		readonly cha: number;
+	};
+	readonly items?: string;
+	readonly ac: number;
+	readonly acConditional?: string;
+	readonly saveFort: number;
+	readonly saveRef: number;
+	readonly saveWill: number;
+	readonly hp: number;
+	readonly immunities?: string;
+	readonly resistances?: string;
+	readonly weaknesses?: string;
+	readonly speed: string;
+	readonly attacks?: readonly TraitBlock[];
+	readonly abilitiesTop?: readonly TraitBlock[];
+	readonly abilitiesMid?: readonly TraitBlock[];
+	readonly abilitiesBot?: readonly TraitBlock[];
+	readonly spellcasting?: readonly SpellcastingBlock[];
+}
+
+export type AnyCreature = Creature | Pf2eCreature;
+
+export interface Pf2eBestiaryIndexEntry {
+	readonly name: string;
+	readonly source: string;
+	readonly level: number;
+	readonly ac: number;
+	readonly hp: number;
+	readonly perception: number;
+	readonly size: string;
+	readonly type: string;
+}
+
+export interface Pf2eBestiaryIndex {
+	readonly sources: Readonly<Record<string, string>>;
+	readonly creatures: readonly Pf2eBestiaryIndexEntry[];
+}
+
 /** Maps a CR string to the corresponding proficiency bonus. */
 export function proficiencyBonus(cr: string): number {
 	const numericCr = cr.includes("/")

packages/domain/src/events.ts

@@ -112,12 +112,14 @@ export interface ConditionAdded {
 	readonly type: "ConditionAdded";
 	readonly combatantId: CombatantId;
 	readonly condition: ConditionId;
+	readonly value?: number;
 }
 
 export interface ConditionRemoved {
 	readonly type: "ConditionRemoved";
 	readonly combatantId: CombatantId;
 	readonly condition: ConditionId;
+	readonly value?: number;
 }
 
 export interface ConcentrationStarted {

packages/domain/src/index.ts

@@ -13,6 +13,7 @@ export {
 export {
 	CONDITION_DEFINITIONS,
 	type ConditionDefinition,
+	type ConditionEntry,
 	type ConditionId,
 	getConditionDescription,
 	getConditionsForEdition,
@@ -23,6 +24,7 @@ export {
 	createPlayerCharacter,
 } from "./create-player-character.js";
 export {
+	type AnyCreature,
 	type BestiaryIndex,
 	type BestiaryIndexEntry,
 	type BestiarySource,
@@ -31,6 +33,9 @@ export {
 	creatureId,
 	type DailySpells,
 	type LegendaryBlock,
+	type Pf2eBestiaryIndex,
+	type Pf2eBestiaryIndexEntry,
+	type Pf2eCreature,
 	proficiencyBonus,
 	type SpellcastingBlock,
 	type TraitBlock,
@@ -87,6 +92,7 @@ export type { ExportBundle } from "./export-bundle.js";
 export { deriveHpStatus, type HpStatus } from "./hp-status.js";
 export {
 	calculateInitiative,
+	calculatePf2eInitiative,
 	formatInitiativeModifier,
 	type InitiativeResult,
 } from "./initiative.js";
@@ -127,6 +133,8 @@ export {
 	toggleConcentration,
 } from "./toggle-concentration.js";
 export {
+	decrementCondition,
+	setConditionValue,
 	type ToggleConditionSuccess,
 	toggleCondition,
 } from "./toggle-condition.js";

packages/domain/src/initiative.ts

@@ -20,6 +20,14 @@ export function calculateInitiative(creature: {
 	return { modifier, passive: 10 + modifier };
 }
 
+/**
+ * Returns the PF2e initiative result directly from the Perception modifier.
+ * No proficiency bonus calculation — PF2e uses Perception as-is.
+ */
+export function calculatePf2eInitiative(perception: number): InitiativeResult {
+	return { modifier: perception, passive: perception };
+}
+
 /**
  * Formats an initiative modifier with explicit sign.
  * Uses U+2212 (−) for negative values.

packages/domain/src/rehydrate-combatant.ts

@@ -1,4 +1,4 @@
-import type { ConditionId } from "./conditions.js";
+import type { ConditionEntry, ConditionId } from "./conditions.js";
 import { VALID_CONDITION_IDS } from "./conditions.js";
 import { creatureId } from "./creature-types.js";
 import { VALID_CR_VALUES } from "./encounter-difficulty.js";
@@ -16,13 +16,30 @@ function validateAc(value: unknown): number | undefined {
 		: undefined;
 }
 
-function validateConditions(value: unknown): ConditionId[] | undefined {
+function validateConditions(value: unknown): ConditionEntry[] | undefined {
 	if (!Array.isArray(value)) return undefined;
-	const valid = value.filter(
+	const entries: ConditionEntry[] = [];
-		(v): v is ConditionId =>
+	for (const item of value) {
-			typeof v === "string" && VALID_CONDITION_IDS.has(v),
+		if (typeof item === "string" && VALID_CONDITION_IDS.has(item)) {
-	);
+			entries.push({ id: item as ConditionId });
-	return valid.length > 0 ? valid : undefined;
+		} else if (
+			typeof item === "object" &&
+			item !== null &&
+			typeof (item as Record<string, unknown>).id === "string" &&
+			VALID_CONDITION_IDS.has((item as Record<string, unknown>).id as string)
+		) {
+			const id = (item as Record<string, unknown>).id as ConditionId;
+			const rawValue = (item as Record<string, unknown>).value;
+			const entry: ConditionEntry =
+				typeof rawValue === "number" &&
+				Number.isInteger(rawValue) &&
+				rawValue > 0
+					? { id, value: rawValue }
+					: { id };
+			entries.push(entry);
+		}
+	}
+	return entries.length > 0 ? entries : undefined;
 }
 
 function validateHp(

packages/domain/src/rules-edition.ts

@@ -1 +1 @@
-export type RulesEdition = "5e" | "5.5e";
+export type RulesEdition = "5e" | "5.5e" | "pf2e";

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(
+function sortByDefinitionOrder(entries: ConditionEntry[]): ConditionEntry[] {
-	encounter: Encounter,
+	const order = CONDITION_DEFINITIONS.map((d) => d.id);
-	combatantId: CombatantId,
+	entries.sort((a, b) => order.indexOf(a.id) - order.indexOf(b.id));
-	conditionId: ConditionId,
+	return entries;
-): ToggleConditionSuccess | DomainError {
+}
+
+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 added = sortByDefinitionOrder([...current, { id: conditionId }]);
-		const order = CONDITION_DEFINITIONS.map((d) => d.id);
-		added.sort((a, b) => order.indexOf(a) - order.indexOf(b));
 		newConditions = added;
 		event = { type: "ConditionAdded", combatantId, condition: conditionId };
 	}
 
-	const updatedCombatants = encounter.combatants.map((c) =>
-		c.id === combatantId ? { ...c, conditions: newConditions } : c,
-	);
-
 	return {
-		encounter: {
+		encounter: applyConditions(encounter, combatantId, newConditions),
-			combatants: updatedCombatants,
-			activeIndex: encounter.activeIndex,
-			roundNumber: encounter.roundNumber,
-		},
 		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,
+			},
+		],
+	};
+}

packages/domain/src/types.ts

@@ -5,7 +5,7 @@ export function combatantId(id: string): CombatantId {
 	return id as CombatantId;
 }
 
-import type { ConditionId } from "./conditions.js";
+import type { ConditionEntry } from "./conditions.js";
 import type { CreatureId } from "./creature-types.js";
 import type { PlayerCharacterId } from "./player-character-types.js";
 
@@ -17,7 +17,7 @@ export interface Combatant {
 	readonly currentHp?: number;
 	readonly tempHp?: number;
 	readonly ac?: number;
-	readonly conditions?: readonly ConditionId[];
+	readonly conditions?: readonly ConditionEntry[];
 	readonly isConcentrating?: boolean;
 	readonly creatureId?: CreatureId;
 	readonly cr?: string;

pnpm-lock.yaml

@@ -17,7 +17,7 @@ importers:
         version: 2.4.8
       '@vitest/coverage-v8':
         specifier: ^4.1.0
-        version: 4.1.0(vitest@4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)))
+        version: 4.1.0(vitest@4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)))
       jscpd:
         specifier: ^4.0.8
         version: 4.0.8
@@ -41,7 +41,7 @@ importers:
         version: 5.9.3
       vitest:
         specifier: ^4.1.0
-        version: 4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
+        version: 4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
 
   apps/web:
     dependencies:
@@ -75,7 +75,7 @@ importers:
     devDependencies:
       '@tailwindcss/vite':
         specifier: ^4.2.2
-        version: 4.2.2(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
+        version: 4.2.2(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
       '@testing-library/jest-dom':
         specifier: ^6.9.1
         version: 6.9.1
@@ -93,7 +93,7 @@ importers:
         version: 19.2.3(@types/react@19.2.14)
       '@vitejs/plugin-react':
         specifier: ^6.0.1
-        version: 6.0.1(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
+        version: 6.0.1(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
       jsdom:
         specifier: ^29.0.1
         version: 29.0.1
@@ -101,8 +101,8 @@ importers:
         specifier: ^4.2.2
         version: 4.2.2
       vite:
-        specifier: ^8.0.1
+        specifier: ^8.0.5
-        version: 8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
+        version: 8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
 
   packages/application:
     dependencies:
@@ -162,6 +162,10 @@ packages:
     resolution: {integrity: sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/runtime@7.29.2':
+    resolution: {integrity: sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/types@7.29.0':
     resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
     engines: {node: '>=6.9.0'}
@@ -327,6 +331,12 @@ packages:
   '@napi-rs/wasm-runtime@1.1.1':
     resolution: {integrity: sha512-p64ah1M1ld8xjWv3qbvFwHiFVWrq1yFvV4f7w+mzaqiR4IlSgkqhcRdHwsGgomwzBH51sRY4NEowLxnaBjcW/A==}
 
+  '@napi-rs/wasm-runtime@1.1.2':
+    resolution: {integrity: sha512-sNXv5oLJ7ob93xkZ1XnxisYhGYXfaG9f65/ZgYuAu3qt7b3NadcOEhLvx28hv31PgX8SZJRYrAIPQilQmFpLVw==}
+    peerDependencies:
+      '@emnapi/core': ^1.7.1
+      '@emnapi/runtime': ^1.7.1
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -339,8 +349,8 @@ packages:
     resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
     engines: {node: '>= 8'}
 
-  '@oxc-project/types@0.120.0':
+  '@oxc-project/types@0.122.0':
-    resolution: {integrity: sha512-k1YNu55DuvAip/MGE1FTsIuU3FUCn6v/ujG9V7Nq5Df/kX2CWb13hhwD0lmJGMGqE+bE1MXvv9SZVnMzEXlWcg==}
+    resolution: {integrity: sha512-oLAl5kBpV4w69UtFZ9xqcmTi+GENWOcPF7FCrczTiBbmC0ibXxCwyvZGbO39rCVEuLGAZM84DH0pUIyyv/YJzA==}
 
   '@oxc-resolver/binding-android-arm-eabi@11.19.1':
     resolution: {integrity: sha512-aUs47y+xyXHUKlbhqHUjBABjvycq6YSD7bpxSW7vplUmdzAlJ93yXY6ZR0c1o1x5A/QKbENCvs3+NlY8IpIVzg==}
@@ -602,103 +612,103 @@ packages:
     cpu: [x64]
     os: [win32]
 
-  '@rolldown/binding-android-arm64@1.0.0-rc.10':
+  '@rolldown/binding-android-arm64@1.0.0-rc.12':
-    resolution: {integrity: sha512-jOHxwXhxmFKuXztiu1ORieJeTbx5vrTkcOkkkn2d35726+iwhrY1w/+nYY/AGgF12thg33qC3R1LMBF5tHTZHg==}
+    resolution: {integrity: sha512-pv1y2Fv0JybcykuiiD3qBOBdz6RteYojRFY1d+b95WVuzx211CRh+ytI/+9iVyWQ6koTh5dawe4S/yRfOFjgaA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [android]
 
-  '@rolldown/binding-darwin-arm64@1.0.0-rc.10':
+  '@rolldown/binding-darwin-arm64@1.0.0-rc.12':
-    resolution: {integrity: sha512-gED05Teg/vtTZbIJBc4VNMAxAFDUPkuO/rAIyyxZjTj1a1/s6z5TII/5yMGZ0uLRCifEtwUQn8OlYzuYc0m70w==}
+    resolution: {integrity: sha512-cFYr6zTG/3PXXF3pUO+umXxt1wkRK/0AYT8lDwuqvRC+LuKYWSAQAQZjCWDQpAH172ZV6ieYrNnFzVVcnSflAg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [darwin]
 
-  '@rolldown/binding-darwin-x64@1.0.0-rc.10':
+  '@rolldown/binding-darwin-x64@1.0.0-rc.12':
-    resolution: {integrity: sha512-rI15NcM1mA48lqrIxVkHfAqcyFLcQwyXWThy+BQ5+mkKKPvSO26ir+ZDp36AgYoYVkqvMcdS8zOE6SeBsR9e8A==}
+    resolution: {integrity: sha512-ZCsYknnHzeXYps0lGBz8JrF37GpE9bFVefrlmDrAQhOEi4IOIlcoU1+FwHEtyXGx2VkYAvhu7dyBf75EJQffBw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [darwin]
 
-  '@rolldown/binding-freebsd-x64@1.0.0-rc.10':
+  '@rolldown/binding-freebsd-x64@1.0.0-rc.12':
-    resolution: {integrity: sha512-XZRXHdTa+4ME1MuDVp021+doQ+z6Ei4CCFmNc5/sKbqb8YmkiJdj8QKlV3rCI0AJtAeSB5n0WGPuJWNL9p/L2w==}
+    resolution: {integrity: sha512-dMLeprcVsyJsKolRXyoTH3NL6qtsT0Y2xeuEA8WQJquWFXkEC4bcu1rLZZSnZRMtAqwtrF/Ib9Ddtpa/Gkge9Q==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [freebsd]
 
-  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.10':
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.12':
-    resolution: {integrity: sha512-R0SQMRluISSLzFE20sPWYHVmJdDQnRyc/FzSCN72BqQmh2SOZUFG+N3/vBZpR4C6WpEUVYJLrYUXaj43sJsNLA==}
+    resolution: {integrity: sha512-YqWjAgGC/9M1lz3GR1r1rP79nMgo3mQiiA+Hfo+pvKFK1fAJ1bCi0ZQVh8noOqNacuY1qIcfyVfP6HoyBRZ85Q==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
-  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.10':
+  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.12':
-    resolution: {integrity: sha512-Y1reMrV/o+cwpduYhJuOE3OMKx32RMYCidf14y+HssARRmhDuWXJ4yVguDg2R/8SyyGNo+auzz64LnPK9Hq6jg==}
+    resolution: {integrity: sha512-/I5AS4cIroLpslsmzXfwbe5OmWvSsrFuEw3mwvbQ1kDxJ822hFHIx+vsN/TAzNVyepI/j/GSzrtCIwQPeKCLIg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
     libc: [glibc]
 
-  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.10':
+  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.12':
-    resolution: {integrity: sha512-vELN+HNb2IzuzSBUOD4NHmP9yrGwl1DVM29wlQvx1OLSclL0NgVWnVDKl/8tEks79EFek/kebQKnNJkIAA4W2g==}
+    resolution: {integrity: sha512-V6/wZztnBqlx5hJQqNWwFdxIKN0m38p8Jas+VoSfgH54HSj9tKTt1dZvG6JRHcjh6D7TvrJPWFGaY9UBVOaWPw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
     libc: [musl]
 
-  '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.10':
+  '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.12':
-    resolution: {integrity: sha512-ZqrufYTgzxbHwpqOjzSsb0UV/aV2TFIY5rP8HdsiPTv/CuAgCRjM6s9cYFwQ4CNH+hf9Y4erHW1GjZuZ7WoI7w==}
+    resolution: {integrity: sha512-AP3E9BpcUYliZCxa3w5Kwj9OtEVDYK6sVoUzy4vTOJsjPOgdaJZKFmN4oOlX0Wp0RPV2ETfmIra9x1xuayFB7g==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ppc64]
     os: [linux]
     libc: [glibc]
 
-  '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.10':
+  '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.12':
-    resolution: {integrity: sha512-gSlmVS1FZJSRicA6IyjoRoKAFK7IIHBs7xJuHRSmjImqk3mPPWbR7RhbnfH2G6bcmMEllCt2vQ/7u9e6bBnByg==}
+    resolution: {integrity: sha512-nWwpvUSPkoFmZo0kQazZYOrT7J5DGOJ/+QHHzjvNlooDZED8oH82Yg67HvehPPLAg5fUff7TfWFHQS8IV1n3og==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [s390x]
     os: [linux]
     libc: [glibc]
 
-  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.10':
+  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.12':
-    resolution: {integrity: sha512-eOCKUpluKgfObT2pHjztnaWEIbUabWzk3qPZ5PuacuPmr4+JtQG4k2vGTY0H15edaTnicgU428XW/IH6AimcQw==}
+    resolution: {integrity: sha512-RNrafz5bcwRy+O9e6P8Z/OCAJW/A+qtBczIqVYwTs14pf4iV1/+eKEjdOUta93q2TsT/FI0XYDP3TCky38LMAg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
     libc: [glibc]
 
-  '@rolldown/binding-linux-x64-musl@1.0.0-rc.10':
+  '@rolldown/binding-linux-x64-musl@1.0.0-rc.12':
-    resolution: {integrity: sha512-Xdf2jQbfQowJnLcgYfD/m0Uu0Qj5OdxKallD78/IPPfzaiaI4KRAwZzHcKQ4ig1gtg1SuzC7jovNiM2TzQsBXA==}
+    resolution: {integrity: sha512-Jpw/0iwoKWx3LJ2rc1yjFrj+T7iHZn2JDg1Yny1ma0luviFS4mhAIcd1LFNxK3EYu3DHWCps0ydXQ5i/rrJ2ig==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
     libc: [musl]
 
-  '@rolldown/binding-openharmony-arm64@1.0.0-rc.10':
+  '@rolldown/binding-openharmony-arm64@1.0.0-rc.12':
-    resolution: {integrity: sha512-o1hYe8hLi1EY6jgPFyxQgQ1wcycX+qz8eEbVmot2hFkgUzPxy9+kF0u0NIQBeDq+Mko47AkaFFaChcvZa9UX9Q==}
+    resolution: {integrity: sha512-vRugONE4yMfVn0+7lUKdKvN4D5YusEiPilaoO2sgUWpCvrncvWgPMzK00ZFFJuiPgLwgFNP5eSiUlv2tfc+lpA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [openharmony]
 
-  '@rolldown/binding-wasm32-wasi@1.0.0-rc.10':
+  '@rolldown/binding-wasm32-wasi@1.0.0-rc.12':
-    resolution: {integrity: sha512-Ugv9o7qYJudqQO5Y5y2N2SOo6S4WiqiNOpuQyoPInnhVzCY+wi/GHltcLHypG9DEUYMB0iTB/huJrpadiAcNcA==}
+    resolution: {integrity: sha512-ykGiLr/6kkiHc0XnBfmFJuCjr5ZYKKofkx+chJWDjitX+KsJuAmrzWhwyOMSHzPhzOHOy7u9HlFoa5MoAOJ/Zg==}
     engines: {node: '>=14.0.0'}
     cpu: [wasm32]
 
-  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.10':
+  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.12':
-    resolution: {integrity: sha512-7UODQb4fQUNT/vmgDZBl3XOBAIOutP5R3O/rkxg0aLfEGQ4opbCgU5vOw/scPe4xOqBwL9fw7/RP1vAMZ6QlAQ==}
+    resolution: {integrity: sha512-5eOND4duWkwx1AzCxadcOrNeighiLwMInEADT0YM7xeEOOFcovWZCq8dadXgcRHSf3Ulh1kFo/qvzoFiCLOL1Q==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [win32]
 
-  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.10':
+  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.12':
-    resolution: {integrity: sha512-PYxKHMVHOb5NJuDL53vBUl1VwUjymDcYI6rzpIni0C9+9mTiJedvUxSk7/RPp7OOAm3v+EjgMu9bIy3N6b408w==}
+    resolution: {integrity: sha512-PyqoipaswDLAZtot351MLhrlrh6lcZPo2LSYE+VDxbVk24LVKAGOuE4hb8xZQmrPAuEtTZW8E6D2zc5EUZX4Lw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [win32]
 
-  '@rolldown/pluginutils@1.0.0-rc.10':
+  '@rolldown/pluginutils@1.0.0-rc.12':
-    resolution: {integrity: sha512-UkVDEFk1w3mveXeKgaTuYfKWtPbvgck1dT8TUG3bnccrH0XtLTuAyfCoks4Q/M5ZGToSVJTIQYCzy2g/atAOeg==}
+    resolution: {integrity: sha512-HHMwmarRKvoFsJorqYlFeFRzXZqCt2ETQlEDOb9aqssrnVBB1/+xgTGtuTrIk5vzLNX1MjMtTf7W9z3tsSbrxw==}
 
   '@rolldown/pluginutils@1.0.0-rc.7':
     resolution: {integrity: sha512-qujRfC8sFVInYSPPMLQByRh7zhwkGFS4+tyMQ83srV1qrxL4g8E2tyxVVyxd0+8QeBM1mIk9KbWxkegRr76XzA==}
@@ -1657,8 +1667,8 @@ packages:
     resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
     engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
 
-  rolldown@1.0.0-rc.10:
+  rolldown@1.0.0-rc.12:
-    resolution: {integrity: sha512-q7j6vvarRFmKpgJUT8HCAUljkgzEp4LAhPlJUvQhA5LA1SUL36s5QCysMutErzL3EbNOZOkoziSx9iZC4FddKA==}
+    resolution: {integrity: sha512-yP4USLIMYrwpPHEFB5JGH1uxhcslv6/hL0OyvTuY+3qlOSJvZ7ntYnoWpehBxufkgN0cvXxppuTu5hHa/zPh+A==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
 
@@ -1821,14 +1831,14 @@ packages:
     resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
     engines: {node: '>= 10.0.0'}
 
-  vite@8.0.1:
+  vite@8.0.5:
-    resolution: {integrity: sha512-wt+Z2qIhfFt85uiyRt5LPU4oVEJBXj8hZNWKeqFG4gRG/0RaRGJ7njQCwzFVjO+v4+Ipmf5CY7VdmZRAYYBPHw==}
+    resolution: {integrity: sha512-nmu43Qvq9UopTRfMx2jOYW5l16pb3iDC1JH6yMuPkpVbzK0k+L7dfsEDH4jRgYFmsg0sTAqkojoZgzLMlwHsCQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
     peerDependencies:
       '@types/node': ^20.19.0 || >=22.12.0
       '@vitejs/devtools': ^0.1.0
-      esbuild: ^0.27.0
+      esbuild: ^0.27.0 || ^0.28.0
       jiti: '>=1.21.0'
       less: ^4.0.0
       sass: ^1.70.0
@@ -2001,6 +2011,8 @@ snapshots:
 
   '@babel/runtime@7.28.6': {}
 
+  '@babel/runtime@7.29.2': {}
+
   '@babel/types@7.29.0':
     dependencies:
       '@babel/helper-string-parser': 7.27.1
@@ -2158,6 +2170,13 @@ snapshots:
       '@tybys/wasm-util': 0.10.1
     optional: true
 
+  '@napi-rs/wasm-runtime@1.1.2(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)':
+    dependencies:
+      '@emnapi/core': 1.8.1
+      '@emnapi/runtime': 1.8.1
+      '@tybys/wasm-util': 0.10.1
+    optional: true
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -2170,7 +2189,7 @@ snapshots:
       '@nodelib/fs.scandir': 2.1.5
       fastq: 1.20.1
 
-  '@oxc-project/types@0.120.0': {}
+  '@oxc-project/types@0.122.0': {}
 
   '@oxc-resolver/binding-android-arm-eabi@11.19.1':
     optional: true
@@ -2309,54 +2328,57 @@ snapshots:
   '@oxlint/binding-win32-x64-msvc@1.56.0':
     optional: true
 
-  '@rolldown/binding-android-arm64@1.0.0-rc.10':
+  '@rolldown/binding-android-arm64@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-darwin-arm64@1.0.0-rc.10':
+  '@rolldown/binding-darwin-arm64@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-darwin-x64@1.0.0-rc.10':
+  '@rolldown/binding-darwin-x64@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-freebsd-x64@1.0.0-rc.10':
+  '@rolldown/binding-freebsd-x64@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.10':
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.10':
+  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.10':
+  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.10':
+  '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.10':
+  '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.10':
+  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-linux-x64-musl@1.0.0-rc.10':
+  '@rolldown/binding-linux-x64-musl@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-openharmony-arm64@1.0.0-rc.10':
+  '@rolldown/binding-openharmony-arm64@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-wasm32-wasi@1.0.0-rc.10':
+  '@rolldown/binding-wasm32-wasi@1.0.0-rc.12(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)':
     dependencies:
-      '@napi-rs/wasm-runtime': 1.1.1
+      '@napi-rs/wasm-runtime': 1.1.2(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)
+    transitivePeerDependencies:
+      - '@emnapi/core'
+      - '@emnapi/runtime'
     optional: true
 
-  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.10':
+  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.10':
+  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/pluginutils@1.0.0-rc.10': {}
+  '@rolldown/pluginutils@1.0.0-rc.12': {}
 
   '@rolldown/pluginutils@1.0.0-rc.7': {}
 
@@ -2423,17 +2445,17 @@ snapshots:
       '@tailwindcss/oxide-win32-arm64-msvc': 4.2.2
       '@tailwindcss/oxide-win32-x64-msvc': 4.2.2
 
-  '@tailwindcss/vite@4.2.2(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))':
+  '@tailwindcss/vite@4.2.2(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))':
     dependencies:
       '@tailwindcss/node': 4.2.2
       '@tailwindcss/oxide': 4.2.2
       tailwindcss: 4.2.2
-      vite: 8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
+      vite: 8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
 
   '@testing-library/dom@10.4.1':
     dependencies:
       '@babel/code-frame': 7.29.0
-      '@babel/runtime': 7.28.6
+      '@babel/runtime': 7.29.2
       '@types/aria-query': 5.0.4
       aria-query: 5.3.0
       dom-accessibility-api: 0.5.16
@@ -2494,12 +2516,12 @@ snapshots:
 
   '@types/sarif@2.1.7': {}
 
-  '@vitejs/plugin-react@6.0.1(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))':
+  '@vitejs/plugin-react@6.0.1(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))':
     dependencies:
       '@rolldown/pluginutils': 1.0.0-rc.7
-      vite: 8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
+      vite: 8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
 
-  '@vitest/coverage-v8@4.1.0(vitest@4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)))':
+  '@vitest/coverage-v8@4.1.0(vitest@4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)))':
     dependencies:
       '@bcoe/v8-coverage': 1.0.2
       '@vitest/utils': 4.1.0
@@ -2511,7 +2533,7 @@ snapshots:
       obug: 2.1.1
       std-env: 4.0.0
       tinyrainbow: 3.1.0
-      vitest: 4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
+      vitest: 4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
 
   '@vitest/expect@4.1.0':
     dependencies:
@@ -2522,13 +2544,13 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.1.0
 
-  '@vitest/mocker@4.1.0(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))':
+  '@vitest/mocker@4.1.0(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))':
     dependencies:
       '@vitest/spy': 4.1.0
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
+      vite: 8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
 
   '@vitest/pretty-format@4.1.0':
     dependencies:
@@ -3330,26 +3352,29 @@ snapshots:
 
   reusify@1.1.0: {}
 
-  rolldown@1.0.0-rc.10:
+  rolldown@1.0.0-rc.12(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1):
     dependencies:
-      '@oxc-project/types': 0.120.0
+      '@oxc-project/types': 0.122.0
-      '@rolldown/pluginutils': 1.0.0-rc.10
+      '@rolldown/pluginutils': 1.0.0-rc.12
     optionalDependencies:
-      '@rolldown/binding-android-arm64': 1.0.0-rc.10
+      '@rolldown/binding-android-arm64': 1.0.0-rc.12
-      '@rolldown/binding-darwin-arm64': 1.0.0-rc.10
+      '@rolldown/binding-darwin-arm64': 1.0.0-rc.12
-      '@rolldown/binding-darwin-x64': 1.0.0-rc.10
+      '@rolldown/binding-darwin-x64': 1.0.0-rc.12
-      '@rolldown/binding-freebsd-x64': 1.0.0-rc.10
+      '@rolldown/binding-freebsd-x64': 1.0.0-rc.12
-      '@rolldown/binding-linux-arm-gnueabihf': 1.0.0-rc.10
+      '@rolldown/binding-linux-arm-gnueabihf': 1.0.0-rc.12
-      '@rolldown/binding-linux-arm64-gnu': 1.0.0-rc.10
+      '@rolldown/binding-linux-arm64-gnu': 1.0.0-rc.12
-      '@rolldown/binding-linux-arm64-musl': 1.0.0-rc.10
+      '@rolldown/binding-linux-arm64-musl': 1.0.0-rc.12
-      '@rolldown/binding-linux-ppc64-gnu': 1.0.0-rc.10
+      '@rolldown/binding-linux-ppc64-gnu': 1.0.0-rc.12
-      '@rolldown/binding-linux-s390x-gnu': 1.0.0-rc.10
+      '@rolldown/binding-linux-s390x-gnu': 1.0.0-rc.12
-      '@rolldown/binding-linux-x64-gnu': 1.0.0-rc.10
+      '@rolldown/binding-linux-x64-gnu': 1.0.0-rc.12
-      '@rolldown/binding-linux-x64-musl': 1.0.0-rc.10
+      '@rolldown/binding-linux-x64-musl': 1.0.0-rc.12
-      '@rolldown/binding-openharmony-arm64': 1.0.0-rc.10
+      '@rolldown/binding-openharmony-arm64': 1.0.0-rc.12
-      '@rolldown/binding-wasm32-wasi': 1.0.0-rc.10
+      '@rolldown/binding-wasm32-wasi': 1.0.0-rc.12(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)
-      '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.10
+      '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.12
-      '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.10
+      '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.12
+    transitivePeerDependencies:
+      - '@emnapi/core'
+      - '@emnapi/runtime'
 
   run-parallel@1.2.0:
     dependencies:
@@ -3467,23 +3492,26 @@ snapshots:
 
   universalify@2.0.1: {}
 
-  vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3):
+  vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3):
     dependencies:
       lightningcss: 1.32.0
       picomatch: 4.0.4
       postcss: 8.5.8
-      rolldown: 1.0.0-rc.10
+      rolldown: 1.0.0-rc.12(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)
       tinyglobby: 0.2.15
     optionalDependencies:
       '@types/node': 25.3.3
       fsevents: 2.3.3
       jiti: 2.6.1
       yaml: 2.8.3
+    transitivePeerDependencies:
+      - '@emnapi/core'
+      - '@emnapi/runtime'
 
-  vitest@4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)):
+  vitest@4.1.0(@types/node@25.3.3)(jsdom@29.0.1)(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)):
     dependencies:
       '@vitest/expect': 4.1.0
-      '@vitest/mocker': 4.1.0(vite@8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
+      '@vitest/mocker': 4.1.0(vite@8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3))
       '@vitest/pretty-format': 4.1.0
       '@vitest/runner': 4.1.0
       '@vitest/snapshot': 4.1.0
@@ -3500,7 +3528,7 @@ snapshots:
       tinyexec: 1.0.4
       tinyglobby: 0.2.15
       tinyrainbow: 3.1.0
-      vite: 8.0.1(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
+      vite: 8.0.5(@emnapi/core@1.8.1)(@emnapi/runtime@1.8.1)(@types/node@25.3.3)(jiti@2.6.1)(yaml@2.8.3)
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 25.3.3

scripts/generate-pf2e-bestiary-index.mjs

@@ -0,0 +1,215 @@
+import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// Usage: node scripts/generate-pf2e-bestiary-index.mjs <path-to-Pf2eTools>
+//
+// Requires a local clone/checkout of https://github.com/Pf2eToolsOrg/Pf2eTools (dev branch)
+// with at least data/bestiary/.
+//
+// Example:
+//   git clone --depth 1 --branch dev --sparse https://github.com/Pf2eToolsOrg/Pf2eTools.git /tmp/pf2etools
+//   cd /tmp/pf2etools && git sparse-checkout set data/bestiary data
+//   node scripts/generate-pf2e-bestiary-index.mjs /tmp/pf2etools
+
+const TOOLS_ROOT = process.argv[2];
+if (!TOOLS_ROOT) {
+	console.error(
+		"Usage: node scripts/generate-pf2e-bestiary-index.mjs <Pf2eTools-path>",
+	);
+	process.exit(1);
+}
+
+const PROJECT_ROOT = join(import.meta.dirname, "..");
+const BESTIARY_DIR = join(TOOLS_ROOT, "data/bestiary");
+const OUTPUT_PATH = join(PROJECT_ROOT, "data/bestiary/pf2e-index.json");
+
+// --- Source display names ---
+// Pf2eTools doesn't have a single books.json with all adventure paths.
+// We map known source codes to display names here.
+const SOURCE_NAMES = {
+	B1: "Bestiary",
+	B2: "Bestiary 2",
+	B3: "Bestiary 3",
+	CRB: "Core Rulebook",
+	GMG: "Gamemastery Guide",
+	LOME: "Lost Omens: The Mwangi Expanse",
+	LOMM: "Lost Omens: Monsters of Myth",
+	LOIL: "Lost Omens: Impossible Lands",
+	LOCG: "Lost Omens: Character Guide",
+	LOSK: "Lost Omens: Knights of Lastwall",
+	LOTXWG: "Lost Omens: Travel Guide",
+	LOACLO: "Lost Omens: Absalom, City of Lost Omens",
+	LOHh: "Lost Omens: Highhelm",
+	AoA1: "Age of Ashes #1: Hellknight Hill",
+	AoA2: "Age of Ashes #2: Cult of Cinders",
+	AoA3: "Age of Ashes #3: Tomorrow Must Burn",
+	AoA4: "Age of Ashes #4: Fires of the Haunted City",
+	AoA5: "Age of Ashes #5: Against the Scarlet Triad",
+	AoA6: "Age of Ashes #6: Broken Promises",
+	AoE1: "Agents of Edgewatch #1",
+	AoE2: "Agents of Edgewatch #2",
+	AoE3: "Agents of Edgewatch #3",
+	AoE4: "Agents of Edgewatch #4",
+	AoE5: "Agents of Edgewatch #5",
+	AoE6: "Agents of Edgewatch #6",
+	EC1: "Extinction Curse #1",
+	EC2: "Extinction Curse #2",
+	EC3: "Extinction Curse #3",
+	EC4: "Extinction Curse #4",
+	EC5: "Extinction Curse #5",
+	EC6: "Extinction Curse #6",
+	AV1: "Abomination Vaults #1",
+	AV2: "Abomination Vaults #2",
+	AV3: "Abomination Vaults #3",
+	FRP1: "Fists of the Ruby Phoenix #1",
+	FRP2: "Fists of the Ruby Phoenix #2",
+	FRP3: "Fists of the Ruby Phoenix #3",
+	SoT1: "Strength of Thousands #1",
+	SoT2: "Strength of Thousands #2",
+	SoT3: "Strength of Thousands #3",
+	SoT4: "Strength of Thousands #4",
+	SoT5: "Strength of Thousands #5",
+	SoT6: "Strength of Thousands #6",
+	OoA1: "Outlaws of Alkenstar #1",
+	OoA2: "Outlaws of Alkenstar #2",
+	OoA3: "Outlaws of Alkenstar #3",
+	BotD: "Book of the Dead",
+	DA: "Dark Archive",
+	FoP: "The Fall of Plaguestone",
+	LTiBA: "Little Trouble in Big Absalom",
+	Sli: "The Slithering",
+	TiO: "Troubles in Otari",
+	NGD: "Night of the Gray Death",
+	BB: "Beginner Box",
+	SoG1: "Sky King's Tomb #1",
+	SoG2: "Sky King's Tomb #2",
+	SoG3: "Sky King's Tomb #3",
+	GW1: "Gatewalkers #1",
+	GW2: "Gatewalkers #2",
+	GW3: "Gatewalkers #3",
+	WoW1: "Wardens of Wildwood #1",
+	WoW2: "Wardens of Wildwood #2",
+	WoW3: "Wardens of Wildwood #3",
+	SF1: "Season of Ghosts #1",
+	SF2: "Season of Ghosts #2",
+	SF3: "Season of Ghosts #3",
+	POS1: "Pathfinder One-Shots",
+	AFoF: "A Fistful of Flowers",
+	TaL: "Threshold of Knowledge",
+	ToK: "Threshold of Knowledge",
+	DaLl: "Dinner at Lionlodge",
+	MotM: "Monsters of the Multiverse",
+	Mal: "Malevolence",
+	TEC: "The Enmity Cycle",
+	SaS: "Shadows at Sundown",
+	Rust: "Rusthenge",
+	CotT: "Crown of the Kobold King",
+	SoM: "Secrets of Magic",
+};
+
+// --- Size extraction from traits ---
+const SIZES = new Set([
+	"tiny",
+	"small",
+	"medium",
+	"large",
+	"huge",
+	"gargantuan",
+]);
+
+// Creature type traits (PF2e types are lowercase in the traits array)
+const CREATURE_TYPES = new Set([
+	"aberration",
+	"animal",
+	"astral",
+	"beast",
+	"celestial",
+	"construct",
+	"dragon",
+	"dream",
+	"elemental",
+	"ethereal",
+	"fey",
+	"fiend",
+	"fungus",
+	"giant",
+	"humanoid",
+	"monitor",
+	"ooze",
+	"petitioner",
+	"plant",
+	"spirit",
+	"time",
+	"undead",
+]);
+
+function extractSize(traits) {
+	if (!Array.isArray(traits)) return "medium";
+	const found = traits.find((t) => SIZES.has(t.toLowerCase()));
+	return found ? found.toLowerCase() : "medium";
+}
+
+function extractType(traits) {
+	if (!Array.isArray(traits)) return "";
+	const found = traits.find((t) => CREATURE_TYPES.has(t.toLowerCase()));
+	return found ? found.toLowerCase() : "";
+}
+
+// --- Main ---
+
+const files = readdirSync(BESTIARY_DIR).filter(
+	(f) => f.startsWith("creatures-") && f.endsWith(".json"),
+);
+
+const creatures = [];
+const seenSources = new Set();
+
+for (const file of files.sort()) {
+	const raw = JSON.parse(readFileSync(join(BESTIARY_DIR, file), "utf-8"));
+	const entries = raw.creature ?? [];
+
+	for (const c of entries) {
+		// Skip copies/references
+		if (c._copy) continue;
+
+		const source = c.source ?? "";
+		seenSources.add(source);
+
+		const ac = c.defenses?.ac?.std ?? 0;
+		const hp = c.defenses?.hp?.[0]?.hp ?? 0;
+		const perception = c.perception?.std ?? 0;
+
+		creatures.push({
+			n: c.name,
+			s: source,
+			lv: c.level ?? 0,
+			ac,
+			hp,
+			pc: perception,
+			sz: extractSize(c.traits),
+			tp: extractType(c.traits),
+		});
+	}
+}
+
+// Sort by name then source for stable output
+creatures.sort((a, b) => a.n.localeCompare(b.n) || a.s.localeCompare(b.s));
+
+// Build source map from seen sources
+const sources = {};
+for (const code of [...seenSources].sort()) {
+	sources[code] = SOURCE_NAMES[code] ?? code;
+}
+
+const output = { sources, creatures };
+writeFileSync(OUTPUT_PATH, JSON.stringify(output));
+
+const rawSize = Buffer.byteLength(JSON.stringify(output));
+console.log(`Sources: ${Object.keys(sources).length}`);
+console.log(`Creatures: ${creatures.length}`);
+console.log(`Output size: ${(rawSize / 1024).toFixed(1)} KB`);
+
+const unmapped = [...seenSources].filter((s) => !SOURCE_NAMES[s]);
+if (unmapped.length > 0) {
+	console.log(`Unmapped sources: ${unmapped.sort().join(", ")}`);
+}

specs/003-combatant-state/spec.md

@@ -23,10 +23,15 @@ interface Combatant {
   readonly currentHp?: number;        // 0..maxHp
   readonly tempHp?: number;           // positive integer, damage buffer
   readonly ac?: number;               // non-negative integer
-  readonly conditions?: readonly ConditionId[];
+  readonly conditions?: readonly ConditionEntry[];
   readonly isConcentrating?: boolean;
   readonly creatureId?: CreatureId;   // link to bestiary entry
 }
+
+interface ConditionEntry {
+  readonly id: ConditionId;
+  readonly value?: number;  // PF2e valued conditions (e.g., Clumsy 2); undefined for D&D
+}
 ```
 
 ---
@@ -273,21 +278,41 @@ Acceptance scenarios:
 3. **Given** a combatant is NOT concentrating, **When** damage is taken, **Then** no pulse/flash occurs.
 4. **Given** a concentrating combatant takes damage, **When** the animation completes, **Then** the row returns to its normal concentration-active appearance.
 
-**Story CC-8 — Rules Edition Setting (P2)**
+**Story CC-8 — Game System Setting (P2)**
-As a DM who plays in both 5e (2014) and 5.5e (2024) groups, I want to choose which edition's condition descriptions appear in tooltips so I reference the correct rules for the game I am running.
+As a DM who runs games across D&D 5e, 5.5e, and Pathfinder 2e, I want to choose which game system the tracker uses so that conditions, bestiary search, stat block layout, and initiative calculation all match the game I am running.
 
 Acceptance scenarios:
 1. **Given** the user opens the kebab menu, **When** they click "Settings", **Then** a settings modal opens.
-2. **Given** the settings modal is open, **When** viewing the Conditions section, **Then** a rules edition selector shows 5e (2014) and 5.5e (2024) with 5.5e selected by default.
+2. **Given** the settings modal is open, **When** viewing the Game System section, **Then** a selector shows three options: D&D 5e (2014), D&D 5.5e (2024), and Pathfinder 2e, with D&D 5.5e selected by default.
-3. **Given** the user selects 5e (2014), **When** hovering a condition icon (e.g., Exhaustion), **Then** the tooltip shows the 2014 description.
+3. **Given** the user selects Pathfinder 2e, **When** viewing condition icons/tooltips, **Then** the PF2e condition set is used (Clumsy, Drained, Enfeebled, etc.) instead of D&D conditions.
-4. **Given** the user selects 5.5e (2024), **When** hovering the same condition, **Then** the tooltip shows the 2024 description.
+4. **Given** the user selects Pathfinder 2e, **When** searching creatures in the bestiary, **Then** results come from the PF2e index (~2,700+ creatures) instead of the D&D index.
-5. **Given** the user changes the edition and reloads the page, **Then** the selected edition is preserved.
+5. **Given** the user selects Pathfinder 2e, **When** viewing a creature stat block, **Then** the PF2e layout is shown (level, Fort/Ref/Will, ability modifiers, top/mid/bot ability sections).
-6. **Given** a condition with identical rules across editions (e.g., Deafened), **Then** the tooltip text is the same regardless of setting.
+6. **Given** the user selects Pathfinder 2e, **When** rolling initiative for a bestiary creature, **Then** Perception is used as the initiative modifier instead of DEX + proficiency.
-7. **Given** the settings modal is open, **When** viewing the Theme section, **Then** a System / Light / Dark selector is available, replacing the inline cycle button in the kebab menu.
+7. **Given** the user selects D&D 5e (2014), **When** hovering a condition icon (e.g., Exhaustion), **Then** the tooltip shows the 2014 description. **When** 5.5e (2024) is selected, **Then** the tooltip shows the 2024 description.
+8. **Given** the user changes the game system and reloads the page, **Then** the selected game system is preserved.
+9. **Given** a condition with identical rules across D&D editions (e.g., Deafened), **Then** the tooltip text is the same regardless of D&D edition.
+10. **Given** the settings modal is open, **When** viewing the Theme section, **Then** a System / Light / Dark selector is available, replacing the inline cycle button in the kebab menu.
+
+**Story CC-9 — Value-Based Conditions (P2)**
+As a DM running a PF2e encounter, I want conditions like Clumsy, Frightened, and Drained to carry an integer value so I can track escalating severity levels as defined by the PF2e rules.
+
+The condition picker uses the same counter pattern as the bestiary batch-add (see `specs/004-bestiary/spec.md`, US-S2): clicking a valued condition shows `[-] N [+] [✓]` controls inline; the user adjusts the value and confirms. Clicking a condition tag on the combatant row decrements the value by 1.
+
+Acceptance scenarios:
+1. **Given** the game system is Pathfinder 2e and the condition picker is open, **When** the user clicks an inactive valued condition (e.g., Frightened), **Then** the row shows a counter at value 1 with `[-]`, `[+]`, and `[✓]` (confirm) buttons — the condition is not yet applied.
+2. **Given** the counter is showing value 1, **When** the user clicks `[+]` twice, **Then** the counter shows value 3.
+3. **Given** the counter is showing a value, **When** the user clicks `[✓]` (confirm), **Then** the condition is applied at that value and its icon appears inline with the value as a badge.
+4. **Given** a combatant already has Frightened 2 and the picker is open, **When** the user clicks Frightened in the picker, **Then** the counter shows pre-filled at value 2 for adjustment.
+5. **Given** a combatant has Frightened 2, **When** the user clicks the Frightened icon tag on the row, **Then** the value decrements to 1.
+6. **Given** a combatant has Frightened 1, **When** the user clicks the Frightened icon tag on the row, **Then** the condition is removed entirely.
+7. **Given** a PF2e condition that is not valued (e.g., Prone, Off-Guard), **When** the user clicks it in the picker, **Then** it toggles on/off with no counter or value badge — identical to D&D condition behavior.
+8. **Given** the game system is D&D (5e or 5.5e), **When** interacting with conditions, **Then** no value counters or badges are shown and conditions toggle on/off as before.
+9. **Given** a combatant has Clumsy 3, **When** the user hovers over the condition icon, **Then** the tooltip shows the condition name, the current value, and the PF2e rules description.
+10. **Given** a valued condition counter is showing, **When** the user clicks a different valued condition, **Then** the previous counter is replaced (only one counter at a time).
 
 ### Requirements
 
-- **FR-032**: The MVP MUST support the following 15 standard D&D 5e/5.5e conditions: blinded, charmed, deafened, exhaustion, frightened, grappled, incapacitated, invisible, paralyzed, petrified, poisoned, prone, restrained, stunned, unconscious.
+- **FR-032**: When a D&D game system is active, the system MUST support the following 15 standard D&D 5e/5.5e conditions: blinded, charmed, deafened, exhaustion, frightened, grappled, incapacitated, invisible, paralyzed, petrified, poisoned, prone, restrained, stunned, unconscious. When Pathfinder 2e is active, the system MUST support the PF2e condition set (see FR-103).
 - **FR-033**: Each condition MUST have a fixed icon and color mapping (Lucide icons; no emoji):
 
   | Condition     | Icon       | Color   |
@@ -312,9 +337,9 @@ Acceptance scenarios:
 - **FR-035**: Conditions MUST be displayed in the fixed definition order (blinded -> unconscious), regardless of application order.
 - **FR-036**: The "+" condition button MUST be hidden by default and appear only on row hover (or touch/focus on touch devices).
 - **FR-037**: Clicking "+" MUST open the compact condition picker showing all conditions as icon + label pairs.
-- **FR-038**: Clicking a condition in the picker MUST toggle it on or off.
+- **FR-038**: Clicking a condition in the picker MUST toggle it on or off. For PF2e valued conditions, clicking MUST open an inline counter (same pattern as the bestiary batch-add count badge: `[-] N [+] [✓]`) instead of toggling immediately. The user adjusts the value and confirms with the `[✓]` button. Only one valued condition counter may be open at a time.
-- **FR-039**: Clicking an active condition icon tag in the row MUST remove that condition.
+- **FR-039**: For D&D conditions, clicking an active condition icon tag in the row MUST remove that condition. For PF2e valued conditions, clicking MUST decrement the value by 1; the condition is removed when the value reaches 0. For PF2e non-valued conditions, clicking removes the condition.
-- **FR-040**: Hovering an active condition icon MUST show a tooltip with the condition name and its rules description for the selected edition.
+- **FR-040**: Hovering an active condition icon MUST show a tooltip with the condition name and its rules description for the active game system. For PF2e valued conditions, the tooltip MUST also display the current value (e.g., "Frightened 2").
 - **FR-041**: Condition icons MUST NOT increase the row's width; row height MAY increase to accommodate wrapping.
 - **FR-042**: The condition picker MUST close when the user clicks outside of it.
 - **FR-043**: Conditions MUST persist as part of combatant state (surviving page reload).
@@ -330,6 +355,11 @@ Acceptance scenarios:
 - **FR-053**: When a concentrating combatant takes damage, the Brain icon and row accent MUST briefly pulse/flash for 700 ms.
 - **FR-054**: The pulse animation MUST NOT trigger on healing or when concentration is inactive.
 - **FR-055**: Concentration MUST persist across page reloads via existing storage.
+- **FR-103**: When Pathfinder 2e is active, the system MUST support the following PF2e conditions: blinded, clumsy (valued), concealed, confused, controlled, dazzled, deafened, doomed (valued), drained (valued), dying (valued), enfeebled (valued), fascinated, fatigued, fleeing, frightened (valued), grabbed, hidden, immobilized, off-guard, paralyzed, petrified, prone, quickened, restrained, sickened (valued), slowed (valued), stunned (valued), stupefied (valued), unconscious, undetected, wounded (valued).
+- **FR-104**: Each PF2e condition MUST have a fixed icon and color mapping (Lucide icons; no emoji). The icon/color table for PF2e conditions is defined separately from the D&D table (FR-033).
+- **FR-105**: For PF2e valued conditions, the condition icon tag MUST display the current value as a small numeric badge (e.g., "2" next to the Frightened icon). Non-valued PF2e conditions display without a badge.
+- **FR-106**: The condition data model MUST use `ConditionEntry` objects (`{ id: ConditionId, value?: number }`) instead of bare `ConditionId` values. D&D conditions MUST be stored without a `value` field (backwards-compatible).
+- **FR-107**: Switching the game system MUST NOT clear existing combatant conditions. Conditions from the previous game system that are not valid in the new system remain stored but are hidden from display until the user switches back.
 
 ### Edge Cases
 
@@ -340,9 +370,13 @@ Acceptance scenarios:
 - When concentration is toggled during an active pulse animation, the animation cancels and the new state applies immediately.
 - Multiple combatants may concentrate simultaneously; concentration is independent per combatant.
 - Conditions have no mechanical effects in the MVP baseline (no auto-disadvantage, no automation).
-- When the rules edition preference is missing from localStorage, the system defaults to 5.5e (2024).
+- When the game system preference is missing from localStorage, the system defaults to D&D 5.5e (2024).
-- Changing the edition while a condition tooltip is visible updates the tooltip on next hover (no live update required).
+- Changing the game system while a condition tooltip is visible updates the tooltip on next hover (no live update required).
 - The settings modal is app-level UI; it does not interact with encounter state.
+- When the game system is switched from D&D to PF2e, existing D&D conditions on combatants are hidden (not deleted). Switching back to D&D restores them.
+- PF2e valued condition at value 0 is treated as removed — it MUST NOT appear on the row.
+- Dying 4 in PF2e has special mechanical significance (death), but the system does not enforce this automatically — it displays the value only.
+- Persistent damage is excluded from the PF2e MVP condition set. It can be added as a follow-up feature.
 
 ---
 
@@ -410,12 +444,12 @@ Acceptance scenarios:
 - **FR-066**: System MUST display a d20 icon button in the initiative slot for every combatant that has a linked bestiary creature and does not yet have an initiative value.
 - **FR-067**: System MUST NOT display the d20 button for combatants without a linked bestiary creature; they see a "--" placeholder that is clickable to type a value.
 - **FR-068**: When the d20 button is clicked, the system MUST generate a uniform random integer in [1, 20], add the creature's initiative modifier, and set the result as the initiative value.
-- **FR-069**: The initiative modifier MUST be calculated as: DEX modifier + (proficiency multiplier x proficiency bonus), where DEX modifier = floor((DEX - 10) / 2) and proficiency bonus is derived from challenge rating.
+- **FR-069**: For D&D creatures, the initiative modifier MUST be calculated as: DEX modifier + (proficiency multiplier x proficiency bonus), where DEX modifier = floor((DEX - 10) / 2) and proficiency bonus is derived from challenge rating. For PF2e creatures, the initiative modifier MUST be the creature's Perception value from the index.
 - **FR-070**: The initiative proficiency multiplier MUST be read from `initiative.proficiency` in bestiary data (0 if absent, 1 for proficiency, 2 for expertise).
 - **FR-071**: System MUST provide a "Roll All Initiative" button in the top bar. Clicking it MUST roll for every bestiary-linked combatant that does not already have an initiative value; all others MUST be left unchanged.
 - **FR-072**: After any initiative roll (single or batch), the encounter list MUST re-sort descending per existing behavior.
 - **FR-073**: Once a combatant has an initiative value, the d20 button is replaced by the value as plain text using a click-to-edit pattern (consistent with AC and name editing).
-- **FR-074**: The stat block header MUST display initiative in the format "Initiative +X (Y)" where X is the modifier (with + or - sign) and Y = 10 + X.
+- **FR-074**: For D&D creatures, the stat block header MUST display initiative in the format "Initiative +X (Y)" where X is the modifier (with + or - sign) and Y = 10 + X. For PF2e creatures, the stat block MUST display "Perception +X" where X is the Perception modifier.
 - **FR-075**: The initiative display in the stat block MUST be positioned adjacent to the AC value, matching Monster Manual 2024 layout.
 - **FR-076**: No initiative line MUST be shown in the stat block for combatants without bestiary data.
 - **FR-077**: The initiative display in the stat block is display-only. It MUST NOT modify encounter turn order or trigger rolling automatically.
@@ -489,11 +523,11 @@ Acceptance scenarios:
 - **FR-093**: All interactive elements in the row MUST remain keyboard-accessible (focusable and operable via keyboard).
 - **FR-094**: On touch devices, hover-only controls ("+" button, "x" button) MUST remain accessible via tap or focus.
 - **FR-095**: The system MUST provide a settings modal accessible via a "Settings" item in the kebab overflow menu.
-- **FR-096**: The settings modal MUST include a Conditions section with a rules edition selector offering two options: 5e (2014) and 5.5e (2024).
+- **FR-096**: The settings modal MUST include a Game System section with a selector offering three options: D&D 5e (2014), D&D 5.5e (2024), and Pathfinder 2e. The label MUST read "Game System" (not "Conditions" or "Rules Edition").
-- **FR-097**: The default rules edition MUST be 5.5e (2024).
+- **FR-097**: The default game system MUST be D&D 5.5e (2024).
-- **FR-098**: Each condition definition MUST carry a description for both editions. Conditions with identical rules across editions MAY share a single description value.
+- **FR-098**: Each D&D condition definition MUST carry a description for both D&D editions. Each PF2e condition definition MUST carry a PF2e rules description. Conditions with identical rules across D&D editions MAY share a single description value.
-- **FR-099**: Condition tooltips MUST display the description corresponding to the active rules edition preference.
+- **FR-099**: Condition tooltips MUST display the description corresponding to the active game system. For D&D game systems, the tooltip uses the edition-specific description. For PF2e, the tooltip uses the PF2e description.
-- **FR-100**: The rules edition preference MUST persist across sessions via localStorage (key `"initiative:rules-edition"`).
+- **FR-100**: The game system preference MUST persist across sessions via localStorage (key `"initiative:game-system"`).
 - **FR-101**: The settings modal MUST include a Theme section with System / Light / Dark options, replacing the inline theme cycle button in the kebab menu.
 - **FR-102**: The settings modal MUST close on Escape, click-outside, or the close button.
 
@@ -539,6 +573,10 @@ Acceptance scenarios:
 - **SC-028**: The AC number is visually identifiable as armor class through the shield shape alone.
 - **SC-029**: No layout shift occurs when hovering/unhovering rows.
 - **SC-030**: All HP, AC, initiative, condition, and concentration interactions remain fully operable using only a keyboard.
-- **SC-031**: The user can switch rules edition in 2 interactions (open settings → select edition).
+- **SC-031**: The user can switch game system in 2 interactions (open settings → select system).
-- **SC-032**: Condition tooltips accurately reflect the selected edition's rules text for all conditions that differ between editions.
+- **SC-032**: Condition tooltips accurately reflect the active game system's rules text for all conditions.
-- **SC-033**: The rules edition preference survives a full page reload.
+- **SC-033**: The game system preference survives a full page reload.
+- **SC-034**: All PF2e conditions are available and visually distinguishable by icon and color when PF2e is the active game system.
+- **SC-035**: PF2e valued conditions display their current value and can be incremented/decremented within 1 click each.
+- **SC-036**: Switching game system immediately changes the available conditions, bestiary search results, stat block layout, and initiative calculation — no page reload required.
+- **SC-037**: The game system preference survives a full page reload.

specs/004-bestiary/spec.md

@@ -8,9 +8,11 @@
 
 ## Overview
 
-The Bestiary feature provides creature search across a pre-indexed library of 3,312+ creatures from 102+ D&D sources, stat block display for full creature reference during combat, source data management via on-demand fetch or file upload, and a dual-panel UX with collapse/expand and pin capabilities. Creatures can be added individually or in batch from a search dropdown, with stats pre-filled from the index.
+The Bestiary feature provides creature search across pre-indexed creature libraries: 3,312+ D&D creatures from 102+ sources and ~2,700+ Pathfinder 2e creatures from 79 Pf2eTools sources. The active game system setting (see `specs/003-combatant-state/spec.md`, FR-096) determines which index the search operates against. Stat block display, source management, and creature pre-fill all adapt to the active game system.
 
-The architecture uses a two-tier design: a lightweight search index (`data/bestiary/index.json`) shipped with the app containing mechanical facts for all creatures, and full stat block data loaded on-demand at the source level, normalized, and cached in IndexedDB.
+The feature also includes full creature reference via stat block display during combat, source data management via on-demand fetch or file upload, and a dual-panel UX with collapse/expand and pin capabilities. Creatures can be added individually or in batch from a search dropdown, with stats pre-filled from the index.
+
+The architecture uses a two-tier design: lightweight search indexes shipped with the app (one per game system) containing mechanical facts for all creatures, and full stat block data loaded on-demand at the source level, normalized, and cached in IndexedDB.
 
 **Structure**: This spec is organized by topic area. Each topic section contains its own user scenarios, requirements, and edge cases.
 
@@ -37,11 +39,11 @@ When the search input has no bestiary matches (or fewer than 2 characters typed)
 
 ### Requirements
 
-- **FR-001**: The app MUST ship a pre-generated search index (`data/bestiary/index.json`) containing creature name, source code, AC, HP average, DEX score, CR, initiative proficiency multiplier, size code, and creature type for all indexed creatures.
+- **FR-001**: The app MUST ship pre-generated search indexes for each supported game system. The D&D index (`data/bestiary/index.json`) MUST contain creature name, source code, AC, HP average, DEX score, CR, initiative proficiency multiplier, size code, and creature type. The PF2e index (`data/bestiary/pf2e-index.json`) MUST contain creature name, source code, AC, HP, level, Perception modifier, size, and creature type.
 - **FR-002**: The app MUST include a source display name map translating source codes to human-readable names (e.g., "XMM" -> "Monster Manual (2025)").
-- **FR-003**: Search MUST operate against the full shipped index — case-insensitive substring match on creature name, minimum 2 characters, maximum 10 results, sorted alphabetically.
+- **FR-003**: Search MUST operate against the shipped index corresponding to the active game system — case-insensitive substring match on creature name, minimum 2 characters, maximum 10 results, sorted alphabetically.
 - **FR-004**: Search results MUST display the source display name alongside the creature name.
-- **FR-005**: Adding a creature from search MUST populate name, HP, AC, and initiative data directly from the index without any network fetch.
+- **FR-005**: Adding a creature from search MUST populate name, HP, AC, and initiative data directly from the index without any network fetch. For D&D creatures, initiative data is the DEX-based modifier. For PF2e creatures, initiative data is the Perception modifier.
 - **FR-006**: The system MUST auto-number duplicate creature names (e.g., "Goblin 1", "Goblin 2") when multiple combatants share the same bestiary creature name. When a second copy is added, the existing combatant is renamed to include the suffix.
 - **FR-007**: Auto-numbered names MUST remain editable via the existing rename functionality.
 - **FR-008**: Combatants added from the bestiary MUST retain a link (`creatureId`) to their creature data so the stat block can be re-opened from the tracker.
@@ -67,6 +69,8 @@ When the search input has no bestiary matches (or fewer than 2 characters typed)
 10. **Given** the user types a name with no bestiary match, **When** the dropdown shows no results, **Then** optional input fields for initiative, AC, and max HP appear with visible labels.
 11. **Given** the optional fields are visible, **When** the user leaves all optional fields empty and submits, **Then** the creature is added with only the name (no stats pre-filled).
 12. **Given** the search input is open, **When** the user presses Escape, **Then** the search closes without adding a combatant.
+13. **Given** the game system is Pathfinder 2e, **When** the DM types "abo" in the search field, **Then** results show PF2e creatures (e.g., "Aboleth (Bestiary 1)") from the PF2e index, not D&D creatures.
+14. **Given** the game system is Pathfinder 2e, **When** the DM selects a PF2e creature, **Then** a combatant is added with name, HP, AC, and Perception as the initiative modifier.
 
 ### Edge Cases
 
@@ -97,7 +101,7 @@ As a DM using the app on different devices, I want the layout to adapt between s
 ### Requirements
 
 - **FR-016**: The system MUST display a stat block panel with full creature information when a creature is selected.
-- **FR-017**: The stat block MUST include: name, size, type, alignment, AC (with armor source if applicable), HP (average + formula), speed, ability scores with modifiers, saving throws, skills, damage vulnerabilities, damage resistances, damage immunities, condition immunities, senses, languages, challenge rating, proficiency bonus, passive perception, traits, actions, bonus actions, reactions, spellcasting, and legendary actions.
+- **FR-017**: For D&D creatures, the stat block MUST include: name, size, type, alignment, AC (with armor source if applicable), HP (average + formula), speed, ability scores with modifiers, saving throws, skills, damage vulnerabilities, damage resistances, damage immunities, condition immunities, senses, languages, challenge rating, proficiency bonus, passive perception, traits, actions, bonus actions, reactions, spellcasting, and legendary actions. For PF2e creatures, the stat block MUST include: name, level, traits (as tags), Perception and senses, languages, skills, ability modifiers (Str/Dex/Con/Int/Wis/Cha as modifiers, not scores), items, AC, saving throws (Fort/Ref/Will), HP (with optional immunities/resistances/weaknesses), speed, attacks, top abilities, mid abilities (reactions/auras), bot abilities (active), and spellcasting.
 - **FR-018**: Optional stat block sections (traits, legendary actions, bonus actions, reactions, etc.) MUST be omitted entirely when the creature has none.
 - **FR-019**: The system MUST strip bestiary markup tags (spell references, dice notation, attack tags) and render them as plain readable text (e.g., `{@spell fireball|XPHB}` -> "fireball", `{@dice 3d6}` -> "3d6").
 - **FR-020**: On wide viewports (desktop), the layout MUST be side-by-side with the encounter tracker on the left and stat block on the right.
@@ -105,6 +109,12 @@ As a DM using the app on different devices, I want the layout to adapt between s
 - **FR-022**: The stat block panel MUST scroll independently of the encounter tracker.
 - **FR-023**: When the user clicks the book icon on a different bestiary-linked combatant row, the stat block panel MUST update to show that creature's data.
 - **FR-024**: The existing search/view button MUST be repurposed to open the stat block for the currently focused/selected creature in the dropdown.
+- **FR-063**: The stat block renderer MUST select the appropriate layout (D&D or PF2e) based on the creature's game system. The creature's game system is determined by the index it was added from.
+- **FR-064**: PF2e stat blocks MUST display level in place of challenge rating. Level MUST appear in the stat block header.
+- **FR-065**: PF2e stat blocks MUST display three saving throws (Fortitude, Reflex, Will) instead of D&D's six ability-based saves.
+- **FR-066**: PF2e stat blocks MUST display ability modifiers directly (e.g., "Str +4") rather than ability scores with derived modifiers.
+- **FR-067**: PF2e stat blocks MUST organize abilities into three sections: top (above defenses), mid (reactions and auras), and bot (active abilities), matching the Pf2eTools source structure.
+- **FR-068**: PF2e stat blocks MUST strip Pf2eTools markup tags (e.g., `{@damage 1d8+7}`, `{@condition frightened}`) and render them as plain readable text, using the same tag-stripping approach as D&D (FR-019).
 - **FR-062**: Bestiary-linked combatant rows MUST display a small book icon (Lucide `BookOpen`) as the dedicated stat block trigger. The icon MUST have a tooltip ("View stat block") and an `aria-label="View stat block"` for accessibility. The book icon is the only way to manually open a stat block from the tracker — clicking the combatant name always enters inline rename mode. Non-bestiary combatant rows MUST NOT display the book icon.
 
 ### Acceptance Scenarios
@@ -119,6 +129,8 @@ As a DM using the app on different devices, I want the layout to adapt between s
 8. **Given** a bestiary-linked combatant row is visible, **When** the user looks at the row, **Then** a small book icon is visible as the stat block trigger with a tooltip "View stat block".
 9. **Given** a custom (non-bestiary) combatant row is visible, **When** the user looks at the row, **Then** no book icon is displayed.
 10. **Given** a bestiary-linked combatant row is visible, **When** the user clicks the combatant's name, **Then** inline rename mode is entered — the stat block does NOT open.
+11. **Given** a PF2e creature is selected, **When** the stat block opens, **Then** it displays: name, level, traits as tags, Perception, senses, languages, skills, ability modifiers, AC, Fort/Ref/Will saves, HP, speed, attacks, abilities (top/mid/bot sections), and spellcasting (if applicable). No CR, no ability scores, no legendary actions.
+12. **Given** a PF2e creature with conditional AC (e.g., "with shield raised"), **When** viewing the stat block, **Then** both the standard AC and conditional AC are shown.
 
 ### Edge Cases
 
@@ -164,7 +176,7 @@ A DM wants to see which sources are cached, find a specific source, clear a spec
 - **FR-034**: An import button (Lucide Import icon) in the top bar MUST open the stat block side panel with the bulk import prompt.
 - **FR-035**: The bulk import prompt MUST show a descriptive text explaining the operation, including approximate data volume (~12.5 MB) and the dynamic number of sources derived from the bestiary index at runtime.
 - **FR-036**: The system MUST pre-fill a base URL that the user can edit.
-- **FR-037**: The system MUST construct individual fetch URLs by appending `bestiary-{sourceCode}.json` to the base URL for each source.
+- **FR-037**: The system MUST construct individual fetch URLs by appending the appropriate filename pattern to the base URL: `bestiary-{sourceCode}.json` for D&D sources, `creatures-{sourceCode}.json` for PF2e sources (matching the Pf2eTools naming convention).
 - **FR-038**: All fetch requests during bulk import MUST fire concurrently (browser handles connection pooling).
 - **FR-039**: Already-cached sources MUST be skipped during bulk import.
 - **FR-040**: The system MUST show a text counter ("Loading sources... N/T") and progress bar during bulk import.
@@ -177,6 +189,10 @@ A DM wants to see which sources are cached, find a specific source, clear a spec
 - **FR-047**: The app MUST provide a management UI showing cached sources with a filter input for searching by display name and options to clear individual sources or all cached data.
 - **FR-048**: The normalization adapter and tag-stripping utility MUST remain the canonical pipeline for all fetched and uploaded data.
 - **FR-049**: The distributed app bundle MUST contain zero copyrighted prose content — only mechanical facts and creature names in the search index.
+- **FR-069**: The system MUST use a separate normalization pipeline for PF2e source data, mapping the Pf2eTools JSON structure to the PF2e creature type. Both pipelines (D&D and PF2e) MUST use the canonical tag-stripping utility.
+- **FR-070**: The source cache MUST be scoped by game system. D&D and PF2e sources MUST NOT collide in IndexedDB (e.g., both may have a source code "B1" but they are different sources).
+- **FR-071**: The bulk import prompt MUST adapt to the active game system: showing the correct source count, base URL (Pf2eTools for PF2e, 5etools for D&D), and approximate data volume for the active system.
+- **FR-072**: The source management UI MUST show only sources for the active game system.
 
 ### Acceptance Scenarios
 
@@ -199,6 +215,8 @@ A DM wants to see which sources are cached, find a specific source, clear a spec
 17. **Given** the source management UI is open, **When** the DM clears a single source, **Then** that source's data is removed; stat blocks for its creatures require re-fetching, while other cached sources remain.
 18. **Given** the source management UI is open, **When** the DM clears all cached data, **Then** all source data is removed and all stat blocks require re-fetching.
 19. **Given** many sources are cached, **When** the DM types a partial name in the filter input, **Then** only sources whose display name matches (case-insensitive) are shown.
+20. **Given** the game system is Pathfinder 2e, **When** the user clicks the import button, **Then** the bulk import prompt shows the PF2e source count (~79), a Pf2eTools-based URL, and a PF2e-appropriate data volume estimate.
+21. **Given** the game system is Pathfinder 2e and a PF2e source is cached, **When** the user opens a PF2e creature's stat block from that source, **Then** the PF2e stat block renders correctly from cached data.
 
 ### Edge Cases
 
@@ -273,8 +291,9 @@ As a DM with a creature pinned, I want to collapse the right (browse) panel inde
 
 ## Key Entities
 
-- **Search Index** (`BestiaryIndex`): Pre-shipped lightweight dataset keyed by name + source, containing mechanical facts (name, source code, AC, HP average, DEX score, CR, initiative proficiency multiplier, size, type) for all creatures. Sufficient for adding combatants; insufficient for rendering a full stat block.
+- **Search Index (D&D)** (`BestiaryIndex`): Pre-shipped lightweight dataset keyed by name + source, containing mechanical facts (name, source code, AC, HP average, DEX score, CR, initiative proficiency multiplier, size, type) for all creatures. Sufficient for adding combatants; insufficient for rendering a full stat block.
-- **Source** (`BestiarySource`): A D&D publication identified by a code (e.g., "XMM") with a display name (e.g., "Monster Manual (2025)"). Caching and fetching operate at the source level.
+- **Search Index (PF2e)** (`Pf2eBestiaryIndex`): Pre-shipped lightweight dataset for PF2e creatures, containing name, source code, AC, HP, level, Perception modifier, size, and creature type. Parallel to the D&D search index but with PF2e-specific fields (level instead of CR, Perception instead of DEX/proficiency).
+- **Source** (`BestiarySource`): A D&D or PF2e publication identified by a code (e.g., "XMM") with a display name (e.g., "Monster Manual (2025)"). Caching and fetching operate at the source level.
 - **Creature (Full)** (`Creature`): A complete creature record with all stat block data (traits, actions, legendary actions, spellcasting, etc.), available only after source data is fetched/uploaded and cached. Identified by a branded `CreatureId`.
 - **Cached Source Data**: The full normalized bestiary data for a single source, stored in IndexedDB. Contains complete creature stat blocks.
 - **Combatant** (extended): Gains an optional `creatureId` reference to a `Creature`, enabling stat block lookup and stat pre-fill on creation.
@@ -287,7 +306,7 @@ As a DM with a creature pinned, I want to collapse the right (browse) panel inde
 
 ## Success Criteria *(mandatory)*
 
-- **SC-001**: All 3,312+ indexed creatures are searchable immediately on app load, with search results appearing within 100ms of typing.
+- **SC-001**: All indexed creatures for the active game system (3,312+ D&D or ~2,700+ PF2e) are searchable immediately on app load, with search results appearing within 100ms of typing.
 - **SC-002**: Adding a creature from search to the encounter completes without any network request and within 200ms.
 - **SC-003**: After a source is cached, stat blocks for any creature from that source display within 200ms with no additional prompt.
 - **SC-004**: The distributed app bundle contains zero copyrighted prose content — only mechanical facts and creature names in the search index.
@@ -304,3 +323,7 @@ As a DM with a creature pinned, I want to collapse the right (browse) panel inde
 - **SC-015**: Users can pin a creature and browse a different creature's stat block simultaneously, without any additional navigation steps.
 - **SC-016**: The pinned panel is never visible on screens narrower than the dual-panel breakpoint, ensuring mobile usability is not degraded.
 - **SC-017**: All collapse/expand and pin/unpin interactions are discoverable through visible button controls without requiring documentation or tooltips.
+- **SC-018**: All ~2,700+ PF2e indexed creatures are searchable when PF2e is the active game system, with search results appearing within 100ms of typing.
+- **SC-019**: PF2e stat blocks render the correct layout (level, three saves, ability modifiers, ability sections) for all PF2e creatures — no D&D-specific fields (CR, ability scores, legendary actions) are shown.
+- **SC-020**: Switching game system immediately changes which creatures appear in search — no page reload required.
+- **SC-021**: Both D&D and PF2e search indexes ship bundled with the app; no network fetch is required to search creatures in either system.