[Bug]: Promise was collected in cross frame promises

[goloveychuk]

Version

1.58.2

Steps to reproduce

Reproducing is hard, it requires GC calls from browser.

on playwright side

page.evaluate('someFunction')

On main frame

window.someFunction = () => iframeWindow.someOtherFunction()

On iframe

window.someOtherFunction = () => Promise.resolve()

Somewhere on that time GC need to happen and clean promise from iframe.

Expected behavior

Ideally we need to fix cross-frames promises GC, but idk if it's possible because it seems like cdp issue.
If there is no solution, at least we need to write a meaningful msg about what happened in error message.
Either add cdp error message to playwright error description or map it to a description for developers to help solve the issue.

Actual behavior

Playwright side throws
page.evaluate: Execution context was destroyed, most likely because of a navigation.

Additional context

In cdp debug I see a

{
  "method": "Runtime.callFunctionOn",
  "params": {
    "functionDeclaration": "(utilityScript, ...args) => utilityScript.evaluate(...args)",
    "objectId": "...",
    "arguments": [
      { "objectId": "..." },
      { "value": true },
      { "value": true },
      {
        "value": "(function anonymous() { return __SomeE2EApi__.waitForChangesAppliedAsync() })"
      },
      { "value": 1 },
      { "value": { "v": "undefined" } }
    ],
    "returnByValue": true,
    "awaitPromise": true,
    "userGesture": true
  }

{"code":-32000,"message":"Promise was collected"}

To fix (I don't see the error after this change but I cannot have 100% proof that this fix works) the issue I've changed the implementation from

waitForChangesAppliedAsync = () => iframeWindow.waitForChangesAppliedAsync() 

to

waitForChangesAppliedAsync = async () => {
  await iframeWindow.waitForChangesAppliedAsync() 
}

which creates promise on main frame instead of passthrough iframe promise.

Reproduced on macos local browser and linux with remote browser pool on k8s pods on different chrome versions.
Not a env-dependent issue.

Environment

System:
    OS: macOS 26.2
    CPU: (10) arm64 Apple M1 Pro
    Memory: 70.80 MB / 32.00 GB
  Binaries:
    Node: 24.10.0 - /Users/vadymh/.local/state/fnm_multishells/63441_1783516106428/bin/node
    Yarn: 1.22.19 - /Users/vadymh/.local/state/fnm_multishells/63441_1783516106428/bin/yarn
    npm: 11.6.1 - /Users/vadymh/.local/state/fnm_multishells/63441_1783516106428/bin/npm
  IDEs:
    VSCode: 1.128.0 - /usr/local/bin/code
    Cursor: 3.1.10 - /usr/local/bin/cursor
    Claude Code: 2.1.202 - /Users/vadymh/.local/bin/claude
    Codex: 0.142.5 - /Users/vadymh/.local/bin/codex
  Languages:
    Bash: 3.2.57 - /bin/bash

[goloveychuk]

Reproduce code

import { test, expect, type CDPSession, type Page } from '@playwright/test';

test('raw CDP reports Promise was collected for an unretained cross-frame promise', async ({ page, browserName }) => {
  test.skip(browserName !== 'chromium', 'Chromium/V8-specific CDP behavior');

  const client = await page.context().newCDPSession(page);
  await installCrossFramePromiseFixture(page);

  const error = await reproducePromiseCollection(page, client, 'cdp');

  console.log(`Reproduced raw CDP error: ${error.message}`);
  expect(error.message).toContain('Promise was collected');
});

test('reproduces misleading page.evaluate error for a collected cross-frame promise', async ({ page, browserName }) => {
  test.skip(browserName !== 'chromium', 'Chromium/V8-specific CDP behavior');

  const client = await page.context().newCDPSession(page);
  await installCrossFramePromiseFixture(page);

  const error = await reproducePromiseCollection(page, client, 'playwright');

  console.log(`Reproduced Playwright error: ${error.message}`);
  expect(error.message).toContain('Execution context was destroyed, most likely because of a navigation.');
  expect(error.message).not.toContain('Promise was collected');
});

test('retaining and awaiting the cross-frame promise avoids collection', async ({ page, browserName }) => {
  test.skip(browserName !== 'chromium', 'Chromium/V8-specific CDP behavior');

  const client = await page.context().newCDPSession(page);
  await installCrossFramePromiseFixture(page);

  const resultPromise = page.evaluate(async () => {
    return window['__SomeE2EApi__'].waitForChangesAppliedAsync2();
  });

  await forceGarbageCollection(client);

  await expect(resultPromise).resolves.toBe('resolved from iframe');
});

async function installCrossFramePromiseFixture(page: Page) {
  await page.setContent(`
    <!doctype html>
    <html>
      <body>
        <iframe id="child" srcdoc="
          <!doctype html>
          <script>
            window.createUnretainedNeverSettlingPromise = () => new Promise(() => {});
            // window.createUnretainedNeverSettlingPromise = () => Promise.resolve()
            window.createUnretainedResolvingPromise = () => {
              const promise = new Promise(resolve => setTimeout(() => resolve('resolved from iframe'), 1000));
              return promise;
            };
          </script>
        "></iframe>
        <script>
          window.__SomeE2EApi__ = {
            waitForChangesAppliedAsync() {
              const child = document.querySelector('#child').contentWindow;
              return child.createUnretainedNeverSettlingPromise();
            },
            async waitForChangesAppliedAsync2() {
              const child = document.querySelector('#child').contentWindow;
              return await child.createUnretainedResolvingPromise();
            }
          };
        </script>
      </body>
    </html>
  `);

  await page.waitForFunction(() => {
    const child = document.querySelector('iframe')?.contentWindow;
    return !!window['__SomeE2EApi__'] && !!child?.['createUnretainedNeverSettlingPromise'];
  });
}

async function reproducePromiseCollection(page: Page, client: CDPSession, mode: 'cdp' | 'playwright'): Promise<Error> {
  let lastResult: unknown;
  for (let attempt = 0; attempt < 30; ++attempt) { // 1 is probably enough
    const resultPromise = mode === 'cdp' ? client.send('Runtime.evaluate', {
      expression: 'window.__SomeE2EApi__.waitForChangesAppliedAsync()',
      returnByValue: true,
      awaitPromise: true,
      userGesture: true,
    }).catch(e => e) : page.evaluate(() => window['__SomeE2EApi__'].waitForChangesAppliedAsync()).catch(e => e);

    await forceGarbageCollection(client);

    lastResult = await Promise.race([
      resultPromise,
      new Promise(resolve => setTimeout(() => resolve('timed out waiting for evaluation result'), 5000)),
    ]);

    if (lastResult instanceof Error)
      return lastResult;
  }

  throw new Error(`Did not reproduce promise collection. Last result: ${String(lastResult)}`);
}

async function forceGarbageCollection(client: CDPSession) {
  for (let i = 0; i < 20; ++i)
    await client.send('HeapProfiler.collectGarbage');
}

Not sure what is going on.
Iframes might be unrelated or there could be different conditions to repro this error

waitForChangesAppliedAsync() {
              // const child = document.querySelector('#child').contentWindow;
              // return child.createUnretainedNeverSettlingPromise();
              return new Promise(() => {});
            },

also reproducing same issue.
Looks like empty promises are collected by gc.
But in my project where I reproduced this error, it's 100% not empty promises.

[github-actions]

Hi, I'm the Playwright bot and I took a first look.

Reproduced on tip-of-tree (npm 1.62.0-next, sha 2bcd8f2), chromium only. When a cross-frame promise gets garbage-collected before it settles, CDP returns {"code":-32000,"message":"Promise was collected"}, and Playwright rewrites that into the misleading page.evaluate: Execution context was destroyed, most likely because of a navigation. — no navigation actually happened. So the "fix cross-frame GC" part is really V8/CDP behavior, but the wrong error message is on us: crExecutionContext.rewriteError funnels any unrecognized CDP error into the "execution context was destroyed" string. That's the concrete, actionable bug here.

Your workaround (async () => { await iframeWindow.foo() }) is sound: awaiting in the parent frame keeps a reference so the promise isn't collected.

Minimal repro (condensed from your comment)

import { test, expect } from './pageTest';

test('promise collected cross frame', async ({ page, browserName }) => {
  test.skip(browserName !== 'chromium');
  const client = await page.context().newCDPSession(page);
  await page.setContent(`
    <iframe id="child" srcdoc="<script>window.makePromise = () => new Promise(() => {});</script>"></iframe>
    <script>
      window.api = () => document.querySelector('#child').contentWindow.makePromise();
    </script>
  `);
  await page.waitForFunction(() => !!document.querySelector('iframe')?.contentWindow?.['makePromise']);

  const resultPromise = page.evaluate(() => window['api']()).catch(e => e);
  for (let i = 0; i < 20; ++i)
    await client.send('HeapProfiler.collectGarbage');
  const result = await Promise.race([
    resultPromise,
    new Promise(resolve => setTimeout(() => resolve('did not settle'), 5000)),
  ]);
  console.log('RESULT:', result instanceof Error ? result.message : result);
  expect(result).toBeInstanceOf(Error);
});

Output: RESULT: page.evaluate: Execution context was destroyed, most likely because of a navigation.

What I ran

• version: tip-of-tree (npm 1.62.0-next, sha 2bcd8f2)
• browser: chromium — reproduces. This is Chromium/V8-CDP-specific (HeapProfiler.collectGarbage + Runtime.callFunctionOn returning -32000 Promise was collected); firefox/webkit don't have the equivalent path, so I scoped the repro to chromium.
• The raw CDP error is Promise was collected; it's lost because packages/playwright-core/src/server/chromium/crExecutionContext.ts rewriteError() throws the generic "Execution context was destroyed" for anything not recognized as a JS error or a closed session.
• variation: a plain unretained new Promise(() => {}) (no iframe) collected by GC reproduces the same message, matching your note.

Two things a maintainer will want to weigh: whether to surface the real CDP reason (e.g. keep the Promise was collected text) instead of the navigation message, and whether Playwright should retain the awaited promise so GC can't collect it mid-flight. I can't tell which they'll pick, but the misleading message is clearly the reproducible bug.

_{Triaged by the Playwright bot - agent run}

[dgozman]

I have reproduced this without any iframes. Chromium collects the evaluation promise unless it is retained by something in the page. Firefox/WebKit keep it alive.

test('promise collected', async ({ page }) => {
  const resultPromise = page.evaluate(() => {
    window['createPromise'] = () => new Promise(() => {});
    return window['createPromise']();
  }).catch(e => e);
  for (let i = 0; i < 20; i++)
    await page.requestGC();
  console.log((await resultPromise).message);
});