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!

fix: bound stalled resume metadata writes (RX-162) (#3771)

Amruth Pillaiff0e82f10601
diff --git a/apps/web/src/dialogs/resume/index.tsx b/apps/web/src/dialogs/resume/index.tsx
index c4d27e1b0..b9091b675 100644
--- a/apps/web/src/dialogs/resume/index.tsx
+++ b/apps/web/src/dialogs/resume/index.tsx
@@ -45,7 +45,9 @@ export function ResumeDialog({ mode, data }: ResumeDialogProps) {
const update = useMutation({
...updateOptions,
mutationFn: (value) =>
- saveResumeMetadata(value.id, (expectedUpdatedAt) => orpc.resume.update.call({ ...value, expectedUpdatedAt })),
+ saveResumeMetadata(value.id, (expectedUpdatedAt, options) =>
+ orpc.resume.update.call({ ...value, expectedUpdatedAt }, options),
+ ),
});
const duplicate = useMutation(orpc.resume.duplicate.mutationOptions());
diff --git a/apps/web/src/features/resume/builder/draft.test.ts b/apps/web/src/features/resume/builder/draft.test.ts
index ba6d9394e..ea31a5b31 100644
--- a/apps/web/src/features/resume/builder/draft.test.ts
+++ b/apps/web/src/features/resume/builder/draft.test.ts
@@ -346,6 +346,7 @@ describe("builder resume autosave", () => {
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;
@@ -354,6 +355,153 @@ describe("builder resume autosave", () => {
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);
@@ -374,7 +522,10 @@ describe("builder resume autosave", () => {
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 () => renamed);
+ 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();
@@ -391,17 +542,43 @@ describe("builder resume autosave", () => {
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 earlier;
+ 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);
@@ -492,13 +669,14 @@ describe("builder resume autosave", () => {
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 writing;
+ await result;
expect(useResumeStore.getState().resume?.name).toBe(name);
useResumeStore.getState().updateResumeData((draft) => {
draft.basics.headline = "Later headline";
diff --git a/apps/web/src/features/resume/builder/draft.ts b/apps/web/src/features/resume/builder/draft.ts
index d78ecd781..d0e538563 100644
--- a/apps/web/src/features/resume/builder/draft.ts
+++ b/apps/web/src/features/resume/builder/draft.ts
@@ -144,7 +144,7 @@ type ResumeUpdateSubscriptionOptions = {
};
const SAVE_DEBOUNCE_MS = 500;
-const NAVIGATION_SAVE_WAIT_MS = 10_000;
+const SAVE_WAIT_MS = 10_000;
// Edits without a field key coalesce within this window (e.g. dragging); keyed edits to the same field
// coalesce within FIELD_COALESCE_MS (typing a sentence).
const HISTORY_COALESCE_MS = 500;
@@ -652,8 +652,7 @@ export const useResumeStore = create<ResumeStore>()(
}
setRuntimeBaseline(resume);
- // This runs both for the echo of our own autosave (identical data → keep history) and for
- // external/cross-tab/AI rebases (different data → local undo history no longer applies).
+ // Only an acknowledged revision keeps history: identical body data can hide a remote receipt-only Undo.
const current = get().resume;
// An echo keeps the data object the store already holds: a new but identical one would make everything that
// renders from it run again, the preview's PDF render of every page included, after every save.
@@ -913,10 +912,33 @@ function trackResumeMetadataWrite(id: string) {
/** Shares the autosave owner: finish earlier body writes, then hold later edits until this metadata revision is known. */
export async function saveResumeMetadata<T extends Resume>(
id: string,
- write: (expectedUpdatedAt: Date | undefined) => Promise<T>,
+ write: (expectedUpdatedAt: Date | undefined, options?: { signal: AbortSignal }) => Promise<T>,
): Promise<T> {
const runtime = runtimes.get(id);
- if (!runtime) return write(undefined);
+ if (!runtime?.baseUpdatedAt) throw new DOMException("", "AbortError");
+ /** Cancels transport and releases the local wait without trusting a late response. */
+ const writeWithDeadline = async (expectedUpdatedAt: Date | undefined) => {
+ const controller = new AbortController();
+ const endVisit = () => controller.abort(runtime.abortController.signal.reason);
+ runtime.abortController.signal.addEventListener("abort", endVisit, { once: true });
+ const timeout = setTimeout(
+ () =>
+ controller.abort(
+ new DOMException(t`Saving is taking longer than expected. Your changes are still open.`, "TimeoutError"),
+ ),
+ SAVE_WAIT_MS,
+ );
+ const aborted = new Promise<never>((_, reject) => {
+ controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+ });
+ try {
+ // A cancelled request may have committed; late answers cannot certify its revision.
+ return await Promise.race([write(expectedUpdatedAt, { signal: controller.signal }), aborted]);
+ } finally {
+ clearTimeout(timeout);
+ runtime.abortController.signal.removeEventListener("abort", endVisit);
+ }
+ };
const acknowledge = trackResumeMetadataWrite(id);
const pending = (runtime.metadataWrite?.catch(() => undefined) ?? Promise.resolve()).then(async () => {
if (runtime.abortController.signal.aborted) throw runtime.abortController.signal.reason;
@@ -924,7 +946,7 @@ export async function saveResumeMetadata<T extends Resume>(
if (runtime.abortController.signal.aborted) throw runtime.abortController.signal.reason;
runtime.metadataWriting = true;
try {
- const updated = await write(runtime.baseUpdatedAt);
+ const updated = await writeWithDeadline(runtime.baseUpdatedAt);
acknowledge(updated);
return updated;
} finally {
@@ -1039,15 +1061,18 @@ export function useBuilderResumeUpdateSubscription() {
const onUpdate = useCallback(
async (event: ResumeUpdateEvent) => {
if (!resumeId) return;
+ const visit = runtimes.get(resumeId);
+ if (!visit) return;
bindRuntimeQueryClient(resumeId, queryClient);
const resume = (await orpc.resume.getById.call({ id: resumeId })) as Resume;
// Let this visit acknowledge its own metadata before an early stream echo can rebase its history.
- await runtimes.get(resumeId)?.metadataWrite?.catch(() => undefined);
+ await visit.metadataWrite?.catch(() => undefined);
const runtime = runtimes.get(resumeId);
if (
!runtime ||
+ runtime !== visit ||
useResumeStore.getState().resume?.id !== resumeId ||
(runtime.baseUpdatedAt && resume.updatedAt < runtime.baseUpdatedAt)
)
@@ -1137,7 +1162,7 @@ export function savePendingChanges(id: string): boolean | Promise<boolean> {
id: runtime.slowSaveToastId,
timeout: 0,
});
- }, NAVIGATION_SAVE_WAIT_MS);
+ }, SAVE_WAIT_MS);
void flushResumeSave(id);
});
}
diff --git a/apps/web/src/features/resume/share/share-panel.tsx b/apps/web/src/features/resume/share/share-panel.tsx
index 3ebb48d23..9c75453f5 100644
--- a/apps/web/src/features/resume/share/share-panel.tsx
+++ b/apps/web/src/features/resume/share/share-panel.tsx
@@ -140,7 +140,9 @@ function useShareSetting() {
const { mutateAsync: updateResume, isPending } = useMutation({
...options,
mutationFn: (value) =>
- saveResumeMetadata(value.id, (expectedUpdatedAt) => orpc.resume.update.call({ ...value, expectedUpdatedAt })),
+ saveResumeMetadata(value.id, (expectedUpdatedAt, options) =>
+ orpc.resume.update.call({ ...value, expectedUpdatedAt }, options),
+ ),
});
const update = async (settings: ShareSettings) => {
diff --git a/apps/web/src/libs/query/client.test.ts b/apps/web/src/libs/query/client.test.ts
index 1fd2c3074..857f0c479 100644
--- a/apps/web/src/libs/query/client.test.ts
+++ b/apps/web/src/libs/query/client.test.ts
@@ -2,32 +2,39 @@ import { describe, expect, it } from "vite-plus/test";
import { getQueryClient } from "./client";
describe("getQueryClient mutationCache", () => {
- it("invalidates data queries but excludes auth session and flags on mutation settled", async () => {
- const queryClient = getQueryClient();
+ it.each([false, true])(
+ "invalidates data queries but excludes auth and flags after settlement (failure: %s)",
+ async (fails) => {
+ const queryClient = getQueryClient();
- queryClient.setQueryData(["auth", "session"], { user: { id: "u-1" } });
- queryClient.setQueryData(["flags"], { disableSignups: false });
- queryClient.setQueryData(["resume", "list"], [{ id: "res-1" }]);
+ queryClient.setQueryData(["auth", "session"], { user: { id: "u-1" } });
+ queryClient.setQueryData(["flags"], { disableSignups: false });
+ queryClient.setQueryData(["resume", "list"], [{ id: "res-1" }]);
- const authQuery = queryClient.getQueryCache().find({ queryKey: ["auth", "session"] });
- const flagsQuery = queryClient.getQueryCache().find({ queryKey: ["flags"] });
- const resumeQuery = queryClient.getQueryCache().find({ queryKey: ["resume", "list"] });
+ const authQuery = queryClient.getQueryCache().find({ queryKey: ["auth", "session"] });
+ const flagsQuery = queryClient.getQueryCache().find({ queryKey: ["flags"] });
+ const resumeQuery = queryClient.getQueryCache().find({ queryKey: ["resume", "list"] });
- expect(authQuery?.isStale()).toBe(false);
- expect(flagsQuery?.isStale()).toBe(false);
- expect(resumeQuery?.isStale()).toBe(false);
+ expect(authQuery?.isStale()).toBe(false);
+ expect(flagsQuery?.isStale()).toBe(false);
+ expect(resumeQuery?.isStale()).toBe(false);
- // Trigger a mutation that settles
- const mutation = queryClient.getMutationCache().build(queryClient, {
- mutationFn: async () => "success",
- });
- await mutation.execute(undefined);
+ // Trigger a mutation that settles
+ const mutation = queryClient.getMutationCache().build(queryClient, {
+ mutationFn: async () => {
+ if (fails) throw new Error("Unknown write outcome");
+ return "success";
+ },
+ });
+ if (fails) await expect(mutation.execute(undefined)).rejects.toThrow("Unknown write outcome");
+ else await mutation.execute(undefined);
- // Resume query is invalidated (stale)
- expect(resumeQuery?.isStale()).toBe(true);
+ // Resume query is invalidated (stale)
+ expect(resumeQuery?.isStale()).toBe(true);
- // Auth and flags are preserved (not stale)
- expect(authQuery?.isStale()).toBe(false);
- expect(flagsQuery?.isStale()).toBe(false);
- });
+ // Auth and flags are preserved (not stale)
+ expect(authQuery?.isStale()).toBe(false);
+ expect(flagsQuery?.isStale()).toBe(false);
+ },
+ );
});
diff --git a/tests/e2e/specs/document-title.spec.ts b/tests/e2e/specs/document-title.spec.ts
index ab2c522aa..871d5652b 100644
--- a/tests/e2e/specs/document-title.spec.ts
+++ b/tests/e2e/specs/document-title.spec.ts
@@ -77,3 +77,63 @@ for (const kind of ["resume", "letter"] as const) {
await expect(page).toHaveTitle(`${savedName} - Reactive Resume`);
});
}
+
+test("resume metadata timeout cancels the request and releases stream updates and later saves", async ({
+ authPage: page,
+}) => {
+ test.setTimeout(60_000);
+ const created = await page.request.post("/api/openapi/resumes", { data: { name: "Before rename", tags: [] } });
+ await expect(created).toBeOK();
+ const id: string = await created.json();
+ await page.goto(`/builder/${id}`);
+ await expect(page).toHaveTitle("Before rename - Reactive Resume");
+
+ let committed!: () => void;
+ let release!: () => void;
+ const serverCommitted = new Promise<void>((resolve) => {
+ committed = resolve;
+ });
+ const lateResponse = new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ const updateUrl = "**/api/rpc/resume/update";
+ await page.route(updateUrl, async (route) => {
+ const response = await route.fetch();
+ committed();
+ await lateResponse;
+ // The client deliberately aborts after the server has committed.
+ await route.fulfill({ response }).catch(() => undefined);
+ });
+ try {
+ const cancelled = page.waitForEvent("requestfailed", {
+ predicate: (request) => request.url().endsWith("/resume/update"),
+ });
+ await rename(page, "resume", "Server accepted rename");
+ await serverCommitted;
+ await cancelled;
+ const dialog = page.getByRole("dialog", { name: "Update resume", exact: true });
+ await expect(dialog.getByRole("button", { name: "Save changes", exact: true })).toBeEnabled();
+ await expect(page).toHaveTitle("Server accepted rename - Reactive Resume");
+ await page.unroute(updateUrl);
+ await dialog.getByRole("textbox", { name: "Name", exact: true }).fill("Renamed after timeout");
+ await dialog.getByRole("button", { name: "Save changes", exact: true }).click();
+ await expect(dialog).not.toBeVisible();
+ await expect(page).toHaveTitle("Renamed after timeout - Reactive Resume");
+ const saved = page.waitForResponse((response) => response.url().endsWith("/resume/update") && response.ok());
+ await page.getByRole("textbox", { name: "Headline", exact: true }).fill("Saved after timeout");
+ await saved;
+ release();
+ const read = await page.request.get(`/api/openapi/resumes/${id}`);
+ await expect(read).toBeOK();
+ expect(await read.json()).toMatchObject({
+ name: "Renamed after timeout",
+ data: { basics: { headline: "Saved after timeout" } },
+ });
+ await page.reload();
+ await expect(page).toHaveTitle("Renamed after timeout - Reactive Resume");
+ await expect(page.getByRole("textbox", { name: "Headline", exact: true })).toHaveValue("Saved after timeout");
+ } finally {
+ release();
+ if (!page.isClosed()) await page.unroute(updateUrl);
+ }
+});