editor.spec.ts · Source

editor.spec.tstests/e2e/specs/editor.spec.tsraw ← specs24,775 B← Back to the app
1/**
2 * AI Software Factory — E2E: Block Editor (Phase 4)
3 *
4 * The canonical editor interaction suite. Slash commands, block types, the
5 * ⋮ context menu ("turn into" / delete), copy/paste, and reload persistence.
6 *
7 * T-194 — rewritten against the REAL editor surface (the pre-rewrite spec
8 * asserted a surface that never existed: an `<h1>` tag for headings, a
9 * `drag-handle-{id}` testid, a `context-menu-turn-heading1` id, a
10 * `toggle-handle-{id}` caret, `slash-menu-item-heading1`, block-level
11 * Backspace demotion, and block-level undo/redo — none of which the app
12 * implements, so the suite was red across the board). This rewrite drives
13 * the surface the app actually ships and asserts type/content changes
14 * SERVER-side (the read API is the source of truth — headings and quotes
15 * render as styled Tiptap contenteditables, not semantic tags), per AGENTS
16 * rule 29.
17 *
18 * Fresh-page typing surface (T-194 design decision — recorded conflict,
19 * rule 29): a freshly created page carries exactly ONE block, the seeded
20 * title (`properties.isTitle`). The render loop does NOT draw the title in
21 * the body (the header's `page-title` contenteditable is the canonical
22 * title and self-syncs). So the body of a fresh page is an empty canvas +
23 * the `new-block` trailing area — clicking it creates + focuses the first
24 * real paragraph (`onTrailingAreaClick` → `createSibling`), which is where
25 * typing and "/" begin. The recommended "server seeds an initial empty
26 * paragraph" was deliberately NOT taken: it would flip `contentBlockCount`
27 * to 1 and hide the TASK-0126 Home AI card on every fresh page, and would
28 * leave a stray empty leading block in the AI/template/import/duplicate
29 * flows (all of which call `pages.create` then populate). The existing
30 * `new-block` surface already provides a first-class fresh-page entry.
31 *
32 * Selector convention (tests/README.md): locate INTERACTIVE elements by
33 * `data-testid` only. (Text/role locators for controls are banned — they
34 * couple to copy and break on i18n. Reading rendered content text for an
35 * ASSERTION is allowed and used in the pinned green specs.)
36 *   data-testid="editor-root"               editor container
37 *   data-testid="block-{id}"                a top-level block row
38 *   data-testid="new-block"                 trailing "keep typing" area
39 *   data-testid="slash-menu" / "-item-{id}" slash palette + items
40 *   data-testid="block-context-menu"        right-click menu on a block
41 *   data-testid="context-menu-turn-into"    "Turn into…" button
42 *   data-testid="context-menu-turn-{type}"  a "Turn into" target type
43 *   data-testid="context-menu-delete"       the Delete menu item
44 *   data-testid="todo-checkbox-{id}"        checkbox on a TODO block
45 *   data-testid="toggle-chevron-{id}"       toggle open/close caret
46 *   data-testid="column-list" / "column-{n}" columns container + cell
47 *   data-testid="code-block-pre"            rendered (non-edit) code block
48 *
49 * Keyboard (the documented, implemented set):
50 *   "/" (in an EMPTY block) → slash menu
51 *   Enter (text block)      → new sibling paragraph below
52 *   Enter (toggle title)    → new CHILD inside the toggle
53 */
54import { test, expect } from "../fixtures";
55import type { APIRequestContext, Page } from "@playwright/test";
56 
57interface BlockRow {
58  id: string;
59  parentId: string | null;
60  type: string;
61  content: unknown;
62  properties: unknown;
63}
64 
65interface BlocksResponse {
66  data: BlockRow[];
67}
68 
69/**
70 * Top-level block rows. The `[data-block-id]` guard excludes
71 * `block-context-menu` (which also starts with the `block-` prefix) — only
72 * real rows carry both attributes.
73 */
74function rows(page: Page) {
75  return page.locator('[data-testid^="block-"][data-block-id]');
76}
77 
78/** Create a page under a workspace (BARE `{ id }` body — no wrapper). */
79async function createPage(
80  api: APIRequestContext,
81  wsId: string,
82  title: string,
83): Promise<string> {
84  const res = await api.post(`/api/v1/workspaces/${wsId}/pages`, {
85    data: { title },
86  });
87  expect(res.status(), await res.text()).toBe(201);
88  return ((await res.json()) as { id: string }).id;
89}
90 
91/** Top-level CONTENT blocks (the seeded title block is excluded). */
92async function contentBlocks(
93  api: APIRequestContext,
94  pageId: string,
95): Promise<BlockRow[]> {
96  const res = await api.get(`/api/v1/pages/${pageId}/blocks`);
97  expect(res.status()).toBe(200);
98  const body = (await res.json()) as BlocksResponse;
99  return body.data.filter(
100    (b) => b.parentId === null && !(b.properties as { isTitle?: boolean })?.isTitle,
101  );
102}
103 
104/** Every live block on the page (all parents) — for nested/count asserts. */
105async function allBlocks(api: APIRequestContext, pageId: string): Promise<BlockRow[]> {
106  const res = await api.get(`/api/v1/pages/${pageId}/blocks?depth=all`);
107  expect(res.status()).toBe(200);
108  return ((await res.json()) as BlocksResponse).data;
109}
110 
111/** The server-stored text of a block (`{ text }` / html string / `{}`). */
112function blockText(b: BlockRow): string {
113  const c = b.content as { text?: unknown } | string | null;
114  if (typeof c === "string") return c.replace(/<[^>]*>/g, "");
115  if (c && typeof c === "object" && typeof c.text === "string") return c.text;
116  return "";
117}
118 
119/** Wait for a given number of top-level rows to render. */
120async function expectRowCount(page: Page, n: number) {
121  await expect(rows(page)).toHaveCount(n, { timeout: 5_000 });
122}
123 
124/** Wait until the top-level row count has been unchanged for ~450 ms. Used
125 *  after async insert/delete sequences (slash pick, Enter, TASK-0136 auto-
126 *  delete) so the count/id we read next is stable. Gives up silently at the
127 *  timeout (the caller's own assertions then apply). */
128async function waitStableRows(page: Page, timeout = 8_000) {
129  const start = Date.now();
130  let prev = await rows(page).count();
131  let stable = 0;
132  for (;;) {
133    if (Date.now() - start > timeout) return;
134    await page.waitForTimeout(150);
135    const c = await rows(page).count();
136    stable = c === prev ? stable + 1 : 0;
137    prev = c;
138    if (stable >= 3) return;
139  }
140}
141 
142/**
143 * Press Enter in the focused text block (creates an empty sibling below)
144 * and leave the caret in it. The create→re-render→focus round-trip is async,
145 * and a TASK-0136 auto-delete of an earlier EMPTY sibling can be in flight
146 * (or a stale refetch can briefly resurrect a deleted row), so a fixed
147 * `before+1` count is racy — instead identify the new sibling by its fresh
148 * `data-block-id` (it is the new last row) and settle before clicking.
149 */
150async function enterNewBlock(page: Page) {
151  await waitStableRows(page);
152  const lastIdBefore = await rows(page).last().getAttribute("data-block-id");
153  await page.keyboard.press("Enter");
154  await expect
155    .poll(async () => {
156      const n = await rows(page).count();
157      if (n === 0) return false;
158      return (await rows(page).last().getAttribute("data-block-id")) !== lastIdBefore;
159    }, { timeout: 8_000 })
160    .toBe(true);
161  await waitStableRows(page);
162  await rows(page).last().locator("[contenteditable]").first().click();
163}
164 
165/**
166 * Pick a slash command from a focused EMPTY block and leave the caret in the
167 * created block.
168 *
169 * The slash trigger only fires in a block whose text STARTS with "/" — so
170 * the caller must have an empty, focused block (the one `openFreshPage` or a
171 * prior `enterNewBlock` created). That block (the "anchor") is always the LAST
172 * row; the pick clears it (→ it auto-deletes on blur via TASK-0136) and
173 * inserts the new block AFTER it. Row-count arithmetic is racy here (the count
174 * oscillates `before → before+1 → before` across the insert + anchor delete),
175 * so instead we wait for the new block by its identity: a fresh
176 * `data-block-id` that differs from the anchor's. The anchor stays the last
177 * row until the new one renders, so the last row's id flips exactly once.
178 */
179async function slashCommand(page: Page, itemId: string, focusNew = true) {
180  const anchorId = await rows(page).last().getAttribute("data-block-id");
181  await page.keyboard.type("/");
182  await expect(page.getByTestId("slash-menu")).toBeVisible({ timeout: 5_000 });
183  await page.getByTestId(`slash-menu-item-${itemId}`).click();
184  if (!focusNew) return; // structural blocks (divider, code, columns, …)
185  await expect
186    .poll(async () => {
187      const n = await rows(page).count();
188      if (n === 0) return false;
189      return (await rows(page).last().getAttribute("data-block-id")) !== anchorId;
190    }, { timeout: 8_000 })
191    .toBe(true);
192  await rows(page).last().locator("[contenteditable]").first().click();
193}
194 
195/**
196 * Open a fresh page and leave the caret in a real, focused paragraph:
197 * `new-block` click → the trailing area creates + focuses the first block.
198 * Returns the page id. (A fresh page has no `block-*` rows in the body —
199 * the seeded title is not rendered — so this must NOT click a first block.)
200 */
201async function openFreshPage(
202  authPage: Page,
203  api: APIRequestContext,
204  wsId: string,
205): Promise<string> {
206  const pageId = await createPage(api, wsId, "Editor Test Page");
207  await authPage.goto(`/w/${wsId}/page/${pageId}`);
208  await expect(authPage.getByTestId("editor-root")).toBeVisible({ timeout: 20_000 });
209  // No body blocks yet (title-only page; the title is not rendered in body).
210  expect(await rows(authPage).count()).toBe(0);
211  // Enter the trailing area → creates + focuses the first paragraph.
212  await authPage.locator("#workspace-main").getByTestId("new-block").click();
213  await expectRowCount(authPage, 1);
214  // Settle the caret in the (single) new row's editor.
215  await rows(authPage).first().locator("[contenteditable]").click();
216  return pageId;
217}
218 
219test.describe("Block Editor — Phase 4 (T-194)", () => {
220  test("type a paragraph and it persists", async ({ authPage, api, freshWorkspace }) => {
221    const ws = await freshWorkspace("Editor WS");
222    const pageId = await openFreshPage(authPage, api, ws.id);
223    await authPage.keyboard.type("Hello from the editor");
224    // The block row renders the typed text…
225    await expect(rows(authPage).first()).toContainText("Hello from the editor");
226    // …and it round-trips to the server (1 content block, text intact).
227    await expect
228      .poll(async () => {
229        const blocks = await contentBlocks(api, pageId);
230        return blocks.length === 1 ? blockText(blocks[0]!) : "";
231      }, { timeout: 10_000 })
232      .toBe("Hello from the editor");
233  });
234 
235  test("slash menu: /h1 creates a heading", async ({ authPage, api, freshWorkspace }) => {
236    const ws = await freshWorkspace("Editor WS");
237    const pageId = await openFreshPage(authPage, api, ws.id);
238    await slashCommand(authPage, "h1");
239    await authPage.keyboard.type("A Heading One");
240    // Headings render as a styled contenteditable (NOT an <h1> tag): assert
241    // the change server-side (type HEADING_1) + the text is visible.
242    await expect
243      .poll(async () => {
244        const b = (await contentBlocks(api, pageId)).find((x) => x.type === "HEADING_1");
245        return b ? blockText(b) : "";
246      }, { timeout: 10_000 })
247      .toBe("A Heading One");
248    await expect(authPage.getByText("A Heading One")).toBeVisible();
249  });
250 
251  test("slash menu: /todo creates a checkable checkbox block", async ({
252    authPage,
253    api,
254    freshWorkspace,
255  }) => {
256    const ws = await freshWorkspace("Editor WS");
257    const pageId = await openFreshPage(authPage, api, ws.id);
258    await slashCommand(authPage, "todo");
259    await authPage.keyboard.type("Buy milk");
260    const checkbox = authPage.getByTestId(/todo-checkbox-/).first();
261    await expect(checkbox).toBeVisible({ timeout: 5_000 });
262    // Initially unchecked; checking it persists server-side (props.checked).
263    await expect(checkbox).toHaveAttribute("aria-checked", "false");
264    await checkbox.click();
265    await expect
266      .poll(async () => {
267        const b = (await contentBlocks(api, pageId)).find((x) => x.type === "TODO");
268        return (b?.properties as { checked?: boolean })?.checked ?? false;
269      }, { timeout: 10_000 })
270      .toBe(true);
271    await expect(checkbox).toHaveAttribute("aria-checked", "true");
272  });
273 
274  test("slash menu: /quote /callout /code create their blocks", async ({
275    authPage,
276    api,
277    freshWorkspace,
278  }) => {
279    const ws = await freshWorkspace("Editor WS");
280    const pageId = await openFreshPage(authPage, api, ws.id);
281 
282    // Each command is typed in its own EMPTY block (the slash trigger needs
283    // the text to START with "/"), so Enter opens a fresh sibling between them.
284    await slashCommand(authPage, "quote");
285    await authPage.keyboard.type("A quote");
286    await enterNewBlock(authPage);
287 
288    await slashCommand(authPage, "callout");
289    await authPage.keyboard.type("A callout");
290    await enterNewBlock(authPage);
291 
292    // Code is NOT a contenteditable: it is a <pre> + an Edit/Save overlay, so
293    // the text is entered through the edit textarea, then read back from the
294    // rendered <pre> (the non-edit overlay).
295    await slashCommand(authPage, "code", false);
296    await expect(authPage.getByLabel("Edit code")).toBeVisible({ timeout: 5_000 });
297    await authPage.getByLabel("Edit code").click();
298    await authPage.getByLabel("Code", { exact: true }).fill("const x = 1;");
299    // Commit via Escape (the documented save path; the Save button label
300    // flip is flaky right after a rapid block sequence).
301    await authPage.keyboard.press("Escape");
302    await expect(authPage.getByTestId("code-block-pre")).toContainText("const x = 1;");
303 
304    // All three types persist server-side with their text.
305    await expect
306      .poll(async () => {
307        const blocks = await contentBlocks(api, pageId);
308        const quote = blocks.find((b) => b.type === "QUOTE");
309        const callout = blocks.find((b) => b.type === "CALLOUT");
310        const code = blocks.find((b) => b.type === "CODE");
311        return (
312          !!quote && blockText(quote) === "A quote" &&
313          !!callout && blockText(callout) === "A callout" &&
314          !!code && blockText(code).includes("const x = 1;")
315        );
316      }, { timeout: 10_000 })
317      .toBe(true);
318  });
319 
320  test("slash menu: /divider inserts a divider", async ({
321    authPage,
322    api,
323    freshWorkspace,
324  }) => {
325    const ws = await freshWorkspace("Editor WS");
326    const pageId = await openFreshPage(authPage, api, ws.id);
327    await authPage.keyboard.type("above");
328    await enterNewBlock(authPage); // fresh empty sibling (caret settled)
329    await slashCommand(authPage, "divider", false);
330    // A divider is a non-text block: the <hr> renders.
331    await expect(authPage.locator("hr")).toBeVisible({ timeout: 5_000 });
332    await expect
333      .poll(async () => (await contentBlocks(api, pageId)).some((b) => b.type === "DIVIDER"))
334      .toBe(true);
335  });
336 
337  test("slash menu: /toggle creates a collapsible block with a child", async ({
338    authPage,
339    api,
340    freshWorkspace,
341  }) => {
342    const ws = await freshWorkspace("Editor WS");
343    const pageId = await openFreshPage(authPage, api, ws.id);
344    await slashCommand(authPage, "toggle");
345    await authPage.keyboard.type("Toggle me");
346    // Enter in the toggle TITLE creates a CHILD inside (Notion semantics).
347    await authPage.keyboard.press("Enter");
348    // The toggle is the only top-level row; its child editor is the LAST
349    // contenteditable within it (the title editor comes first).
350    const toggleRow = rows(authPage).last();
351    await expect(toggleRow.locator("[contenteditable]")).toHaveCount(2, { timeout: 5_000 });
352    const child = toggleRow.locator("[contenteditable]").last();
353    await child.click();
354    await authPage.keyboard.type("hidden child");
355    await expect(child).toContainText("hidden child");
356 
357    // The chevron reports expanded; collapse HIDES the child (a controlled
358    // <details> keeps it in the DOM — assert visibility, not presence).
359    const chevron = authPage.getByTestId(/toggle-chevron-/).first();
360    await expect(chevron).toHaveAttribute("aria-expanded", "true");
361    await chevron.click();
362    await expect(chevron).toHaveAttribute("aria-expanded", "false");
363    await expect(child).toBeHidden();
364    await chevron.click();
365    await expect(chevron).toHaveAttribute("aria-expanded", "true");
366    await expect(child).toBeVisible();
367 
368    // Server: the toggle has exactly one child paragraph.
369    await expect
370      .poll(async () => {
371        const all = await allBlocks(api, pageId);
372        const toggle = all.find((b) => b.type === "TOGGLE");
373        return all.filter((b) => b.parentId === toggle?.id).length;
374      }, { timeout: 10_000 })
375      .toBe(1);
376  });
377 
378  test("slash menu: /columns creates an editable 2-column grid", async ({
379    authPage,
380    api,
381    freshWorkspace,
382  }) => {
383    const ws = await freshWorkspace("Editor WS");
384    const pageId = await openFreshPage(authPage, api, ws.id);
385    await slashCommand(authPage, "columns", false);
386    // The container + the two server-seeded column cells appear (async child
387    // load — poll). `^column-\d` excludes the `column-list` container itself.
388    await expect(authPage.getByTestId("column-list")).toBeVisible({ timeout: 10_000 });
389    await expect
390      .poll(async () => authPage.getByTestId(/^column-\d/).count(), { timeout: 10_000 })
391      .toBe(2);
392    // The first column holds an editable paragraph — type into it.
393    await authPage.locator('[data-testid="column-1"] [contenteditable]').first().click();
394    await authPage.keyboard.type("left column");
395    await expect(authPage.getByTestId("column-list")).toContainText("left column");
396    // Server: column_list + two column children (a grid, not a dead end).
397    await expect
398      .poll(async () => (await allBlocks(api, pageId)).filter((b) => b.type === "COLUMN").length, {
399        timeout: 10_000,
400      })
401      .toBe(2);
402  });
403 
404  test("context menu: delete a block", async ({ authPage, api, freshWorkspace }) => {
405    const ws = await freshWorkspace("Editor WS");
406    const pageId = await openFreshPage(authPage, api, ws.id);
407    // Two content blocks.
408    await authPage.keyboard.type("keep me");
409    await enterNewBlock(authPage);
410    await authPage.keyboard.type("remove me");
411    await expectRowCount(authPage, 2);
412    // Right-click the second block → Delete. (The app deletes a SELECTION via
413    // the menu — there is no block-level Backspace/undo keyboard path.)
414    await rows(authPage).nth(1).click({ button: "right" });
415    const menu = authPage.getByTestId("block-context-menu");
416    await expect(menu).toBeVisible({ timeout: 5_000 });
417    await menu.getByTestId("context-menu-delete").click();
418    // The row is gone; the surviving block + its text remain.
419    await expectRowCount(authPage, 1);
420    await expect(rows(authPage).first()).toContainText("keep me");
421    await expect
422      .poll(async () => (await contentBlocks(api, pageId)).map(blockText), { timeout: 10_000 })
423      .toEqual(["keep me"]);
424  });
425 
426  test("slash menu search filters commands", async ({
427    authPage,
428    api,
429    freshWorkspace,
430  }) => {
431    const ws = await freshWorkspace("Editor WS");
432    await openFreshPage(authPage, api, ws.id);
433    await authPage.keyboard.type("/");
434    const menu = authPage.getByTestId("slash-menu");
435    await expect(menu).toBeVisible({ timeout: 5_000 });
436    // Filter to a single match; unrelated commands drop out.
437    await authPage.keyboard.type("div");
438    await expect(menu.getByTestId("slash-menu-item-divider")).toBeVisible({ timeout: 5_000 });
439    await expect(menu.getByTestId("slash-menu-item-todo")).toHaveCount(0);
440  });
441 
442  test("context menu: turn into heading 1", async ({
443    authPage,
444    api,
445    freshWorkspace,
446  }) => {
447    const ws = await freshWorkspace("Editor WS");
448    const pageId = await openFreshPage(authPage, api, ws.id);
449    await authPage.keyboard.type("Turn me");
450    await rows(authPage).first().click({ button: "right" });
451    const menu = authPage.getByTestId("block-context-menu");
452    await expect(menu).toBeVisible({ timeout: 5_000 });
453    // Open the "Turn into…" submenu, then pick Heading 1.
454    await menu.getByTestId("context-menu-turn-into").click();
455    await authPage.getByTestId("context-menu-turn-heading_1").click();
456    // The conversion is server-persisted (type HEADING_1); text survives.
457    await expect
458      .poll(async () => {
459        const b = (await contentBlocks(api, pageId))[0];
460        return b && b.type === "HEADING_1" ? blockText(b) : "";
461      }, { timeout: 10_000 })
462      .toBe("Turn me");
463    await expect(authPage.getByText("Turn me")).toBeVisible();
464  });
465 
466  test("copy / paste a paragraph (plain-text native paste)", async ({
467    authPage,
468    api,
469    freshWorkspace,
470  }) => {
471    const ws = await freshWorkspace("Editor WS");
472    const pageId = await openFreshPage(authPage, api, ws.id);
473    await authPage.keyboard.type("Copyable line");
474    await enterNewBlock(authPage); // empty sibling, caret settled
475    // Synthetic plain-text paste on the FOCUSED editor: ProseMirror's native
476    // paste handler inserts at the caret (the window handler only hijacks
477    // structural/HTML + the app's internal payload — plain text passes
478    // through). Dispatching on the contenteditable (not the window) is what
479    // lets the editor's own handler see it; real Ctrl+C/V would need clipboard
480    // permissions the fixture contexts don't grant.
481    await authPage.evaluate(() => {
482      const dt = new DataTransfer();
483      dt.setData("text/plain", "Copyable line");
484      const evt = new ClipboardEvent("paste", {
485        clipboardData: dt,
486        bubbles: true,
487        cancelable: true,
488      });
489      (document.activeElement as HTMLElement).dispatchEvent(evt);
490    });
491    // Two blocks, both carrying the text.
492    await expectRowCount(authPage, 2);
493    await expect
494      .poll(async () => {
495        const blocks = await contentBlocks(api, pageId);
496        return blocks.length === 2 && blocks.every((b) => blockText(b) === "Copyable line");
497      }, { timeout: 10_000 })
498      .toBe(true);
499  });
500 
501  test("empty-block cleanup on blur", async ({ authPage, api, freshWorkspace }) => {
502    const ws = await freshWorkspace("Editor WS");
503    const pageId = await openFreshPage(authPage, api, ws.id);
504    // Type a block, Enter (creates an EMPTY sibling, caret in it), then
505    // click back into the first block: the empty sibling loses focus while
506    // still empty → it is auto-deleted (TASK-0136), page back to one block.
507    await authPage.keyboard.type("first line");
508    await enterNewBlock(authPage);
509    await expectRowCount(authPage, 2);
510    // Click into the first (non-empty) block → the empty one blurs + cleans.
511    await rows(authPage).first().locator("[contenteditable]").click();
512    await expect
513      .poll(async () => (await contentBlocks(api, pageId)).length, { timeout: 10_000 })
514      .toBe(1);
515    await expectRowCount(authPage, 1);
516  });
517 
518  test("reload preserves blocks (ordering + count survive)", async ({
519    authPage,
520    api,
521    freshWorkspace,
522  }) => {
523    const ws = await freshWorkspace("Editor WS");
524    const pageId = await openFreshPage(authPage, api, ws.id);
525    await authPage.keyboard.type("persist A");
526    await enterNewBlock(authPage);
527    await authPage.keyboard.type("persist B");
528    await expectRowCount(authPage, 2);
529    // Settle: block content is debounced into a ~500 ms batch flush and a
530    // hard reload won't run the unmount flush — so wait until BOTH blocks are
531    // server-persisted before reloading, or the second (unflushed) block
532    // would be lost.
533    await expect
534      .poll(async () => (await contentBlocks(api, pageId)).map(blockText), { timeout: 10_000 })
535      .toEqual(["persist A", "persist B"]);
536 
537    await authPage.reload();
538    await expect(authPage.getByTestId("editor-root")).toBeVisible({ timeout: 20_000 });
539 
540    // Both blocks render, in order (read the contenteditable's own text —
541    // the row also carries gutter/handle markup). Tiptap re-hydrates the
542    // editors after the query resolves, so poll until BOTH texts are present
543    // (a naive read can catch a row before its editor content mounts).
544    const blockRows = rows(authPage);
545    await expect(blockRows).toHaveCount(2, { timeout: 10_000 });
546    await expect
547      .poll(async () =>
548        Promise.all(
549          [0, 1].map(
550            async (i) =>
551              ((await blockRows.nth(i).locator("[contenteditable]").first().textContent()) ?? "").trim(),
552          ),
553        ),
554      { timeout: 10_000 })
555      .toEqual(["persist A", "persist B"]);
556 
557    // The server carries both content blocks in order (the title block is
558    // excluded — it is not body content).
559    expect((await contentBlocks(api, pageId)).map(blockText)).toEqual([
560      "persist A",
561      "persist B",
562    ]);
563  });
564});
565