Skip to content

A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!

78.7 KB
Raw Blame
// @vitest-environment happy-dom

import type { Resume } from "./draft";
import type { Proposal } from "@reactive-resume/resume/proposals";
import type { ResumeData } from "@reactive-resume/schema/resume/data";
import { act, renderHook } from "@testing-library/react";
import { afterEach, assert, beforeEach, describe, expect, it, vi } from "vite-plus/test";
import { i18n } from "@lingui/core";
import { ORPCError } from "@orpc/client";
import { applyResumeProposals } from "@reactive-resume/resume/proposals";
import { sortSectionItemsByPeriod } from "@reactive-resume/resume/section-sort";
import { parseResumeData } from "@reactive-resume/schema/resume/data";
import { defaultResumeData } from "@reactive-resume/schema/resume/default";
import {
	clearResumeDrafts,
	readUnsavedResumeData,
	savePendingChanges,
	saveResumeMetadata,
	useBuilderResumeUpdateSubscription,
	useResumeCleanup,
	useResumeStore,
	useResumeUpdateSubscription,
} from "./draft";

const orpcMocks = vi.hoisted(() => ({
	getResumeById: vi.fn(),
	importResume: vi.fn(),
	patchResume: vi.fn(),
	streamSubscribe: vi.fn(),
	updateResume: vi.fn(),
}));

const useBlockerMock = vi.hoisted(() => vi.fn());

const consumeEventIteratorMock = vi.hoisted(() => vi.fn());

const queryClientMock = vi.hoisted(() => ({
	setQueryData: vi.fn(),
}));

const routerParamsMock = vi.hoisted(() => ({
	value: {} as { resumeId?: string },
}));

const toastMocks = vi.hoisted(() => ({
	add: vi.fn(() => "sync-error-toast"),
	close: vi.fn(),
}));

type LeaveToast = {
	id?: string;
	timeout?: number;
	description: string;
	actionProps: { onClick: () => void };
	onClose: () => void;
};
const leaveToast = () =>
	(toastMocks.add.mock.calls as unknown as [LeaveToast][]).find(([toast]) => toast.id === "resume-leave-unsaved")?.[0];

vi.mock("@orpc/client", async (importOriginal) => ({
	ORPCError: (await importOriginal<typeof import("@orpc/client")>()).ORPCError,
	consumeEventIterator: consumeEventIteratorMock,
}));

vi.mock("@tanstack/react-query", () => ({
	useQueryClient: () => queryClientMock,
}));

vi.mock("@tanstack/react-router", () => ({
	useParams: () => routerParamsMock.value,
	useBlocker: useBlockerMock,
}));

vi.mock("@/libs/orpc/client", () => ({
	orpc: {
		documents: { key: () => ["documents"] },
		resume: {
			getById: {
				call: orpcMocks.getResumeById,
				queryOptions: ({ input }: { input: { id: string } }) => ({
					queryKey: ["resume", "getById", input.id],
				}),
			},
			import: { call: orpcMocks.importResume },
			patch: {
				call: orpcMocks.patchResume,
			},
			update: {
				call: orpcMocks.updateResume,
			},
		},
	},
	streamClient: {
		resume: {
			updates: {
				subscribe: orpcMocks.streamSubscribe,
			},
		},
	},
}));

vi.mock("@reactive-resume/ui/components/toast", () => ({
	toast: toastMocks,
}));

function cloneResumeData(data: ResumeData): ResumeData {
	return structuredClone(data);
}

function makeResume(id: string): Resume {
	return {
		id,
		name: "Resume",
		slug: id,
		tags: [],
		data: cloneResumeData(defaultResumeData),
		isLocked: false,
		isPublic: false,
		hasPassword: false,
		createdAt: new Date("2026-05-20T09:00:00.000Z"),
		updatedAt: new Date("2026-05-26T12:00:00.000Z"),
	};
}

function withBasicsName(resume: Resume, name: string): Resume {
	return {
		...resume,
		data: {
			...resume.data,
			basics: {
				...resume.data.basics,
				name,
			},
		},
	};
}

function experienceItem(
	id: string,
	company: string,
	period: string,
): ResumeData["sections"]["experience"]["items"][number] {
	return {
		id,
		company,
		position: "Engineer",
		location: "",
		period,
		description: "",
		hidden: false,
		website: { url: "", label: "", inlineLink: false },
		roles: [],
	};
}

function deferred<T>() {
	let resolve!: (value: T) => void;
	let reject!: (reason: unknown) => void;
	const promise = new Promise<T>((done, fail) => {
		resolve = done;
		reject = fail;
	});
	return { promise, resolve, reject };
}

async function flushMicrotasks() {
	await Promise.resolve();
	await Promise.resolve();
	await Promise.resolve();
}

