@reticlehq/server 3.8.2 → 3.10.0

package/dist/portal/pool/lease-emulation.js

@@ -11,6 +11,24 @@ export const ColorScheme = {
     NO_PREFERENCE: 'no-preference',
 };
 export const ReducedMotion = { REDUCE: 'reduce', NO_PREFERENCE: 'no-preference' };
+export const Pointer = { FINE: 'fine', COARSE: 'coarse' };
+/**
+ * Translate a lease's emulation into context options. `pointer` is not one of Playwright's: a
+ * coarse primary pointer is what touch support produces, so it travels as `hasTouch`.
+ *
+ * Measured in real headless Chromium: `hasTouch: true` makes `(pointer: coarse)` match and
+ * `(pointer: fine)` stop matching, with `maxTouchPoints` at 1. `isMobile` does the same and also
+ * changes viewport-meta handling, so it is deliberately left out.
+ */
+export function contextEmulationOf(emulate) {
+    const { pointer, deterministic, ...rest } = emulate;
+    return {
+        ...rest,
+        ...(pointer === undefined ? {} : { hasTouch: Pointer.COARSE === pointer }),
+        // A deterministic page draws at one density on every machine.
+        ...(deterministic === undefined ? {} : { deviceScaleFactor: 1 }),
+    };
+}
 /** The page's own layout viewport, read back after a resize. */
 const VIEWPORT_READ_SCRIPT = '[window.innerWidth, window.innerHeight]';
 /** The size a page reports for itself, or undefined when it cannot be read. */

package/dist/portal/pool/lease-marker-stamp.d.ts

@@ -5,6 +5,7 @@ interface LeaseMarkerArg {
     targetOrigin: string;
     sessionParam: string;
     projectParam: string;
+    sessionStorageKey: string;
 }
 /**
  * Init script restoring the marker a server redirect dropped, so the SDK registers under the lease id.
@@ -13,6 +14,11 @@ interface LeaseMarkerArg {
  * target origin (never an identity provider's or any third party's URL), and the pool installs it
  * only when the navigated URL's marker matches this lease's id. Must stay self-contained: Playwright
  * serialises the function source into the page.
+ *
+ * It also writes the lease id to the tab session store before page scripts run. An SPA that calls
+ * `history.replaceState` on load drops the URL marker before `connect()`, and the SDK then reads
+ * the id from that store (#2026). A value the tab holds already stays: a reload holds the lease id,
+ * and a different value is one the SDK stored for an explicit `connect({ session })`.
  */
 export declare function stampLeaseMarker(arg: LeaseMarkerArg): void;
 export declare function installLeaseMarker(page: PooledPage, leaseId: string, targetOrigin: string | undefined, project: string | undefined): Promise<void>;

package/dist/portal/pool/lease-marker-stamp.js

