chore: bump playwright (#13947)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **Chores**
* Updated Playwright test tooling to 1.58.2 across the repository and
test packages.

* **Tests**
* Improved end-to-end robustness: replaced fragile timing/coordinate
logic with element-based interactions, added polling/retry checks for
flaky asserts and async state, and simplified input/rename flows to
reduce test flakiness.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

tests/blocksuite/e2e/utils/actions/edgeless.ts

@@ -820,10 +820,10 @@ export async function updateExistedBrushElementSize(
   page: Page,
   nthSizeButton: 1 | 2 | 3 | 4 | 5 | 6
 ) {
-  // get the nth brush size button
-  const btn = page.locator(
-    `edgeless-line-width-panel .point-button:nth-child(${nthSizeButton})`
-  );
+  // pick from the visible panel to avoid strict-mode collisions from hidden/duplicate toolbars
+  const btn = page
+    .locator('edgeless-line-width-panel:visible .point-button')
+    .nth(nthSizeButton - 1);
 
   await btn.click();
 }

tests/blocksuite/e2e/utils/actions/misc.ts

@@ -1015,31 +1015,63 @@ export async function getIndexCoordinate(
   [richTextIndex, vIndex]: [number, number],
   coordOffSet: { x: number; y: number } = { x: 0, y: 0 }
 ) {
-  const coord = await page.evaluate(
-    ({ richTextIndex, vIndex, coordOffSet, currentEditorIndex }) => {
-      const editorHost =
-        document.querySelectorAll('editor-host')[currentEditorIndex];
-      const richText = editorHost.querySelectorAll('rich-text')[
-        richTextIndex
-      ] as any;
-      const domRange = richText.inlineEditor.toDomRange({
-        index: vIndex,
-        length: 0,
-      });
-      const pointBound = domRange.getBoundingClientRect();
-      return {
-        x: pointBound.left + coordOffSet.x,
-        y: pointBound.top + pointBound.height / 2 + coordOffSet.y,
-      };
-    },
-    {
-      richTextIndex,
-      vIndex,
-      coordOffSet,
-      currentEditorIndex,
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const coord = await page.evaluate(
+      ({ richTextIndex, vIndex, coordOffSet, currentEditorIndex }) => {
+        const editorHost =
+          document.querySelectorAll('editor-host')[currentEditorIndex];
+        const richTexts = Array.from(
+          editorHost?.querySelectorAll('rich-text') ?? []
+        );
+        if (!richTexts.length) {
+          return null;
+        }
+        const richText = richTexts[
+          Math.min(richTextIndex, richTexts.length - 1)
+        ] as any;
+        const inlineEditor = richText?.inlineEditor;
+        if (!inlineEditor) {
+          return null;
+        }
+        const clampedIndex = Math.max(
+          0,
+          Math.min(vIndex, inlineEditor.yTextLength ?? vIndex)
+        );
+        const domRange = inlineEditor.toDomRange({
+          index: clampedIndex,
+          length: 0,
+        });
+        if (!domRange) {
+          return null;
+        }
+        const pointBound = domRange.getBoundingClientRect();
+        if (
+          !Number.isFinite(pointBound.left) ||
+          !Number.isFinite(pointBound.top)
+        ) {
+          return null;
+        }
+        return {
+          x: pointBound.left + coordOffSet.x,
+          y: pointBound.top + pointBound.height / 2 + coordOffSet.y,
+        };
+      },
+      {
+        richTextIndex,
+        vIndex,
+        coordOffSet,
+        currentEditorIndex,
+      }
+    );
+    if (coord) {
+      return coord;
     }
+    await page.waitForTimeout(50);
+  }
+
+  throw new Error(
+    `Failed to get index coordinate: richTextIndex=${richTextIndex}, vIndex=${vIndex}`
   );
-  return coord;
 }
 
 export function inlineEditorInnerTextToString(innerText: string): string {

tests/blocksuite/e2e/utils/asserts.ts

@@ -159,17 +159,20 @@ export async function assertTextContain(page: Page, text: string, i = 0) {
 }
 
 export async function assertRichTexts(page: Page, texts: string[]) {
-  const actualTexts = await page.evaluate(() => {
-    const editorHost = document.querySelector('editor-host');
-    const richTexts = Array.from(
-      editorHost?.querySelectorAll<RichText>('rich-text') ?? []
-    );
-    return richTexts.map(richText => {
-      const editor = richText.inlineEditor as AffineInlineEditor;
-      return editor.yText.toString();
-    });
-  });
-  expect(actualTexts).toEqual(texts);
+  await expect
+    .poll(async () => {
+      return page.evaluate(() => {
+        const editorHost = document.querySelector('editor-host');
+        const richTexts = Array.from(
+          editorHost?.querySelectorAll<RichText>('rich-text') ?? []
+        );
+        return richTexts.map(richText => {
+          const editor = richText.inlineEditor as AffineInlineEditor;
+          return editor.yText.toString();
+        });
+      });
+    })
+    .toEqual(texts);
 }
 
 export async function assertEdgelessCanvasText(page: Page, text: string) {
@@ -274,16 +277,20 @@ export async function assertRichTextInlineRange(
   rangeIndex: number,
   rangeLength = 0
 ) {
-  const actual = await page.evaluate(
-    ([richTextIndex]) => {
-      const editorHost = document.querySelector('editor-host');
-      const richText = editorHost?.querySelectorAll('rich-text')[richTextIndex];
-      const inlineEditor = richText?.inlineEditor;
-      return inlineEditor?.getInlineRange();
-    },
-    [richTextIndex]
-  );
-  expect(actual).toEqual({ index: rangeIndex, length: rangeLength });
+  await expect
+    .poll(async () => {
+      return page.evaluate(
+        ([richTextIndex]) => {
+          const editorHost = document.querySelector('editor-host');
+          const richText =
+            editorHost?.querySelectorAll('rich-text')[richTextIndex];
+          const inlineEditor = richText?.inlineEditor;
+          return inlineEditor?.getInlineRange();
+        },
+        [richTextIndex]
+      );
+    })
+    .toEqual({ index: rangeIndex, length: rangeLength });
 }
 
 export async function assertNativeSelectionRangeCount(
@@ -1137,15 +1144,18 @@ export async function assertNoteSequence(page: Page, expected: string) {
 }
 
 export async function assertBlockSelections(page: Page, paths: string[]) {
-  const selections = await page.evaluate(() => {
-    const host = document.querySelector<EditorHost>('editor-host');
-    if (!host) {
-      throw new Error('editor-host host not found');
-    }
-    return host.selection.value.filter(b => b.type === 'block');
-  });
-  const actualPaths = selections.map(selection => selection.blockId);
-  expect(actualPaths).toEqual(paths);
+  await expect
+    .poll(async () => {
+      const selections = await page.evaluate(() => {
+        const host = document.querySelector<EditorHost>('editor-host');
+        if (!host) {
+          throw new Error('editor-host host not found');
+        }
+        return host.selection.value.filter(b => b.type === 'block');
+      });
+      return selections.map(selection => selection.blockId);
+    })
+    .toEqual(paths);
 }
 
 export async function assertTextSelection(