describe("builder resume autosave", () => {
	it("waits for a queued edit after an in-flight save before navigating", async () => {
		const initial = makeResume("navigation-queued");
		useResumeStore.getState().initialize(initial);
		routerParamsMock.value = { resumeId: initial.id };
		const hook = renderHook(() => useResumeCleanup());
		const completions: Array<(resume: Resume) => void> = [];
		orpcMocks.updateResume.mockImplementation(
			() =>
				new Promise<Resume>((resolve) => {
					completions.push(resolve);
				}),
		);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "First";
		});
		await vi.advanceTimersByTimeAsync(500);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Latest";
		});
		const blocker = useBlockerMock.mock.lastCall?.[0];
		let settled = false;
		const result = blocker.shouldBlockFn({ next: { params: {} } }).then((blocked: boolean) => {
			settled = true;
			return blocked;
		});
		assert.exists(completions[0]);
		completions[0](withBasicsName(initial, "First"));
		await flushMicrotasks();
		expect(settled).toBe(false);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].data.basics.name).toBe("Latest");
		assert.exists(completions[1]);
		completions[1](withBasicsName(initial, "Latest"));
		expect(await result).toBe(false);
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Latest");
		hook.unmount();
	});

	it("ends a stalled navigation wait without aborting or discarding the pending save", async () => {
		const initial = makeResume("navigation-timeout");
		useResumeStore.getState().initialize(initial);
		routerParamsMock.value = { resumeId: initial.id };
		const hook = renderHook(() => useResumeCleanup());
		let complete!: (resume: Resume) => void;
		orpcMocks.updateResume.mockImplementationOnce(
			() =>
				new Promise<Resume>((resolve) => {
					complete = resolve;
				}),
		);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Pending name";
		});
		const blocker = useBlockerMock.mock.lastCall?.[0];
		let settled = false;
		const result = blocker.shouldBlockFn({ next: { params: {} } }).then((blocked: boolean) => {
			settled = true;
			return blocked;
		});
		await vi.advanceTimersByTimeAsync(10000);
		expect(settled).toBe(true);
		expect(await result).toBe(true);
		expect(useResumeStore.getState().saveStatus).toBe("saving");
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Pending name");
		expect(orpcMocks.updateResume.mock.lastCall?.[1].signal.aborted).toBe(false);

		orpcMocks.updateResume.mockResolvedValueOnce(withBasicsName(initial, "Latest name"));
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Latest name";
		});
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);
		complete(withBasicsName(initial, "Pending name"));
		await flushMicrotasks();
		expect(useResumeStore.getState().saveStatus).toBe("saved");
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Latest name");
		expect(await blocker.shouldBlockFn({ next: { params: {} } })).toBe(false);
		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(2);
		hook.unmount();
	});

	beforeEach(() => {
		vi.useFakeTimers();
		orpcMocks.getResumeById.mockReset();
		orpcMocks.importResume.mockReset();
		useBlockerMock.mockReset();
		useBlockerMock.mockReturnValue({ status: "idle" });
		orpcMocks.patchResume.mockReset();
		orpcMocks.streamSubscribe.mockReset();
		orpcMocks.updateResume.mockReset();
		consumeEventIteratorMock.mockReset();
		queryClientMock.setQueryData.mockClear();
		routerParamsMock.value = {};
		i18n.loadAndActivate({ locale: "en-US", messages: {} });
		toastMocks.add.mockClear();
		toastMocks.close.mockClear();
		clearResumeDrafts();
		window.localStorage.clear();
	});

	afterEach(() => {
		vi.clearAllTimers();
		vi.useRealTimers();
		vi.unstubAllGlobals();
		clearResumeDrafts();
		window.localStorage.clear();
	});

	it("keeps edits during a rename until its revision is acknowledged, preserving Undo", async () => {
		const store = useResumeStore.getState;
		const initial = makeResume("metadata-write");
		store().initialize(initial);
		const response = deferred<Resume>();
		const write = vi.fn(() => response.promise);
		const renaming = saveResumeMetadata(initial.id, write);
		await flushMicrotasks();
		expect(write).toHaveBeenCalledTimes(1);
		store().updateResumeData((draft) => {
			draft.basics.name = "Later name";
		});
		const renamed = { ...initial, name: "Renamed again", updatedAt: new Date(initial.updatedAt.getTime() + 1000) };
		const saved = { ...withBasicsName(renamed, "Later name"), updatedAt: new Date(renamed.updatedAt.getTime() + 1000) };
		orpcMocks.updateResume.mockResolvedValueOnce(saved);
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume).not.toHaveBeenCalled();
		response.resolve(renamed);
		await renaming;
		await flushMicrotasks();
		expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(renamed.updatedAt);
		expect(store().saveStatus).toBe("saved");
		expect(store().resume).toMatchObject({ name: "Renamed again", data: { basics: { name: "Later name" } } });
		store().replaceResumeFromServer(saved);
		expect(store().undoStack).toHaveLength(1);
	});

	it("takes its own lock revision as the base, so the next edit after unlocking saves without a conflict (RX-160)", async () => {
		const store = useResumeStore.getState;
		const initial = makeResume("lock-write");
		store().initialize(initial);
		store().updateResumeData((draft) => {
			draft.basics.name = "Before lock";
		});
		const saved = {
			...withBasicsName(initial, "Before lock"),
			updatedAt: new Date(initial.updatedAt.getTime() + 1000),
		};
		orpcMocks.updateResume.mockResolvedValueOnce(saved);
		await vi.advanceTimersByTimeAsync(500);
		// The lock endpoint answers with the resume as it left it, like resume.update.
		const answer = (base: Resume, isLocked: boolean) => (expectedUpdatedAt?: Date) => {
			if (expectedUpdatedAt?.getTime() !== base.updatedAt.getTime()) throw new ORPCError("RESUME_VERSION_CONFLICT");
			return Promise.resolve({ ...base, isLocked, updatedAt: new Date(base.updatedAt.getTime() + 1000) });
		};
		const locked = await saveResumeMetadata(initial.id, answer(saved, true));
		expect(store().resume?.isLocked).toBe(true);
		const unlocked = await saveResumeMetadata(initial.id, answer(locked, false));
		expect(store().resume?.isLocked).toBe(false);
		store().updateResumeData((draft) => {
			draft.basics.headline = "After unlock";
		});
		orpcMocks.updateResume.mockResolvedValueOnce({
			...unlocked,
			updatedAt: new Date(unlocked.updatedAt.getTime() + 1000),
		});
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(unlocked.updatedAt);
		expect(store().saveStatus).toBe("saved");
		expect(store().undoStack.length).toBeGreaterThan(0);
	});

	it("unlocks without waiting for edits a lock stopped, then builds on the unlock when the data is unchanged (RX-160)", async () => {
		const store = useResumeStore.getState;
		const initial = makeResume("unlock-write");
		store().initialize(initial);
		// A lock from elsewhere stops this edit's save.
		orpcMocks.updateResume.mockRejectedValueOnce(new ORPCError("RESUME_LOCKED", { status: 403 }));
		store().updateResumeData((draft) => {
			draft.basics.name = "Waiting edit";
		});
		await vi.advanceTimersByTimeAsync(500);
		const unlocked = { ...initial, isLocked: false, updatedAt: new Date(initial.updatedAt.getTime() + 2000) };
		const write = vi.fn(async (expectedUpdatedAt?: Date) => {
			expect(expectedUpdatedAt).toEqual(initial.updatedAt);
			return unlocked;
		});
		await saveResumeMetadata(initial.id, write, { savePending: false });
		expect(write).toHaveBeenCalledTimes(1);
		orpcMocks.updateResume.mockResolvedValueOnce({
			...withBasicsName(unlocked, "Waiting edit"),
			updatedAt: new Date(unlocked.updatedAt.getTime() + 1000),
		});
		store().retrySave();
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(unlocked.updatedAt);
	});

	it("finishes an in-flight body save before renaming, then saves from the rename revision", async () => {
		const initial = makeResume("metadata-inflight");
		useResumeStore.getState().initialize(initial);
		const body = deferred<Resume>();
		const saved = {
			...withBasicsName(initial, "Before rename"),
			updatedAt: new Date(initial.updatedAt.getTime() + 1000),
		};
		const flushed = { ...saved, updatedAt: new Date(saved.updatedAt.getTime() + 1000) };
		orpcMocks.updateResume.mockImplementationOnce(() => body.promise).mockResolvedValueOnce(flushed);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Before rename";
		});
		await vi.advanceTimersByTimeAsync(500);
		const renamed = { ...flushed, name: "Manual title", updatedAt: new Date(flushed.updatedAt.getTime() + 1000) };
		const write = vi.fn(async (expectedUpdatedAt?: Date) => {
			if (expectedUpdatedAt?.getTime() !== flushed.updatedAt.getTime()) throw new ORPCError("RESUME_VERSION_CONFLICT");
			return renamed;
		});
		const renaming = saveResumeMetadata(initial.id, write);
		await flushMicrotasks();
		expect(write).not.toHaveBeenCalled();
		body.resolve(saved);
		await renaming;
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.headline = "After rename";
		});
		orpcMocks.updateResume.mockResolvedValueOnce({ ...renamed, data: useResumeStore.getState().resume?.data });
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(renamed.updatedAt);
		expect(useResumeStore.getState().resume?.name).toBe("Manual title");
	});

	it("waits for an own metadata response before applying its early stream echo", async () => {
		const initial = makeResume("metadata-early-echo");
		routerParamsMock.value = { resumeId: initial.id };
		useResumeStore.getState().initialize(initial);
		const saved = { ...withBasicsName(initial, "Saved name"), updatedAt: new Date(initial.updatedAt.getTime() + 1000) };
		orpcMocks.updateResume.mockResolvedValueOnce(saved);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Saved name";
		});
		await vi.advanceTimersByTimeAsync(500);
		const response = deferred<Resume>();
		const renamed = { ...saved, name: "Manual title", updatedAt: new Date(saved.updatedAt.getTime() + 1000) };
		const writing = saveResumeMetadata(initial.id, () => response.promise);
		await flushMicrotasks();
		orpcMocks.getResumeById.mockResolvedValueOnce(renamed);
		consumeEventIteratorMock.mockReturnValueOnce(async () => undefined);
		const hook = renderHook(() => useBuilderResumeUpdateSubscription());
		const handler = consumeEventIteratorMock.mock.lastCall?.[1].onEvent;
		assert(handler);
		const event = handler({ mutation: "update" });
		await flushMicrotasks();
		expect(useResumeStore.getState().undoStack).toHaveLength(1);
		expect(useResumeStore.getState().resume?.name).toBe(saved.name);
		response.resolve(renamed);
		await writing;
		await event;
		expect(useResumeStore.getState().undoStack).toHaveLength(1);
		expect(useResumeStore.getState().resume?.name).toBe("Manual title");
		hook.unmount();
	});

	it("releases a stalled metadata request and stream, ignoring its late answer", async () => {
		const initial = makeResume("metadata-stalled");
		routerParamsMock.value = { resumeId: initial.id };
		useResumeStore.getState().initialize(initial);
		const answer = deferred<Resume>();
		const write = vi.fn((_expected?: Date, _options?: { signal: AbortSignal }) => answer.promise);
		let failure: unknown;
		const writing = saveResumeMetadata(initial.id, write).catch((error: unknown) => {
			failure = error;
		});
		await flushMicrotasks();
		const remote = {
			...withBasicsName(initial, "Remote body"),
			name: "Remote title",
			updatedAt: new Date(initial.updatedAt.getTime() + 2000),
		};
		orpcMocks.getResumeById.mockResolvedValueOnce(remote);
		consumeEventIteratorMock.mockReturnValueOnce(async () => undefined);
		const hook = renderHook(() => useBuilderResumeUpdateSubscription());
		const event = consumeEventIteratorMock.mock.lastCall?.[1].onEvent({ mutation: "update" });
		await flushMicrotasks();
		expect(useResumeStore.getState().resume?.data.basics.name).toBe(initial.data.basics.name);
		await vi.advanceTimersByTimeAsync(10_000);
		expect(failure).toMatchObject({ name: "TimeoutError" });
		await writing;
		await event;
		expect(write.mock.lastCall?.[1]?.signal.aborted).toBe(true);
		expect(useResumeStore.getState().resume).toMatchObject(remote);
		answer.resolve({ ...initial, name: "Late title", updatedAt: new Date(initial.updatedAt.getTime() + 1000) });
		await flushMicrotasks();
		expect(useResumeStore.getState().resume).toMatchObject(remote);
		const next = { ...remote, name: "Next title", updatedAt: new Date(remote.updatedAt.getTime() + 1000) };
		const nextWrite = vi.fn(async (expected?: Date) => {
			expect(expected).toEqual(remote.updatedAt);
			return next;
		});
		await saveResumeMetadata(initial.id, nextWrite);
		expect(useResumeStore.getState().resume?.name).toBe(next.name);
		hook.unmount();
	});

	it("refuses an unversioned metadata write without an open draft", async () => {
		const answer = deferred<Resume>();
		const write = vi.fn((_expected?: Date, _options?: { signal: AbortSignal }) => answer.promise);
		let failure: unknown;
		const writing = saveResumeMetadata("library-rename", write).catch((error: unknown) => {
			failure = error;
		});
		await vi.advanceTimersByTimeAsync(10_000);
		expect(failure).toMatchObject({ name: "AbortError" });
		await writing;
		expect(write).not.toHaveBeenCalled();
		answer.resolve(makeResume("library-rename"));
	});

	it("invalidates unproven same-body revisions after metadata timeout, including receipt history", async () => {
		const store = useResumeStore.getState;
		const initial = makeResume("metadata-unproven-echo");
		routerParamsMock.value = { resumeId: initial.id };
		store().initialize(initial);
		let server = initial;
		orpcMocks.updateResume.mockImplementation(async ({ data }: { data: ResumeData }) => {
			server = { ...server, data, updatedAt: new Date(server.updatedAt.getTime() + 1000) };
			return server;
		});
		store().updateResumeData(
			(draft) => {
				draft.summary.content = "<p>Accepted</p>";
			},
			{ newStep: true, applied: [{ id: "edit", after: "<p>Accepted</p>" }] },
		);
		expect(await savePendingChanges(initial.id)).toBe(true);
		store().updateResumeData(
			(draft) => {
				draft.basics.headline = "Later edit";
			},
			{ newStep: true },
		);
		expect(await savePendingChanges(initial.id)).toBe(true);
		store().undo();
		expect(await savePendingChanges(initial.id)).toBe(true);
		expect(store().undoStack).toHaveLength(1);
		expect(store().redoStack).toHaveLength(1);
		expect(store().proposalApplications).toEqual({ edit: "<p>Accepted</p>" });

		const answer = deferred<Resume>();
		const writing = saveResumeMetadata(initial.id, () => answer.promise);
		const rejected = expect(writing).rejects.toMatchObject({ name: "TimeoutError" });
		await flushMicrotasks();
		// This read is indistinguishable from a rename followed by another client's receipt-only Undo.
		const remote = { ...server, name: "Unproven rename", updatedAt: new Date(server.updatedAt.getTime() + 1000) };
		orpcMocks.getResumeById.mockResolvedValueOnce(remote);
		consumeEventIteratorMock.mockReturnValueOnce(async () => undefined);
		const hook = renderHook(() => useBuilderResumeUpdateSubscription());
		const event = consumeEventIteratorMock.mock.lastCall?.[1].onEvent({ mutation: "update" });
		await vi.advanceTimersByTimeAsync(10_000);
		await rejected;
		await event;
		expect(store().resume?.data).toEqual(server.data);
		expect(store().undoStack).toEqual([]);
		expect(store().redoStack).toEqual([]);
		expect(store().proposalApplications).toEqual({});
		answer.resolve(remote);
		await flushMicrotasks();
		store().redo();
		expect(store().proposalApplications).toEqual({});
		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(3);
		hook.unmount();
	});

	it("keeps pending edits and receipts on the old revision after an uncertain metadata timeout", async () => {
		const initial = makeResume("metadata-stalled-draft");
		useResumeStore.getState().initialize(initial);
		const answer = deferred<Resume>();
		let failure: unknown;
		const writing = saveResumeMetadata(initial.id, () => answer.promise).catch((error: unknown) => {
			failure = error;
		});
		await flushMicrotasks();
		useResumeStore.getState().updateResumeData(
			(draft) => {
				draft.summary.content = "<p>Keep this proposal</p>";
			},
			{ newStep: true, applied: [{ id: "pending-proposal", after: "<p>Keep this proposal</p>" }] },
		);
		orpcMocks.updateResume.mockRejectedValueOnce(new ORPCError("RESUME_VERSION_CONFLICT"));
		await vi.advanceTimersByTimeAsync(10_000);
		expect(failure).toMatchObject({ name: "TimeoutError" });
		await writing;
		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(initial.updatedAt);
		expect(useResumeStore.getState().saveStatus).toBe("conflict");
		expect(useResumeStore.getState().undoStack).toHaveLength(1);
		expect(useResumeStore.getState().resume?.data.summary.content).toBe("<p>Keep this proposal</p>");
		const recovery = Object.entries(window.localStorage).find(([key]) => key.includes(initial.id));
		assert(recovery);
		expect(JSON.parse(recovery[1])).toMatchObject({
			baseUpdatedAt: initial.updatedAt.toISOString(),
			pendingProposalApplications: { "pending-proposal": "<p>Keep this proposal</p>" },
		});
		answer.resolve({ ...initial, name: "Late title", updatedAt: new Date(initial.updatedAt.getTime() + 1000) });
		await flushMicrotasks();
		expect(useResumeStore.getState().resume?.name).toBe(initial.name);
		expect(useResumeStore.getState().saveStatus).toBe("conflict");
		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);
	});

	it("keeps the draft and does not send metadata if its earlier body save failed", async () => {
		const initial = makeResume("metadata-flush-error");
		useResumeStore.getState().initialize(initial);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Unsaved name";
		});
		orpcMocks.updateResume.mockRejectedValueOnce(new Error("Network failure"));
		const write = vi.fn(async () => initial);
		await expect(saveResumeMetadata(initial.id, write)).rejects.toThrow("Couldn't save your changes");
		expect(write).not.toHaveBeenCalled();
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Unsaved name");
		expect(useResumeStore.getState().saveStatus).toBe("error");
	});

	it.each([false, true])("serializes separate metadata requests after earlier failure=%s", async (fails) => {
		const initial = makeResume("metadata-serialized");
		useResumeStore.getState().initialize(initial);
		const first = deferred<Resume>();
		const earlier = saveResumeMetadata(initial.id, () => first.promise).catch((error: unknown) => error);
		const renamed = { ...initial, name: "Second request", updatedAt: new Date(initial.updatedAt.getTime() + 2000) };
		const write = vi.fn(async (expected?: Date) => {
			expect(expected).toEqual(fails ? initial.updatedAt : new Date(initial.updatedAt.getTime() + 1000));
			return renamed;
		});
		const later = saveResumeMetadata(initial.id, write);
		await flushMicrotasks();
		expect(write).not.toHaveBeenCalled();
		if (fails) first.reject(new Error("Metadata rejected"));
		else first.resolve({ ...initial, name: "First request", updatedAt: new Date(initial.updatedAt.getTime() + 1000) });
		await earlier;
		await later;
		expect(write).toHaveBeenCalledTimes(1);
		expect(useResumeStore.getState().resume?.name).toBe("Second request");
	});

	it("never sends a queued metadata write after its visit is cleared", async () => {
		const initial = makeResume("metadata-cancelled");
		useResumeStore.getState().initialize(initial);
		const first = deferred<Resume>();
		const earlier = saveResumeMetadata(initial.id, () => first.promise);
		const earlierRejected = expect(earlier).rejects.toMatchObject({ name: "AbortError" });
		await flushMicrotasks();
		const write = vi.fn(async () => initial);
		const later = saveResumeMetadata(initial.id, write);
		const rejected = expect(later).rejects.toMatchObject({ name: "AbortError" });
		clearResumeDrafts();
		first.resolve(initial);
		await earlierRejected;
		await rejected;
		expect(write).not.toHaveBeenCalled();
	});

	it("never applies an old visit's delayed metadata stream event to a new visit", async () => {
		const initial = makeResume("metadata-stream-visit");
		routerParamsMock.value = { resumeId: initial.id };
		useResumeStore.getState().initialize(initial);
		const response = deferred<Resume>();
		const writing = saveResumeMetadata(initial.id, () => response.promise);
		const rejected = expect(writing).rejects.toMatchObject({ name: "AbortError" });
		await flushMicrotasks();
		const old = { ...withBasicsName(initial, "Old visit"), updatedAt: new Date(initial.updatedAt.getTime() + 1000) };
		orpcMocks.getResumeById.mockResolvedValueOnce(old);
		consumeEventIteratorMock.mockReturnValueOnce(async () => undefined);
		const hook = renderHook(() => useBuilderResumeUpdateSubscription());
		const event = consumeEventIteratorMock.mock.lastCall?.[1].onEvent({ mutation: "update" });
		await flushMicrotasks();
		clearResumeDrafts();
		const current = withBasicsName(initial, "New visit");
		useResumeStore.getState().initialize(current);
		await rejected;
		await event;
		response.resolve(old);
		await flushMicrotasks();
		expect(useResumeStore.getState().resume).toMatchObject(current);
		hook.unmount();
	});

	it("does not send metadata if its visit ends while the pending-save check settles", async () => {
		const initial = makeResume("metadata-flush-cancelled");
		useResumeStore.getState().initialize(initial);
		const write = vi.fn(async () => initial);
		const saving = saveResumeMetadata(initial.id, write);
		const rejected = expect(saving).rejects.toMatchObject({ name: "AbortError" });
		await Promise.resolve();
		clearResumeDrafts();
		await rejected;
		expect(write).not.toHaveBeenCalled();
	});

	it("recognizes a metadata-only write when stored data still needs read normalization", async () => {
		const initial = makeResume("metadata-legacy");
		const raw = cloneResumeData(initial.data);
		delete raw.summary.showHeading;
		for (const section of Object.values(raw.sections)) delete section.showHeading;
		initial.data = parseResumeData(raw);
		useResumeStore.getState().initialize(initial);
		const renamed = {
			...initial,
			data: raw,
			name: "Renamed legacy",
			updatedAt: new Date(initial.updatedAt.getTime() + 1000),
		};
		await saveResumeMetadata(initial.id, async () => renamed);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.headline = "After legacy rename";
		});
		orpcMocks.updateResume.mockResolvedValueOnce({ ...renamed, data: useResumeStore.getState().resume?.data });
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(renamed.updatedAt);
	});

	it("does not certify an unseen receipt-only revision through a metadata write", async () => {
		const store = useResumeStore.getState;
		const initial = makeResume("metadata-foreign-receipt");
		initial.data.summary.content = "<p>Original</p>";
		store().initialize(initial);
		let server = initial;
		orpcMocks.updateResume.mockImplementation(async ({ data }: { data: ResumeData }) => {
			server = { ...server, data, updatedAt: new Date(server.updatedAt.getTime() + 1000) };
			return server;
		});
		store().updateResumeData(
			(draft) => {
				draft.summary.content = "<p>Accepted</p>";
			},
			{ newStep: true, applied: [{ id: "edit", after: "<p>Accepted</p>" }] },
		);
		expect(await savePendingChanges(initial.id)).toBe(true);
		store().updateResumeData((draft) => {
			draft.summary.content = initial.data.summary.content;
		});
		expect(await savePendingChanges(initial.id)).toBe(true);
		const acceptedRevision = server.updatedAt;
		// Another client undoes only the receipt; body equality cannot prove the revision is ours.
		server = { ...server, updatedAt: new Date(server.updatedAt.getTime() + 1000) };
		const write = vi.fn(async (expectedUpdatedAt?: Date) => {
			if (expectedUpdatedAt && expectedUpdatedAt.getTime() !== server.updatedAt.getTime())
				throw new ORPCError("RESUME_VERSION_CONFLICT");
			server = { ...server, name: "Renamed", updatedAt: new Date(server.updatedAt.getTime() + 1000) };
			return server;
		});
		await expect(saveResumeMetadata(initial.id, write)).rejects.toMatchObject({ code: "RESUME_VERSION_CONFLICT" });
		expect(write).toHaveBeenCalledTimes(1);
		expect(server.name).toBe(initial.name);
		expect(store().resume?.updatedAt).toEqual(acceptedRevision);
		store().replaceResumeFromServer(server);
		expect(store().proposalApplications).toEqual({});
		expect(store().undoStack).toEqual([]);
		const recovery = Object.entries(window.localStorage).filter(([key]) => key.includes(initial.id));
		expect(recovery).toEqual([]);
	});

	it.each([
		[
			"another write came in between",
			(resume: Resume) => withBasicsName(resume, "From another tab"),
			1000,
			false,
			"Renamed",
		],
		["it answers an earlier visit", (resume: Resume) => resume, 1000, true, "Resume"],
		["the visit already holds a newer revision", (resume: Resume) => resume, -1000, false, "Resume"],
	])("keeps the autosave revision when a rename response %s", async (_, server, ms, revisit, name) => {
		const initial = makeResume("metadata-write-guarded");
		useResumeStore.getState().initialize(initial);
		const answer = deferred<Resume>();
		const writing = saveResumeMetadata(initial.id, () => answer.promise);
		const result = revisit ? expect(writing).rejects.toMatchObject({ name: "AbortError" }) : writing;
		await flushMicrotasks();
		if (revisit) {
			clearResumeDrafts();
			useResumeStore.getState().initialize(initial);
		}
		answer.resolve({ ...server(initial), name: "Renamed", updatedAt: new Date(initial.updatedAt.getTime() + ms) });
		await result;
		expect(useResumeStore.getState().resume?.name).toBe(name);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.headline = "Later headline";
		});
		orpcMocks.updateResume.mockResolvedValueOnce(initial);
		await vi.advanceTimersByTimeAsync(500);

		expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(initial.updatedAt);
	});

	it("keeps a failed draft in the builder and retries on the next navigation", async () => {
		const initial = makeResume("navigation-error");
		useResumeStore.getState().initialize(initial);
		routerParamsMock.value = { resumeId: initial.id };
		const hook = renderHook(() => useResumeCleanup());
		orpcMocks.updateResume.mockRejectedValueOnce(new Error("Offline"));
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Keep this draft";
		});
		const blocker = useBlockerMock.mock.lastCall?.[0];
		expect(blocker).toBeDefined();
		expect(await blocker.shouldBlockFn({ next: { params: {} } })).toBe(true);
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Keep this draft");
		expect(blocker.enableBeforeUnload()).toBe(true);
		orpcMocks.updateResume.mockResolvedValueOnce(withBasicsName(initial, "Keep this draft"));
		expect(await blocker.shouldBlockFn({ next: { params: {} } })).toBe(false);
		expect(blocker.enableBeforeUnload()).toBe(false);
		hook.unmount();
	});

	it("says a save failed because the resume was locked, and sends it once unlocked (L3-05)", async () => {
		const initial = makeResume("locked-save");
		useResumeStore.getState().initialize(initial);
		orpcMocks.updateResume.mockRejectedValueOnce(new ORPCError("RESUME_LOCKED"));
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Typed before the lock";
		});
		await vi.advanceTimersByTimeAsync(500);
		await flushMicrotasks();
		expect(useResumeStore.getState().saveStatus).toBe("locked");

		// Locking and unlocking moved the server's revision; the content is still what the edit builds on.
		const unlockedAt = new Date(initial.updatedAt.getTime() + 2000);
		orpcMocks.getResumeById.mockResolvedValueOnce({ ...initial, updatedAt: unlockedAt });
		orpcMocks.updateResume.mockResolvedValueOnce({
			...withBasicsName(initial, "Typed before the lock"),
			updatedAt: new Date(unlockedAt.getTime() + 1000),
		});
		useResumeStore.setState((state) => {
			if (state.resume) state.resume.isLocked = true;
		});
		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);
		useResumeStore.setState((state) => {
			if (state.resume) state.resume.isLocked = false;
		});
		await flushMicrotasks();
		await flushMicrotasks();
		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(2);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].data.basics.name).toBe("Typed before the lock");
		expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(unlockedAt);
	});

	it("explains a blocked leave and lets the user leave with the draft kept (L3-05)", () => {
		const initial = makeResume("leave-anyway");
		useResumeStore.getState().initialize(initial);
		useResumeStore.getState().setSaveStatus("error");
		routerParamsMock.value = { resumeId: initial.id };
		const proceed = vi.fn();
		const reset = vi.fn();
		useBlockerMock.mockReturnValue({ status: "blocked", proceed, reset });
		const hook = renderHook(() => useResumeCleanup());
		const shown = leaveToast();
		assert(shown);
		expect(shown.timeout).toBe(0);
		expect(shown.description).toContain("Couldn't save your latest changes");
		shown.actionProps.onClick();
		shown.onClose();
		expect(proceed).toHaveBeenCalledTimes(1);
		expect(reset).not.toHaveBeenCalled();
		hook.unmount();
	});

	it("stays when the leave toast is dismissed", () => {
		const initial = makeResume("leave-dismissed");
		useResumeStore.getState().initialize(initial);
		useResumeStore.getState().setSaveStatus("offline");
		routerParamsMock.value = { resumeId: initial.id };
		const proceed = vi.fn();
		const reset = vi.fn();
		useBlockerMock.mockReturnValue({ status: "blocked", proceed, reset });
		const hook = renderHook(() => useResumeCleanup());
		const shown = leaveToast();
		assert(shown);
		shown.onClose();
		expect(reset).toHaveBeenCalledTimes(1);
		expect(proceed).not.toHaveBeenCalled();
		hook.unmount();
	});

	it("initializes and autosaves rapid edits without crypto.randomUUID (HTTP LAN origins)", async () => {
		vi.stubGlobal("crypto", { getRandomValues: crypto.getRandomValues.bind(crypto) });
		const initial = makeResume("resume-rapid");
		const updated = withBasicsName(initial, "Latest Name");
		orpcMocks.updateResume.mockResolvedValue(updated);
		useResumeStore.getState().initialize(initial);
		expect(useResumeStore.getState().isReady).toBe(true);

		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "First Name";
		});
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Latest Name";
		});

		vi.advanceTimersByTime(500);
		await flushMicrotasks();

		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);
		expect(orpcMocks.updateResume).toHaveBeenCalledWith(
			{
				id: initial.id,
				data: updated.data,
				expectedUpdatedAt: initial.updatedAt,
				sessionId: expect.any(String),
				proposalSafety: "v1",
			},
			expect.objectContaining({ signal: expect.any(AbortSignal) }),
		);
		expect(orpcMocks.patchResume).not.toHaveBeenCalled();
		expect(useResumeStore.getState().saveStatus).toBe("saved");
	});

	it("saves the latest pending snapshot after an in-flight save resolves", async () => {
		const initial = makeResume("resume-in-flight");
		const first = { ...withBasicsName(initial, "First Name"), updatedAt: new Date(initial.updatedAt.getTime() + 1) };
		const latest = { ...withBasicsName(initial, "Latest Name"), updatedAt: new Date(first.updatedAt.getTime() + 1) };
		let resolveFirst!: (resume: Resume) => void;

		orpcMocks.updateResume
			.mockReturnValueOnce(
				new Promise<Resume>((resolve) => {
					resolveFirst = resolve;
				}),
			)
			.mockResolvedValueOnce(latest);

		useResumeStore.getState().initialize(initial);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "First Name";
		});

		vi.advanceTimersByTime(500);
		await flushMicrotasks();

		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Latest Name";
		});
		vi.advanceTimersByTime(500);
		await flushMicrotasks();

		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);

		resolveFirst(first);
		await flushMicrotasks();

		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(2);
		expect(orpcMocks.updateResume.mock.calls[0]?.[0]).toEqual({
			id: initial.id,
			data: first.data,
			expectedUpdatedAt: initial.updatedAt,
			sessionId: expect.any(String),
			proposalSafety: "v1",
		});
		expect(orpcMocks.updateResume.mock.calls[1]?.[0]).toEqual({
			id: initial.id,
			data: latest.data,
			expectedUpdatedAt: first.updatedAt,
			sessionId: expect.any(String),
			proposalSafety: "v1",
		});
		expect(orpcMocks.patchResume).not.toHaveBeenCalled();
	});

	it("reports offline, keeps the draft on this device and sends it when the connection returns", async () => {
		const initial = makeResume("resume-offline");
		const onLine = vi.spyOn(navigator, "onLine", "get").mockReturnValue(false);
		orpcMocks.updateResume.mockRejectedValueOnce(new TypeError("Failed to fetch"));
		useResumeStore.getState().initialize(initial);

		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Written offline";
		});
		vi.advanceTimersByTime(500);
		await flushMicrotasks();

		expect(useResumeStore.getState().saveStatus).toBe("offline");
		expect(readUnsavedResumeData("resume-offline")?.basics.name).toBe("Written offline");
		orpcMocks.updateResume.mockRejectedValueOnce(new TypeError("Failed to fetch"));
		expect(await savePendingChanges("resume-offline")).toBe(false);
		expect(toastMocks.add).toHaveBeenCalledWith(
			expect.objectContaining({ id: "resume-offline-navigation", description: expect.stringContaining("Reconnect") }),
		);

		onLine.mockReturnValue(true);
		orpcMocks.updateResume.mockImplementation((input: { id: string; data: ResumeData }) =>
			Promise.resolve({ ...makeResume(input.id), data: input.data }),
		);
		window.dispatchEvent(new Event("online"));
		await flushMicrotasks();
		await flushMicrotasks();

		expect(orpcMocks.updateResume).toHaveBeenLastCalledWith(
			expect.objectContaining({ id: "resume-offline" }),
			expect.anything(),
		);
		expect(useResumeStore.getState().saveStatus).toBe("saved");
		expect(readUnsavedResumeData("resume-offline")).toBeUndefined();
		onLine.mockRestore();
	});

	it("does not recreate private recovery data after account cleanup during a failed save", async () => {
		let failSave = (_error: Error): void => {
			throw new Error("Save did not start");
		};
		const pending = new Promise<Resume>((_resolve, reject) => {
			failSave = reject;
		});
		orpcMocks.updateResume.mockReturnValueOnce(pending);
		useResumeStore.getState().initialize(makeResume("departing"));
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Private";
		});
		vi.advanceTimersByTime(500);
		await flushMicrotasks();
		clearResumeDrafts();
		window.localStorage.clear();
		failSave(new Error("late network failure"));
		await flushMicrotasks();
		expect(readUnsavedResumeData("departing")).toBeUndefined();
		expect(useResumeStore.getState().resume).toBeNull();
	});

	it("pauses a conflicted draft across typing, retry, reconnect and navigation", async () => {
		const initial = makeResume("version-conflict");
		useResumeStore.getState().initialize(initial);
		orpcMocks.updateResume.mockRejectedValue(new ORPCError("RESUME_VERSION_CONFLICT", { status: 409 }));
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Mine";
		});
		await vi.advanceTimersByTimeAsync(500);
		expect(useResumeStore.getState().saveStatus).toBe("conflict");
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Still mine";
		});
		await vi.advanceTimersByTimeAsync(500);
		useResumeStore.getState().retrySave();
		window.dispatchEvent(new Event("online"));
		expect(await savePendingChanges(initial.id)).toBe(false);
		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);
		expect(useResumeStore.getState().saveStatus).toBe("conflict");
		expect(readUnsavedResumeData(initial.id)?.basics.name).toBe("Still mine");
	});

	it.each(["stale", "legacy"])("does not send a %s recovered draft over newer server data", async (kind) => {
		const initial = makeResume(`recovery-${kind}`);
		window.localStorage.setItem(
			`reactive-resume:unsaved:${initial.id}`,
			JSON.stringify({
				data: withBasicsName(initial, "Recovered typing").data,
				storedAt: Date.now(),
				...(kind === "stale" ? { baseUpdatedAt: new Date(initial.updatedAt.getTime() - 1) } : {}),
			}),
		);
		useResumeStore.getState().initialize(initial);
		await flushMicrotasks();
		expect(orpcMocks.updateResume).not.toHaveBeenCalled();
		expect(useResumeStore.getState().saveStatus).toBe("conflict");
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Recovered typing");
	});

	it.each(["success", "failure", "typing"])("keeps local edits safe when reload ends with %s", async (outcome) => {
		const initial = makeResume(`reload-${outcome}`);
		const remote = { ...withBasicsName(initial, "Theirs"), updatedAt: new Date(initial.updatedAt.getTime() + 1) };
		useResumeStore.getState().initialize(initial);
		orpcMocks.updateResume.mockRejectedValueOnce(new ORPCError("RESUME_VERSION_CONFLICT", { status: 409 }));
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Mine";
		});
		await vi.advanceTimersByTimeAsync(500);
		let finishCopy!: (id: string) => void;
		orpcMocks.importResume.mockReturnValueOnce(
			new Promise<string>((resolve) => {
				finishCopy = resolve;
			}),
		);
		orpcMocks.updateResume.mockResolvedValue(withBasicsName(initial, "Mine"));
		orpcMocks.getResumeById.mockImplementation(() =>
			outcome === "failure" ? Promise.reject(new Error("Network error")) : Promise.resolve(remote),
		);
		const reload = useResumeStore.getState().reloadFromServer();
		if (outcome === "typing")
			useResumeStore.getState().updateResumeData((draft) => {
				draft.basics.name = "More typing";
			});
		finishCopy("my-copy");
		if (outcome === "success") {
			await reload;
			expect(useResumeStore.getState().resume?.data.basics.name).toBe("Theirs");
			expect(useResumeStore.getState().saveStatus).toBe("saved");
			expect(readUnsavedResumeData(initial.id)).toBeUndefined();
		} else {
			await expect(reload).rejects.toThrow(outcome === "failure" ? "Network error" : "Your changes are still open");
			expect(useResumeStore.getState().saveStatus).toBe("conflict");
			expect(readUnsavedResumeData(initial.id)?.basics.name).toBe(outcome === "typing" ? "More typing" : "Mine");
			orpcMocks.getResumeById.mockResolvedValue(remote);
			await useResumeStore.getState().reloadFromServer();
			expect(orpcMocks.importResume).toHaveBeenCalledTimes(1);
		}
		expect(orpcMocks.updateResume.mock.lastCall?.[0]).toMatchObject({
			id: "my-copy",
			name: "Resume (mine)",
			data: { basics: { name: outcome === "typing" ? "More typing" : "Mine" } },
		});
	});

	it("recovers queued typing against the version returned by its earlier in-flight save", async () => {
		const initial = makeResume("queued-recovery");
		const first = { ...withBasicsName(initial, "First"), updatedAt: new Date(initial.updatedAt.getTime() + 1) };
		let finishFirst!: (resume: Resume) => void;
		orpcMocks.updateResume
			.mockReturnValueOnce(
				new Promise<Resume>((resolve) => {
					finishFirst = resolve;
				}),
			)
			.mockRejectedValueOnce(new Error("Connection lost"));
		useResumeStore.getState().initialize(initial);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "First";
		});
		await vi.advanceTimersByTimeAsync(500);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Latest";
		});
		await vi.advanceTimersByTimeAsync(500);
		finishFirst(first);
		await flushMicrotasks();
		clearResumeDrafts();
		orpcMocks.updateResume.mockImplementation((input: { data: ResumeData; expectedUpdatedAt?: Date }) => {
			if (input.expectedUpdatedAt?.getTime() !== first.updatedAt.getTime())
				throw new ORPCError("RESUME_VERSION_CONFLICT", { status: 409 });
			return Promise.resolve({ ...first, data: input.data });
		});
		useResumeStore.getState().initialize(first);
		await flushMicrotasks();
		expect(useResumeStore.getState().saveStatus).toBe("saved");
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Latest");
	});

	it("leaves another visit's recovery intact after saving", async () => {
		const initial = makeResume("other-visit");
		useResumeStore.getState().initialize(initial);
		const recovery = JSON.stringify({
			data: withBasicsName(initial, "Other typing").data,
			baseUpdatedAt: initial.updatedAt,
			storedAt: Date.now(),
		});
		window.localStorage.setItem(`reactive-resume:unsaved:${initial.id}:other`, recovery);
		orpcMocks.updateResume.mockResolvedValue(withBasicsName(initial, "Mine"));
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Mine";
		});
		await vi.advanceTimersByTimeAsync(500);
		expect(useResumeStore.getState().saveStatus).toBe("saved");
		expect(window.localStorage.getItem(`reactive-resume:unsaved:${initial.id}:other`)).toBe(recovery);
	});

	it("expires local recovery after seven days", () => {
		window.localStorage.setItem(
			"reactive-resume:unsaved:expired",
			JSON.stringify({ data: defaultResumeData, storedAt: Date.now() - 8 * 86_400_000 }),
		);
		expect(readUnsavedResumeData("expired")).toBeUndefined();
		expect(window.localStorage.getItem("reactive-resume:unsaved:expired")).toBeNull();
	});

	it("restores changes kept on this device when the editor opens again", async () => {
		const initial = makeResume("resume-restore");
		window.localStorage.setItem(
			"reactive-resume:unsaved:resume-restore",
			JSON.stringify({
				data: withBasicsName(initial, "Kept locally").data,
				storedAt: Date.now(),
				baseUpdatedAt: initial.updatedAt,
			}),
		);
		orpcMocks.updateResume.mockImplementation((input: { id: string; data: ResumeData }) =>
			Promise.resolve({ ...makeResume(input.id), data: input.data }),
		);

		useResumeStore.getState().initialize(initial);
		await flushMicrotasks();

		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Kept locally");
		expect(orpcMocks.updateResume).toHaveBeenCalledWith(
			expect.objectContaining({ id: "resume-restore" }),
			expect.anything(),
		);
		expect(toastMocks.add).toHaveBeenCalledWith(
			expect.objectContaining({ description: "Restored changes that hadn't been saved yet." }),
		);
	});

	it("never vouches for what an older app kept: it goes out unchecked until the server takes it", async () => {
		const initial = makeResume("resume-older-recovery");
		// An older app's recovery record: no proposalSafety, and a decision it never sent.
		window.localStorage.setItem(
			`reactive-resume:unsaved:${initial.id}`,
			JSON.stringify({
				data: withBasicsName(initial, "Older app").data,
				storedAt: Date.now(),
				baseUpdatedAt: initial.updatedAt,
				pendingProposalApplications: { held: true },
			}),
		);
		orpcMocks.updateResume.mockRejectedValueOnce(new ORPCError("RESUME_VERSION_CONFLICT", { status: 409 }));
		useResumeStore.getState().initialize(initial);
		await flushMicrotasks();
		expect(orpcMocks.updateResume.mock.calls[0]?.[0]).not.toHaveProperty("proposalSafety");
		expect(orpcMocks.updateResume.mock.calls[0]?.[0]).toMatchObject({ proposalApplications: { held: true } });
		// Refused: the draft stays, still marked as the older app's, for Keep as a copy.
		expect(useResumeStore.getState().saveStatus).toBe("conflict");
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Older app");
		const kept = Object.entries(window.localStorage).find(([key]) =>
			key.startsWith(`reactive-resume:unsaved:${initial.id}`),
		);
		expect(JSON.parse(kept?.[1] ?? "{}")).not.toHaveProperty("proposalSafety");

		// Where the server takes it, what's typed next is this app's own.
		clearResumeDrafts();
		window.localStorage.clear();
		orpcMocks.updateResume.mockReset();
		orpcMocks.updateResume.mockImplementation((input: { id: string; data: ResumeData }) =>
			Promise.resolve({ ...initial, data: input.data }),
		);
		window.localStorage.setItem(
			`reactive-resume:unsaved:${initial.id}`,
			JSON.stringify({
				data: withBasicsName(initial, "Older app").data,
				storedAt: Date.now(),
				baseUpdatedAt: initial.updatedAt,
			}),
		);
		useResumeStore.getState().initialize(initial);
		await flushMicrotasks();
		expect(orpcMocks.updateResume.mock.calls[0]?.[0]).not.toHaveProperty("proposalSafety");
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Typed after updating";
		});
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.calls[1]?.[0]).toMatchObject({ proposalSafety: "v1" });

		// This app's own recovery keeps its mark.
		clearResumeDrafts();
		window.localStorage.clear();
		orpcMocks.updateResume.mockClear();
		window.localStorage.setItem(
			`reactive-resume:unsaved:${initial.id}`,
			JSON.stringify({
				data: withBasicsName(initial, "This app").data,
				storedAt: Date.now(),
				baseUpdatedAt: initial.updatedAt,
				proposalSafety: "v1",
			}),
		);
		useResumeStore.getState().initialize(initial);
		await flushMicrotasks();
		expect(orpcMocks.updateResume.mock.calls[0]?.[0]).toMatchObject({ proposalSafety: "v1" });
	});
});

