From 2172ee5313c05b534492d19b32fbeb5ab10ce8ea Mon Sep 17 00:00:00 2001
From: rcorreia <rcorreia@cloudflare.com>
Date: Mon, 26 Oct 2026 11:15:52 +0000
Subject: [PATCH] Setup brapi wrapped binding with websocket upgrade

---
 src/cloudflare/internal/br-api.ts             | 145 ++-
 src/cloudflare/internal/browser-run.d.ts      | 916 ++++++++++++++++++
 .../internal/test/br/br-api-test.js           | 165 ++++
 .../internal/test/br/br-api-test.wd-test      |   2 +-
 src/cloudflare/internal/test/br/br-mock.js    | 100 +-
 5 files changed, 1318 insertions(+), 10 deletions(-)
 create mode 100644 src/cloudflare/internal/browser-run.d.ts

diff --git a/src/cloudflare/internal/br-api.ts b/src/cloudflare/internal/br-api.ts
index 67619ca8329..41c7a469655 100644
--- a/src/cloudflare/internal/br-api.ts
+++ b/src/cloudflare/internal/br-api.ts
@@ -4,23 +4,158 @@
 
 import wrappedBinding from 'cloudflare-internal:wrapped-binding';
 
+// Pairs each `BrowserRun.quickAction()` overload's action with its options.
+type QuickActionOptions = {
+  screenshot: BrowserRunScreenshotOptions;
+  pdf: BrowserRunPDFOptions;
+  content: BrowserRunContentOptions;
+  scrape: BrowserRunScrapeOptions;
+  links: BrowserRunLinksOptions;
+  snapshot: BrowserRunSnapshotOptions;
+  json: BrowserRunJsonOptions;
+  markdown: BrowserRunMarkdownOptions;
+  accessibilityTree: BrowserRunAccessibilityTreeOptions;
+};
+
 interface Fetcher {
   fetch: typeof fetch;
+  quickAction<Action extends keyof QuickActionOptions>(
+    action: Action,
+    options: QuickActionOptions[Action]
+  ): Promise<Response>;
+  acquire(options?: BrowserRunAcquireOptions): Promise<BrowserRunAcquireResult>;
+  launch(options?: BrowserRunAcquireOptions): Promise<BrowserRunConnection>;
+  connectSession(
+    sessionId: string,
+    options?: BrowserRunConnectOptions
+  ): Promise<BrowserRunConnection>;
+  getLiveView(
+    sessionId: string,
+    options?: BrowserRunLiveViewOptions
+  ): Promise<BrowserRunLiveView>;
+  listSessions(
+    options?: BrowserRunListSessionsOptions
+  ): Promise<BrowserRunSession[]>;
+  history(options?: BrowserRunHistoryOptions): Promise<BrowserRunSession[]>;
+  limits(): Promise<BrowserRunLimits>;
+  getSession(sessionId: string): Promise<BrowserRunSession | null>;
+  closeSession(sessionId: string): Promise<BrowserRunCloseSessionResult>;
+  readonly devtools: BrowserRunDevtools;
 }
 
