feedback4: the real-server suites' long "own battle over" waits poll in slices under the browser's CDP protocol timeout (test/e2e/client.mjs waitForFunctionLong, PROTOCOL_TIMEOUT_MS = the Client's 90 s) — puppeteer runs a page.waitForFunction's whole poll inside one Runtime.callFunctionOn, so watch-bonds.e2e subtest 3's 240 s wait (line 489) died with a bare "Waiting failed" (cause: Runtime.callFunctionOn timed out) whenever the own battle at 1× outlasted 90 s (the 0.1.4 candidate rerun: 152 s ≈ 62 s to COMBAT + 90 s; 65–67 s in isolated runs); reproduced at the same line with a 30 s protocol timeout, which passes with the slices; playtest2.real's 120 s wait had the same gap (a silent 'timeout' round); test/e2e/client-wait.test.js (slices until the deadline, other errors not retried, no Client suite with a plain wait as long as the protocol timeout); a test-harness timing flake, no product change; golden unchanged

test/e2e/client-wait.test.js

@@ -0,0 +1,86 @@
+// test/e2e/client.mjs waitForFunctionLong (Node, no browser): a long wait of the real-server browser suites polls in
+// slices shorter than the CDP protocol timeout. A plain page.waitForFunction runs its whole poll inside one
+// Runtime.callFunctionOn, which the 90 s protocol timeout cut off: watch-bonds.e2e's "own battle over" wait (240 s) failed
+// with a bare "Waiting failed" whenever the own battle at 1× lasted longer than 90 s (0.1.4 release candidate).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { ROOT, PROTOCOL_TIMEOUT_MS, waitForFunctionLong } from './client.mjs';
+
+const timeoutError = (ms) => Object.assign(new Error(`Waiting failed: ${ms}ms exceeded`), { name: 'TimeoutError' });
+
+/** A page whose predicate turns true after `trueAfter` ms; each waitForFunction slice behaves like puppeteer's. */
+function fakePage(trueAfter) {
+  const t0 = Date.now();
+  const calls = [];
+  return {
+    calls,
+    waitForFunction(fn, opts, ...args) {
+      calls.push({ fn, opts, args });
+      const left = t0 + trueAfter - Date.now();
+      return new Promise((resolve, reject) => {
+        if (left <= opts.timeout) setTimeout(() => resolve({ handle: 'ok', args }), Math.max(0, left));
+        else setTimeout(() => reject(timeoutError(opts.timeout)), opts.timeout);
+      });
+    },
+  };
+}
+
+test('a wait longer than one slice keeps polling the same predicate until it holds', async () => {
+  const page = fakePage(95);
+  const fn = () => true;
+  const got = await waitForFunctionLong(page, fn, { timeout: 1000, polling: 200, slice: 30 }, 'a', 2);
+  assert.deepEqual(got, { handle: 'ok', args: ['a', 2] });
+  assert.ok(page.calls.length >= 4, `sliced (${page.calls.length} calls)`);
+  for (const c of page.calls) {
+    assert.equal(c.fn, fn);
+    assert.deepEqual(c.args, ['a', 2]);
+    assert.equal(c.opts.polling, 200);
+    assert.ok(c.opts.timeout > 0 && c.opts.timeout <= 30, `slice ${c.opts.timeout}`);
+  }
+});
+
+test('the overall timeout still ends the wait with a TimeoutError naming it; the last slice is the remainder', async () => {
+  const page = fakePage(10_000);
+  const t0 = Date.now();
+  await assert.rejects(waitForFunctionLong(page, () => false, { timeout: 70, slice: 30 }), (e) => e.name === 'TimeoutError' && /70ms exceeded/.test(e.message));
+  assert.ok(Date.now() - t0 >= 65, 'not before the deadline');
+  assert.ok(page.calls.at(-1).opts.timeout <= 30);
+  assert.ok(page.calls.reduce((n, c) => n + c.opts.timeout, 0) <= 75, 'the slices add up to the timeout');
+});
+
+test('any other failure is not retried (a page error, a detached frame, the protocol timeout itself)', async () => {
+  for (const err of [new Error('Waiting failed'), Object.assign(new Error('boom'), { name: 'ProtocolError' })]) {
+    let n = 0;
+    const page = { waitForFunction: () => { n++; return Promise.reject(err); } };
+    await assert.rejects(waitForFunctionLong(page, () => true, { timeout: 1000, slice: 30 }), (e) => e === err);
+    assert.equal(n, 1);
+  }
+});
+
+test('the default slice stays well under the protocol timeout every Client launches with', async () => {
+  const page = fakePage(0);
+  await waitForFunctionLong(page, () => true, { timeout: 240000 });
+  assert.ok(page.calls[0].opts.timeout < PROTOCOL_TIMEOUT_MS / 2, `slice ${page.calls[0].opts.timeout}`);
+  const client = readFileSync(path.join(ROOT, 'test/e2e/client.mjs'), 'utf8');
+  assert.match(client, /protocolTimeout: PROTOCOL_TIMEOUT_MS \}/, 'Client.open launches with the exported constant');
+});
+
+test('no Client suite has a plain page.waitForFunction as long as the protocol timeout (use waitForFunctionLong)', () => {
+  const files = [];
+  for (const dir of ['test/ui', 'test/e2e']) {
+    for (const f of readdirSync(path.join(ROOT, dir))) if (/\.(m?js)$/.test(f)) files.push(path.join(dir, f));
+  }
+  const long = [];
+  for (const f of files) {
+    const src = readFileSync(path.join(ROOT, f), 'utf8');
+    if (!/from '\.\.\/e2e\/client\.mjs'|from '\.\/client\.mjs'/.test(src)) continue;
+    for (let i = src.indexOf('.waitForFunction('); i >= 0; i = src.indexOf('.waitForFunction(', i + 1)) {
+      const next = src.indexOf('.waitForFunction(', i + 1);
+      const m = src.slice(i, next < 0 ? undefined : next).match(/\{ timeout: ([0-9_]+)/);
+      if (m && Number(m[1].replace(/_/g, '')) >= PROTOCOL_TIMEOUT_MS) long.push(`${f}:${src.slice(0, i).split('\n').length} (${m[1]} ms)`);
+    }
+  }
+  assert.deepEqual(long, []);
+});