describe("builder resume undo/redo", () => {
	beforeEach(() => {
		vi.useFakeTimers();
		orpcMocks.updateResume.mockReset();
		// Echo the submitted data back so the autosave completion doesn't count as an external rebase.
		orpcMocks.updateResume.mockImplementation((input: { id: string; data: ResumeData }) =>
			Promise.resolve({ ...makeResume(input.id), data: input.data }),
		);
		routerParamsMock.value = {};
		i18n.loadAndActivate({ locale: "en-US", messages: {} });
		clearResumeDrafts();
		window.localStorage.clear();
	});

	afterEach(() => {
		vi.clearAllTimers();
		vi.useRealTimers();
		clearResumeDrafts();
		window.localStorage.clear();
	});

	it("coalesces rapid edits into a single undo step and restores the pre-burst state", () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("undo-coalesce"));

		store().updateResumeData((draft) => {
			draft.basics.name = "First";
		});
		store().updateResumeData((draft) => {
			draft.basics.name = "Second";
		});

		expect(store().undoStack.length).toBe(1);
		expect(store().undoStack.length > 0).toBe(true);
		expect(store().redoStack.length > 0).toBe(false);
		expect(store().resume?.data.basics.name).toBe("Second");

		store().undo();
		expect(store().resume?.data.basics.name).toBe(defaultResumeData.basics.name);
		expect(store().undoStack.length > 0).toBe(false);
		expect(store().redoStack.length > 0).toBe(true);

		store().redo();
		expect(store().resume?.data.basics.name).toBe("Second");
		expect(store().redoStack.length > 0).toBe(false);
	});

	it("keeps an accepted AI replacement as its own step after rapid typing and starts a new step for later typing", () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("undo-improve"));

		store().updateResumeData(
			(draft) => {
				draft.summary.content = "Owned";
			},
			{ coalesceKey: "summary.content" },
		);
		store().updateResumeData(
			(draft) => {
				draft.summary.content = "Owned synthetic delivery.";
			},
			{ coalesceKey: "summary.content" },
		);
		// The accepted AI replacement arrives inside the typing coalesce window and must still be its own step.
		store().updateResumeData(
			(draft) => {
				draft.summary.content = "Led fictional delivery work.";
			},
			{ coalesceKey: "summary.content", newStep: true },
		);

		expect(store().undoStack.length).toBe(2);
		store().undo();
		expect(store().resume?.data.summary.content).toBe("Owned synthetic delivery.");
		store().redo();
		expect(store().resume?.data.summary.content).toBe("Led fictional delivery work.");

		// Typing immediately after the replacement is a new step, not merged back into the AI one.
		store().updateResumeData(
			(draft) => {
				draft.summary.content = "Led fictional delivery work. More";
			},
			{ coalesceKey: "summary.content" },
		);
		expect(store().undoStack.length).toBe(3);
		store().undo();
		expect(store().resume?.data.summary.content).toBe("Led fictional delivery work.");
		store().undo();
		expect(store().resume?.data.summary.content).toBe("Owned synthetic delivery.");
	});

	it("merges typing in one field into one step, but not edits to different fields", () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("undo-fields"));

		store().updateResumeData(
			(draft) => {
				draft.basics.name = "J";
			},
			{ coalesceKey: "basics.name" },
		);
		store().updateResumeData(
			(draft) => {
				draft.basics.name = "Jo";
			},
			{ coalesceKey: "basics.name" },
		);
		store().updateResumeData(
			(draft) => {
				draft.basics.headline = "Designer";
			},
			{ coalesceKey: "basics.headline" },
		);

		expect(store().undoStack.length).toBe(2);
		store().undo();
		expect(store().resume?.data.basics.headline).toBe(defaultResumeData.basics.headline);
		expect(store().resume?.data.basics.name).toBe("Jo");
		store().undo();
		expect(store().resume?.data.basics.name).toBe(defaultResumeData.basics.name);
	});

	it("keeps structural actions as steps of their own", () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("undo-structural"));

		store().updateResumeData((draft) => {
			draft.basics.name = "A";
		});
		store().updateResumeData(
			(draft) => {
				draft.sections.skills.hidden = true;
			},
			{ newStep: true },
		);
		store().updateResumeData((draft) => {
			draft.basics.name = "B";
		});

		expect(store().undoStack.length).toBe(3);
	});

	it("merges a multi-edit action with the same key into one step, however long it takes", () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("undo-same-step"));
		const now = vi.spyOn(Date, "now");

		now.mockReturnValue(1_000);
		store().updateResumeData(
			(draft) => {
				draft.metadata.page.gapY = 4;
			},
			{ coalesceKey: "fit:1", sameStep: true },
		);
		now.mockReturnValue(9_000);
		store().updateResumeData(
			(draft) => {
				draft.metadata.page.marginX = 10;
			},
			{ coalesceKey: "fit:1", sameStep: true },
		);
		now.mockRestore();

		expect(store().undoStack).toHaveLength(1);
		store().undo();
		expect(store().resume?.data.metadata.page).toMatchObject({ gapY: 6, marginX: 14 });
	});

	it("restores the exact authored Experience order with one undo after a one-shot sort", () => {
		const store = useResumeStore.getState;
		const initial = makeResume("sort-undo");
		initial.data.sections.experience.items = [
			experienceItem("unknown", "Mystery Co", "Recently"),
			experienceItem("older", "Older Co", "2018 - 2020"),
			experienceItem("current", "Current Co", "2023 - Present"),
		];
		const authoredItems = cloneResumeData(initial.data).sections.experience.items;
		store().initialize(initial);

		store().updateResumeData((draft) => {
			draft.sections.experience.items = sortSectionItemsByPeriod(
				draft.sections.experience.items,
				draft.metadata.page.locale,
			).items;
		});

		expect(store().resume?.data.sections.experience.items.map(({ id }) => id)).toEqual(["current", "older", "unknown"]);
		expect(store().undoStack).toHaveLength(1);

		store().undo();
		expect(store().resume?.data.sections.experience.items).toEqual(authoredItems);
		expect(store().undoStack.length > 0).toBe(false);
	});

	it("retains the chosen order through autosave/reload and never resorts later field edits", async () => {
		const store = useResumeStore.getState;
		const initial = makeResume("sort-persistence");
		initial.data.sections.experience.items = [
			experienceItem("older", "Older Co", "2018 - 2020"),
			experienceItem("current", "Current Co", "2023 - Present"),
		];
		let savedResume: Resume | undefined;
		orpcMocks.updateResume.mockImplementation((input: { id: string; data: ResumeData }) => {
			savedResume = { ...makeResume(input.id), data: cloneResumeData(input.data) };
			return Promise.resolve(savedResume);
		});
		store().initialize(initial);

		store().updateResumeData((draft) => {
			draft.sections.experience.items = sortSectionItemsByPeriod(
				draft.sections.experience.items,
				draft.metadata.page.locale,
			).items;
		});
		vi.advanceTimersByTime(500);
		await flushMicrotasks();

		expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);
		expect(savedResume?.data.sections.experience.items.map(({ id }) => id)).toEqual(["current", "older"]);
		if (!savedResume) throw new Error("expected the sorted resume to be saved");

		store().reset();
		store().initialize(savedResume);
		store().updateResumeData((draft) => {
			const currentItem = draft.sections.experience.items.find(({ id }) => id === "current");
			if (currentItem) currentItem.period = "2010 - 2011";
		});

		expect(store().resume?.data.sections.experience.items.map(({ id }) => id)).toEqual(["current", "older"]);
	});

	it("separates edits outside the coalesce window into distinct undo steps", async () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("undo-boundary"));

		store().updateResumeData((draft) => {
			draft.basics.name = "A";
		});

		// Let the autosave flush (echoes the data back) and advance past the coalesce window.
		vi.advanceTimersByTime(600);
		await flushMicrotasks();

		store().updateResumeData((draft) => {
			draft.basics.name = "B";
		});

		expect(store().undoStack.length).toBe(2);

		store().undo();
		expect(store().resume?.data.basics.name).toBe("A");

		store().undo();
		expect(store().resume?.data.basics.name).toBe(defaultResumeData.basics.name);
	});

	it("clears the redo branch when a new edit follows an undo", () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("undo-redo-clear"));

		store().updateResumeData((draft) => {
			draft.basics.name = "One";
		});
		store().undo();
		expect(store().redoStack.length > 0).toBe(true);

		store().updateResumeData((draft) => {
			draft.basics.name = "Two";
		});

		expect(store().redoStack.length > 0).toBe(false);
		expect(store().redoStack.length).toBe(0);
	});

	it("preserves the undo stack when the server echoes the current data (autosave)", () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("rebase-echo"));

		store().updateResumeData((draft) => {
			draft.basics.name = "Edited";
		});
		expect(store().undoStack.length).toBe(1);

		const current = store().resume;
		if (!current) throw new Error("expected a current resume");
		// Autosave echo: the server returns data identical to what's already in the store.
		store().replaceResumeFromServer({ ...current, data: cloneResumeData(current.data) });

		expect(store().undoStack.length).toBe(1);
		expect(store().undoStack.length > 0).toBe(true);
		// The same object stays, so the preview doesn't render the identical document again.
		expect(store().resume?.data).toBe(current.data);
	});

	it("clears the undo stack when the server sends different data (external rebase)", async () => {
		const store = useResumeStore.getState;
		store().initialize(makeResume("rebase-external"));
		orpcMocks.updateResume.mockImplementation(async (input) => ({ ...makeResume(input.id), data: input.data }));

		store().updateResumeData((draft) => {
			draft.basics.name = "Edited";
		});
		expect(store().undoStack.length).toBe(1);

		const current = store().resume;
		if (!current) throw new Error("expected a current resume");
		expect(await savePendingChanges(current.id)).toBe(true);
		// External / AI rebase: incoming data differs, so the local undo history no longer applies.
		store().replaceResumeFromServer(withBasicsName(current, "External Name"));

		expect(store().undoStack.length).toBe(0);
		expect(store().undoStack.length > 0).toBe(false);
	});
});

