@reticlehq/server 3.8.2 → 3.10.0

package/dist/portal/input/network-detail.d.ts

@@ -49,6 +49,10 @@ export interface NetworkDetail {
      * Omitted when the whole body fits, so the caveat means something when it appears.
      */
     requestBodyTruncated?: boolean;
+    /** The response body, captured only where the page cannot (a server-sent download); capped. */
+    responseBody?: string;
+    /** True when `responseBody` was cut to the cap: a body check on the rest cannot be decided. */
+    responseBodyTruncated?: boolean;
     /**
      * The document that ISSUED the request, which is what identifies the session it belongs to.
      *
@@ -73,6 +77,8 @@ export declare function buildNetworkDetail(raw: {
     headers: Record<string, string>;
     resourceType?: string;
     requestBody?: string;
+    /** The response body, when the capture could read it (a server-sent download). */
+    responseBody?: string;
     pageUrl?: string;
 }, policy?: RedactionPolicy): NetworkDetail;
 /** The minimal Playwright surfaces this attachment reads — kept structural so it's fake-testable. */

package/dist/portal/input/network-detail.js

@@ -19,8 +19,9 @@ const DEFAULT_POLICY = { isSensitiveKey: defaultIsSensitiveKey };
  * which is key-based over a parsed object — not string-shaped.
  */
 function redactByKey(value, policy) {
-    if (Array.isArray(value))
+    if (Array.isArray(value)) {
         return value.map((v) => redactByKey(v, policy));
+    }
     if (value !== null && 'object' === typeof value) {
         const out = {};
         for (const [k, v] of Object.entries(value)) {
@@ -86,6 +87,10 @@ function projectHeaders(headers, policy) {
  * about the function's inputs.
  */
 export function buildNetworkDetail(raw, policy = DEFAULT_POLICY) {
+    // Capped and redacted exactly like the request body, and the cut is declared the same way.
+    const responseBody = raw.responseBody === undefined || 0 === raw.responseBody.length
+        ? undefined
+        : projectWireBody(raw.responseBody, policy);
     const wireBody = raw.requestBody === undefined || 0 === raw.requestBody.length
         ? undefined
         : projectWireBody(raw.requestBody, policy);
@@ -101,6 +106,12 @@ export function buildNetworkDetail(raw, policy = DEFAULT_POLICY) {
                 requestBody: wireBody.body,
                 ...(wireBody.truncated ? { requestBodyTruncated: true } : {}),
             }),
+        ...(responseBody === undefined
+            ? {}
+            : {
+                responseBody: responseBody.body,
+                ...(responseBody.truncated ? { responseBodyTruncated: true } : {}),
+            }),
         ...(raw.pageUrl === undefined || 0 === raw.pageUrl.length ? {} : { pageUrl: raw.pageUrl }),
     };
 }

package/dist/portal/input/network-mock-tools.js

@@ -8,6 +8,17 @@ function mockProvider(deps) {
     const p = deps.realInput;
     return p !== undefined && 'function' === typeof p.setMocks ? p : undefined;
 }
+/**
+ * Whether this call can mock the session: a lease of this caller, or a page the driven browser has.
+ * Having a driven browser is not enough: it mocks its own page, whatever session was named.
+ */
+async function canMock(deps, session) {
+    if (true === deps.pool?.heldBy(session.id, deps.attachId)) {
+        return true;
+    }
+    const driven = mockProvider(deps);
+    return driven !== undefined && driven.isAvailableFor(session.url);
+}
 const ruleShape = z.object({
     urlContains: z
         .string()
@@ -22,6 +33,11 @@ const ruleShape = z.object({
         .boolean()
         .optional()
         .describe('Simulate a network failure (offline) instead of a response.'),
+    forwardTo: z
+        .string()
+        .url()
+        .optional()
+        .describe('Send the matching request on to this origin, e.g. "http://127.0.0.1:15500"; the path and query stay and the real server answers.'),
 });
 /**
  * Narrow the validated tool args into MockRule[], omitting undefined keys (exactOptionalPropertyTypes).
@@ -41,8 +57,9 @@ const ruleShape = z.object({
  * to parse.
  */
 export function toRules(value) {
-    if (value === undefined)
+    if (value === undefined) {
         return [];
+    }
     const parsed = z.array(ruleShape).safeParse(value);
     if (!parsed.success) {
         const problem = parsed.error.issues
@@ -50,23 +67,32 @@ export function toRules(value) {
             .join('; ');
         throw new Error(`reticle_network_mock could not read \`mocks\` (${problem}). Nothing was applied and mocking ` +
             'was left unchanged — an unreadable rule is NOT treated as a request to clear. A rule is ' +
-            '{ urlContains, method?, status?, body?, contentType?, delayMs?, abort? }; pass `clear: true` ' +
+            '{ urlContains, method?, status?, body?, contentType?, delayMs?, abort?, forwardTo? }; pass `clear: true` ' +
             'or an empty array if you meant to turn mocking off.');
     }
     return parsed.data.map((r) => {
         const rule = { urlContains: r.urlContains };
-        if (r.method !== undefined)
+        if (r.method !== undefined) {
             rule.method = r.method;
-        if (r.status !== undefined)
+        }
+        if (r.status !== undefined) {
             rule.status = r.status;
-        if (r.body !== undefined)
+        }
+        if (r.body !== undefined) {
             rule.body = r.body;
-        if (r.contentType !== undefined)
+        }
+        if (r.contentType !== undefined) {
             rule.contentType = r.contentType;
-        if (r.delayMs !== undefined)
+        }
+        if (r.delayMs !== undefined) {
             rule.delayMs = r.delayMs;
-        if (r.abort !== undefined)
+        }
+        if (r.abort !== undefined) {
             rule.abort = r.abort;
+        }
+        if (r.forwardTo !== undefined) {
+            rule.forwardTo = r.forwardTo;
+        }
         return rule;
     });
 }
@@ -95,7 +121,7 @@ export const NETWORK_MOCK_TOOLS = [
             mocks: z
                 .array(ruleShape)
                 .optional()
-                .describe('Interception rules, first match wins: { urlContains, method?, status?, body?, contentType?, delayMs?, abort? }. Omit or pass [] to clear.'),
+                .describe('Interception rules, first match wins: { urlContains, method?, status?, body?, contentType?, delayMs?, abort?, forwardTo? }. Omit or pass [] to clear.'),
             clear: z.boolean().optional().describe('Clear all active mocks (same as mocks: []).'),
             ...sessionIdShape,
         },
@@ -107,20 +133,30 @@ export const NETWORK_MOCK_TOOLS = [
             recommendation: z.string().optional(),
         },
         handler: async (deps, args) => {
-            const session = deps.sessions.resolve(asString(args['sessionId']));
+            const session = await deps.sessions.resolveServing(asString(args['sessionId']), (s) => canMock(deps, s));
             const rules = true === args['clear'] ? [] : toRules(args['mocks']);
-            const provider = mockProvider(deps);
+            // A lease is mocked as the lease, and the driven browser mocks only a page it has. The driven
+            // provider mocks its own page whatever session was named: taken first, it mocked another tab,
+            // answered `applied: true`, and the lease's real write reached the backend.
+            const driven = mockProvider(deps);
+            const provider = driven !== undefined &&
+                deps.pool?.leaseUrl(session.id) === undefined &&
+                (await driven.isAvailableFor(session.url))
+                ? driven
+                : undefined;
             if (provider !== undefined) {
                 const applied = await provider.setMocks(session.url, rules);
-                if (applied)
+                if (applied) {
                     return mocksApplied(deps, session.id, rules.length);
+                }
             }
             // A lease is a Playwright-owned page — CDP intercept was always there, this tool just had no
             // route to it. Tried after the driven provider: when both exist, drive is the page the caller
             // means, and a lease is the fallback rather than a competitor.
             const leased = await deps.pool?.setMocksLease(session.id, rules);
-            if (true === leased)
+            if (true === leased) {
                 return mocksApplied(deps, session.id, rules.length);
+            }
             return {
                 applied: false,
                 count: 0,

package/dist/portal/input/network-mock.d.ts

@@ -26,6 +26,12 @@ export interface MockRule {
     delayMs?: number;
     /** Simulate a network failure (offline / connection refused) instead of a response. */
     abort?: boolean;
+    /**
+     * Send the request on to this origin (protocol, host and port; the path and query stay). An app that
+     * calls a fixed address (`http://localhost:5000`) can then reach its API on any port, for example when
+     * the host already uses that port. The real server answers.
+     */
+    forwardTo?: string;
 }
 /** What to do with a request after matching: fulfill a canned response, abort it, or let it through. */
 interface MockOutcome {
@@ -34,6 +40,8 @@ interface MockOutcome {
     body?: string;
     contentType?: string;
     delayMs?: number;
+    /** For `continue`: the url the request goes on with (a `forwardTo` rule). */
+    url?: string;
 }
 /**
  * Decide the outcome for a request from the active rules. Pure: no IO, no clock. The first rule

package/dist/portal/input/network-mock.js

@@ -6,12 +6,26 @@ const DEFAULT_CONTENT_TYPE = 'application/json';
  */
 export function matchMock(rules, req) {
     for (const rule of rules) {
-        if (!req.url.includes(rule.urlContains))
+        if (!req.url.includes(rule.urlContains)) {
             continue;
-        if (rule.method !== undefined && rule.method.toUpperCase() !== req.method.toUpperCase())
+        }
+        if (rule.method !== undefined && rule.method.toUpperCase() !== req.method.toUpperCase()) {
             continue;
-        if (true === rule.abort)
+        }
+        if (true === rule.abort) {
             return { kind: 'abort' };
+        }
+        if (rule.forwardTo !== undefined) {
+            const to = new URL(rule.forwardTo);
+            const next = new URL(req.url);
+            next.protocol = to.protocol;
+            next.host = to.host;
+            const outcome = { kind: 'continue', url: next.toString() };
+            if (rule.delayMs !== undefined) {
+                outcome.delayMs = rule.delayMs;
+            }
+            return outcome;
+        }
         /*
          * A rule that says only WHEN says nothing about WHAT.
          *
@@ -35,10 +49,12 @@ export function matchMock(rules, req) {
             status: rule.status ?? DEFAULT_STATUS,
             contentType: rule.contentType ?? DEFAULT_CONTENT_TYPE,
         };
-        if (rule.body !== undefined)
+        if (rule.body !== undefined) {
             outcome.body = rule.body;
-        if (rule.delayMs !== undefined)
+        }
+        if (rule.delayMs !== undefined) {
             outcome.delayMs = rule.delayMs;
+        }
         return outcome;
     }
     return { kind: 'continue' };
@@ -47,18 +63,21 @@ export function matchMock(rules, req) {
 export async function applyOutcome(route, outcome, sleep) {
     if ('continue' === outcome.kind) {
         // Sleep FIRST, then let it through: the delay is the whole perturbation, and the response that
-        // comes back is the server's own.
-        if (outcome.delayMs !== undefined && outcome.delayMs > 0)
+        // comes back is the server's own. Fallback, not continue: a lease's context route (the CSP
+        // widening, #2016) must still see the request.
+        if (outcome.delayMs !== undefined && outcome.delayMs > 0) {
             await sleep(outcome.delayMs);
-        await route.continue();
+        }
+        await (outcome.url === undefined ? route.fallback() : route.fallback({ url: outcome.url }));
         return;
     }
     if ('abort' === outcome.kind) {
         await route.abort('failed');
         return;
     }
-    if (outcome.delayMs !== undefined && outcome.delayMs > 0)
+    if (outcome.delayMs !== undefined && outcome.delayMs > 0) {
         await sleep(outcome.delayMs);
+    }
     await route.fulfill({
         status: outcome.status ?? DEFAULT_STATUS,
         contentType: outcome.contentType ?? DEFAULT_CONTENT_TYPE,
@@ -73,8 +92,9 @@ const realSleep = (ms) => new Promise((res) => setTimeout(res, ms));
  */
 export async function installNetworkMocks(page, rules, sleep = realSleep) {
     await page.unroute('**/*').catch(() => undefined);
-    if (0 === rules.length)
+    if (0 === rules.length) {
         return;
+    }
     await page.route('**/*', (route) => {
         const req = route.request();
         const outcome = matchMock(rules, { url: req.url(), method: req.method() });

package/dist/portal/input/page-capture.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A screenshot of a Playwright page, shared by the CDP and launched providers so the capture path
+ * lives in one place.
+ */
+import type { Page } from 'playwright';
+import type { ElementBox } from './real-input.js';
+/** Options for a page screenshot — full-page scroll capture and/or a clip box. */
+export interface ScreenshotOpts {
+    fullPage?: boolean;
+    /** Restrict the capture to one element/region (viewport CSS px). */
+    clip?: ElementBox;
+    /**
+     * A live picture, as a JPEG at this quality: what a person is watching, taken as it is. The
+     * baseline tweaks (hiding the HUD, stopping animations) would make their window flicker each second.
+     */
+    jpegQuality?: number;
+    /** One image pixel per CSS pixel, so a high-density display does not double a step screenshot. */
+    cssScale?: boolean;
+}
+/**
+ * Capture a PNG from a Playwright page. Shared by the CDP + launched providers so the
+ * screenshot path lives in one place (mirrors performGesture). Returns the raw PNG bytes.
+ */
+export declare function capturePage(page: Page, opts: ScreenshotOpts): Promise<Uint8Array>;

package/dist/portal/input/page-capture.js

@@ -0,0 +1,33 @@
+import { SCREENSHOT_DETERMINISM, captureWithChromeHidden, } from '../pool/playwright-launcher.js';
+/**
+ * Capture a PNG from a Playwright page. Shared by the CDP + launched providers so the
+ * screenshot path lives in one place (mirrors performGesture). Returns the raw PNG bytes.
+ */
+export async function capturePage(page, opts) {
+    // A step capture injects nothing into the page, so Reticle's own hosts are hidden another way.
+    if (true === opts.cssScale) {
+        return captureWithChromeHidden({ evaluate: (script) => page.evaluate(script) }, () => shoot(page, opts));
+    }
+    return shoot(page, opts);
+}
+/** Playwright screenshot options for one capture: a JPEG, a clip, the full page, or the viewport. */
+function screenshotOptions(opts) {
+    if (opts.jpegQuality !== undefined) {
+        return {
+            type: 'jpeg',
+            quality: opts.jpegQuality,
+            ...(true === opts.cssScale ? { scale: 'css' } : {}),
+        };
+    }
+    if (opts.clip !== undefined) {
+        return { ...SCREENSHOT_DETERMINISM, clip: opts.clip };
+    }
+    if (true === opts.fullPage) {
+        return { ...SCREENSHOT_DETERMINISM, fullPage: true };
+    }
+    return { ...SCREENSHOT_DETERMINISM };
+}
+async function shoot(page, opts) {
+    const buf = await page.screenshot(screenshotOptions(opts));
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}

package/dist/portal/input/real-input.d.ts

@@ -12,7 +12,7 @@
 import { type ScriptCoverage } from './js-coverage.js';
 import type { Browser, Page } from 'playwright';
 import { DriveError } from './drive-error.js';
-import { ActionType, InputMode } from '@reticlehq/core';
+import { ActionType, InputMode, type BoxFraction } from '@reticlehq/core';
 import { type MockRule } from './network-mock.js';
 import { type NetworkDetail } from './network-detail.js';
 /** Viewport CSS-px box as returned by the INSPECT command (getBoundingClientRect). */
@@ -49,8 +49,12 @@ export type RealInputArgs = {
      * for exactly as long as one driven in the page.
      */
     holdMs?: number;
-    /** For drag: the resolved box of the drop-target ref (toRef). */
+    /** For drag: the resolved box of the drop-target ref (toRef), or the source box for `to` alone. */
     toBox?: ElementBox;
+    /** For a pointer action: the point inside the box, as fractions of it. Absent means the centre. */
+    at?: BoxFraction;
+    /** For drag: the end point inside `toBox`, as fractions of it. Absent means its centre. */
+    to?: BoxFraction;
     steps?: number;
 };
 /** What a provider reports for one driven gesture. Exported so a fake can build it by name. */
@@ -80,19 +84,8 @@ export interface RealInputResult {
      */
     heldMs?: number;
 }
-/** Options for a page screenshot — full-page scroll capture and/or a clip box. */
-export interface ScreenshotOpts {
-    fullPage?: boolean;
-    /** Restrict the capture to one element/region (viewport CSS px). */
-    clip?: ElementBox;
-    /**
-     * A live picture, as a JPEG at this quality: what a person is watching, taken as it is. The
-     * baseline tweaks (hiding the HUD, stopping animations) would make their window flicker each second.
-     */
-    jpegQuality?: number;
-    /** One image pixel per CSS pixel, so a high-density display does not double a step screenshot. */
-    cssScale?: boolean;
-}
+export { capturePage, type ScreenshotOpts } from './page-capture.js';
+import { type ScreenshotOpts } from './page-capture.js';
 /** The capability surface reticle_act depends on. A FAKE implementing this is injected in tests. */
 export interface RealInputProvider {
     /** Whether a Playwright Page currently matches this SDK session URL. */
@@ -120,6 +113,14 @@ export interface RealInputProvider {
      */
     storageState?(sessionUrl: string): Promise<unknown>;
     applyStorageState?(sessionUrl: string, state: unknown): Promise<boolean>;
+    /**
+     * Close every page of the driven context except the one this provider drives, and say how many.
+     *
+     * A flow that opens another tab (a modifier-click on a link) leaves it behind; its page connects
+     * as a second session, and everything after that asks for "the" session and is refused. Optional:
+     * only a provider that owns its context can know which pages are its own.
+     */
+    closeOtherPages?(): Promise<number>;
     /**
      * Install (or replace, or with [] clear) network-mock rules on the correlated page — stub a 500,
      * force offline, delay a response — for deterministic error/edge-state testing. Returns true when
@@ -162,6 +163,11 @@ export declare function boxCenter(box: ElementBox): {
     cx: number;
     cy: number;
 };
+/** The point `at` names inside a box, or its centre when `at` is absent. */
+export declare function boxPoint(box: ElementBox, at: BoxFraction | undefined): {
+    cx: number;
+    cy: number;
+};
 /**
  * Which actions are driven by a native pointer. `press` is excluded on purpose — a key has no
  * pointer, and widening this would change what every existing caller of it means.
@@ -182,10 +188,15 @@ export declare function performGesture(page: Page, action: ActionType, box: Elem
 /** Injected so a test can assert the achieved hold deterministically; defaults to the real clock. */
 now?: () => number): Promise<RealInputResult>;
 /**
- * Capture a PNG from a Playwright page. Shared by the CDP + launched providers so the
- * screenshot path lives in one place (mirrors performGesture). Returns the raw PNG bytes.
+ * Run a real pointer gesture with Reticle's own UI out of the hit test, and put it back after.
+ *
+ * A real pointer goes to the topmost element under it. When the HUD sat over the app's control, a
+ * driven click went to the HUD and the verdict said the app did nothing; a drag ended short (#992).
+ * The restore runs whatever the gesture did, so the HUD does not stay unclickable for a person.
  */
-export declare function capturePage(page: Page, opts: ScreenshotOpts): Promise<Uint8Array>;
+export declare function withChromePassThrough<T>(page: {
+    evaluate: (script: string) => Promise<unknown>;
+}, gesture: () => Promise<T>): Promise<T>;
 interface CdpProviderOptions {
     cdpUrl: string;
     /** Injected so the settle delay is deterministic in tests; defaults to a real Node timer. */
@@ -262,6 +273,11 @@ export interface LaunchedProviderOptions {
      * inside-app view never loses fidelity to the outside-in view. Omitted → no network detail captured.
      */
     onNetworkDetail?: (detail: NetworkDetail) => void;
+    /**
+     * Reticle's own reader for a page with no SDK, as the lease pool gives one (see zero-install.ts).
+     * Undefined, or a loader that answers undefined, leaves such a page with no session.
+     */
+    zeroInstallScript?: () => string | undefined;
 }
 /** The only place the dynamic value import of Playwright lives for the launched (drive) path. */
 export declare const launchedChromium: LaunchFn;
@@ -282,6 +298,7 @@ export declare class LaunchedRealInputProvider implements OwnedRealInputProvider
      * driven session had no fixture port at all, and every suite seeded nothing while reading as if it
      * seeded everything. Same two methods, same contract, one page instead of a page lookup.
      */
+    closeOtherPages(): Promise<number>;
     storageState(_sessionUrl: string): Promise<unknown>;
     /**
      * Put a captured state back: cookies through the context, per-origin storage through the page.

package/dist/portal/input/real-input.js

@@ -14,20 +14,34 @@ import { DriveError } from './drive-error.js';
 import { pressViaKeyboard } from './real-input-press.js';
 import { stampedDriveUrl } from './drive-url-stamp.js';
 import { launchChromium } from '../../launch-chromium.js';
-import { chromiumLaunchHint, gotoOptions, SCREENSHOT_DETERMINISM, captureWithChromeHidden, } from '../pool/playwright-launcher.js';
+import { pageViewportOptions } from '../../chromium-launch-options.js';
+import { chromiumLaunchHint, gotoOptions } from '../pool/playwright-launcher.js';
 import { BrowserLaunchKind } from '@reticlehq/core/telemetry';
 import { getSessionMetrics } from '../../telemetry/session-metrics.js';
 import { classifyConnectFailure } from '../../telemetry/connect-failure.js';
-import { ActionType, DriveErrorCode, DRIVE_PLAYWRIGHT_MISSING_MSG, ClickButton, clickButtonFromArgs, InputMode, pressModifiersFromArgs, } from '@reticlehq/core';
+import { ActionType, DriveErrorCode, DRIVE_PLAYWRIGHT_MISSING_MSG, ClickButton, clickButtonFromArgs, InputMode, pointInBox, pressModifiersFromArgs, RETICLE_CHROME_PASS_THROUGH_SCRIPT, RETICLE_CHROME_RESTORE_POINTER_SCRIPT, } from '@reticlehq/core';
 import { installNetworkMocks } from './network-mock.js';
 import { attachNetworkDetail } from './network-detail.js';
+import { attachDownloadCapture } from './download-capture.js';
 import { injectedConnectArgs } from '../pool/zero-install.js';
+import { EARLY_CAPTURE_ARG, queueEarlyConsole } from '../pool/lease-page-error.js';
+// The screenshot capture lives in page-capture.ts; re-exported for existing importers.
+export { capturePage } from './page-capture.js';
+import { capturePage } from './page-capture.js';
 export { DriveError };
 export { unspellablePressReason } from './real-input-press.js';
 /** Center of a viewport box in CSS px. Pure — unit-tested directly. */
 export function boxCenter(box) {
     return { cx: box.x + box.width / 2, cy: box.y + box.height / 2 };
 }
+/** The point `at` names inside a box, or its centre when `at` is absent. */
+export function boxPoint(box, at) {
+    if (at === undefined) {
+        return boxCenter(box);
+    }
+    const p = pointInBox(box, at);
+    return { cx: p.x, cy: p.y };
+}
 /**
  * Which actions are driven by a native pointer. `press` is excluded on purpose — a key has no
  * pointer, and widening this would change what every existing caller of it means.
@@ -85,7 +99,28 @@ now = Date.now) {
             ...(heldMs > 0 ? { heldMs } : {}),
         };
     }
-    const center = boxCenter(box);
+    return withChromePassThrough(page, () => pointerGesture(page, action, box, args, sleep));
+}
+/**
+ * Run a real pointer gesture with Reticle's own UI out of the hit test, and put it back after.
+ *
+ * A real pointer goes to the topmost element under it. When the HUD sat over the app's control, a
+ * driven click went to the HUD and the verdict said the app did nothing; a drag ended short (#992).
+ * The restore runs whatever the gesture did, so the HUD does not stay unclickable for a person.
+ */
+export async function withChromePassThrough(page, gesture) {
+    await page.evaluate(RETICLE_CHROME_PASS_THROUGH_SCRIPT);
+    try {
+        return await gesture();
+    }
+    finally {
+        // A click that navigated takes the old page and its held values with it.
+        await page.evaluate(RETICLE_CHROME_RESTORE_POINTER_SCRIPT).catch(() => undefined);
+    }
+}
+/** The pointer half of `performGesture`: every action that lands at a point. */
+async function pointerGesture(page, action, box, args, sleep) {
+    const center = boxPoint(box, args.at);
     const { cx, cy } = center;
     const real = (performed) => ({
         performed,
@@ -125,7 +160,7 @@ now = Date.now) {
         if (args.toBox === undefined) {
             return real(false);
         }
-        const dst = boxCenter(args.toBox);
+        const dst = boxPoint(args.toBox, args.to);
         const steps = args.steps ?? DEFAULT_DRAG_STEPS;
         await page.mouse.move(cx, cy);
         await page.mouse.down();
@@ -144,31 +179,6 @@ now = Date.now) {
     }
     return real(false);
 }
-/**
- * Capture a PNG from a Playwright page. Shared by the CDP + launched providers so the
- * screenshot path lives in one place (mirrors performGesture). Returns the raw PNG bytes.
- */
-export async function capturePage(page, opts) {
-    // A step capture injects nothing into the page, so Reticle's own hosts are hidden another way.
-    if (true === opts.cssScale) {
-        return captureWithChromeHidden({ evaluate: (script) => page.evaluate(script) }, () => shoot(page, opts));
-    }
-    return shoot(page, opts);
-}
-async function shoot(page, opts) {
-    const buf = await page.screenshot(opts.jpegQuality !== undefined
-        ? {
-            type: 'jpeg',
-            quality: opts.jpegQuality,
-            ...(true === opts.cssScale ? { scale: 'css' } : {}),
-        }
-        : opts.clip !== undefined
-            ? { ...SCREENSHOT_DETERMINISM, clip: opts.clip }
-            : true === opts.fullPage
-                ? { ...SCREENSHOT_DETERMINISM, fullPage: true }
-                : { ...SCREENSHOT_DETERMINISM });
-    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
 const nodeSleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
@@ -352,6 +362,8 @@ export class CdpRealInputProvider {
     }
 }
 const INJECT_CONNECT_WAIT_MS = 8_000;
+/** True on a page whose Reticle SDK has loaded. */
+const SDK_PRESENT = '!!globalThis.__reticleInstance';
 /** The only place the dynamic value import of Playwright lives for the launched (drive) path. */
 export const launchedChromium = async (headless) => {
     let mod;
@@ -386,6 +398,7 @@ export class LaunchedRealInputProvider {
     #injectConnect;
     #storageState;
     #onNetworkDetail;
+    #zeroInstallScript;
     #browser;
     #page;
     /** Pages collecting V8 coverage — see js-coverage.ts. */
@@ -399,14 +412,28 @@ export class LaunchedRealInputProvider {
         this.#injectConnect = options.injectConnect;
         this.#storageState = options.storageState;
         this.#onNetworkDetail = options.onNetworkDetail;
+        this.#zeroInstallScript = options.zeroInstallScript;
     }
     async navigate() {
         this.#browser = await this.#launch(this.#headless);
-        const page = await this.#browser.newPage(this.#storageState !== undefined ? { storageState: this.#storageState } : undefined);
+        const page = await this.#browser.newPage({
+            ...pageViewportOptions(this.#headless),
+            ...(this.#storageState !== undefined ? { storageState: this.#storageState } : {}),
+        });
         this.#page = page;
+        // Before goto: a console error the page logs while it loads comes before its SDK connects.
+        await page.addInitScript(queueEarlyConsole, EARLY_CAPTURE_ARG);
         // Capture CDP-authoritative response detail into the driven session's journal (best-effort).
-        if (this.#onNetworkDetail !== undefined) {
-            attachNetworkDetail(page, this.#onNetworkDetail);
+        const sink = this.#onNetworkDetail;
+        if (sink !== undefined) {
+            attachNetworkDetail(page, sink);
+            // A server-sent download never reaches the page's network events; CDP request interception
+            // does see it (download-capture.ts). Attached before the first navigation, best-effort.
+            await page
+                .context()
+                .newCDPSession(page)
+                .then((cdp) => attachDownloadCapture(cdp, sink, () => page.url()))
+                .catch(() => undefined);
         }
         try {
             // Same navigation rule as the pool, and for the same measured reason: Playwright's default
@@ -420,8 +447,35 @@ export class LaunchedRealInputProvider {
         catch (e) {
             throw new DriveError(DriveErrorCode.NAVIGATE_FAILED, e instanceof Error ? e.message : String(e));
         }
+        await this.#supplyReader(page);
         await this.#tryInjectConnect(page);
     }
+    /**
+     * Give a page with no Reticle SDK the zero-install reader, so `verify` on an app with no `init`
+     * still gets a session. The wait for the page's own SDK comes first, as on a leased tab, and the
+     * script checks the singleton, so a page with an SDK never gets a second one.
+     */
+    async #supplyReader(page) {
+        const script = this.#zeroInstallScript?.();
+        if (script === undefined) {
+            return;
+        }
+        try {
+            await page.waitForFunction(SDK_PRESENT, { timeout: INJECT_CONNECT_WAIT_MS });
+            return;
+        }
+        catch {
+            // No SDK on the page: supply the reader below.
+        }
+        try {
+            // Also on every later document, so a full navigation keeps the session.
+            await page.addInitScript(script);
+            await page.evaluate(script);
+        }
+        catch {
+            // A page that refuses the reader has no session. verify's no-session guard reports it.
+        }
+    }
     /**
      * Wait for the page's Reticle singleton to exist, then re-invoke connect with our token + loopback
      * URL so a hosted (non-localhost) preview pairs to our bridge without the app being reconfigured.
@@ -433,7 +487,7 @@ export class LaunchedRealInputProvider {
             return;
         }
         try {
-            await page.waitForFunction('!!globalThis.__reticleInstance', {
+            await page.waitForFunction(SDK_PRESENT, {
                 timeout: INJECT_CONNECT_WAIT_MS,
             });
             const arg = JSON.stringify(injectedConnectArgs(opts));
@@ -482,6 +536,18 @@ export class LaunchedRealInputProvider {
      * driven session had no fixture port at all, and every suite seeded nothing while reading as if it
      * seeded everything. Same two methods, same contract, one page instead of a page lookup.
      */
+    async closeOtherPages() {
+        const page = this.#livePage();
+        if (page === undefined) {
+            return 0;
+        }
+        const others = page
+            .context()
+            .pages()
+            .filter((other) => other !== page && !other.isClosed());
+        await Promise.all(others.map((other) => other.close()));
+        return others.length;
+    }
     async storageState(_sessionUrl) {
         const page = this.#livePage();
         if (page === undefined) {