E2E speedup (Step 2): replace fixed sleeps with condition polling

Cuts Playwright wall-clock from 10m12s to 5m6s (-50%) and checker total
from 13m12s to 6m25s (-51%) by replacing the highest-payoff fixed sleeps
with `pollUntil` / `waitForSelector` conditions.

Highlights:
- `pollUntil` default interval 100 → 50 ms
- `ensureAppReady`: dropped `sleep(500)` after route nav (waitForSelector
  follows) and `sleep(300)` after mcp-nav-to-path (file-poll covers it)
- MTP / SMB / network-toggle `beforeEach`: `sleep(2000)` after volume
  switch → poll `cmdr://state` for both panes on local volume
- a11y `setTheme`: dropped `sleep(2000)` entirely — only mattered for
  color-contrast which is disabled in this suite
- a11y Settings-section loop: trimmed two `sleep(500)`s (one redundant
  with pollUntil-visibility, the other shortened)
- MTP 50 MB copy: `sleep(10000)` → poll `fs.statSync(dest).size`
- mtp-conflicts post-op `sleep(3000)` × 5: poll the actual file-state
  contract (src absent + dest content) or drop where `waitForDialogsToClose`
  already gates the user-visible signal
- error-pane: `sleep(2000)` after navigate → poll `.error-pane` visibility
- file-watching deleted-dir test: `sleep(3000)` → 5 s poll for temp file
  to drop from listing

Also fixes a pre-existing lint warning in the sleep-instrumentation
(`${ms}` template expression).

Suite result: 122 expected pass, 17 skipped, 0 failed, 0 flaky.
Sleep budget total: 488.9 s → 172.3 s (-65%).

Author: vdavid

apps/desktop/test/e2e-playwright/accessibility.spec.ts

@@ -181,12 +181,11 @@ async function setTheme(tauriPage: PageLike, mode: 'dark' | 'light'): Promise<vo
     5000,
   )
 
-  // Force a synchronous reflow so WKWebView invalidates cached computed styles,
-  // then sleep to give the browser time to propagate to all descendant elements.
-  // 2s is generous but WKWebView's style cache invalidation can lag significantly
-  // under load (the first theme switch after app launch is the worst case).
+  // Force a synchronous reflow so WKWebView invalidates cached computed styles.
+  // Historically a 2 s sleep followed this to wait for descendant style cache
+  // flushing, but that mattered only for color-contrast auditing — which is
+  // disabled in this suite. The :root pollUntil above is enough.
   await tauriPage.evaluate(`document.documentElement.offsetHeight`)
-  await sleep(2000)
 }
 
 // ── Tests ───────────────────────────────────────────────────────────────────
@@ -343,7 +342,6 @@ for (const mode of ['light', 'dark'] as const) {
                 }
             }
         })()`)
-        await sleep(500)
 
         // Wait for the section to be visible
         const sectionSelector = `[data-section-id="${section.sectionId}"]`
@@ -354,9 +352,11 @@ for (const mode of ['light', 'dark'] as const) {
           continue
         }
 
-        // Extra settle time for sections with async data (for example, Drive indexing
+        // Brief settle for sections with async data (for example, Drive indexing
         // loads dbFileSize which controls the "Clear index" button's disabled state).
-        await sleep(500)
+        // The pollUntil above already gated on section visibility — this just lets
+        // any reactive child updates land before axe inspects the DOM.
+        await sleep(150)
 
         const { all } = await runAxeAudit(tauriPage, `Settings: ${section.name} (${mode})`)
         if (all.length > 0) {

apps/desktop/test/e2e-playwright/error-pane.spec.ts

@@ -59,7 +59,9 @@ async function injectAndNavigateIntoSubDir(tauriPage: PageLike, errorCode: numbe
             payload: { pane: 'left', path: ${JSON.stringify(subDirPath)} }
         });
     })()`)
-  await sleep(2000)
+  // Wait for the error pane to render (the injected error fires during the
+  // background listing kicked off by the navigation above).
+  await pollUntil(tauriPage, async () => tauriPage.evaluate<boolean>(`!!document.querySelector('.error-pane')`), 10000)
 }
 
 /** Navigates the focused pane back to the fixture root's left/ directory. */

apps/desktop/test/e2e-playwright/file-watching.spec.ts