describe("resume update stream subscription", () => {
	beforeEach(() => {
		vi.useFakeTimers();
		orpcMocks.streamSubscribe.mockReset();
		orpcMocks.updateResume.mockReset();
		consumeEventIteratorMock.mockReset();
		orpcMocks.getResumeById.mockReset();
		orpcMocks.importResume.mockReset();
		queryClientMock.setQueryData.mockClear();
		routerParamsMock.value = {};
		i18n.loadAndActivate({ locale: "en-US", messages: {} });
		clearResumeDrafts();
		window.localStorage.clear();
	});

	afterEach(() => {
		vi.clearAllTimers();
		vi.useRealTimers();
		clearResumeDrafts();
		window.localStorage.clear();
	});

	it.each([
		{ name: "resubscribes after the stream drops", error: new Error("stream dropped"), subscribes: 2, reported: 1 },
		// A signed-out tab would otherwise send a 401 every 2.5 s until it closes.
		{ name: "stops once the session is signed out", error: new ORPCError("UNAUTHORIZED"), subscribes: 1, reported: 0 },
	])("$name", ({ error, subscribes, reported }) => {
		const onUpdate = vi.fn().mockResolvedValue(undefined);
		const onError = vi.fn();
		consumeEventIteratorMock.mockReturnValue(vi.fn().mockResolvedValue(undefined));

		renderHook(() => useResumeUpdateSubscription({ resumeId: "resume-retry", onUpdate, onError }));
		expect(orpcMocks.streamSubscribe).toHaveBeenCalledTimes(1);

		const handlers = consumeEventIteratorMock.mock.calls[0]?.[1] as { onError: (error: unknown) => void };
		act(() => handlers.onError(error));
		expect(onError).toHaveBeenCalledTimes(reported);
		act(() => {
			vi.advanceTimersByTime(2500);
		});
		expect(orpcMocks.streamSubscribe).toHaveBeenCalledTimes(subscribes);
	});

	it("replaces the builder draft from the server when there are no pending local edits", async () => {
		const initial = makeResume("resume-clean");
		const remote = { ...withBasicsName(initial, "Remote Name"), updatedAt: new Date(initial.updatedAt.getTime() + 1) };
		const cancel = vi.fn().mockResolvedValue(undefined);
		consumeEventIteratorMock.mockReturnValue(cancel);
		orpcMocks.getResumeById.mockResolvedValue(remote);
		routerParamsMock.value = { resumeId: initial.id };
		useResumeStore.getState().initialize(initial);

		renderHook(() => useBuilderResumeUpdateSubscription());
		const handlers = consumeEventIteratorMock.mock.calls[0]?.[1] as { onEvent: () => Promise<void> } | undefined;

		await act(async () => {
			await handlers?.onEvent();
		});

		expect(queryClientMock.setQueryData).toHaveBeenCalledWith(["resume", "getById", initial.id], remote);
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Remote Name");
	});

	it.each(["conflict", "saved"])(
		"does not apply an obsolete deferred snapshot after a local save is %s",
		async (outcome) => {
			const initial = makeResume(`focused-${outcome}`);
			let server = { ...withBasicsName(initial, "Theirs"), updatedAt: new Date(initial.updatedAt.getTime() + 1) };
			useResumeStore.getState().initialize(initial);
			routerParamsMock.value = { resumeId: initial.id };
			const input = document.createElement("input");
			document.body.append(input);
			input.focus();
			orpcMocks.getResumeById.mockResolvedValue(server);
			consumeEventIteratorMock.mockReturnValue(vi.fn().mockResolvedValue(undefined));
			const hook = renderHook(() => useBuilderResumeUpdateSubscription());
			const onEvent = consumeEventIteratorMock.mock.lastCall?.[1].onEvent;
			await act(async () => {
				await onEvent({ mutation: "update" });
			});
			// Simulate a newer accepted version with the same remote data before typing.
			if (outcome === "saved")
				useResumeStore
					.getState()
					.replaceResumeFromServer({ ...server, updatedAt: new Date(server.updatedAt.getTime() + 1) });
			orpcMocks.updateResume.mockImplementation((submitted: { data: ResumeData; expectedUpdatedAt?: Date }) => {
				if (outcome === "conflict" && submitted.expectedUpdatedAt?.getTime() !== server.updatedAt.getTime())
					throw new ORPCError("RESUME_VERSION_CONFLICT", { status: 409 });
				server = { ...server, data: submitted.data, updatedAt: new Date(server.updatedAt.getTime() + 2) };
				return Promise.resolve(server);
			});
			act(() => {
				useResumeStore.getState().updateResumeData((draft) => {
					draft.basics.location = "My typing";
				});
			});
			await act(async () => {
				await vi.advanceTimersByTimeAsync(500);
			});
			input.blur();
			await act(async () => {
				await vi.advanceTimersByTimeAsync(0);
			});
			expect(useResumeStore.getState().resume?.data.basics.location).toBe("My typing");
			expect(useResumeStore.getState().saveStatus).toBe(outcome);
			expect(server.data.basics.name).toBe("Theirs");
			expect(server.data.basics.location).toBe(outcome === "saved" ? "My typing" : initial.data.basics.location);
			input.remove();
			hook.unmount();
		},
	);

	it("does not overwrite pending local builder edits when a remote update arrives", async () => {
		const initial = makeResume("resume-pending");
		const remote = { ...withBasicsName(initial, "Remote Name"), updatedAt: new Date(initial.updatedAt.getTime() + 1) };
		const cancel = vi.fn().mockResolvedValue(undefined);
		consumeEventIteratorMock.mockReturnValue(cancel);
		orpcMocks.getResumeById.mockResolvedValue(remote);
		routerParamsMock.value = { resumeId: initial.id };
		useResumeStore.getState().initialize(initial);
		useResumeStore.getState().updateResumeData((draft) => {
			draft.basics.name = "Local Name";
		});

		renderHook(() => useBuilderResumeUpdateSubscription());
		const handlers = consumeEventIteratorMock.mock.calls[0]?.[1] as { onEvent: () => Promise<void> } | undefined;

		await act(async () => {
			await handlers?.onEvent();
		});

		expect(queryClientMock.setQueryData).toHaveBeenCalledWith(["resume", "getById", initial.id], remote);
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Local Name");
		orpcMocks.updateResume.mockImplementation((input: { expectedUpdatedAt?: Date }) => {
			if (input.expectedUpdatedAt?.getTime() !== remote.updatedAt.getTime())
				throw new ORPCError("RESUME_VERSION_CONFLICT", { status: 409 });
			return Promise.resolve(remote);
		});
		await act(async () => {
			await vi.advanceTimersByTimeAsync(500);
		});
		expect(useResumeStore.getState().saveStatus).toBe("conflict");
		expect(useResumeStore.getState().resume?.data.basics.name).toBe("Local Name");
	});
});