@@ -1,4 +1,4 @@
-import { RETICLE_URL_PARAM } from '@reticlehq/core';
+import { RETICLE_SESSION_STORAGE_KEY, RETICLE_URL_PARAM } from '@reticlehq/core';
 /**
  * Init script restoring the marker a server redirect dropped, so the SDK registers under the lease id.
  * It runs only in pages of the lease's own browser context, so a person's tab at the same URL never
@@ -6,11 +6,24 @@ import { RETICLE_URL_PARAM } from '@reticlehq/core';
  * target origin (never an identity provider's or any third party's URL), and the pool installs it
  * only when the navigated URL's marker matches this lease's id. Must stay self-contained: Playwright
  * serialises the function source into the page.
+ *
+ * It also writes the lease id to the tab session store before page scripts run. An SPA that calls
+ * `history.replaceState` on load drops the URL marker before `connect()`, and the SDK then reads
+ * the id from that store (#2026). A value the tab holds already stays: a reload holds the lease id,
+ * and a different value is one the SDK stored for an explicit `connect({ session })`.
  */
 export function stampLeaseMarker(arg) {
     const win = globalThis.window;
     if (win === undefined || win.top !== win || win.location.origin !== arg.targetOrigin)
         return;
+    try {
+        if (null === win.sessionStorage.getItem(arg.sessionStorageKey)) {
+            win.sessionStorage.setItem(arg.sessionStorageKey, arg.session);
+        }
+    }
+    catch {
+        // A page with storage blocked still gets the URL marker below.
+    }
     try {
         const url = new URL(win.location.href);
         if (url.searchParams.has(arg.sessionParam))
@@ -34,6 +47,7 @@ export async function installLeaseMarker(page, leaseId, targetOrigin, project) {
         targetOrigin,
         sessionParam: RETICLE_URL_PARAM.SESSION,
         projectParam: RETICLE_URL_PARAM.PROJECT,
+        sessionStorageKey: RETICLE_SESSION_STORAGE_KEY,
     });
 }
 export function leaseMarkerOf(url) {

package/dist/portal/pool/lease-page-error.d.ts

@@ -0,0 +1,56 @@
+import type { PooledDialog, PooledPage, PooledPageError } from './pool-contract.js';
+/** The page-error hooks `BrowserPoolOptions` carries, forwarded here verbatim. */
+export interface LeasePageErrorHooks {
+    onPageError?: ((leaseId: string, error: PooledPageError) => void) | undefined;
+    onLeaseClosed?: ((leaseId: string) => void) | undefined;
+    /** Each native dialog the pool dismissed. See `BrowserPoolOptions.onDialog`. */
+    onDialog?: ((leaseId: string, dialog: Pick<PooledDialog, 'kind' | 'message'>) => void) | undefined;
+}
+/**
+ * Install the lease's uncaught-error listener and its early console queue. Call BEFORE the first
+ * navigation — the timing is the whole fix: an import-time throw lands during `goto`, and one
+ * attached after it reads a broken page as healthy. Forwarded with the lease id, because the
+ * session for this lease usually does not exist yet, so the sink buffers.
+ */
+export declare function listenForPageErrors(page: PooledPage, leaseId: string, hooks: LeasePageErrorHooks | undefined): Promise<void>;
+/**
+ * Report a closed lease — manual release, reaper and crash reclaim all funnel through the pool's
+ * one release path. The wiring owns whether anything was kept FOR that lease and drops it.
+ */
+export declare function reportLeaseClosed(hooks: LeasePageErrorHooks | undefined, leaseId: string): void;
+/** How many console calls and error events a page keeps for an SDK that has not installed yet. */
+export declare const EARLY_CAPTURE_LIMIT = 200;
+/**
+ * The argument for `queueEarlyConsole`. Every driven page gets the same one: a pool lease, and
+ * `verify`'s own page. It looks for the SDK every `pollMs`, for at most `maxPolls` looks (30 s).
+ */
+export declare const EARLY_CAPTURE_ARG: {
+    key: string;
+    limit: number;
+    pollMs: number;
+    maxPolls: number;
+};
+interface EarlyCaptureArg {
+    key: string;
+    limit: number;
+    pollMs: number;
+    maxPolls: number;
+}
+/**
+ * Init script: keep the console errors and warnings a page logs before the SDK installs.
+ *
+ * An app connects the SDK from a module script or a bundle, and both run after the page's own
+ * classic scripts. An error such a script logs while the page loads was lost, so "no console
+ * errors" passed on a page that logged one on every load. Playwright's own console event is not a
+ * substitute: it also reports messages the browser writes itself (a failed WebSocket, which is how
+ * the SDK's own first dial can fail), and the SDK's console channel has never counted those.
+ *
+ * So this keeps the RAW calls and events. Once the SDK has wrapped the console, this hands them to
+ * it: each call goes through the console again and each event is dispatched again, so the SDK's own
+ * handlers report them and the meaning of "console error" stays the SDK's. The SDK needs no code for
+ * this, so a page that Reticle does not drive downloads nothing for it. Entries the bound did not
+ * keep are declared with one console warning. Must stay self-contained: Playwright serialises the
+ * function source into the page.
+ */
+export declare function queueEarlyConsole(arg: EarlyCaptureArg): void;
+export {};

package/dist/portal/pool/lease-page-error.js

@@ -0,0 +1,160 @@
+/**
+ * The page-error side of a lease: listen for the throws the SDK will never see, and tell the
+ * wiring when the lease is gone.
+ *
+ * An app whose module graph throws during the first navigation fires its `error` event while the
+ * page still has no Reticle SDK in it — the zero-install reader is only evaluated after `goto`
+ * resolves — so nothing on the page records it, and a blank page reported as a bare console-error
+ * count (#1966). The server's Playwright handle is attached before the navigation, so it is the
+ * one witness that cannot miss the throw. This module owns that wiring for `BrowserPool`; the
+ * journal that buffers and journals what arrives lives in `page-error-journal.ts`.
+ */
+import { RETICLE_EARLY_CAPTURE } from '@reticlehq/core';
+/**
+ * Install the lease's uncaught-error listener and its early console queue. Call BEFORE the first
+ * navigation — the timing is the whole fix: an import-time throw lands during `goto`, and one
+ * attached after it reads a broken page as healthy. Forwarded with the lease id, because the
+ * session for this lease usually does not exist yet, so the sink buffers.
+ */
+export async function listenForPageErrors(page, leaseId, hooks) {
+    page.onPageError?.((error) => {
+        hooks?.onPageError?.(leaseId, error);
+    });
+    await page.addInitScript?.(queueEarlyConsole, EARLY_CAPTURE_ARG);
+}
+/**
+ * Report a closed lease — manual release, reaper and crash reclaim all funnel through the pool's
+ * one release path. The wiring owns whether anything was kept FOR that lease and drops it.
+ */
+export function reportLeaseClosed(hooks, leaseId) {
+    hooks?.onLeaseClosed?.(leaseId);
+}
+/** How many console calls and error events a page keeps for an SDK that has not installed yet. */
+export const EARLY_CAPTURE_LIMIT = 200;
+/**
+ * The argument for `queueEarlyConsole`. Every driven page gets the same one: a pool lease, and
+ * `verify`'s own page. It looks for the SDK every `pollMs`, for at most `maxPolls` looks (30 s).
+ */
+export const EARLY_CAPTURE_ARG = {
+    key: RETICLE_EARLY_CAPTURE,
+    limit: EARLY_CAPTURE_LIMIT,
+    pollMs: 50,
+    maxPolls: 600,
+};
+/**
+ * Init script: keep the console errors and warnings a page logs before the SDK installs.
+ *
+ * An app connects the SDK from a module script or a bundle, and both run after the page's own
+ * classic scripts. An error such a script logs while the page loads was lost, so "no console
+ * errors" passed on a page that logged one on every load. Playwright's own console event is not a
+ * substitute: it also reports messages the browser writes itself (a failed WebSocket, which is how
+ * the SDK's own first dial can fail), and the SDK's console channel has never counted those.
+ *
+ * So this keeps the RAW calls and events. Once the SDK has wrapped the console, this hands them to
+ * it: each call goes through the console again and each event is dispatched again, so the SDK's own
+ * handlers report them and the meaning of "console error" stays the SDK's. The SDK needs no code for
+ * this, so a page that Reticle does not drive downloads nothing for it. Entries the bound did not
+ * keep are declared with one console warning. Must stay self-contained: Playwright serialises the
+ * function source into the page.
+ */
+export function queueEarlyConsole(arg) {
+    const win = globalThis.window;
+    if (win === undefined || win[arg.key] !== undefined) {
+        return;
+    }
+    const capture = { queue: [], dropped: 0 };
+    win[arg.key] = capture;
+    const keep = (item) => {
+        if (win[arg.key] !== capture) {
+            return;
+        }
+        if (capture.queue.length < arg.limit) {
+            capture.queue.push(item);
+        }
+        else {
+            capture.dropped += 1;
+        }
+    };
+    const mine = {};
+    for (const method of ['error', 'warn']) {
+        const original = win.console[method];
+        const wrapper = (...args) => {
+            keep({ method, args });
+            original.apply(win.console, args);
+        };
+        mine[method] = wrapper;
+        win.console[method] = wrapper;
+    }
+    win.addEventListener('error', (event) => keep({ event }), true);
+    win.addEventListener('unhandledrejection', (event) => keep({ event }), true);
+    // A copy of a kept event: an event that has been dispatched once is copied, not sent again.
+    const copy = (event) => {
+        if ('reason' in event) {
+            return new win.PromiseRejectionEvent('unhandledrejection', {
+                promise: event['promise'],
+                reason: event['reason'],
+            });
+        }
+        const init = {};
+        for (const field of ['message', 'filename', 'lineno', 'colno', 'error']) {
+            if (event[field] !== undefined) {
+                init[field] = event[field];
+            }
+        }
+        return new win.ErrorEvent('error', init);
+    };
+    // A `<script>`, `<img>` or `<link>` that failed to load dispatches a plain `Event` on its element,
+    // and only the element names the URL. A copy on `window` loses it, and the SDK reported an error
+    // with no message, no source and line 0 (#2220). So such an event is sent again from the same
+    // element, and the SDK's capture listener on `window` reads the tag and the URL. A listener added
+    // after the SDK's stops it on `window`, so the page's own handlers on the element do not run twice.
+    // An element that left the page cannot reach `window`, so it gets the copy.
+    const resend = (event) => {
+        const target = event['target'];
+        if ('message' in event || 'reason' in event || true !== target?.isConnected) {
+            return false;
+        }
+        const again = new win.Event('error');
+        const stop = (seen) => {
+            if (seen === again) {
+                again.stopPropagation();
+            }
+        };
+        win.addEventListener('error', stop, true);
+        try {
+            target.dispatchEvent?.(again);
+        }
+        finally {
+            win.removeEventListener('error', stop, true);
+        }
+        return true;
+    };
+    let polls = 0;
+    const timer = win.setInterval(() => {
+        polls += 1;
+        // The SDK has installed when the console is no longer this script's own wrapper.
+        const installed = win.console.error !== mine.error;
+        if (!installed && polls < arg.maxPolls) {
+            return;
+        }
+        win.clearInterval(timer);
+        win[arg.key] = null;
+        if (!installed) {
+            return;
+        }
+        for (const item of capture.queue) {
+            if ('method' in item) {
+                win.console[item['method']](...item['args']);
+            }
+            else {
+                const event = item['event'];
+                if (!resend(event)) {
+                    win.dispatchEvent(copy(event));
+                }
+            }
+        }
+        if (capture.dropped > 0) {
+            win.console.warn(`reticle: ${String(capture.dropped)} early console entries were not kept`);
+        }
+    }, arg.pollMs);
+}

package/dist/portal/pool/page-error-journal.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Journal the uncaught page errors the SDK was never installed in time to see.
+ *
+ * An app whose module graph throws during the first navigation fires its `error` event while the
+ * page still has no Reticle SDK in it — the zero-install reader is only evaluated after `goto`
+ * resolves. The agent then saw a blank page and a bare console-error count, and had to re-run the
+ * app under `--enable-logging` to learn why (#1966). The pool's Playwright handle is attached
+ * before the navigation, so the server is the one witness that cannot miss the throw.
+ *
+ * The pool hands errors here with the lease id. The session for that lease usually does not exist
+ * yet, so errors buffer per lease and flush the moment the session connects
+ * (`bridge.attachSessionCreate`). One already connected means the error is journaled at once.
+ *
+ * The daemon runs for days, so both maps are told to forget: a lease that is released or reaped
+ * has its buffer dropped (`onLeaseClosed`), and a session that has ended has its dedupe memory
+ * dropped (`onSessionEnd`). Without those, every failed lease and every ended session leaves an
+ * entry behind forever.
+ *
+ * Deduplication: when the SDK IS installed it reports the same throw as `error.uncaught` — with
+ * the browser's `Uncaught ` prefix on the message, which Playwright's spelling lacks. Both
+ * spellings fold into one identity (`uncaughtIdentity`), and whichever source is seen first
+ * suppresses the other's copy. A journal write is deferred by a short window first, so an SDK
+ * event racing the page error lands inside the window and wins. The reverse race — our copy
+ * first, the SDK's right after — can still journal both; the SDK's own event is authoritative and
+ * only the redundant second copy is cost, not wrong evidence.
+ */
+import { type ReticleEvent } from '@reticlehq/core';
+import type { PooledDialog, PooledPageError } from './pool-contract.js';
+/** The session surface the journal needs. The real `Session` satisfies this structurally. */
+export interface JournalableSession {
+    readonly id: string;
+    readonly url?: string;
+    pushEvent(event: ReticleEvent): void;
+    eventsSince(cursor: number): ReticleEvent[];
+    onEvent(listener: (event: ReticleEvent) => void): () => void;
+}
+export interface PageErrorJournal {
+    /** The pool's sink — hand it to `BrowserPoolOptions.onPageError`. */
+    onPoolPageError(leaseId: string, error: PooledPageError): void;
+    /** The bridge hook — register with `bridge.attachSessionCreate`. */
+    onSessionCreate(session: JournalableSession): void;
+    /** The pool's release hook — register with `BrowserPoolOptions.onLeaseClosed`. */
+    onLeaseClosed(leaseId: string): void;
+    /** The bridge hook — register with `bridge.attachSessionEnd`. */
+    onSessionEnd(sessionId: string): void;
+    /**
+     * The pool's dialog sink — hand it to `BrowserPoolOptions.onDialog`. Journals the dismissal as
+     * `dialog.opened` on the lease's session, so a verdict reads it as the SDK's own answer. A dialog
+     * before the session connects is dropped: no action window can hold it.
+     */
+    onPoolDialog(leaseId: string, dialog: Pick<PooledDialog, 'kind' | 'message'>): void;
+}
+/**
+ * Fold the two spellings of one throw into one identity. Chromium prefixes a window-reported
+ * uncaught error with `Uncaught ` and often the error class (`Uncaught TypeError: ...`); the
+ * Playwright `pageerror` message is the bare exception text. Everything after the first line is a
+ * stack fragment and never matches, so it is dropped.
+ */
+export declare function uncaughtIdentity(rawMessage: string): string;
+export declare function makePageErrorJournal(deps: {
+    resolveSession: (leaseId: string) => JournalableSession | undefined;
+    sleep?: (ms: number) => Promise<void>;
+}): PageErrorJournal;

package/dist/portal/pool/page-error-journal.js

@@ -0,0 +1,208 @@
+/**
+ * Journal the uncaught page errors the SDK was never installed in time to see.
+ *
+ * An app whose module graph throws during the first navigation fires its `error` event while the
+ * page still has no Reticle SDK in it — the zero-install reader is only evaluated after `goto`
+ * resolves. The agent then saw a blank page and a bare console-error count, and had to re-run the
+ * app under `--enable-logging` to learn why (#1966). The pool's Playwright handle is attached
+ * before the navigation, so the server is the one witness that cannot miss the throw.
+ *
+ * The pool hands errors here with the lease id. The session for that lease usually does not exist
+ * yet, so errors buffer per lease and flush the moment the session connects
+ * (`bridge.attachSessionCreate`). One already connected means the error is journaled at once.
+ *
+ * The daemon runs for days, so both maps are told to forget: a lease that is released or reaped
+ * has its buffer dropped (`onLeaseClosed`), and a session that has ended has its dedupe memory
+ * dropped (`onSessionEnd`). Without those, every failed lease and every ended session leaves an
+ * entry behind forever.
+ *
+ * Deduplication: when the SDK IS installed it reports the same throw as `error.uncaught` — with
+ * the browser's `Uncaught ` prefix on the message, which Playwright's spelling lacks. Both
+ * spellings fold into one identity (`uncaughtIdentity`), and whichever source is seen first
+ * suppresses the other's copy. A journal write is deferred by a short window first, so an SDK
+ * event racing the page error lands inside the window and wins. The reverse race — our copy
+ * first, the SDK's right after — can still journal both; the SDK's own event is authoritative and
+ * only the redundant second copy is cost, not wrong evidence.
+ */
+import { CONSOLE_EVENT, EventType, RETICLE_URL_PARAM } from '@reticlehq/core';
+/**
+ * What a dismissal answers, per dialog kind the wire knows. The same replies the SDK gives
+ * (`observers/dialogs.ts`): `confirm` is "no", `prompt` is no value, `alert` has no answer.
+ * A kind not in this map (`beforeunload`) is not a `dialog.opened` and is not reported.
+ */
+const DISMISSED_ANSWER = {
+    alert: {},
+    confirm: { answered: false },
+    prompt: { answered: null },
+};
+/** How many errors wait per lease for a session that may never connect. Older ones give way. */
+const MAX_BUFFERED_PER_LEASE = 8;
+/** How many recent error identities a session tracks — the dedupe memory for both sources. */
+const MAX_TRACKED_IDENTITIES = 32;
+/**
+ * How long a journal write waits before committing, so an SDK event for the same throw — the
+ * websocket hop against a CDP callback — can arrive first and claim the identity.
+ */
+const DEDUPE_WAIT_MS = 50;
+/**
+ * Fold the two spellings of one throw into one identity. Chromium prefixes a window-reported
+ * uncaught error with `Uncaught ` and often the error class (`Uncaught TypeError: ...`); the
+ * Playwright `pageerror` message is the bare exception text. Everything after the first line is a
+ * stack fragment and never matches, so it is dropped.
+ */
+export function uncaughtIdentity(rawMessage) {
+    const withoutPrefix = rawMessage.replace(/^Uncaught\s+/i, '');
+    const firstLine = withoutPrefix.split('\n')[0] ?? withoutPrefix;
+    // Lazy `*?`: the greedy spelling cannot match a BARE `Error: ` — the leading character class
+    // eats the `E` and backtracking never gives it back.
+    return firstLine.replace(/^[A-Za-z0-9_]*?(?:Error|Exception):\s*/, '');
+}
+/** The first stack frame's file and line — the `source (file:line)` the issue asks the agent to see. */
+const STACK_FRAME = /\bat\s+(\S+?):(\d+):\d+\b/;
+function originOf(stack) {
+    if (stack === undefined) {
+        return {};
+    }
+    const frame = STACK_FRAME.exec(stack);
+    const source = frame?.[1];
+    const line = frame?.[2];
+    if (source === undefined || line === undefined) {
+        return {};
+    }
+    return { source, line: Number(line) };
+}
+function leaseParamOf(url) {
+    if (url === undefined) {
+        return undefined;
+    }
+    try {
+        return new URL(url).searchParams.get(RETICLE_URL_PARAM.SESSION) ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const realSleep = (ms) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+export function makePageErrorJournal(deps) {
+    const sleep = deps.sleep ?? realSleep;
+    /** Errors heard before their session connected, keyed by lease id. */
+    const buffered = new Map();
+    /** Per session: identities already claimed by the SDK or by us, oldest first. */
+    const seen = new Map();
+    const mark = (sessionId, identity) => {
+        const identities = seen.get(sessionId) ?? [];
+        if (identities.includes(identity)) {
+            return;
+        }
+        identities.push(identity);
+        if (identities.length > MAX_TRACKED_IDENTITIES) {
+            identities.shift();
+        }
+        seen.set(sessionId, identities);
+    };
+    const seenBefore = (sessionId, identity) => {
+        return (seen.get(sessionId) ?? []).includes(identity);
+    };
+    const journal = async (session, error, droppedCount) => {
+        await sleep(DEDUPE_WAIT_MS);
+        const identity = uncaughtIdentity(error.message);
+        if (seenBefore(session.id, identity)) {
+            return;
+        }
+        mark(session.id, identity);
+        const { source, line } = originOf(error.stack);
+        session.pushEvent({
+            t: 0, // pushEvent re-stamps with the session's own clock
+            type: EventType.CONSOLE_ERROR,
+            sessionId: session.id,
+            data: {
+                message: error.message,
+                kind: CONSOLE_EVENT.PAGE_ERROR,
+                ...(error.stack === undefined ? {} : { stack: error.stack }),
+                ...(source === undefined ? {} : { source }),
+                ...(line === undefined ? {} : { line }),
+                ...(droppedCount === undefined
+                    ? {}
+                    : { [CONSOLE_EVENT.DROPPED_PAGE_ERRORS]: droppedCount }),
+            },
+        });
+    };
+    // A page error must never break the connect path or the session that receives it.
+    const journalSafely = (session, error, droppedCount) => {
+        journal(session, error, droppedCount).catch(() => undefined);
+    };
+    return {
+        onPoolPageError(leaseId, error) {
+            const session = deps.resolveSession(leaseId);
+            if (session !== undefined) {
+                journalSafely(session, error);
+                return;
+            }
+            const entry = buffered.get(leaseId) ?? { errors: [], dropped: 0 };
+            if (entry.errors.length >= MAX_BUFFERED_PER_LEASE) {
+                entry.errors.shift();
+                entry.dropped += 1;
+            }
+            entry.errors.push(error);
+            buffered.set(leaseId, entry);
+        },
+        onSessionCreate(session) {
+            // Claim identities the SDK reports, so a page error the SDK already journaled adds no copy.
+            session.onEvent((event) => {
+                if (event.type !== EventType.ERROR_UNCAUGHT) {
+                    return;
+                }
+                const message = event.data['message'];
+                if ('string' !== typeof message) {
+                    return;
+                }
+                mark(session.id, uncaughtIdentity(message));
+            });
+            const leaseId = leaseParamOf(session.url);
+            if (leaseId === undefined) {
+                return;
+            }
+            const entry = buffered.get(leaseId);
+            if (entry === undefined) {
+                return;
+            }
+            buffered.delete(leaseId);
+            // The buffer is bounded, so a page that threw harder than the bound reports the loss on the
+            // first error that survived — the count names what the agent is not seeing.
+            entry.errors.forEach((error, i) => {
+                journalSafely(session, error, 0 === i && entry.dropped > 0 ? entry.dropped : undefined);
+            });
+        },
+        // A lease that is released or reaped will never flush: its session already ended, or its page
+        // died before any SDK connected. The buffer has nowhere to go, so it goes away.
+        onLeaseClosed(leaseId) {
+            buffered.delete(leaseId);
+        },
+        // The dedupe memory belongs to one session's lifetime; an ended session's identities would
+        // otherwise suppress nothing real and grow for the life of the daemon.
+        onSessionEnd(sessionId) {
+            seen.delete(sessionId);
+        },
+        onPoolDialog(leaseId, dialog) {
+            // An own key only: an inherited name such as `toString` is not a dialog kind.
+            const kind = dialog.kind;
+            const answer = kind !== undefined && Object.hasOwn(DISMISSED_ANSWER, kind)
+                ? DISMISSED_ANSWER[kind]
+                : undefined;
+            const session = deps.resolveSession(leaseId);
+            if (answer === undefined || session === undefined) {
+                return;
+            }
+            session.pushEvent({
+                t: 0, // pushEvent re-stamps with the session's own clock
+                type: EventType.DIALOG_OPENED,
+                sessionId: session.id,
+                data: { kind: dialog.kind, message: dialog.message, ...answer },
+            });
+        },
+    };
+}