@@ -201,8 +201,19 @@ test.describe('File watching', () => {
     fs.rmSync(tempDir, { recursive: true, force: true })
     extraPaths.length = 0 // Already removed
 
-    // Give the app time to react
-    await sleep(3000)
+    // Give the app time to react. We don't have a strict UI signal for "the
+    // watcher noticed the parent went away", so poll until the file-pane stops
+    // listing the temp file (which proves the listing was refreshed) or until
+    // the timeout — then the subsequent assertions cover the "app still works"
+    // contract regardless.
+    await pollUntil(
+      tauriPage,
+      async () => {
+        const stillThere = await fileExistsInPane(tauriPage, 'temp-file.txt', 1)
+        return !stillThere
+      },
+      5000,
+    )
 
     // The app should still be functional — left pane unaffected
     expect(await fileExistsInPane(tauriPage, 'file-a.txt', 0)).toBe(true)

apps/desktop/test/e2e-playwright/helpers.ts

@@ -114,7 +114,6 @@ export async function ensureAppReady(
   // Navigate to the main route to ensure we're on the file explorer page.
   // This does NOT reset the directory — just ensures we're on the right route.
   await navigateToRoute(tauriPage, '/')
-  await sleep(500)
 
   // Wait for file entries to be visible (confirms app is fully loaded)
   await tauriPage.waitForSelector('.file-entry', 15000)
@@ -159,7 +158,8 @@ export async function ensureAppReady(
             payload: { pane: 'right', path: ${JSON.stringify(rightPanePath)} }
         });
     })()`)
-  await sleep(300)
+
+  // The leftExpected file poll below covers the wait for navigation to land.
 
   // Wait for the left pane to show the expected fixture files
   const leftExpected = expectedFiles?.leftPane ?? ['file-a.txt', 'sub-dir']
@@ -399,6 +399,13 @@ export async function countEntriesWithPrefix(tauriPage: PageLike, prefix: string
 // ── Utility ─────────────────────────────────────────────────────────────────
 
 export function sleep(ms: number): Promise<void> {
+  if (process.env.SLEEP_LOG === '1') {
+    const stack = new Error().stack ?? ''
+    const lines = stack.split('\n')
+    // index 0 = "Error", 1 = sleep itself, 2 = caller
+    const frame = (lines[2] ?? '').trim().slice(0, 200)
+    process.stdout.write(`[sleep] +${String(ms)}ms @ ${frame}\n`)
+  }
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
@@ -410,7 +417,7 @@ export async function pollUntil(
   _page: PageLike,
   condition: () => Promise<boolean>,
   timeout: number,
-  interval = 100,
+  interval = 50,
 ): Promise<boolean> {
   const deadline = Date.now() + timeout
   while (Date.now() < deadline) {

apps/desktop/test/e2e-playwright/mtp-conflicts.spec.ts

@@ -23,7 +23,7 @@ import {
   mcpAwaitItem,
   mcpSwitchPane,
 } from '../e2e-shared/mcp-client.js'
-import { ensureAppReady, getFixtureRoot, sleep, TRANSFER_DIALOG } from './helpers.js'
+import { ensureAppReady, getFixtureRoot, pollUntil, sleep, TRANSFER_DIALOG } from './helpers.js'
 import {
   waitForConflictPolicy,
   selectConflictPolicy,
@@ -34,6 +34,30 @@ import {
 const INTERNAL_STORAGE = 'Virtual Pixel 9 - Internal Storage'
 const LOCAL_VOLUME_NAME = os.platform() === 'linux' ? 'Root' : 'Macintosh HD'
 
+/** True when both panes show the local volume in cmdr://state. */
+async function bothPanesOnLocalVolume(): Promise<boolean> {
+  const state = await mcpReadResource('cmdr://state')
+  const volumeLines = (state.match(/\n {2}volume: ([^\n]+)/g) ?? []).map((line) => line.replace(/^\n {2}volume: /, ''))
+  return volumeLines.length >= 2 && volumeLines[0] === LOCAL_VOLUME_NAME && volumeLines[1] === LOCAL_VOLUME_NAME
+}
+
+/**
+ * Polls a sync filesystem predicate until it returns true or timeout is reached.
+ * Used to wait for MTP / cross-volume operations to settle on disk.
+ */
+async function pollFs(
+  tauriPage: Parameters<typeof pollUntil>[0],
+  predicate: () => boolean,
+  timeoutMs = 15000,
+): Promise<boolean> {
+  return pollUntil(
+    tauriPage,
+    // eslint-disable-next-line @typescript-eslint/require-await -- pollUntil expects a Promise<boolean>
+    async () => predicate(),
+    timeoutMs,
+  )
+}
+
 /** Discovers the mtp:// path prefix for a named MTP storage from cmdr://state. */
 async function getMtpVolumePath(storageName: string): Promise<string> {
   const state = await mcpReadResource('cmdr://state')
@@ -67,11 +91,10 @@ test.beforeEach(async ({ tauriPage }) => {
     invoke('plugin:event|emit', { event: 'mcp-volume-select', payload: { pane: 'left', name: '${LOCAL_VOLUME_NAME}' } });
     invoke('plugin:event|emit', { event: 'mcp-volume-select', payload: { pane: 'right', name: '${LOCAL_VOLUME_NAME}' } });
   })()`)