it("restores proposal decisions only at their explicit undo checkpoints, preserving refinements and redo", () => {
	const store = () => useResumeStore.getState();
	store().initialize(makeResume("proposal-history"));
	store().updateResumeData(
		(draft) => {
			draft.summary.content = "<p>Accepted</p>";
		},
		{ newStep: true, applied: [{ id: "edit", after: "<p>Accepted</p>" }] },
	);
	store().updateResumeData(
		(draft) => {
			draft.summary.content = "<p>Refined</p>";
		},
		{ newStep: true },
	);
	expect(store().proposalApplications).toEqual({ edit: "<p>Accepted</p>" });
	store().undo();
	expect(store().proposalApplications).toEqual({ edit: "<p>Accepted</p>" });
	expect(store().resume?.data.summary.content).toBe("<p>Accepted</p>");
	store().undo();
	expect(store().proposalApplications).toEqual({ edit: false });
	store().redo();
	expect(store().proposalApplications).toEqual({ edit: "<p>Accepted</p>" });
	store().redo();
	expect(store().resume?.data.summary.content).toBe("<p>Refined</p>");
	expect(store().proposalApplications).toEqual({ edit: "<p>Accepted</p>" });
});

it("retains offscreen resume Undo and pending synchronization through a failed save and builder reload", async () => {
	vi.useFakeTimers();
	window.localStorage.clear();
	const store = () => useResumeStore.getState();
	const initial = makeResume("closed-assistant-undo");
	initial.data.summary.content = "<p>Original</p>";
	try {
		orpcMocks.updateResume.mockImplementation(async (input: { data: ResumeData }) => ({
			...initial,
			data: input.data,
		}));
		store().initialize(initial);
		store().updateResumeData(
			(draft) => {
				draft.summary.content = "<p>Rewritten</p>";
			},
			{ newStep: true, applied: [{ id: "edit", after: "<p>Rewritten</p>" }] },
		);
		expect(await savePendingChanges(initial.id)).toBe(true);
		// No Conversation is mounted. Document owner must save the decision with Undo's content.
		store().undo();
		orpcMocks.updateResume.mockRejectedValueOnce(new Error("Offline"));
		expect(await savePendingChanges(initial.id)).toBe(false);
		expect(orpcMocks.updateResume).toHaveBeenCalledWith(
			expect.objectContaining({ proposalApplications: { edit: false } }),
			expect.anything(),
		);
		vi.setSystemTime(Date.now() + 8 * 86_400_000);
		clearResumeDrafts();
		store().initialize(initial);
		expect(store().proposalApplications).toEqual({ edit: false });
		expect(await savePendingChanges(initial.id)).toBe(true);
		expect(orpcMocks.updateResume).toHaveBeenCalledWith(
			expect.objectContaining({ proposalApplications: { edit: false } }),
			expect.anything(),
		);
		const saved = store().resume;
		if (!saved) throw new Error("Missing saved resume");
		clearResumeDrafts();
		store().initialize(saved);
		expect(store().proposalApplications).toEqual({ edit: false });
	} finally {
		clearResumeDrafts();
		window.localStorage.clear();
		vi.clearAllTimers();
		vi.useRealTimers();
	}
});

