fix(browser): handle navigation waiter edge cases

Author: MagMueller

packages/bcode-browser/skills/browser-execute/SKILL.md

@@ -116,9 +116,12 @@ Common moves:
 // Navigate.
 await session.Page.enable()
 const loaded = session.waitFor("Page.loadEventFired", { timeoutMs: 15_000 })
+// Keep the rejection observed if navigation itself fails before `await loaded`.
+void loaded.catch(() => {})
 const navigation = await session.Page.navigate({ url: "https://example.com" })
 if (navigation.errorText) throw new Error(`Navigation failed: ${navigation.errorText}`)
-await loaded
+// Same-document navigations have no loaderId and do not fire a new load event.
+if (navigation.loaderId) await loaded
 
 // Evaluate JS in the page.
 const r = await session.Runtime.evaluate({
@@ -156,9 +159,10 @@ export async function scrapeTitles(session: any, urls: string[]) {
   await session.Page.enable()
   for (const url of urls) {
     const loaded = session.waitFor("Page.loadEventFired", { timeoutMs: 15_000 })
+    void loaded.catch(() => {})
     const navigation = await session.Page.navigate({ url })
     if (navigation.errorText) throw new Error(`Navigation failed: ${navigation.errorText}`)
-    await loaded
+    if (navigation.loaderId) await loaded
     const r = await session.Runtime.evaluate({ expression: "document.title", returnByValue: true })
     titles.push(r.result.value)
   }

packages/bcode-browser/src/cdp/session.ts

@@ -216,6 +216,7 @@ export class Session implements Transport {
     }
     const predicate = typeof predicateOrOptions === 'function' ? predicateOrOptions : options?.predicate;
     const timeoutMs = options?.timeoutMs ?? positionalTimeoutMs ?? 30_000;
+    const sessionId = isBrowserLevel(method) ? undefined : this.activeSessionId;
     if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
       throw new TypeError('waitFor timeoutMs must be a non-negative finite number');
     }
@@ -225,8 +226,9 @@ export class Session implements Transport {
         unsub();
         reject(new Error(`Timeout waiting for ${method}`));
       }, timeoutMs);
-      const unsub = this.onEvent((m, params) => {
+      const unsub = this.onEvent((m, params, eventSessionId) => {
         if (m !== method) return;
+        if (sessionId !== undefined && eventSessionId !== sessionId) return;
         try {
           if (predicate && !predicate(params as T)) return;
         } catch (error) {

packages/bcode-browser/test/cdp-session.test.ts

@@ -17,6 +17,12 @@ const server = Bun.serve({
       const method = Reflect.get(message, "method")
       const id = Reflect.get(message, "id")
       if (method !== "Page.navigate" || typeof id !== "number") return
+      const params = Reflect.get(message, "params")
+      const url = typeof params === "object" && params !== null ? Reflect.get(params, "url") : undefined
+      if (url === "https://navigation-fails.example") {
+        ws.send(JSON.stringify({ id, result: { frameId: "frame", errorText: "net::ERR_FAILED" } }))
+        return
+      }
       ws.send(JSON.stringify({ method: "Page.loadEventFired", params: { timestamp: 1 } }))
       ws.send(JSON.stringify({ id, result: { frameId: "frame" } }))
     },
@@ -34,8 +40,8 @@ afterAll(() => {
   server.stop(true)
 })
 
-const emit = (method: string, params: unknown) => {
-  server.publish(channel, JSON.stringify({ method, params }))
+const emit = (method: string, params: unknown, sessionId?: string) => {
+  server.publish(channel, JSON.stringify({ method, params, sessionId }))
 }
 
 test("waitFor accepts predicate and timeout options", async () => {
@@ -82,6 +88,26 @@ test("a waiter registered before navigation catches an event emitted before the
   expect(await loaded).toEqual({ timestamp: 1 })
 })
 
+test("waitFor ignores matching events from another attached session", async () => {
+  session.setActiveSession("session-active")
+  try {
+    const waiting = session.waitFor<{ source: string }>("Page.loadEventFired", { timeoutMs: 1_000 })
+    emit("Page.loadEventFired", { source: "background" }, "session-background")
+    emit("Page.loadEventFired", { source: "active" }, "session-active")
+    expect(await waiting).toEqual({ source: "active" })
+  } finally {
+    session.setActiveSession(undefined)
+  }
+})
+
+test("navigation failure does not leave an unhandled waiter rejection", async () => {
+  const loaded = session.waitFor("Page.loadEventFired", { timeoutMs: 20 })
+  void loaded.catch(() => {})
+  const navigation = await session.domains.Page.navigate({ url: "https://navigation-fails.example" })
+  expect(navigation.errorText).toBe("net::ERR_FAILED")
+  await Bun.sleep(30)
+})
+
 test("waitFor rejects invalid runtime arguments immediately", () => {
   expect(() =>
     // @ts-expect-error Runtime callers can still pass invalid JavaScript.