-  await sleep(2000)
+  await pollUntil(tauriPage, async () => bothPanesOnLocalVolume(), 5000)
   await tauriPage.keyboard.press('Escape')
-  await sleep(200)
   await tauriPage.keyboard.press('Escape')
-  await sleep(200)
+  await pollUntil(tauriPage, async () => !(await tauriPage.isVisible('.modal-overlay')), 2000)
 })
 
 // ── Cross-volume move conflicts (MTP ↔ local) ──────────────────────────────
@@ -100,15 +123,25 @@ test.describe('MTP cross-volume move conflicts', () => {
     await clickTransferStart(tauriPage)
     await waitForDialogsToClose(tauriPage, 30000)
 
-    // Wait for MTP operation
-    await sleep(3000)
+    // Wait for the MTP operation to settle on disk: dest contains MTP content AND source removed.
+    const destPath = path.join(fixtureRoot, 'right', 'report.txt')
+    const srcPath = path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'report.txt')
+    await pollFs(
+      tauriPage,
+      () => {
+        if (fs.existsSync(srcPath)) return false
+        if (!fs.existsSync(destPath)) return false
+        return fs.readFileSync(destPath, 'utf-8').includes('Quarterly report')
+      },
+      15000,
+    )
 
     // Dest should have MTP content (overwritten)
-    const destContent = fs.readFileSync(path.join(fixtureRoot, 'right', 'report.txt'), 'utf-8')
+    const destContent = fs.readFileSync(destPath, 'utf-8')
     expect(destContent).toContain('Quarterly report')
 
     // Source should be deleted from MTP
-    expect(fs.existsSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'report.txt'))).toBe(false)
+    expect(fs.existsSync(srcPath)).toBe(false)
   })
 
   test('MTP-to-local move with skip preserves both files', async ({ tauriPage }) => {
@@ -132,8 +165,6 @@ test.describe('MTP cross-volume move conflicts', () => {
     await clickTransferStart(tauriPage)
     await waitForDialogsToClose(tauriPage, 30000)
 
-    await sleep(3000)
-
     // Dest unchanged (skip)
     const destContent = fs.readFileSync(path.join(fixtureRoot, 'right', 'report.txt'), 'utf-8')
     expect(destContent).toBe('local-version')
@@ -164,15 +195,27 @@ test.describe('MTP cross-volume move conflicts', () => {
     await clickTransferStart(tauriPage)
     await waitForDialogsToClose(tauriPage, 30000)
 
-    await sleep(3000)
+    // Wait for the move to settle on disk: MTP file has overwritten content AND source removed.
+    const mtpDest = path.join(MTP_FIXTURE_ROOT, 'internal', 'file-a.txt')
+    const localSrc = path.join(fixtureRoot, 'left', 'file-a.txt')
+    const expectedContent = 'A'.repeat(1024)
+    await pollFs(
+      tauriPage,
+      () => {
+        if (fs.existsSync(localSrc)) return false
+        if (!fs.existsSync(mtpDest)) return false
+        return fs.readFileSync(mtpDest, 'utf-8') === expectedContent
+      },
+      15000,
+    )
     await mcpCall('refresh', {})
 
     // MTP file should have local content (overwritten) — local fixture is 1024 'A' chars
-    const mtpContent = fs.readFileSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'file-a.txt'), 'utf-8')
-    expect(mtpContent).toBe('A'.repeat(1024))
+    const mtpContent = fs.readFileSync(mtpDest, 'utf-8')
+    expect(mtpContent).toBe(expectedContent)
 
     // Local source should be gone (moved)
-    expect(fs.existsSync(path.join(fixtureRoot, 'left', 'file-a.txt'))).toBe(false)
+    expect(fs.existsSync(localSrc)).toBe(false)
   })
 })
 