+type WebSocketOption = { websocket?: boolean };
+
+type LaunchOptions = BrowserRunAcquireOptions & WebSocketOption;
+
+type ConnectSessionOptions = BrowserRunConnectOptions & WebSocketOption;
+
+type WebSocketConnection = Omit<BrowserRunConnection, 'webSocket'> & {
+  webSocket: WebSocket;
+};
+
+type UpgradeResponse = Response & { webSocket: WebSocket | null };
+
 export class BrowserRendering extends wrappedBinding.WrappedBinding {
-  // TODO(soon): Can we use the # syntax here?
-  // eslint-disable-next-line no-restricted-syntax
-  private readonly fetcher: Fetcher;
+  readonly #fetcher: Fetcher;
 
   constructor(fetcher: Fetcher) {
     super(fetcher);
-    this.fetcher = fetcher;
+    this.#fetcher = fetcher;
   }
 
   async fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-    return this.fetcher.fetch(input, init);
+    return this.#fetcher.fetch(input, init);
+  }
+
+  quickAction<Action extends keyof QuickActionOptions>(
+    action: Action,
+    options: QuickActionOptions[Action]
+  ): Promise<Response> {
+    return this.#fetcher.quickAction(action, options);
+  }
+
+  acquire(
+    options?: BrowserRunAcquireOptions
+  ): Promise<BrowserRunAcquireResult> {
+    return this.#fetcher.acquire(options);
+  }
+
+  launch({ websocket, ...options }: LaunchOptions = {}): Promise<
+    BrowserRunConnection | WebSocketConnection
+  > {
+    const connection = this.#fetcher.launch(options);
+    if (!websocket) {
+      return connection;
+    }
+    return connection.then(async (con) => {
+      try {
+        return await upgrade(con);
+      } catch (err) {
+        await this.#fetcher.closeSession(con.sessionId).catch(() => undefined);
+        throw err;
+      }
+    });
+  }
+
+  connectSession(
+    sessionId: string,
+    { websocket, ...options }: ConnectSessionOptions = {}
+  ): Promise<BrowserRunConnection | WebSocketConnection> {
+    const connection = this.#fetcher.connectSession(sessionId, options);
+    return websocket ? connection.then(upgrade) : connection;
+  }
+
+  getLiveView(
+    sessionId: string,
+    options?: BrowserRunLiveViewOptions
+  ): Promise<BrowserRunLiveView> {
+    return this.#fetcher.getLiveView(sessionId, options);
+  }
+
+  listSessions(
+    options?: BrowserRunListSessionsOptions
+  ): Promise<BrowserRunSession[]> {
+    return this.#fetcher.listSessions(options);
+  }
+
+  history(options?: BrowserRunHistoryOptions): Promise<BrowserRunSession[]> {
+    return this.#fetcher.history(options);
+  }
+
+  limits(): Promise<BrowserRunLimits> {
+    return this.#fetcher.limits();
+  }
+
+  getSession(sessionId: string): Promise<BrowserRunSession | null> {
+    return this.#fetcher.getSession(sessionId);
+  }
+
+  closeSession(sessionId: string): Promise<BrowserRunCloseSessionResult> {
+    return this.#fetcher.closeSession(sessionId);
+  }
+
+  get devtools(): BrowserRunDevtools {
+    return this.#fetcher.devtools;
+  }
+}
+
+async function upgrade(
+  connection: BrowserRunConnection
+): Promise<WebSocketConnection> {
+  const response = await connection.webSocket.fetch(
+    'https://browser-binding.invalid/',
+    {
+      headers: { Upgrade: 'websocket' },
+    }
+  );
+  const webSocket = (response as UpgradeResponse).webSocket;
+  if (response.status !== 101 || !webSocket) {
+    const body = await response.text();
+    throw new Error(
+      `Browser Run WebSocket upgrade failed with HTTP ${response.status}: ${body}`
+    );
   }
+  return Object.assign(connection, { webSocket });
 }
 
 export default function makeBinding(env: {
diff --git a/src/cloudflare/internal/browser-run.d.ts b/src/cloudflare/internal/browser-run.d.ts
new file mode 100644
index 00000000000..6e3bee6c4e9
--- /dev/null
+++ b/src/cloudflare/internal/browser-run.d.ts
@@ -0,0 +1,916 @@
+// Copyright (c) 2026 Cloudflare, Inc.
+// Licensed under the Apache 2.0 license found in the LICENSE file or at:
+//     https://opensource.org/licenses/Apache-2.0
+
+/*****************************
+ *
+ * !!! WARNING !!!
+ * Changes should be made in `types/defines/browser-run.d.ts`
+ * and then synced back here.
+ *
+ * This file is copy & pasted from the types/ folder
+ * because when bazel runs it doesn't have access to that directly (and thusly is sad).
+ * Only the eslint directive and the `Fetcher` declaration below are not part of the copy.
+ *
+ ******************************/
+
+// The copied DevTools protocol types use `any`, and this copy must match its source.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Stands in for the generated `Fetcher` type, which this build does not have.
+interface Fetcher {
+  fetch: typeof fetch;
+}
+
+type BrowserRunLifecycleEvent =
+  'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
+
+type BrowserRunResourceType =
+  | 'document'
+  | 'stylesheet'
+  | 'image'
+  | 'media'
+  | 'font'
+  | 'script'
+  | 'texttrack'
+  | 'xhr'
+  | 'fetch'
+  | 'prefetch'
+  | 'eventsource'
+  | 'websocket'
+  | 'manifest'
+  | 'signedexchange'
+  | 'ping'
+  | 'cspviolationreport'
+  | 'preflight'
+  | 'other';
+
+/** Options fields shared by all quick actions. */
+interface BrowserRunBaseOptions {
+  /** Adds `<script>` tags into the page with the desired URL or content.
+   * @see https://pptr.dev/api/puppeteer.frameaddscripttagoptions
+   */
+  addScriptTag?: Array<{
+    content?: string;
+    url?: string;
+    type?: string;
+    id?: string;
+  }>;
+  /** Adds `<link rel="stylesheet">` or `<style>` tags into the page.
+   * @see https://pptr.dev/api/puppeteer.frameaddstyletagoptions
+   */
+  addStyleTag?: Array<{ content?: string; url?: string }>;
+  /** Provide credentials for HTTP authentication. @see https://pptr.dev/api/puppeteer.credentials */
+  authenticate?: { username: string; password: string };
+  /** Set cookies before navigating. @see https://pptr.dev/api/puppeteer.cookieparam */
+  cookies?: Array<{
+    name: string;
+    value: string;
+    url?: string;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    expires?: number;
+    priority?: 'Low' | 'Medium' | 'High';
+    sameParty?: boolean;
+    sourceScheme?: 'Unset' | 'NonSecure' | 'Secure';
+    sourcePort?: number;
+    partitionKey?: string;
+  }>;
+  /** Emulate a specific CSS media type (e.g. `"screen"`, `"print"`). */
+  emulateMediaType?: string;
+  /** Navigation options. @see https://pptr.dev/api/puppeteer.gotooptions */
+  gotoOptions?: {
+    /** Navigation timeout in milliseconds (max 60 000). @default 30000 */
+    timeout?: number;
+    /** When to consider navigation complete. @default "domcontentloaded" */
+    waitUntil?: BrowserRunLifecycleEvent | BrowserRunLifecycleEvent[];
+    referer?: string;
+    referrerPolicy?: string;
+  };
+  /** Block requests matching these regex patterns. Mutually exclusive with `allowRequestPattern`. */
+  rejectRequestPattern?: string[];
+  /** Only allow requests matching these regex patterns. Mutually exclusive with `rejectRequestPattern`. */
+  allowRequestPattern?: string[];
+  /** Block requests of these resource types. Mutually exclusive with `allowResourceTypes`. */
+  rejectResourceTypes?: BrowserRunResourceType[];
+  /** Only allow requests of these resource types. Mutually exclusive with `rejectResourceTypes`. */
+  allowResourceTypes?: BrowserRunResourceType[];
+  /** Additional HTTP headers sent with every request. */
+  setExtraHTTPHeaders?: Record<string, string>;
+  /** Whether JavaScript is enabled on the page. */
+  setJavaScriptEnabled?: boolean;
+  /** Override the default user agent string.
+   * @default "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"
+   * */
+  userAgent?: string;
+  /** Set the browser viewport size.
+   * @see https://pptr.dev/api/puppeteer.viewport
+   * @default {width:1920,height:1080}
+   * */
+  viewport?: {
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+    isMobile?: boolean;
+    isLandscape?: boolean;
+    hasTouch?: boolean;
+  };
+  /** Wait for a CSS selector to appear in the page before proceeding.
+   * @see https://pptr.dev/api/puppeteer.waitforselectoroptions
+   */
+  waitForSelector?: {
+    selector: string;
+    hidden?: true;
+    visible?: true;
+    /** Timeout in milliseconds. Max 120000 */
+    timeout?: number;
+  };
+  /** Wait for a fixed delay in milliseconds before proceeding. Max 120000 */
+  waitForTimeout?: number;
+  /** When true, continue on best-effort when awaited events fail or timeout. */
+  bestAttempt?: boolean;
+  /** Maximum duration in milliseconds for the browser action after page load. Max 120000 */
+  actionTimeout?: number;
+  /** Cache time to live in seconds (0-86400). Set to 0 to disable.
+   * @default 5
+   */
+  cacheTTL?: number;
+}
+
+/** Backend selection for quick actions. */
+interface BrowserRunAlternateBackendOptions {
+  /** Render with an alternate browser backend instead of the default one. */
+  browser?: 'kitesurf';
+}
+
+/** Common options shared by all quick actions. Exactly one of `url` or `html` must be provided.*/
+type BrowserRunCommonOptions = BrowserRunBaseOptions &
+  BrowserRunAlternateBackendOptions &
+  (
+    | {
+        /** URL to navigate to, e.g. `"https://example.com"`. */
+        url: string;
+      }
+    | {
+        /** Set the HTML content of the page directly. */
+        html: string;
+      }
+  );
+
+type BrowserRunPuppeteerScreenshotOptions = {
+  /** @default "png" */
+  type?: 'png' | 'jpeg' | 'webp';
+  /** @default "binary" */
+  encoding?: 'binary' | 'base64';
+  quality?: number;
+  fullPage?: boolean;
+  clip?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    scale?: number;
+  };
+  omitBackground?: boolean;
+  optimizeForSpeed?: boolean;
+  captureBeyondViewport?: boolean;
+  fromSurface?: boolean;
+};
+
+type BrowserRunScreenshotOptions = BrowserRunCommonOptions & {
+  /** CSS selector of the element to screenshot. */
+  selector?: string;
+  /** When true, scroll the entire page before taking the screenshot. */
+  scrollPage?: boolean;
+  /** @see https://pptr.dev/api/puppeteer.screenshotoptions */
+  screenshotOptions?: BrowserRunPuppeteerScreenshotOptions;
+};
+
+type BrowserRunPDFOptions = BrowserRunCommonOptions & {
+  /** @see https://pptr.dev/api/puppeteer.pdfoptions */
+  pdfOptions?: {
+    /** @default 1 */
+    scale?: number;
+    /** @default false */
+    displayHeaderFooter?: boolean;
+    headerTemplate?: string;
+    footerTemplate?: string;
+    /** @default false */
+    printBackground?: boolean;
+    /** @default false */
+    landscape?: boolean;
+    pageRanges?: string;
+    /** @default "letter" */
+    format?:
+      | 'letter'
+      | 'legal'
+      | 'tabloid'
+      | 'ledger'
+      | 'a0'
+      | 'a1'
+      | 'a2'
+      | 'a3'
+      | 'a4'
+      | 'a5'
+      | 'a6';
+    width?: string | number;
+    height?: string | number;
+    /** @default false */
+    preferCSSPageSize?: boolean;
+    margin?: {
+      top?: string | number;
+      right?: string | number;
+      bottom?: string | number;
+      left?: string | number;
+    };
+    /** @default false */
+    omitBackground?: boolean;
+    /** @default true */
+    tagged?: boolean;
+    /** @default false */
+    outline?: boolean;
+    /** @default 30000 */
+    timeout?: number;
+  };
+};
+
+type BrowserRunScrapeOptions = BrowserRunCommonOptions & {
+  /** CSS selectors to scrape. At least one element is required. */
+  elements: Array<{ selector: string }>;
+};
+
+type BrowserRunLinksOptions = BrowserRunCommonOptions & {
+  /** When true, only return links that are visible on the page. @default false */
+  visibleLinksOnly?: boolean;
+  /** When true, exclude links pointing to external domains. @default false */
+  excludeExternalLinks?: boolean;
+};
+
+type BrowserRunSnapshotFormat =
+  'content' | 'screenshot' | 'markdown' | 'accessibilityTree';
+
+type BrowserRunSnapshotOptions = BrowserRunCommonOptions & {
+  /** Which representations of the page to return. At least two distinct formats
+   * are required; request a single format from its dedicated action instead.
+   * @default ["content","screenshot"]
+   */
+  formats?: BrowserRunSnapshotFormat[];
+  /** @see https://pptr.dev/api/puppeteer.screenshotoptions */
+  screenshotOptions?: Omit<BrowserRunPuppeteerScreenshotOptions, 'encoding'>;
+};
+
+/** Options for the `accessibilityTree` quick action. */
+type BrowserRunAccessibilityTreeOptions = BrowserRunCommonOptions & {
+  /** When true, prune nodes that carry no semantic meaning, such as generic
+   * containers. Defaults to true, or to false when `root` is set so that the
+   * requested subtree is returned as-is.
+   */
+  interestingOnly?: boolean;
+  /** CSS selector limiting the tree to the matching element's subtree.
+   * A selector that matches nothing yields `accessibilityTree: null` with
+   * HTTP 200; a malformed selector is an error.
+   */
+  root?: string;
+};
+
+interface BrowserRunJsonBaseOptions {
+  /** Custom AI models to try in order. Max 3. Falls back to next on error. */
+  custom_ai?: Array<{
+    /** Model ID in `<provider>/<model_name>` format, e.g. `"workers-ai/@cf/meta/llama-3.3-70b-instruct-fp8-fast"`. */
+    model: string;
+    /** Bearer token. Not needed for workers-ai models. */
+    authorization?: string;
+  }>;
+}
+
+/**
+ * Options for the `json` quick action.
+ * At least one of `prompt` or `response_format` must be provided.
+ */
+type BrowserRunJsonOptions = BrowserRunCommonOptions &
+  BrowserRunJsonBaseOptions &
+  (
+    | {
+        /** Natural-language prompt describing what data to extract. */
+        prompt: string;
+        /** Structured output schema for the AI model. @see https://developers.cloudflare.com/workers-ai/json-mode/ */
+        response_format?: AiTextGenerationResponseFormat;
+      }
+    | {
+        /** Natural-language prompt describing what data to extract. */
+        prompt?: string;
+        /** Structured output schema for the AI model. @see https://developers.cloudflare.com/workers-ai/json-mode/ */
+        response_format: AiTextGenerationResponseFormat;
+      }
+  );
+
+type BrowserRunContentOptions = BrowserRunCommonOptions;
+type BrowserRunMarkdownOptions = BrowserRunCommonOptions;
+
+type BrowserRunRedirectHop = {
+  /** URL that returned the redirect. */
+  url: string;
+  /** HTTP status of the redirect. */
+  status: number;
+  /** Redirect response headers, including `location`. */
+  headers: Record<string, string>;
+};
+
+type BrowserRunResponseMeta = {
+  /** HTTP status code of the rendered page */
+  status: number;
+  /** Page title */
+  title: string;
+  /** Origin response headers, lowercased. Repeated headers are joined with a newline. Credential and transport-only headers that do not survive rendering are omitted. */
+  headers?: Record<string, string>;
+  /** URL that served the response, after any redirects the browser followed. */
+  finalUrl?: string;
+  /** HTTP redirects followed to reach `finalUrl`, oldest first. Omitted for direct navigation and for client-side redirects such as meta refresh. An empty array means redirects occurred but their intermediate responses could not be read. */
+  redirectChain?: BrowserRunRedirectHop[];
+};
+
+/**
+ * A node in the page's accessibility tree, as exposed to assistive technology.
+ * `role` is the only field always present; the rest are populated when the
+ * underlying element defines them.
+ * @see https://pptr.dev/api/puppeteer.serializedaxnode
+ */
+interface BrowserRunSerializedAXNode {
+  /** The ARIA role, e.g. `"button"`, `"heading"`, `"RootWebArea"`. */
+  role: string;
+  /** The `aria-autocomplete` value. */
+  autocomplete?: string;
+  /** Checked state of a checkbox, radio, or menu item. */
+  checked?: boolean | 'mixed';
+  /** Accessible description, typically from `aria-describedby` or `title`. */
+  description?: string;
+  disabled?: boolean;
+  expanded?: boolean;
+  /** Whether the element currently holds keyboard focus. */
+  focused?: boolean;
+  /** The kind of popup the element triggers, e.g. `"menu"`, `"dialog"`. */
+  haspopup?: string;
+  /** The `aria-invalid` value. */
+  invalid?: string;
+  /** Keyboard shortcuts bound to the element, from `aria-keyshortcuts`. */
+  keyshortcuts?: string;
+  /** Hierarchical level, e.g. the heading level of an `<h2>`. */
+  level?: number;
+  /** Whether the element is a modal dialog. */
+  modal?: boolean;
+  /** Whether a text input accepts multiple lines. */
+  multiline?: boolean;
+  /** Whether more than one option can be selected. */
+  multiselectable?: boolean;
+  /** Accessible name, e.g. a button's label or an image's alt text. */
+  name?: string;
+  orientation?: string;
+  /** Pressed state of a toggle button. */
+  pressed?: boolean | 'mixed';
+  readonly?: boolean;
+  required?: boolean;
+  /** Author-supplied role description, from `aria-roledescription`. */
+  roledescription?: string;
+  selected?: boolean;
+  /** Current value of an input or range element. */
+  value?: string | number;
+  valuemax?: number;
+  valuemin?: number;
+  /** Human-readable form of `value`, from `aria-valuetext`. */
+  valuetext?: string;
+  /** Child nodes. Absent for leaf nodes. */
+  children?: BrowserRunSerializedAXNode[];
+}
+
+/** Success response for `content` action. */
+type BrowserRunContentSuccessResponse = {
+  success: true;
+  /** Extracted HTML content */
+  result: string;
+  meta: BrowserRunResponseMeta;
+};
+
+/** Success response for `links` action. */
+type BrowserRunLinksSuccessResponse = {
+  success: true;
+  /** Extracted links */
+  result: string[];
+  meta: BrowserRunResponseMeta;
+};
+
+/** Success response for `scrape` action. */
+type BrowserRunScrapeSuccessResponse = {
+  success: true;
+  result: Array<{
+    /** The CSS selector used to find elements. */
+    selector: string;
+    /** Array of elements matching the selector. */
+    results: Array<{
+      /** Outer HTML of the element. */
+      html: string;
+      /** Text content of the element. */
+      text: string;
+      /** Width of the element in pixels. */
+      width: number;
+      /** Height of the element in pixels. */
+      height: number;
+      /** Top position of the element relative to the viewport in pixels. */
+      top: number;
+      /** Left position of the element relative to the viewport in pixels. */
+      left: number;
+      /** Array of HTML attributes on the element. */
+      attributes: Array<{
+        /** Attribute name. */
+        name: string;
+        /** Attribute value. */
+        value: string;
+      }>;
+    }>;
+  }>;
+  meta: BrowserRunResponseMeta;
+};
+
+/** Success response for `snapshot` action. Each field is present only when the
+ * corresponding entry was requested in `formats`.
+ */
+type BrowserRunSnapshotSuccessResponse = {
+  success: true;
+  result: {
+    /** HTML content of the page. */
+    content?: string;
+    /** Base64-encoded screenshot image. */
+    screenshot?: string;
+    /** Markdown content. Prefixed with YAML frontmatter (e.g. `title`) when the
+     * page provides that metadata.
+     */
+    markdown?: string;
+    /** Root of the page's accessibility tree. */
+    accessibilityTree?: BrowserRunSerializedAXNode;
+  };
+  meta: BrowserRunResponseMeta;
+};
+
+/** Success response for `accessibilityTree` action. */
+type BrowserRunAccessibilityTreeSuccessResponse = {
+  success: true;
+  result: {
+    /** Root of the accessibility tree, or `null` when `root` matched no element. */
+    accessibilityTree: BrowserRunSerializedAXNode | null;
+  };
+  meta: BrowserRunResponseMeta;
+};
+
+/** Success response for `json` action. */
+type BrowserRunJsonSuccessResponse = {
+  success: true;
+  /** JSON data extracted from the page using an AI model */
+  result: Record<string, unknown>;
+  meta: BrowserRunResponseMeta;
+};
+
+/** Success response for `markdown` action. */
+type BrowserRunMarkdownSuccessResponse = {
+  success: true;
+  /** Extracted markdown content */
+  result: string;
+  meta: BrowserRunResponseMeta;
+};
+
+/** Error response for BrowserRun actions. */
+type BrowserRunErrorResponse = {
+  success: false;
+  errors: { message: string; code?: number; detail?: string; path?: string }[];
+};
+
+/** Error response for BrowserRun `json` action. */
+type BrowserRunJsonErrorResponse = BrowserRunErrorResponse & {
+  /** Raw AI response text for debugging */
+  rawAiResponse?: string;
+};
+
+/** Session-scoped guardrails applied when acquiring a browser session. */
+type BrowserRunAcquireGuardrails = {
+  /** Domains that the browser may access. An empty list denies all domains. */
+  allowedDomains?: string[];
+  /** Named domain sets that the browser may access. */
+  allowedDomainSets?: string[];
+};
+
+/** Options for acquiring a new browser session. */
+type BrowserRunAcquireOptions = {
+  /** Idle session lifetime in milliseconds. */
+  keepAlive?: number;
+  /** Record the browser session. */
+  recording?: boolean;
+  /** Geoegress hint as an ISO-3166 alpha-2 country code. */
+  location?: string;
+  /** Map hostnames to caller-provided Workers that handle outbound requests. */
+  outboundByHost?: Record<string, Fetcher>;
+  /** Session-scoped network guardrails. */
+  guardrails?: BrowserRunAcquireGuardrails;
+  /** Include the session's DevTools targets in the result. */
+  targets?: boolean;
+  /** Lifetime of target live-view URLs in milliseconds. */
+  liveViewUrlExpiresInMs?: number;
+};
+
+/** Metadata returned when a browser session is acquired. */
+type BrowserRunAcquireResult = {
+  sessionId: string;
+  targets?: BrowserRunDevToolsTarget[];
+};
+
+/** Options for connecting to an already-acquired browser session. */
+type BrowserRunConnectOptions = {
+  /** Connect to a specific page target instead of the browser-level CDP endpoint. */
+  targetId?: string;
+};
+
+/** Connection capability returned by `connectSession()` and `launch()`. */
+type BrowserRunConnection = {
+  sessionId: string;
+  /** A session-pinned Fetcher. Use its `fetch()` method for a WebSocket upgrade. */
+  webSocket: Fetcher;
+  targets?: BrowserRunDevToolsTarget[];
+};
+
+/** The UI mode for a live-view link. */
+type BrowserRunLiveViewMode = 'devtools' | 'tab' | 'full';
+
+/** Connection-scoped guardrails applied to a live-view link. */
+type BrowserRunConnectionGuardrails = {
+  mode: 'readonly';
+};
+
+/** Options for minting a live-view link. */
+type BrowserRunLiveViewOptions = {
+  mode?: BrowserRunLiveViewMode;
+  targetId?: string;
+  expiresInMs?: number;
+  guardrails?: BrowserRunConnectionGuardrails;
+};
+
+/** Live-view link metadata. */
+type BrowserRunLiveView = {
+  webSocketDebuggerUrl: string;
+  devtoolsFrontendUrl: string;
+  id: string;
+  options: {
+    mode: BrowserRunLiveViewMode;
+    guardrails?: BrowserRunConnectionGuardrails;
+  };
+};
+
+/** Options for listing active browser sessions. */
+type BrowserRunListSessionsOptions = {
+  limit?: number;
+  offset?: number;
+};
+
+/** Options for listing session history. */
+type BrowserRunHistoryOptions = {
+  limit?: number;
+  offset?: number;
+};
+
+/** A browser session returned by the session-management methods. */
+type BrowserRunSession = {
+  sessionId: string;
+  startTime?: number;
+  endTime?: number;
+  closeReason?: number;
+  closeReasonText?: string;
+  connectionId?: string;
+  connectionStartTime?: number;
+  connectionEndTime?: number;
+  lastUpdated?: number;
+  webSocketDebuggerUrl?: string;
+  devtoolsFrontendUrl?: string;
+};
+
+/** Account browser-session and browser-time limits. */
+type BrowserRunLimits = {
+  activeSessions: Array<{ id: string }>;
+  maxConcurrentSessions: number;
+  allowedBrowserAcquisitions: number;
+  timeUntilNextAllowedBrowserAcquisition: number;
+  usedBrowserTimeSeconds?: number;
+};
+
+/** A browser target returned by the DevTools JSON methods. */
+type BrowserRunDevToolsTarget = {
+  id: string;
+  type: string;
+  url: string;
+  title?: string;
+  description?: string;
+  webSocketDebuggerUrl?: string;
+  devtoolsFrontendUrl?: string;
+};
+
+/** Browser and protocol version metadata. */
+type BrowserRunDevToolsVersion = {
+  Browser: string;
+  'Protocol-Version': string;
+  'User-Agent': string;
+  'V8-Version': string;
+  'WebKit-Version': string;
+  webSocketDebuggerUrl: string;
+};
+
+/** A DevTools protocol domain. Protocol definitions may gain additional fields over time. */
+interface BrowserRunDevToolsProtocolDomain extends Record<string, unknown> {
+  domain: string;
+  experimental?: boolean;
+  dependencies?: string[];
+  types?: Array<Record<string, any>>;
+  commands?: Array<Record<string, any>>;
+  events?: Array<Record<string, any>>;
+}
+
+/** The DevTools protocol definition. Additional protocol fields may be returned by Chrome. */
+interface BrowserRunDevToolsProtocol extends Record<string, any> {
+  domains: BrowserRunDevToolsProtocolDomain[];
+  version?: { major: string; minor: string };
+}
+
+/** Options shared by DevTools target-listing and target-creation methods. */
+type BrowserRunTargetOptions = {
+  liveViewUrlExpiresInMs?: number;
+};
+
+/** Result returned by DevTools target activation and close methods. */
+type BrowserRunTargetActionResult = {
+  message: string;
+};
+
+/** Methods exposed by the nested `devtools` binding target. */
+type BrowserRunDevtools = {
+  getVersion(sessionId: string): Promise<BrowserRunDevToolsVersion>;
+  getProtocol(sessionId: string): Promise<BrowserRunDevToolsProtocol>;
+  listTargets(
+    sessionId: string,
+    options?: BrowserRunTargetOptions
+  ): Promise<BrowserRunDevToolsTarget[]>;
+  getTarget(
+    sessionId: string,
+    targetId: string
+  ): Promise<BrowserRunDevToolsTarget>;
+  newTarget(
+    sessionId: string,
+    url?: string,
+    options?: BrowserRunTargetOptions
+  ): Promise<BrowserRunDevToolsTarget>;
+  activateTarget(
+    sessionId: string,
+    targetId: string
+  ): Promise<BrowserRunTargetActionResult>;
+  closeTarget(
+    sessionId: string,
+    targetId: string
+  ): Promise<BrowserRunTargetActionResult>;
+};
+
+/** Result returned when closing a browser session. */
+type BrowserRunCloseSessionResult = {
+  status: 'closing' | 'closed';
+};
+
+/**
+ * Browser Run API binding for automating headless browsers.
+ * @see https://developers.cloudflare.com/browser-run/
+ */
+declare abstract class BrowserRun {
+  /**
+   * Send a raw HTTP request to the Browser Run API.
+   * Used by libraries like `@cloudflare/puppeteer` to acquire and connect to a browser instance.
+   * @see https://developers.cloudflare.com/browser-run/
+   */
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+
+  /**
+   * Take a screenshot of a web page.
+   * @param action - Must be `'screenshot'`.
+   * @param options - Screenshot options including viewport, selectors, and image format.
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - Binary image data with `Content-Type: image/png`, `image/jpeg`, or `image/webp` (when `encoding: 'binary'`, the default)
+   * - Data URI string with `Content-Type: text/plain` (when `encoding: 'base64'`)
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(
+    action: 'screenshot',
+    options: BrowserRunScreenshotOptions
+  ): Promise<Response>;
+
+  /**
+   * Generate a PDF of a web page.
+   * @param action - Must be `'pdf'`.
+   * @param options - PDF generation options including page size, margins, and headers/footers.
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - Binary PDF data with `Content-Type: application/pdf`
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(action: 'pdf', options: BrowserRunPDFOptions): Promise<Response>;
+
+  /**
+   * Get the HTML content of a web page.
+   * @param action - Must be `'content'`.
+   * @param options - Navigation and page interaction options.
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - `BrowserRunContentSuccessResponse` JSON with `Content-Type: application/json`
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(
+    action: 'content',
+    options: BrowserRunContentOptions
+  ): Promise<Response>;
+
+  /**
+   * Scrape elements from a web page by CSS selector.
+   * @param action - Must be `'scrape'`.
+   * @param options - Scrape options with CSS selectors for elements to extract.
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - `BrowserRunScrapeSuccessResponse` JSON with `Content-Type: application/json`
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(
+    action: 'scrape',
+    options: BrowserRunScrapeOptions
+  ): Promise<Response>;
+
+  /**
+   * Extract all links from a web page.
+   * @param action - Must be `'links'`.
+   * @param options - Options to filter visible or internal links only.
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - `BrowserRunLinksSuccessResponse` JSON with `Content-Type: application/json`
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(
+    action: 'links',
+    options: BrowserRunLinksOptions
+  ): Promise<Response>;
+
+  /**
+   * Get several representations of a web page in one request.
+   * @param action - Must be `'snapshot'`.
+   * @param options - Snapshot options including the `formats` to return and
+   * screenshot settings (encoding is always base64).
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - `BrowserRunSnapshotSuccessResponse` JSON with `Content-Type: application/json`
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(
+    action: 'snapshot',
+    options: BrowserRunSnapshotOptions
+  ): Promise<Response>;
+
+  /**
+   * Extract structured JSON data from a web page using AI.
+   * @param action - Must be `'json'`.
+   * @param options - JSON extraction options with prompt or response_format schema.
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - `BrowserRunJsonSuccessResponse` JSON with `Content-Type: application/json`
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   * - HTTP 422 with code `2012` for HTML-to-markdown conversion failures
+   * - HTTP 422/500 for AI extraction failures (may include `rawAiResponse` field)
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(
+    action: 'json',
+    options: BrowserRunJsonOptions
+  ): Promise<Response>;
+
+  /**
+   * Convert a web page to Markdown.
+   * @param action - Must be `'markdown'`.
+   * @param options - Navigation and page interaction options.
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - `BrowserRunMarkdownSuccessResponse` JSON with `Content-Type: application/json`
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   * - HTTP 422 with code `2012` for HTML-to-markdown conversion failures
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(
+    action: 'markdown',
+    options: BrowserRunMarkdownOptions
+  ): Promise<Response>;
+
+  /**
+   * Get the accessibility tree of a web page.
+   * @param action - Must be `'accessibilityTree'`.
+   * @param options - Options to scope the tree to a subtree and to control
+   * whether semantically uninteresting nodes are pruned.
+   * @returns A `Response` containing one of:
+   *
+   * **Success (HTTP 200):**
+   * - `BrowserRunAccessibilityTreeSuccessResponse` JSON with `Content-Type: application/json`
+   * - `result.accessibilityTree` is `null` when `root` matched no element
+   *
+   * **Error:**
+   * - `BrowserRunErrorResponse` JSON with appropriate HTTP status code (400, 422, 429, 500, 503)
+   * - HTTP 422 for a malformed `root` selector
+   * - HTTP 500 with code `2017` or `2018` when the tree could not be built
+   *
+   * **Headers:**
+   * - `X-Browser-Ms-Used`: Browser time consumed in milliseconds (set when status < 500)
+   */
+  quickAction(
+    action: 'accessibilityTree',
+    options: BrowserRunAccessibilityTreeOptions
+  ): Promise<Response>;
+  /** Acquire a new browser session and return its metadata. */
+  acquire(options?: BrowserRunAcquireOptions): Promise<BrowserRunAcquireResult>;
+
+  /** Acquire a browser session and return a session-pinned WebSocket capability. */
+  launch(options?: BrowserRunAcquireOptions): Promise<BrowserRunConnection>;
+
+  /** Return a session-pinned WebSocket capability for an existing session. */
+  connectSession(
+    sessionId: string,
+    options?: BrowserRunConnectOptions
+  ): Promise<BrowserRunConnection>;
+
+  /** Mint an authenticated live-view link for a browser session. */
+  getLiveView(
+    sessionId: string,
+    options?: BrowserRunLiveViewOptions
+  ): Promise<BrowserRunLiveView>;
+
+  /** List the caller's active browser sessions. */
+  listSessions(
+    options?: BrowserRunListSessionsOptions
+  ): Promise<BrowserRunSession[]>;
+
+  /** List recent active and closed browser sessions. */
+  history(options?: BrowserRunHistoryOptions): Promise<BrowserRunSession[]>;
+
+  /** Return the caller's browser-session and browser-time limits. */
+  limits(): Promise<BrowserRunLimits>;
+
+  /** Return details for one browser session, or `null` when it does not exist. */
+  getSession(sessionId: string): Promise<BrowserRunSession | null>;
+
+  /** Close a browser session. */
+  closeSession(sessionId: string): Promise<BrowserRunCloseSessionResult>;
+
+  /** DevTools JSON methods exposed through one nested binding target. */
+  get devtools(): BrowserRunDevtools;
+}
diff --git a/src/cloudflare/internal/test/br/br-api-test.js b/src/cloudflare/internal/test/br/br-api-test.js
index 61261268612..db9cb62e6d5 100644
--- a/src/cloudflare/internal/test/br/br-api-test.js
+++ b/src/cloudflare/internal/test/br/br-api-test.js
@@ -4,6 +4,17 @@
 
 import * as assert from 'node:assert';
 
+// Sends one message on an accepted socket and resolves with the mock's parsed echo.
+function roundTrip(webSocket, message) {
+  return new Promise((resolve, reject) => {
+    webSocket.addEventListener('message', (event) => {
+      resolve(JSON.parse(event.data));
+    });
+    webSocket.addEventListener('error', reject);
+    webSocket.send(message);
+  });
+}
+
 export const tests = {
   async test(_, env) {
     {
@@ -19,3 +30,157 @@ export const tests = {
     }
   },
 };
+
+export const passThroughMethods = {
+  async test(_, env) {
+    assert.strictEqual(env.browser.constructor.name, 'BrowserRendering');
+
+    const resp = await env.browser.quickAction('screenshot', {
+      url: 'https://example.com',
+    });
+    assert.deepStrictEqual(await resp.json(), {
+      action: 'screenshot',
+      url: 'https://example.com',
+    });
+
+    // Results keep RPC promise pipelining.
+    assert.strictEqual(
+      typeof (await env.browser.acquire().sessionId),
+      'string'
+    );
+
+    const { sessionId } = await env.browser.acquire();
+    assert.deepStrictEqual(await env.browser.getSession(sessionId), {
+      sessionId,
+    });
+    assert.ok(
+      (await env.browser.listSessions()).some((s) => s.sessionId === sessionId)
+    );
+    assert.ok(
+      (await env.browser.history()).some((s) => s.sessionId === sessionId)
+    );
+    assert.deepStrictEqual(await env.browser.limits(), {
+      maxConcurrentSessions: 10,
+    });
+    assert.deepStrictEqual(
+      await env.browser.getLiveView(sessionId, { mode: 'devtools' }),
+      { id: sessionId, options: { mode: 'devtools' } }
+    );
+    assert.deepStrictEqual(await env.browser.devtools.listTargets(sessionId), [
+      { id: `${sessionId}-page`, type: 'page', url: 'about:blank' },
+    ]);
+    assert.deepStrictEqual(await env.browser.closeSession(sessionId), {
+      status: 'closed',
+    });
+    assert.strictEqual(await env.browser.getSession(sessionId), null);
+  },
+};
+
+export const launchReturnsFetcherByDefault = {
+  async test(_, env) {
+    for (const options of [undefined, {}, { websocket: false }]) {
+      const connection = await env.browser.launch(options);
+      assert.strictEqual(typeof connection.sessionId, 'string');
+      assert.ok(!(connection.webSocket instanceof WebSocket));
+
+      const resp = await connection.webSocket.fetch(
+        'https://browser-binding.invalid/',
+        { headers: { Upgrade: 'websocket' } }
+      );
+      assert.strictEqual(resp.status, 101);
+      resp.webSocket.accept();
+      resp.webSocket.close();
+    }
+  },
+};
+
+export const launchWithWebSocket = {
+  async test(_, env) {
+    const connection = await env.browser.launch({
+      targets: true,
+      websocket: true,
+    });
+    assert.ok(connection.webSocket instanceof WebSocket);
+    assert.deepStrictEqual(connection.targets, [
+      {
+        id: `${connection.sessionId}-page`,
+        type: 'page',
+        url: 'about:blank',
+      },
+    ]);
+    // The upgrade keeps the RPC result object, so it stays disposable.
+    assert.strictEqual(typeof connection[Symbol.dispose], 'function');
+
+    connection.webSocket.accept();
+    const reply = await roundTrip(connection.webSocket, 'hello');
+    assert.deepStrictEqual(reply, {
+      sessionId: connection.sessionId,
+      targetId: null,
+      echo: 'hello',
+    });
+    connection.webSocket.close();
+  },
+};
+
+export const connectSessionWithWebSocket = {
+  async test(_, env) {
+    const { sessionId } = await env.browser.acquire();
+
+    const connection = await env.browser.connectSession(sessionId, {
+      targetId: 'page-1',
+      websocket: true,
+    });
+    assert.strictEqual(connection.sessionId, sessionId);
+    assert.ok(connection.webSocket instanceof WebSocket);
+
+    connection.webSocket.accept();
+    const reply = await roundTrip(connection.webSocket, 'hello');
+    assert.deepStrictEqual(reply, {
+      sessionId,
+      targetId: 'page-1',
+      echo: 'hello',
+    });
+    connection.webSocket.close();
+
+    const fetcherConnection = await env.browser.connectSession(sessionId, {
+      websocket: false,
+    });
+    assert.ok(!(fetcherConnection.webSocket instanceof WebSocket));
+  },
+};
+
+export const failedUpgradeClosesLaunchedSession = {
+  async test(_, env) {
+    const before = await env.browser.listSessions();
+
+    await assert.rejects(
+      env.browser.launch({ location: 'fail-upgrade', websocket: true }),
+      {
+        message:
+          'Browser Run WebSocket upgrade failed with HTTP 503: upgrade refused',
+      }
+    );
+
+    assert.deepStrictEqual(await env.browser.listSessions(), before);
+  },
+};
+
+export const failedUpgradeKeepsConnectedSession = {
+  async test(_, env) {
+    const { sessionId } = await env.browser.acquire({
+      location: 'fail-upgrade',
+    });
+
+    await assert.rejects(
+      env.browser.connectSession(sessionId, { websocket: true }),
+      {
+        message:
+          'Browser Run WebSocket upgrade failed with HTTP 503: upgrade refused',
+      }
+    );
+
+    assert.deepStrictEqual(await env.browser.getSession(sessionId), {
+      sessionId,
+    });
+  },
+};
diff --git a/src/cloudflare/internal/test/br/br-api-test.wd-test b/src/cloudflare/internal/test/br/br-api-test.wd-test
index 3d6604e6af2..0c7416b37e9 100644
--- a/src/cloudflare/internal/test/br/br-api-test.wd-test
+++ b/src/cloudflare/internal/test/br/br-api-test.wd-test
@@ -24,7 +24,7 @@ const unitTests :Workerd.Config = (
     ),
     ( name = "br-mock",
       worker = (
-        compatibilityFlags = ["experimental", "nodejs_compat"],
+        compatibilityFlags = ["enable_ctx_exports", "web_socket_auto_reply_to_close"],
         modules = [
           (name = "worker", esModule = embed "br-mock.js")
         ],
diff --git a/src/cloudflare/internal/test/br/br-mock.js b/src/cloudflare/internal/test/br/br-mock.js
index 06c105f775a..0dfe794eaa6 100644
--- a/src/cloudflare/internal/test/br/br-mock.js
+++ b/src/cloudflare/internal/test/br/br-mock.js
@@ -2,8 +2,35 @@
 // Licensed under the Apache 2.0 license found in the LICENSE file or at:
 //     https://opensource.org/licenses/Apache-2.0
 
-export default {
-  async fetch(request, env, ctx) {
+import { RpcTarget, WorkerEntrypoint } from 'cloudflare:workers';
+
+const sessions = new Map();
+let nextSessionId = 1;
+
+class Devtools extends RpcTarget {
+  listTargets(sessionId) {
+    return [{ id: `${sessionId}-page`, type: 'page', url: 'about:blank' }];
+  }
+}
+
+export class BrowserBindingWebSocketEntrypoint extends WorkerEntrypoint {
+  fetch() {
+    const { sessionId, targetId, failUpgrade } = this.ctx.props;
+    if (failUpgrade) {
+      return new Response('upgrade refused', { status: 503 });
+    }
+
+    const [client, server] = new WebSocketPair();
+    server.accept();
+    server.addEventListener('message', (event) => {
+      server.send(JSON.stringify({ sessionId, targetId, echo: event.data }));
+    });
+    return new Response(null, { status: 101, webSocket: client });
+  }
+}
+
+export default class extends WorkerEntrypoint {
+  async fetch() {
     return Response.json(
       { success: true },
       {
@@ -12,5 +39,70 @@ export default {
         },
       }
     );
-  },
-};
+  }
+
+  quickAction(action, options) {
+    return Response.json({ action, url: options.url });
+  }
+
+  acquire(options) {
+    const sessionId = `session-${nextSessionId++}`;
+    // Setting `location` to 'fail-upgrade' makes the pinned Fetcher refuse the upgrade.
+    sessions.set(sessionId, options?.location === 'fail-upgrade');
+    return { sessionId };
+  }
+
+  launch(options) {
+    const { sessionId } = this.acquire(options);
+    const connection = this.connectSession(sessionId);
+    if (options?.targets) {
+      connection.targets = new Devtools().listTargets(sessionId);
+    }
+    return connection;
+  }
+
+  connectSession(sessionId, options) {
+    if (!sessions.has(sessionId)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return {
+      sessionId,
+      webSocket: this.ctx.exports.BrowserBindingWebSocketEntrypoint({
+        props: {
+          sessionId,
+          targetId: options?.targetId ?? null,
+          failUpgrade: sessions.get(sessionId),
+        },
+      }),
+    };
+  }
+
+  getLiveView(sessionId, options) {
+    return { id: sessionId, options: { mode: options?.mode ?? 'tab' } };
+  }
+
+  listSessions() {
+    return [...sessions.keys()].map((sessionId) => ({ sessionId }));
+  }
+
+  history() {
+    return this.listSessions();
+  }
+
+  limits() {
+    return { maxConcurrentSessions: 10 };
+  }
+
+  getSession(sessionId) {
+    return sessions.has(sessionId) ? { sessionId } : null;
+  }
+
+  closeSession(sessionId) {
+    sessions.delete(sessionId);
+    return { status: 'closed' };
+  }
+
+  get devtools() {
+    return new Devtools();
+  }
+}