@opengeni/runtime 4.0.1 → 4.0.3-canary.36079201993001

package/dist/{chunk-J5AR5XAJ.js → chunk-GBVN7WSK.js}

@@ -26,14 +26,14 @@ import {
   truncateOutput,
   validateCredentialPair,
   validateRemoteSandboxPathForManifest
-} from "./chunk-SPT3PLMX.js";
+} from "./chunk-PRHMSM6C.js";
 import {
   NoopSnapshotSpec,
   isNoopSnapshotSpec,
   normalizeSandboxClientCreateArgs,
   resolveSandboxArchiveLimits,
   validateSandboxArchiveLimits
-} from "./chunk-ZG2YH25H.js";
+} from "./chunk-JAYHA6BF.js";
 import {
   Environment,
   FileMode,
@@ -96,7 +96,7 @@ import {
   shellQuote,
   stableJsonStringify,
   withSandboxSpan
-} from "./chunk-UNICCRW5.js";
+} from "./chunk-LZIXCZUV.js";
 
 // src/sandbox/index.ts
 import { collectSandboxEnvironment, parseExposedPorts } from "@opengeni/config";
@@ -6567,7 +6567,7 @@ var CloudflareSandboxSession = class {
   async materializeEntry(args) {
     assertSandboxEntryMetadataSupported("CloudflareSandboxClient", args.path, args.entry, MOUNT_MANIFEST_METADATA_SUPPORT);
     if (entryContainsLocalSource(args.entry)) {
-      const { applyLocalSourceManifestEntryToState: applyLocalSourceManifestEntryToState2 } = await import("./localSources-TWHTEKGO.js");
+      const { applyLocalSourceManifestEntryToState: applyLocalSourceManifestEntryToState2 } = await import("./localSources-FDH65AFI.js");
       await applyLocalSourceManifestEntryToState2(this.state, args.path, args.entry, "cloudflare", this.writer(), this.remotePathResolver, this.manifestMaterializationOptions(args.runAs));
       return;
     }
@@ -6578,7 +6578,7 @@ var CloudflareSandboxSession = class {
     assertSandboxManifestMetadataSupported("CloudflareSandboxClient", manifest, MOUNT_MANIFEST_METADATA_SUPPORT);
     assertCloudflareManifestMountsSupported(manifest);
     if (manifestContainsLocalSource(manifest)) {
-      const { applyLocalSourceManifestToState: applyLocalSourceManifestToState2 } = await import("./localSources-TWHTEKGO.js");
+      const { applyLocalSourceManifestToState: applyLocalSourceManifestToState2 } = await import("./localSources-FDH65AFI.js");
       await applyLocalSourceManifestToState2(this.state, manifest, "cloudflare", this.writer(), this.remotePathResolver, this.manifestMaterializationOptions(runAs));
       return;
     }
@@ -15848,8 +15848,9 @@ function notifyDurableOpOwnershipTransferred(opId) {
   storage.getStore()?.onDurableOpOwnershipTransferred?.(opId);
 }
 
-// src/sandbox/routing/routing-session.ts
-import { isDeepStrictEqual } from "util";
+// src/sandbox/providers/modal-command-router-wire.ts
+import { Client, Metadata, credentials, status } from "@grpc/grpc-js";
+import protobuf from "protobufjs";
 
 // src/sandbox/provider-command-session.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
@@ -15895,6 +15896,219 @@ function admittedProviderCommandHandle() {
   return admission.getStore();
 }
 
+// src/sandbox/providers/modal-command-router-wire.ts
+var modalRouterWire = protobuf.parse(`syntax = "proto3";
+message Identity { string task_id = 1; string exec_id = 2; }
+message Pty {
+  bool enabled = 1; uint32 winsz_rows = 2; uint32 winsz_cols = 3;
+  string env_term = 4; string env_colorterm = 5; string env_term_program = 6;
+  int32 pty_type = 7; bool no_terminate_on_idle_stdin = 8;
+}
+message Start {
+  string task_id = 1; string exec_id = 2; repeated string command_args = 3;
+  int32 stdout_config = 4; int32 stderr_config = 5;
+  optional uint32 timeout_secs = 6; optional string workdir = 7;
+  repeated string secret_ids = 8; optional Pty pty_info = 9;
+  bool runtime_debug = 10; string container_id = 11; map<string,string> env = 12;
+}
+message Read {
+  string task_id = 1; string exec_id = 2; uint64 offset = 3; int32 file_descriptor = 4;
+}
+message Data { bytes data = 1; }
+message Poll { optional int32 code = 1; optional int32 signal = 2; }
+message Write {
+  string task_id = 1; string exec_id = 2; uint64 offset = 3; bytes data = 4; bool eof = 5;
+}
+message Empty {}
+`).root;
+var prefix = "/modal.task_command_router.TaskCommandRouter/";
+var maxPageBytes = 64 * 1024;
+var maxWireBytes = 4 * 1024 * 1024;
+var ModalCommandStartRejectedError = class extends ProviderCommandStartRejectedError {
+  constructor(code, cause) {
+    super(cause);
+    this.code = code;
+    this.name = "ModalCommandStartRejectedError";
+  }
+};
+var ModalCommandStartPreDispatchUnavailableError = class _ModalCommandStartPreDispatchUnavailableError extends Error {
+  constructor(cause) {
+    super("Modal command router was not ready before Start dispatch", { cause });
+    this.name = "ModalCommandStartPreDispatchUnavailableError";
+  }
+  static async ensureReady(client, signal) {
+    signal?.throwIfAborted();
+    await new Promise((resolve7, reject) => {
+      let settled = false;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener("abort", abort);
+        if (signal?.aborted) reject(signal.reason);
+        else if (error) reject(new _ModalCommandStartPreDispatchUnavailableError(error));
+        else resolve7();
+      };
+      const abort = () => finish();
+      signal?.addEventListener("abort", abort, { once: true });
+      client.waitForReady(Date.now() + 5e3, finish);
+      if (signal?.aborted) abort();
+    });
+  }
+};
+function encode(type, value) {
+  const codec = modalRouterWire.lookupType(type);
+  return Buffer.from(codec.encode(codec.fromObject(value)).finish());
+}
+var ModalCommandRouterWire = class {
+  client;
+  metadata;
+  closed = false;
+  constructor(access, trustedRoots) {
+    const url = new URL(access.url);
+    if (url.protocol !== "https:" || url.username || url.password || !access.jwt)
+      throw new Error("Modal command router requires authenticated TLS");
+    this.client = new Client(
+      `${url.hostname}:${url.port || "443"}`,
+      credentials.createSsl(trustedRoots),
+      {
+        "grpc.max_receive_message_length": maxWireBytes,
+        "grpc.max_send_message_length": maxWireBytes,
+        "grpc.enable_retries": 0
+      }
+    );
+    this.metadata = new Metadata();
+    this.metadata.set("authorization", `Bearer ${access.jwt}`);
+  }
+  close() {
+    this.closed = true;
+    this.client.close();
+  }
+  async unary(method, requestType, responseType, request, signal) {
+    signal?.throwIfAborted();
+    if (this.closed) throw new Error("Modal command router is closed");
+    return await new Promise((resolve7, reject) => {
+      const call = this.client.makeUnaryRequest(
+        prefix + method,
+        (value) => encode(requestType, value),
+        (bytes) => modalRouterWire.lookupType(responseType).decode(bytes),
+        request,
+        this.metadata,
+        { deadline: Date.now() + 3e4 },
+        (error, result) => {
+          signal?.removeEventListener("abort", abort);
+          if (signal?.aborted) reject(signal.reason);
+          else if (error) reject(error);
+          else if (result) resolve7(result);
+          else reject(new Error("Modal command router returned no response"));
+        }
+      );
+      const abort = () => call.cancel();
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+    });
+  }
+  async start(request, signal) {
+    if (this.closed) throw new Error("Modal command router is closed");
+    try {
+      await ModalCommandStartPreDispatchUnavailableError.ensureReady(this.client, signal);
+    } catch (error) {
+      if (this.closed) throw new Error("Modal command router is closed", { cause: error });
+      throw error;
+    }
+    try {
+      await this.unary(
+        "TaskExecStart",
+        "Start",
+        "Empty",
+        {
+          ...request,
+          stdoutConfig: 1,
+          stderrConfig: 1
+        },
+        signal
+      );
+    } catch (error) {
+      const code = error?.code;
+      if (typeof code === "number" && [
+        status.INVALID_ARGUMENT,
+        status.NOT_FOUND,
+        status.PERMISSION_DENIED,
+        status.UNAUTHENTICATED,
+        status.UNIMPLEMENTED
+      ].includes(code))
+        throw new ModalCommandStartRejectedError(code, error);
+      throw error;
+    }
+  }
+  async write(identity, offset, data, signal) {
+    if (!Number.isSafeInteger(offset) || offset < 0)
+      throw new Error("Invalid Modal stdin byte offset");
+    await this.unary(
+      "TaskExecStdinWrite",
+      "Write",
+      "Empty",
+      { ...identity, offset, data, eof: false },
+      signal
+    );
+  }
+  async poll(identity, signal) {
+    const value = await this.unary("TaskExecPoll", "Identity", "Poll", identity, signal);
+    const decoded = modalRouterWire.lookupType("Poll").toObject(value);
+    if (decoded.code !== void 0) return decoded.code;
+    if (decoded.signal !== void 0) return 128 + decoded.signal;
+    return null;
+  }
+  async read(identity, stream, offset, waitMs, signal) {
+    signal?.throwIfAborted();
+    if (this.closed) throw new Error("Modal command router is closed");
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isFinite(waitMs) || waitMs < 0 || waitMs > 5e4)
+      throw new Error("Invalid Modal output read bounds");
+    const chunks = [];
+    let length = 0;
+    let limited = false;
+    return await new Promise((resolve7, reject) => {
+      const call = this.client.makeServerStreamRequest(
+        prefix + "TaskExecStdioRead",
+        (value) => encode("Read", value),
+        (bytes) => modalRouterWire.lookupType("Data").decode(bytes),
+        { ...identity, offset, fileDescriptor: stream === "stdout" ? 0 : 1 },
+        this.metadata,
+        { deadline: Date.now() + Math.max(1, waitMs) }
+      );
+      const abort = () => call.cancel();
+      const finish = (eof, error) => {
+        signal?.removeEventListener("abort", abort);
+        if (signal?.aborted) reject(signal.reason);
+        else if (error) reject(error);
+        else resolve7({ bytes: Buffer.concat(chunks, length), eof });
+      };
+      call.on("data", (value) => {
+        if (limited) return;
+        const part = Buffer.from(value.data).subarray(0, maxPageBytes - length);
+        if (part.length) {
+          chunks.push(part);
+          length += part.length;
+        }
+        if (length === maxPageBytes) {
+          limited = true;
+          call.cancel();
+        }
+      });
+      call.once("error", (error) => {
+        if (limited && error.code === status.CANCELLED || error.code === status.DEADLINE_EXCEEDED)
+          finish(false);
+        else finish(false, error);
+      });
+      call.once("end", () => finish(!limited));
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+    });
+  }
+};
+
+// src/sandbox/routing/routing-session.ts
+import { isDeepStrictEqual } from "util";
+
 // src/sandbox/materialization-verification-error.ts
 var EXPLANATIONS = {
   path_not_visible: "the provider could not see the destination path",
@@ -17341,7 +17555,7 @@ var RoutingSandboxSession = class {
         }
       } catch (error) {
         if (reservedProcess) {
-          if (error instanceof ProviderCommandStartRejectedError && reservedProcess.providerCommand?.kind === "modal-router-v1") {
+          if ((error instanceof ProviderCommandStartRejectedError || error instanceof ModalCommandStartPreDispatchUnavailableError) && reservedProcess.providerCommand?.kind === "modal-router-v1") {
             const persistence = this.deps.providerCommandPersistence?.(reservedProcess);
             if (persistence?.rejectSupervisedLaunch) {
               try {
@@ -17349,7 +17563,7 @@ var RoutingSandboxSession = class {
               } catch (cause) {
                 throw new RoutingMutationOutcomeUnknownError(
                   op,
-                  "Never-started provider rejection could not settle its exact reservation",
+                  "Never-started provider call could not settle its exact reservation",
                   { cause, retainedProcess: reservedProcess }
                 );
               }
@@ -22716,183 +22930,6 @@ var ModalCommandControl = class _ModalCommandControl {
   }
 };
 
-// src/sandbox/providers/modal-command-router-wire.ts
-import { Client, Metadata, credentials, status } from "@grpc/grpc-js";
-import protobuf from "protobufjs";
-var modalRouterWire = protobuf.parse(`syntax = "proto3";
-message Identity { string task_id = 1; string exec_id = 2; }
-message Pty {
-  bool enabled = 1; uint32 winsz_rows = 2; uint32 winsz_cols = 3;
-  string env_term = 4; string env_colorterm = 5; string env_term_program = 6;
-  int32 pty_type = 7; bool no_terminate_on_idle_stdin = 8;
-}
-message Start {
-  string task_id = 1; string exec_id = 2; repeated string command_args = 3;
-  int32 stdout_config = 4; int32 stderr_config = 5;
-  optional uint32 timeout_secs = 6; optional string workdir = 7;
-  repeated string secret_ids = 8; optional Pty pty_info = 9;
-  bool runtime_debug = 10; string container_id = 11; map<string,string> env = 12;
-}
-message Read {
-  string task_id = 1; string exec_id = 2; uint64 offset = 3; int32 file_descriptor = 4;
-}
-message Data { bytes data = 1; }
-message Poll { optional int32 code = 1; optional int32 signal = 2; }
-message Write {
-  string task_id = 1; string exec_id = 2; uint64 offset = 3; bytes data = 4; bool eof = 5;
-}
-message Empty {}
-`).root;
-var prefix = "/modal.task_command_router.TaskCommandRouter/";
-var maxPageBytes = 64 * 1024;
-var maxWireBytes = 4 * 1024 * 1024;
-var ModalCommandStartRejectedError = class extends ProviderCommandStartRejectedError {
-  constructor(code, cause) {
-    super(cause);
-    this.code = code;
-    this.name = "ModalCommandStartRejectedError";
-  }
-};
-function encode(type, value) {
-  const codec = modalRouterWire.lookupType(type);
-  return Buffer.from(codec.encode(codec.fromObject(value)).finish());
-}
-var ModalCommandRouterWire = class {
-  client;
-  metadata;
-  closed = false;
-  constructor(access, trustedRoots) {
-    const url = new URL(access.url);
-    if (url.protocol !== "https:" || url.username || url.password || !access.jwt)
-      throw new Error("Modal command router requires authenticated TLS");
-    this.client = new Client(url.host, credentials.createSsl(trustedRoots), {
-      "grpc.max_receive_message_length": maxWireBytes,
-      "grpc.max_send_message_length": maxWireBytes,
-      "grpc.enable_retries": 0
-    });
-    this.metadata = new Metadata();
-    this.metadata.set("authorization", `Bearer ${access.jwt}`);
-  }
-  close() {
-    this.closed = true;
-    this.client.close();
-  }
-  async unary(method, requestType, responseType, request, signal) {
-    signal?.throwIfAborted();
-    if (this.closed) throw new Error("Modal command router is closed");
-    return await new Promise((resolve7, reject) => {
-      const call = this.client.makeUnaryRequest(
-        prefix + method,
-        (value) => encode(requestType, value),
-        (bytes) => modalRouterWire.lookupType(responseType).decode(bytes),
-        request,
-        this.metadata,
-        { deadline: Date.now() + 3e4 },
-        (error, result) => {
-          signal?.removeEventListener("abort", abort);
-          if (signal?.aborted) reject(signal.reason);
-          else if (error) reject(error);
-          else if (result) resolve7(result);
-          else reject(new Error("Modal command router returned no response"));
-        }
-      );
-      const abort = () => call.cancel();
-      signal?.addEventListener("abort", abort, { once: true });
-      if (signal?.aborted) abort();
-    });
-  }
-  async start(request, signal) {
-    try {
-      await this.unary(
-        "TaskExecStart",
-        "Start",
-        "Empty",
-        {
-          ...request,
-          stdoutConfig: 1,
-          stderrConfig: 1
-        },
-        signal
-      );
-    } catch (error) {
-      const code = error?.code;
-      if (typeof code === "number" && [
-        status.INVALID_ARGUMENT,
-        status.NOT_FOUND,
-        status.PERMISSION_DENIED,
-        status.UNAUTHENTICATED,
-        status.UNIMPLEMENTED
-      ].includes(code))
-        throw new ModalCommandStartRejectedError(code, error);
-      throw error;
-    }
-  }
-  async write(identity, offset, data, signal) {
-    if (!Number.isSafeInteger(offset) || offset < 0)
-      throw new Error("Invalid Modal stdin byte offset");
-    await this.unary(
-      "TaskExecStdinWrite",
-      "Write",
-      "Empty",
-      { ...identity, offset, data, eof: false },
-      signal
-    );
-  }
-  async poll(identity, signal) {
-    const value = await this.unary("TaskExecPoll", "Identity", "Poll", identity, signal);
-    const decoded = modalRouterWire.lookupType("Poll").toObject(value);
-    if (decoded.code !== void 0) return decoded.code;
-    if (decoded.signal !== void 0) return 128 + decoded.signal;
-    return null;
-  }
-  async read(identity, stream, offset, waitMs, signal) {
-    signal?.throwIfAborted();
-    if (this.closed) throw new Error("Modal command router is closed");
-    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isFinite(waitMs) || waitMs < 0 || waitMs > 5e4)
-      throw new Error("Invalid Modal output read bounds");
-    const chunks = [];
-    let length = 0;
-    let limited = false;
-    return await new Promise((resolve7, reject) => {
-      const call = this.client.makeServerStreamRequest(
-        prefix + "TaskExecStdioRead",
-        (value) => encode("Read", value),
-        (bytes) => modalRouterWire.lookupType("Data").decode(bytes),
-        { ...identity, offset, fileDescriptor: stream === "stdout" ? 0 : 1 },
-        this.metadata,
-        { deadline: Date.now() + Math.max(1, waitMs) }
-      );
-      const abort = () => call.cancel();
-      const finish = (eof, error) => {
-        signal?.removeEventListener("abort", abort);
-        if (signal?.aborted) reject(signal.reason);
-        else if (error) reject(error);
-        else resolve7({ bytes: Buffer.concat(chunks, length), eof });
-      };
-      call.on("data", (value) => {
-        if (limited) return;
-        const part = Buffer.from(value.data).subarray(0, maxPageBytes - length);
-        if (part.length) {
-          chunks.push(part);
-          length += part.length;
-        }
-        if (length === maxPageBytes) {
-          limited = true;
-          call.cancel();
-        }
-      });
-      call.once("error", (error) => {
-        if (limited && error.code === status.CANCELLED || error.code === status.DEADLINE_EXCEEDED)
-          finish(false);
-        else finish(false, error);
-      });
-      call.once("end", () => finish(!limited));
-      signal?.addEventListener("abort", abort, { once: true });
-      if (signal?.aborted) abort();
-    });
-  }
-};
-
 // src/sandbox/providers/modal-command-control.ts
 var ModalCommandControl2 = class _ModalCommandControl {
   constructor(client, sandboxIdentity, root, environment) {
@@ -23063,7 +23100,8 @@ var ModalCommandControl2 = class _ModalCommandControl {
         )
       );
     } catch (error) {
-      if (!supervision || error instanceof ModalCommandStartRejectedError) throw error;
+      if (!supervision || error instanceof ModalCommandStartRejectedError || error instanceof ModalCommandStartPreDispatchUnavailableError)
+        throw error;
     }
     return command;
   }
@@ -23329,8 +23367,6 @@ function installModalListDirCompatibility(session) {
 }
 var MODAL_EXEC_STDIN_WRITE_PATH = "/modal.task_command_router.TaskCommandRouter/TaskExecStdinWrite";
 var MODAL_EXEC_ALREADY_COMPLETED_DETAILS = /^Exec has already completed; stdin is no longer accepting writes(?: \(Error code: [A-Z0-9]+\))?$/;
-var MODAL_TASK_EXEC_START_PATH = "/modal.task_command_router.TaskCommandRouter/TaskExecStart";
-var MODAL_TASK_EXEC_START_DNS_RESOLUTION_DETAILS = /^Name resolution failed for target dns:task-[a-z0-9]+\.w\.modal\.host:443$/;
 var MODAL_TASK_EXEC_START_ERROR_MAX_DEPTH = 8;
 var MODAL_TASK_EXEC_START_ERROR_MAX_NODES = 64;
 var MODAL_TASK_EXEC_START_ERROR_MAX_AGGREGATE_ERRORS = 32;
@@ -23352,10 +23388,7 @@ function hasContradictoryModalHttpStatus(record) {
   }
   return values.some((value) => modalHttpStatus(value) !== null);
 }
-function isModalTaskExecStartDnsResolutionLeaf(record) {
-  return record.name === "ClientError" && record.path === MODAL_TASK_EXEC_START_PATH && (record.code === 14 || record.code === "UNAVAILABLE") && typeof record.details === "string" && MODAL_TASK_EXEC_START_DNS_RESOLUTION_DETAILS.test(record.details);
-}
-function isModalTaskExecStartDnsResolutionError(error) {
+function isModalTaskExecStartPreDispatchUnavailableError(error) {
   const pending = [{ depth: 0, value: error }];
   const seen = /* @__PURE__ */ new WeakSet();
   let inspected = 0;
@@ -23372,7 +23405,12 @@ function isModalTaskExecStartDnsResolutionError(error) {
     let nested;
     try {
       const record = current.value;
+      if (isRoutingMutationOutcomeUnknownError(current.value)) return false;
       if (hasContradictoryModalHttpStatus(record)) return false;
+      if (current.value instanceof ModalCommandStartPreDispatchUnavailableError) {
+        matchingLeaves += 1;
+        continue;
+      }
       nested = [];
       for (const key of ["cause", "error"]) {
         const value = record[key];
@@ -23385,11 +23423,7 @@ function isModalTaskExecStartDnsResolutionError(error) {
         }
         nested.push(...errors);
       }
-      if (nested.length === 0) {
-        if (!isModalTaskExecStartDnsResolutionLeaf(record)) return false;
-        matchingLeaves += 1;
-        continue;
-      }
+      if (nested.length === 0) return false;
     } catch {
       return false;
     }
@@ -33049,6 +33083,7 @@ function shellQuote5(value) {
 // src/sandbox/browser-control-client.ts
 import { createHash as createHash7, randomUUID as randomUUID8 } from "crypto";
 import { posix as posixPath2 } from "path";
+import { parseBrowserFrameMetadata } from "@opengeni/sdk";
 import {
   BROWSER_CONTROL_MAX_JSON_BYTES,
   BROWSER_CONTROL_PORT as BROWSER_CONTROL_PORT2,
@@ -33063,6 +33098,8 @@ import {
   BrowserDownloadExportReceipt,
   BrowserDownloadExportRequest,
   BrowserDownloadListResponse,
+  BrowserDomReadRequest,
+  BrowserDomReadResponse,
   BrowserExternalAuthCommand,
   BrowserExternalAuthResult,
   BrowserObservation,
@@ -33070,6 +33107,7 @@ import {
   BrowserProtectedAuthFillReceipt,
   BrowserRevisionMaterialization,
   BrowserTarget,
+  BrowserTargetState,
   BrowserWorkspaceFileStageRequest,
   BrowserWorkspaceFileStageResponse,
   ComputerActionCommand,
@@ -33536,7 +33574,10 @@ var BrowserControlClient = class {
     return await this.requestJson(input);
   }
   async requestBytesForSession(input) {
-    return await this.requestBytes(input);
+    return await this.requestBytes({ ...input, surface: "computer" });
+  }
+  async requestBrowserBytesForSession(input) {
+    return await this.requestBytes({ ...input, surface: "browser" });
   }
   async requestJson(input, retryNativeEndpoint = true) {
     const requireHostFetch = this.session.requireHostFetchController === true;
@@ -33772,10 +33813,10 @@ var BrowserControlClient = class {
       const data = await readBytes(
         this.session,
         responsePath,
-        COMPUTER_SCREENSHOT_MAX_BYTES,
+        input.surface === "browser" ? 24 * 1024 * 1024 : COMPUTER_SCREENSHOT_MAX_BYTES,
         timeoutMs
       );
-      return computerControlFrame(data, headers, input.expectedFrameEvidence);
+      return controllerImageFrame(data, headers, input);
     } catch (error) {
       if (error instanceof BrowserControlRequestError || error instanceof BrowserControlProtocolError || error instanceof RangeError) {
         throw error;
@@ -33923,6 +33964,75 @@ var BrowserControlSessionClient = class {
       })
     );
   }
+  async targetState(targetId) {
+    let state;
+    try {
+      state = BrowserTargetState.parse(
+        await this.parent.requestForSession({
+          method: "GET",
+          path: this.targetPath(targetId, "state"),
+          token: this.viewToken
+        })
+      );
+    } catch (error) {
+      if (!(error instanceof BrowserControlRequestError) || error.status !== 404 || error.error.code !== "resource_not_found" || error.error.message !== "route not found") {
+        throw error;
+      }
+      const observation = await this.observe(targetId);
+      state = BrowserTargetState.parse({
+        browserSessionId: observation.browserSessionId,
+        controllerGeneration: observation.target.controllerGeneration,
+        targetId: observation.target.id,
+        targetGeneration: observation.target.targetGeneration,
+        documentGeneration: observation.target.documentGeneration,
+        frameId: observation.frameId
+      });
+    }
+    if (state.browserSessionId !== this.reference.browserSessionId || state.controllerGeneration !== this.reference.controllerGeneration || state.targetId !== targetId) {
+      throw new BrowserControlProtocolError("browser target state belongs to another binding");
+    }
+    return state;
+  }
+  async readDom(targetId, requestInput) {
+    const request = BrowserDomReadRequest.parse(requestInput);
+    const result = BrowserDomReadResponse.parse(
+      await this.parent.requestForSession({
+        method: "POST",
+        path: this.targetPath(targetId, "dom-read"),
+        token: this.viewToken,
+        body: request
+      })
+    );
+    if (result.browserSessionId !== this.reference.browserSessionId || result.controllerGeneration !== this.reference.controllerGeneration || result.targetId !== targetId || result.targetGeneration !== request.expectedTargetGeneration || result.documentGeneration !== request.expectedDocumentGeneration || result.frameId !== request.expectedFrameId || result.kind !== request.kind) {
+      throw new BrowserControlProtocolError("browser DOM read belongs to another binding");
+    }
+    return result;
+  }
+  async capture(targetId, options = {}) {
+    const query = new URLSearchParams({
+      format: options.format ?? "jpeg",
+      quality: String(boundedInteger(options.quality ?? 55, 1, 100, "browser screenshot quality"))
+    });
+    if (options.format !== void 0 && options.format !== "jpeg" && options.format !== "png") {
+      throw new RangeError("browser screenshot format is invalid");
+    }
+    if (options.fullPage !== void 0) {
+      if (typeof options.fullPage !== "boolean") {
+        throw new RangeError("browser screenshot fullPage is invalid");
+      }
+      query.set("fullPage", String(options.fullPage));
+    }
+    return await this.parent.requestBrowserBytesForSession({
+      method: "GET",
+      path: this.targetPath(targetId, `screenshot?${query}`),
+      token: this.viewToken,
+      expectedFrameEvidence: {
+        browserSessionId: this.reference.browserSessionId,
+        controllerGeneration: this.reference.controllerGeneration,
+        targetId: requireOpaqueId(targetId, "browser target id")
+      }
+    });
+  }
   async readClipboard() {
     return BrowserClipboard.parse(
       await this.parent.requestForSession({
@@ -34256,12 +34366,69 @@ async function requestExposedControllerBytes(endpoint, input, defaultTimeoutMs)
     throw new BrowserControlProtocolError("browser controller image response is invalid");
   }
   const declaredLength = Number(response.headers.get("content-length"));
-  if (Number.isFinite(declaredLength) && declaredLength > COMPUTER_SCREENSHOT_MAX_BYTES) {
-    await response.body?.cancel("computer frame exceeds its byte bound").catch(() => void 0);
-    throw new RangeError("computer frame exceeds its byte bound");
+  const maxBytes = input.surface === "browser" ? 24 * 1024 * 1024 : COMPUTER_SCREENSHOT_MAX_BYTES;
+  if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+    await response.body?.cancel("frame exceeds its byte bound").catch(() => void 0);
+    throw new RangeError("frame exceeds its byte bound");
+  }
+  const data = await readBoundedFrameResponse(response, maxBytes);
+  return controllerImageFrame(data, response.headers, input);
+}
+async function readBoundedFrameResponse(response, maxBytes) {
+  if (!response.body) throw new BrowserControlProtocolError("browser controller image is empty");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel("frame exceeds its byte bound").catch(() => void 0);
+        throw new RangeError("frame exceeds its byte bound");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
   }
-  const data = new Uint8Array(await response.arrayBuffer());
-  return computerControlFrame(data, response.headers, input.expectedFrameEvidence);
+  const data = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    data.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return data;
+}
+function controllerImageFrame(data, headers, input) {
+  return input.surface === "browser" ? browserControlFrame(data, headers, input.expectedFrameEvidence) : computerControlFrame(data, headers, input.expectedFrameEvidence);
+}
+function browserControlFrame(data, headers, expected) {
+  if (data.byteLength < 1 || data.byteLength > 24 * 1024 * 1024) {
+    throw new RangeError("browser frame exceeds its byte bound");
+  }
+  const get = (name) => headers.get(name.toLowerCase()) ?? null;
+  const mediaType = get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  if (mediaType !== "image/jpeg" && mediaType !== "image/png") {
+    throw new BrowserControlProtocolError("browser frame media type is invalid");
+  }
+  const metadataHeader = get("x-opengeni-browser-frame");
+  if (!metadataHeader || metadataHeader.length > 64 * 1024 || !/^[A-Za-z0-9_-]+$/u.test(metadataHeader)) {
+    throw new BrowserControlProtocolError("browser frame metadata is invalid");
+  }
+  let metadata;
+  try {
+    metadata = parseBrowserFrameMetadata(
+      JSON.parse(Buffer.from(metadataHeader, "base64url").toString("utf8"))
+    );
+  } catch {
+    throw new BrowserControlProtocolError("browser frame metadata is invalid");
+  }
+  if (metadata.browserSessionId !== expected.browserSessionId || metadata.controllerGeneration !== expected.controllerGeneration || metadata.targetId !== expected.targetId || metadata.mediaType !== mediaType) {
+    throw new BrowserControlProtocolError("browser frame evidence does not match its request");
+  }
+  return { data, mediaType, metadataHeader, metadata };
 }
 function computerControlFrame(data, headers, expected) {
   if (data.byteLength < 1 || data.byteLength > COMPUTER_SCREENSHOT_MAX_BYTES) {
@@ -34936,7 +35103,7 @@ async function readText(session, path, maxBytes, timeoutMs) {
 }
 async function readBytes(session, path, maxBytes, timeoutMs) {
   const privatePath = absolutePrivatePath(path, "browser private binary response path");
-  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > COMPUTER_SCREENSHOT_MAX_BYTES) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > Math.max(24 * 1024 * 1024, COMPUTER_SCREENSHOT_MAX_BYTES)) {
     throw new RangeError("browser private binary response limit is invalid");
   }
   const sizeMarker = `OPENGENI_BROWSER_PRIVATE_SIZE_${randomUUID8()}`;
@@ -34955,7 +35122,7 @@ async function readBytes(session, path, maxBytes, timeoutMs) {
     "browser private binary response size"
   );
   if (size < 1 || size > maxBytes) {
-    throw new RangeError("computer frame exceeds its byte bound");
+    throw new RangeError("frame exceeds its byte bound");
   }
   const chunks = [];
   for (let offset = 0; offset < size; offset += PRIVATE_READ_CHUNK_BYTES) {
@@ -38388,7 +38555,7 @@ export {
   assertDescriptorRegistryInvariants,
   modalSandboxAttributionEnvironment,
   modalSandboxAttributionTags,
-  isModalTaskExecStartDnsResolutionError,
+  isModalTaskExecStartPreDispatchUnavailableError,
   ensureModalRegistryImage,
   resolveModalCheckpointProviderBindingForSession,
   modalSessionMatchesCheckpointProviderBinding,
@@ -38571,4 +38738,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-J5AR5XAJ.js.map
+//# sourceMappingURL=chunk-GBVN7WSK.js.map