@@ -212,15 +255,26 @@ test.describe('MTP same-volume move conflicts', () => {
     await clickTransferStart(tauriPage)
     await waitForDialogsToClose(tauriPage, 30000)
 
-    await sleep(3000)
+    // Wait for the same-volume MTP move to settle on disk.
+    const rootPath = path.join(MTP_FIXTURE_ROOT, 'internal', 'report.txt')
+    const docsSrc = path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'report.txt')
+    await pollFs(
+      tauriPage,
+      () => {
+        if (fs.existsSync(docsSrc)) return false
+        if (!fs.existsSync(rootPath)) return false
+        return fs.readFileSync(rootPath, 'utf-8').includes('Quarterly report')
+      },
+      15000,
+    )
     await mcpCall('refresh', {})
 
     // Root report.txt should have Documents content (overwritten)
-    const rootContent = fs.readFileSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'report.txt'), 'utf-8')
+    const rootContent = fs.readFileSync(rootPath, 'utf-8')
     expect(rootContent).toContain('Quarterly report')
 
     // Source should be gone from Documents
-    expect(fs.existsSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'report.txt'))).toBe(false)
+    expect(fs.existsSync(docsSrc)).toBe(false)
   })
 
   test('same-volume MTP move with skip preserves both files', async ({ tauriPage }) => {
@@ -253,8 +307,6 @@ test.describe('MTP same-volume move conflicts', () => {
     await clickTransferStart(tauriPage)
     await waitForDialogsToClose(tauriPage, 30000)
 
-    await sleep(3000)
-
     // Root file unchanged (skip)
     const rootContent = fs.readFileSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'report.txt'), 'utf-8')
     expect(rootContent).toBe('root-version')

apps/desktop/test/e2e-playwright/mtp.spec.ts

@@ -70,6 +70,25 @@ const SD_CARD = 'Virtual Pixel 9 - SD Card'
 // Local volume name differs by platform (macOS: "Macintosh HD", Linux: "Root")
 const LOCAL_VOLUME_NAME = os.platform() === 'linux' ? 'Root' : 'Macintosh HD'
 
+/** Returns the size of a file, or -1 if it doesn't exist / can't be statted. */
+function safeFileSize(p: string): number {
+  try {
+    return fs.statSync(p).size
+  } catch {
+    return -1
+  }
+}
+
+/**
+ * Reads cmdr://state and returns true when both panes show the local volume.
+ * The state YAML has `left:` and `right:` blocks each containing a `  volume: NAME` line.
+ */
+async function bothPanesOnLocalVolume(): Promise<boolean> {
+  const state = await mcpReadResource('cmdr://state')
+  const volumeLines = (state.match(/\n {2}volume: ([^\n]+)/g) ?? []).map((line) => line.replace(/^\n {2}volume: /, ''))
+  return volumeLines.length >= 2 && volumeLines[0] === LOCAL_VOLUME_NAME && volumeLines[1] === LOCAL_VOLUME_NAME
+}
+
 /**
  * Discovers the mtp:// path prefix for a named MTP storage from cmdr://state.
  * The device ID is assigned at runtime, so tests must discover it dynamically.
@@ -114,13 +133,13 @@ test.beforeEach(async ({ tauriPage }) => {
         invoke('plugin:event|emit', { event: 'mcp-volume-select', payload: { pane: 'left', name: '${LOCAL_VOLUME_NAME}' } });
         invoke('plugin:event|emit', { event: 'mcp-volume-select', payload: { pane: 'right', name: '${LOCAL_VOLUME_NAME}' } });
     })()`)
-  await sleep(2000) // Wait for volume switches to complete
+  // Wait for both panes to show the local volume.
+  await pollUntil(tauriPage, async () => bothPanesOnLocalVolume(), 5000)
 
   // Dismiss any lingering dialogs/overlays from previous tests
   await tauriPage.keyboard.press('Escape')
-  await sleep(200)
   await tauriPage.keyboard.press('Escape')
-  await sleep(200)
+  await pollUntil(tauriPage, async () => !(await tauriPage.isVisible('.modal-overlay')), 2000)
 })
 
 // ── Tests ────────────────────────────────────────────────────────────────────
@@ -932,14 +951,21 @@ test.describe('MTP large file transfer', () => {
     await mcpCall('move_cursor', { pane: 'left', filename: 'large-test.dat' })
     await mcpCall('copy', { autoConfirm: true })
 
-    // Large file transfer through MTP protocol stack takes longer
-    await sleep(10000)
+    // Poll until the destination file reaches the expected size (50 MB).
+    const expectedSize = 50 * 1024 * 1024
+    const destPath = path.join(MTP_FIXTURE_ROOT, 'internal', 'large-test.dat')
+    const transferred = await pollUntil(
+      tauriPage,
+      () => Promise.resolve(safeFileSize(destPath) === expectedSize),
+      30000,
+    )
+    expect(transferred).toBe(true)
     await mcpCall('refresh', {})
     await mcpAwaitItem('right', 'large-test.dat', 60)
 
     // Verify file size in MTP backing dir
-    const stat = fs.statSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'large-test.dat'))
-    expect(stat.size).toBe(50 * 1024 * 1024)
+    const stat = fs.statSync(destPath)
+    expect(stat.size).toBe(expectedSize)
   })
 
   test('copies 50 MB file from MTP to local', async ({ tauriPage }) => {
@@ -965,12 +991,20 @@ test.describe('MTP large file transfer', () => {
     await mcpCall('move_cursor', { pane: 'left', filename: 'large-mtp.dat' })
     await mcpCall('copy', { autoConfirm: true })
 
-    await sleep(10000)
+    // Poll until the destination file reaches the expected size (50 MB).
+    const expectedSize = 50 * 1024 * 1024
+    const destPath = path.join(fixtureRoot, 'right', 'large-mtp.dat')
+    const transferred = await pollUntil(
+      tauriPage,
+      () => Promise.resolve(safeFileSize(destPath) === expectedSize),
+      30000,
+    )
+    expect(transferred).toBe(true)
     await mcpCall('refresh', {})
     await mcpAwaitItem('right', 'large-mtp.dat', 60)
 
     // Verify file size on local disk
-    const stat = fs.statSync(path.join(fixtureRoot, 'right', 'large-mtp.dat'))
-    expect(stat.size).toBe(50 * 1024 * 1024)
+    const stat = fs.statSync(destPath)
+    expect(stat.size).toBe(expectedSize)
   })
 })

apps/desktop/test/e2e-playwright/network-toggle.spec.ts

@@ -19,6 +19,7 @@
 import os from 'node:os'
 import { test, expect } from './fixtures.js'
 import { ensureAppReady, pollUntil, sleep } from './helpers.js'
+import { initMcpClient, mcpReadResource } from '../e2e-shared/mcp-client.js'
 
 // Volume name for "Macintosh HD" on macOS / "Root" on Linux. We force both panes back to
 // this volume in `beforeEach` so the spec runs cleanly even when a prior MTP test left a
@@ -87,7 +88,19 @@ test.describe('Network toggle in volume picker', () => {
       invoke('plugin:event|emit', { event: 'mcp-volume-select', payload: { pane: 'left', name: '${LOCAL_VOLUME_NAME}' } });
       invoke('plugin:event|emit', { event: 'mcp-volume-select', payload: { pane: 'right', name: '${LOCAL_VOLUME_NAME}' } });
     })()`)
-    await sleep(2000)
+    // Wait for both panes to actually be on the local volume before asserting picker UX.
+    await initMcpClient(tauriPage)
+    await pollUntil(
+      tauriPage,
+      async () => {
+        const state = await mcpReadResource('cmdr://state')
+        const volumeLines = (state.match(/\n {2}volume: ([^\n]+)/g) ?? []).map((line) =>
+          line.replace(/^\n {2}volume: /, ''),
+        )
+        return volumeLines.length >= 2 && volumeLines[0] === LOCAL_VOLUME_NAME && volumeLines[1] === LOCAL_VOLUME_NAME
+      },
+      5000,
+    )
 
     await ensureAppReady(tauriPage)