describe("concurrent receipt ownership", () => {
	beforeEach(() => {
		vi.useFakeTimers();
		clearResumeDrafts();
		window.localStorage.clear();
		orpcMocks.updateResume.mockReset();
		i18n.loadAndActivate({ locale: "en-US", messages: {} });
	});
	afterEach(() => {
		clearResumeDrafts();
		vi.clearAllTimers();
		vi.useRealTimers();
	});
	const s = () => useResumeStore.getState();
	it("pairs sources populated by the acceptance recipe with save, Undo and Redo, excluding stale edits", async () => {
		const initial = makeResume("accepted-source-pairing");
		initial.aiOperationIds = ["prior-source"];
		initial.data.summary.content = "<p>Original</p>";
		s().initialize(initial);
		const proposal: Proposal = {
			id: "accepted",
			target: { sectionId: "summary", field: "content" },
			location: "Summary",
			why: "Clearer",
			before: initial.data.summary.content,
			after: "<p>Reviewed</p>",
			status: "pending",
			source: "assistant",
			aiOperationIds: ["assistant-source"],
		};
		const stale = { ...proposal, id: "stale", after: "<p>Conflicting</p>", aiOperationIds: ["stale-source"] };
		const applied: Proposal[] = [];
		orpcMocks.updateResume.mockImplementation(async (input) => ({
			...initial,
			data: input.data,
			aiOperationIds: input.aiOperationIds,
			updatedAt: new Date(initial.updatedAt.getTime() + 1),
		}));
		s().updateResumeData(
			(data) => {
				applied.push(...applyResumeProposals(data, [proposal, stale]).applied);
			},
			{ newStep: true, applied },
		);
		expect(applied.map((p) => p.id)).toEqual([proposal.id]);
		expect(s().resume?.aiOperationIds).toEqual(["prior-source", "assistant-source"]);
		expect(orpcMocks.updateResume).not.toHaveBeenCalled();
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].aiOperationIds).toEqual(["prior-source", "assistant-source"]);
		s().undo();
		expect(s().resume?.aiOperationIds).toEqual(["prior-source"]);
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].aiOperationIds).toEqual(["prior-source"]);
		s().redo();
		expect(s().resume?.aiOperationIds).toEqual(["prior-source", "assistant-source"]);
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.lastCall?.[0].aiOperationIds).toEqual(["prior-source", "assistant-source"]);
	});
	it("editor Undo removes only its Improve source and saves it alongside the restored wording", async () => {
		const initial = makeResume("improve-editor-undo");
		initial.aiOperationIds = ["import-source", "reviewed-improve", "other-field-source"];
		initial.data.summary.content = "<p>Improved</p>";
		s().initialize(initial);
		orpcMocks.updateResume.mockImplementation(async (input) => ({
			...initial,
			data: input.data,
			aiOperationIds: input.aiOperationIds,
		}));
		s().updateResumeData(
			(data) => {
				data.summary.content = "<p>Original</p>";
			},
			{
				newStep: true,
				removedAiOperationIds: ["reviewed-improve"],
			},
		);
		await vi.advanceTimersByTimeAsync(500);
		expect(orpcMocks.updateResume.mock.lastCall?.[0]).toMatchObject({
			data: { summary: { content: "<p>Original</p>" } },
			aiOperationIds: ["import-source", "other-field-source"],
		});
		expect(s().resume?.aiOperationIds).toEqual(["import-source", "other-field-source"]);
	});
	it.each([false, true])(
		"pairs Improve sources through inflight Undo and Redo, including unchanged wording=%s",
		async (sameWords) => {
			const initial = makeResume(`improve-inflight-${sameWords}`);
			initial.aiOperationIds = ["import-source"];
			initial.data.summary.content = "<p>Original</p>";
			s().initialize(initial);
			const accepted = deferred<Resume>();
			orpcMocks.updateResume
				.mockImplementationOnce(() => accepted.promise)
				.mockImplementation(async (input) => ({
					...initial,
					data: input.data,
					aiOperationIds: input.aiOperationIds,
					updatedAt: new Date(initial.updatedAt.getTime() + 2),
				}));
			s().updateResumeData(
				(data) => {
					data.summary.content = sameWords ? initial.data.summary.content : "<p>Improved</p>";
				},
				{ newStep: true, aiOperationIds: ["improve-source"] },
			);
			await vi.advanceTimersByTimeAsync(500);
			expect(orpcMocks.updateResume).toHaveBeenCalledOnce();
			s().undo();
			await vi.advanceTimersByTimeAsync(500);
			accepted.resolve({
				...initial,
				data: {
					...initial.data,
					summary: { ...initial.data.summary, content: sameWords ? initial.data.summary.content : "<p>Improved</p>" },
				},
				aiOperationIds: ["import-source", "improve-source"],
				updatedAt: new Date(initial.updatedAt.getTime() + 1),
			});
			await flushMicrotasks();
			await vi.advanceTimersByTimeAsync(0);
			expect(orpcMocks.updateResume.mock.calls.map(([input]) => input.aiOperationIds)).toEqual([
				["import-source", "improve-source"],
				["import-source"],
			]);
			expect(s().resume?.aiOperationIds).toEqual(["import-source"]);
			expect(s().resume?.data.summary.content).toBe(initial.data.summary.content);
			s().redo();
			await vi.advanceTimersByTimeAsync(500);
			expect(s().resume?.aiOperationIds).toEqual(["import-source", "improve-source"]);
			expect(orpcMocks.updateResume.mock.lastCall?.[0].aiOperationIds).toEqual(["import-source", "improve-source"]);
		},
	);
	it.each([false, true])(
		"recovers unsaved Improve sources with their content, including unchanged wording=%s",
		async (sameWords) => {
			const initial = makeResume(`improve-recovery-${sameWords}`);
			initial.aiOperationIds = ["import-source"];
			s().initialize(initial);
			orpcMocks.updateResume.mockRejectedValue(new Error("offline"));
			s().updateResumeData(
				(data) => {
					if (!sameWords) data.summary.content = "<p>Improved</p>";
				},
				{ newStep: true, aiOperationIds: ["improve-source"] },
			);
			await vi.advanceTimersByTimeAsync(500);
			clearResumeDrafts();
			orpcMocks.updateResume.mockReset().mockImplementation(async (input) => ({
				...initial,
				data: input.data,
				aiOperationIds: input.aiOperationIds,
				updatedAt: new Date(initial.updatedAt.getTime() + 1),
			}));
			s().initialize(initial);
			expect(s().resume?.aiOperationIds).toEqual(["import-source", "improve-source"]);
			expect(s().resume?.data.summary.content).toBe(sameWords ? initial.data.summary.content : "<p>Improved</p>");
			await flushMicrotasks();
			expect(orpcMocks.updateResume.mock.lastCall?.[0].aiOperationIds).toEqual(["import-source", "improve-source"]);
		},
	);
	it("newer remote Undo must supersede clean local acceptance, including after restart", async () => {
		const initial = makeResume("remote-undo");
		initial.data.summary.content = "<p>Old</p>";
		const p = {
			id: "receipt",
			target: { sectionId: "summary", field: "content" },
			before: "<p>Old</p>",
			after: "<p>New</p>",
			status: "pending" as const,
			source: "assistant" as const,
			location: "Summary",
			why: "Rewrite",
		};
		const { getProposalState } = await import("@reactive-resume/resume/proposals");
		s().initialize(initial);
		orpcMocks.updateResume.mockImplementation(async (input) => ({
			...initial,
			data: input.data,
			updatedAt: new Date(initial.updatedAt.getTime() + 1),
		}));
		s().updateResumeData(
			(d) => {
				d.summary.content = p.after;
			},
			{ newStep: true, applied: [p] },
		);
		await vi.advanceTimersByTimeAsync(500);
		expect(s().saveStatus).toBe("saved");
		const own = s().resume;
		assert.exists(own);
		// A different revision invalidates confirmed decisions even if the authored text matches.
		s().replaceResumeFromServer({ ...own, updatedAt: new Date(initial.updatedAt.getTime() + 2) });
		expect(s().proposalApplications).toEqual({});
		// Another client explicitly undoes this proposal and commits content+pending receipt at newer revision.
		const remote = { ...initial, updatedAt: new Date(initial.updatedAt.getTime() + 3) };
		s().replaceResumeFromServer(remote);
		const afterRebase = getProposalState(s().resume?.data ?? initial.data, p, s().proposalApplications);
		clearResumeDrafts();
		s().initialize(remote);
		const afterRestart = getProposalState(s().resume?.data ?? initial.data, p, s().proposalApplications);
		expect({ afterRebase, afterRestart }).toEqual({ afterRebase: "pending", afterRestart: "pending" });
	});
	it("an old pending decision cannot attach itself to a newer matching server revision", async () => {
		const initial = makeResume("stale-pending");
		initial.data.summary.content = "<p>Old</p>";
		s().initialize(initial);
		orpcMocks.updateResume.mockRejectedValue(new Error("offline"));
		s().updateResumeData(
			(d) => {
				d.summary.content = "<p>New</p>";
			},
			{ newStep: true, applied: [{ id: "receipt", after: "<p>New</p>" }] },
		);
		s().undo();
		await vi.advanceTimersByTimeAsync(500);
		// A different client has a later historical acceptance, then manually restores Old text.
		// Same content is not proof the failed Undo request committed.
		const remote = { ...initial, updatedAt: new Date(initial.updatedAt.getTime() + 10) };
		clearResumeDrafts();
		orpcMocks.updateResume
			.mockReset()
			.mockResolvedValue({ ...remote, updatedAt: new Date(remote.updatedAt.getTime() + 1) });
		s().initialize(remote);
		await flushMicrotasks();
		expect(orpcMocks.updateResume).not.toHaveBeenCalled();
		expect(s().saveStatus).toBe("conflict");
	});
	it("later Undo while acceptance save is in flight is sent after the earlier acknowledgement", async () => {
		const initial = makeResume("inflight");
		initial.data.summary.content = "<p>Old</p>";
		s().initialize(initial);
		let done: (resume: Resume) => void = () => {
			throw new Error("Save did not start");
		};
		orpcMocks.updateResume
			.mockImplementationOnce(
				() =>
					new Promise((resolve) => {
						done = resolve;
					}),
			)
			.mockImplementation(async (input) => ({
				...initial,
				data: input.data,
				updatedAt: new Date(initial.updatedAt.getTime() + 2),
			}));
		s().updateResumeData(
			(d) => {
				d.summary.content = "<p>New</p>";
			},
			{ newStep: true, applied: [{ id: "receipt", after: "<p>New</p>" }] },
		);
		await vi.advanceTimersByTimeAsync(500);
		s().undo();
		await vi.advanceTimersByTimeAsync(500);
		done({
			...initial,
			data: { ...initial.data, summary: { ...initial.data.summary, content: "<p>New</p>" } },
			updatedAt: new Date(initial.updatedAt.getTime() + 1),
		});
		await flushMicrotasks();
		await vi.advanceTimersByTimeAsync(0);
		expect(orpcMocks.updateResume.mock.calls.map((c) => c[0].proposalApplications)).toEqual([
			{ receipt: "<p>New</p>" },
			{ receipt: false },
		]);
		expect(s().resume?.data.summary.content).toBe("<p>Old</p>");
	});
});