@opengeni/runtime 4.0.1 → 4.0.3-canary.36199476632001

package/dist/{chunk-J5AR5XAJ.js → chunk-FAFZCSN7.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;
     }
@@ -15606,6 +15606,9 @@ import {
   canonicalModalCheckpointProviderBinding
 } from "@opengeni/contracts";
 
+// src/sandbox/channel-a.ts
+import { constants as zlibConstants, createGunzip } from "zlib";
+
 // src/sandbox/selfhosted/workspace-path.ts
 var MAX_MACHINE_PATH_LENGTH = 4096;
 var CONTROL_CHARACTER = /[\u0000-\u001f\u007f]/u;
@@ -15849,7 +15852,11 @@ function notifyDurableOpOwnershipTransferred(opId) {
 }
 
 // src/sandbox/routing/routing-session.ts
-import { isDeepStrictEqual } from "util";
+import { SandboxFilesystemNotFoundError } from "modal";
+
+// 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 +15902,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",
@@ -16365,6 +16585,10 @@ function eligibleForSupervision(args) {
     args && typeof args === "object" && !args.tty && !args.runAs
   );
 }
+var READ_ONLY_PATH_PROBE_OPERATIONS = /* @__PURE__ */ new Set(["readFile", "listDir", "pathExists", "viewImage"]);
+function isReadOnlyPathProbeMiss(op, error) {
+  return READ_ONLY_PATH_PROBE_OPERATIONS.has(op) && (isDefinitePathNotFoundError(error) || error instanceof SandboxWorkspaceReadNotFoundError || error instanceof SandboxFilesystemNotFoundError);
+}
 function recordFirstOperationPhase(timing, phase, durationMs, outcome) {
   if (!timing) return;
   const prior = timing.phases[phase];
@@ -17172,6 +17396,9 @@ var RoutingSandboxSession = class {
       );
       outcome = "completed";
       return result;
+    } catch (error) {
+      if (isReadOnlyPathProbeMiss(op, error)) outcome = "completed";
+      throw error;
     } finally {
       try {
         firstOperationObserver({
@@ -17331,6 +17558,9 @@ var RoutingSandboxSession = class {
             }
           );
           providerOutcome = "completed";
+        } catch (error) {
+          if (isReadOnlyPathProbeMiss(op, error)) providerOutcome = "completed";
+          throw error;
         } finally {
           recordFirstOperationPhase(
             firstOperationTiming,
@@ -17341,7 +17571,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 +17579,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 }
                 );
               }
@@ -17541,7 +17771,7 @@ var RoutingSandboxSession = class {
       return result;
     } catch (error) {
       materializationFailureReason = materializationVerificationDiagnostic(error)?.reason;
-      if ((op === "readFile" || op === "listDir" || op === "pathExists" || op === "viewImage") && isDefinitePathNotFoundError(error)) {
+      if (isReadOnlyPathProbeMiss(op, error)) {
         outcome = "not_found";
       }
       throw error;
@@ -19667,6 +19897,97 @@ var ChannelAPartialMutationError = class extends Error {
 };
 var REPOSITORY_DISCOVERY_LIMIT = 256;
 var REPOSITORY_DISCOVERY_TRUNCATED_SENTINEL = "__OPENGENI_REPOSITORY_DISCOVERY_TRUNCATED__";
+var CODE_SEARCH_RG_MAX_BYTES = 64 * 1024 * 1024;
+var CODE_SEARCH_RG_CHUNK_BYTES = 512 * 1024;
+var CODE_SEARCH_RG_FRAME_CHARS = 768 * 1024;
+var CODE_SEARCH_RG_MAX_TRANSFER_BYTES = 8 * 1024 * 1024;
+var CODE_SEARCH_RG_TOKEN = /^opengeni-code-search\.[A-Za-z0-9]+$/;
+var CODE_SEARCH_RG_BEGIN = "__OPENGENI_CODE_SEARCH_RG_BEGIN__";
+var CODE_SEARCH_RG_END = "__OPENGENI_CODE_SEARCH_RG_END__";
+var CODE_SEARCH_RG_TRAILER = new RegExp(
+  `${CODE_SEARCH_RG_END}(\\d+):([01])(?::(\\d+):([A-Za-z0-9._-]+)(?::(\\d+):([01]))?)?__`
+);
+var CODE_SEARCH_RG_STORE_FAILED = "code search could not store its output on this machine; its temporary directory may be full";
+var CODE_SEARCH_KINDS_BEGIN = "__OPENGENI_CODE_SEARCH_KINDS_BEGIN__";
+var CODE_SEARCH_KINDS_END = "__OPENGENI_CODE_SEARCH_KINDS_END__";
+var CODE_SEARCH_RG_FLAGS = /* @__PURE__ */ new Set([
+  "--files",
+  "--null",
+  "--line-number",
+  "--with-filename",
+  "--no-heading",
+  "-i",
+  "-w",
+  "--no-require-git",
+  "--hidden"
+]);
+var CODE_SEARCH_RG_VALUE_FLAGS = /* @__PURE__ */ new Map([
+  ["--color", (value) => value === "never"],
+  ["-m", (value) => /^[1-9]\d{0,5}$/.test(value)],
+  ["--max-columns", (value) => /^[1-9]\d{0,6}$/.test(value)],
+  ["--max-filesize", (value) => /^[1-9]\d{0,9}$/.test(value)],
+  ["-g", (value) => value.length > 0 && value.length <= 512],
+  ["-e", (value) => value.length > 0 && value.length <= 16384]
+]);
+function validateCodeSearchRipgrepArgs(args, workspaceRoot = "") {
+  const out = [];
+  let index = 0;
+  for (; index < args.length; index++) {
+    const arg = args[index];
+    if (arg.includes(NUL)) throw new ChannelAValidationError("ripgrep argument contains NUL");
+    if (arg === "--") break;
+    if (CODE_SEARCH_RG_FLAGS.has(arg)) {
+      out.push(arg);
+      continue;
+    }
+    const valid = CODE_SEARCH_RG_VALUE_FLAGS.get(arg);
+    const value = args[index + 1];
+    if (!valid || value === void 0 || value.includes(NUL) || !valid(value)) {
+      throw new ChannelAValidationError(`ripgrep argument is not allowed: ${arg}`);
+    }
+    out.push(arg, value);
+    index++;
+  }
+  const paths = args.slice(index + 1);
+  if (index >= args.length || paths.length === 0) {
+    throw new ChannelAValidationError("ripgrep arguments must end with -- and paths");
+  }
+  out.push("--");
+  for (const path of paths) {
+    if (path.includes(NUL) || path.startsWith("-") || path.startsWith("/")) {
+      throw new ChannelAValidationError(`ripgrep path is not allowed: ${path}`);
+    }
+    out.push(assertSafeRelPathOrRoot(path, workspaceRoot) || ".");
+  }
+  return ["--no-config", ...out];
+}
+function decodeCodeSearchChunk(stdout, trailerIndex) {
+  const begin = stdout.indexOf(CODE_SEARCH_RG_BEGIN);
+  if (begin < 0 || begin > trailerIndex) {
+    throw new ChannelAUnavailableError("code search output frame is missing");
+  }
+  const encoded = stdout.slice(begin + CODE_SEARCH_RG_BEGIN.length, trailerIndex).replace(/\s+/g, "");
+  if (encoded.length > Math.ceil(CODE_SEARCH_RG_CHUNK_BYTES / 3) * 4) {
+    throw new ChannelAUnavailableError("code search output frame is malformed");
+  }
+  return Buffer.from(encoded, "base64");
+}
+async function gunzipCodeSearchPrefix(input, limit) {
+  const gunzip = createGunzip({ finishFlush: zlibConstants.Z_SYNC_FLUSH, chunkSize: 64 * 1024 });
+  gunzip.end(input);
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of gunzip) {
+      chunks.push(chunk);
+      size += chunk.length;
+      if (size >= limit) break;
+    }
+  } catch {
+    throw new ChannelAUnavailableError("code search output could not be decoded");
+  }
+  return Buffer.concat(chunks, size).subarray(0, limit);
+}
 var REPOSITORY_DISCOVERY_STATUS_PREFIX = "__OPENGENI_REPOSITORY_DISCOVERY_STATUS__:";
 var NUL = String.fromCharCode(0);
 var FS_LIST_TRUNCATED_MARKER = "__OPENGENI_FS_LIST_TRUNCATED__";
@@ -21257,6 +21578,215 @@ var SandboxChannelAService = class {
   async detectRepos() {
     return (await this.detectReposDetailed()).repos;
   }
+  // ═════════════════════════ Code search (worker-only) ═══════════════════════
+  /**
+   * Run ripgrep read-only in the workspace root for the Jev `code_search` tool.
+   * Arguments are checked against a closed allowlist (no `--pre`, `-z` or other
+   * flags that run programs), so the command is provably read-only and skips
+   * durable mutation admission. stdout is capped at `maxBytes`, gzip+base64
+   * framed so providers that drop newlines or retain limited output cannot
+   * corrupt it, and bounded by a wall-clock watchdog (not GNU `timeout`, which
+   * stock macOS lacks). Resolves `available: false` when `rg` is not installed,
+   * and throws when the box could not store the output whole (a full
+   * temporary directory) rather than returning a prefix as complete.
+   */
+  async codeSearchRipgrep(args, options) {
+    const argv = validateCodeSearchRipgrepArgs(args, this.workspaceRoot);
+    const maxBytes = Math.max(1, Math.min(CODE_SEARCH_RG_MAX_BYTES, Math.floor(options.maxBytes)));
+    const maxTransferBytes = Math.max(
+      CODE_SEARCH_RG_CHUNK_BYTES,
+      Math.min(
+        CODE_SEARCH_RG_MAX_TRANSFER_BYTES,
+        Math.floor(options.maxTransferBytes ?? CODE_SEARCH_RG_MAX_TRANSFER_BYTES)
+      )
+    );
+    const seconds = Math.max(1, Math.min(120, Math.ceil(options.timeoutMs / 1e3)));
+    const script = [
+      // Remove output a previous call could not fetch (worker gone mid-transfer).
+      // The trailing slash makes find enter a symlinked /tmp, as on macOS.
+      `find "\${TMPDIR:-/tmp}/" -maxdepth 1 -name 'opengeni-code-search.*' -mmin +15 -exec rm -f {} + 2>/dev/null`,
+      'gz_file=$(mktemp "${TMPDIR:-/tmp}/opengeni-code-search.XXXXXX") || exit 70',
+      'status_file="${gz_file}.status"',
+      'timeout_file="${gz_file}.timed-out"',
+      "keep_gz=",
+      "search_pid=",
+      "watchdog_pid=",
+      'cleanup() { if [ -n "$search_pid" ]; then kill -TERM -- "-$search_pid" 2>/dev/null || kill "$search_pid" 2>/dev/null || true; fi; if [ -n "$watchdog_pid" ]; then kill "$watchdog_pid" 2>/dev/null || true; fi; rm -f "$status_file" "$timeout_file"; [ -n "$keep_gz" ] || rm -f "$gz_file"; }',
+      "abort() { trap - EXIT; keep_gz=; cleanup; exit 143; }",
+      "trap cleanup EXIT",
+      "trap abort HUP INT TERM",
+      `if ! command -v rg >/dev/null 2>&1; then printf '${CODE_SEARCH_RG_END}127:0__'; exit 0; fi`,
+      // Job control gives the pipeline its own process group, so the watchdog
+      // and cleanup stop ripgrep itself rather than only the subshell. Output is
+      // compressed once, straight into the kept file: providers retain only
+      // about 1 MiB per output stream, and later chunks are fetched by name.
+      // That TERM stops only ripgrep and head. The subshell and gzip ignore it
+      // (bash 3.2 runs a trap before the pipeline ends), so a stopped search
+      // still stores a whole member and records every stage's status.
+      "set -m",
+      `( trap '' TERM; ( trap - TERM; exec rg ${argv.map(shellQuote3).join(" ")} ) 2>/dev/null | ( trap - TERM; exec head -c ${maxBytes + 1} ) | gzip -c > "$gz_file"; printf '%s %s %s' "\${PIPESTATUS[0]}" "\${PIPESTATUS[1]}" "\${PIPESTATUS[2]}" > "$status_file" ) </dev/null >/dev/null 2>&1 &`,
+      "search_pid=$!",
+      `(sleeper_pid=; stop_watchdog() { if [ -n "$sleeper_pid" ]; then kill "$sleeper_pid" 2>/dev/null || true; wait "$sleeper_pid" 2>/dev/null || true; fi; exit 0; }; trap stop_watchdog HUP INT TERM; sleep ${seconds} & sleeper_pid=$!; wait "$sleeper_pid"; sleeper_pid=; if kill -TERM -- "-$search_pid" 2>/dev/null; then : > "$timeout_file"; fi) </dev/null >/dev/null 2>&1 &`,
+      "watchdog_pid=$!",
+      'wait "$search_pid" 2>/dev/null',
+      "search_pid=",
+      'kill "$watchdog_pid" 2>/dev/null || true',
+      'wait "$watchdog_pid" 2>/dev/null || true',
+      "watchdog_pid=",
+      "set +m",
+      "rg_status= head_status= gzip_status=",
+      'if [ -f "$status_file" ]; then read -r rg_status head_status gzip_status < "$status_file"; fi',
+      '[ -n "$rg_status" ] || rg_status=125',
+      "timed_out=0",
+      'if [ -f "$timeout_file" ]; then timed_out=1; fi',
+      // A full temporary directory cuts the member without a word, so decode it
+      // end to end: that yields the raw size and fails on a cut or corrupt member.
+      "stored=0",
+      `if raw_size=$(set -o pipefail; gzip -dc < "$gz_file" 2>/dev/null | wc -c | tr -d ' ') && [ "$head_status" = 0 ] && [ "$gzip_status" = 0 ]; then stored=1; fi`,
+      '[ -n "$raw_size" ] || raw_size=0',
+      `gz_size=$(wc -c < "$gz_file" | tr -d ' ')`,
+      '[ -n "$gz_size" ] || gz_size=0',
+      "token=-",
+      // The worker fails an unstored search that did not time out, so only
+      // keep output it will fetch.
+      `if [ "$gz_size" -gt ${CODE_SEARCH_RG_CHUNK_BYTES} ] && { [ "$stored" = 1 ] || [ "$timed_out" = 1 ]; }; then keep_gz=1; token=$(basename "$gz_file"); fi`,
+      `printf '${CODE_SEARCH_RG_BEGIN}'`,
+      `head -c ${CODE_SEARCH_RG_CHUNK_BYTES} "$gz_file" | base64 | tr -d '\\r\\n'`,
+      `printf '${CODE_SEARCH_RG_END}%s:%s:%s:%s:%s:%s__' "$rg_status" "$timed_out" "$gz_size" "$token" "$raw_size" "$stored"`
+    ].join("\n");
+    const { stdout } = await this.runReadOnly({
+      cmd: internalBashCommand(script),
+      workdir: this.providerWorkspaceRoot(),
+      yieldTimeMs: (seconds + 15) * 1e3,
+      maxOutputTokens: CODE_SEARCH_RG_FRAME_CHARS
+    });
+    const trailer = CODE_SEARCH_RG_TRAILER.exec(stdout);
+    if (!trailer) {
+      throw new ChannelAUnavailableError("code search did not complete in this workspace");
+    }
+    const exitCode = Number.parseInt(trailer[1], 10);
+    if (exitCode === 127) {
+      return { available: false, stdout: "", exitCode: null, truncated: false, timedOut: false };
+    }
+    if (trailer[3] === void 0 || trailer[5] === void 0) {
+      throw new ChannelAUnavailableError("code search output trailer is malformed");
+    }
+    const timedOut = trailer[2] === "1";
+    if (!timedOut && exitCode === 125) {
+      throw new ChannelAUnavailableError(
+        "code search did not record its status on this machine; its temporary directory may be full"
+      );
+    }
+    if (!timedOut && trailer[6] !== "1") {
+      throw new ChannelAUnavailableError(CODE_SEARCH_RG_STORE_FAILED);
+    }
+    const first = decodeCodeSearchChunk(stdout, trailer.index);
+    const reportedSize = Number.parseInt(trailer[3], 10);
+    const rawSize = Number.parseInt(trailer[5], 10);
+    const token = trailer[4] === "-" ? null : trailer[4];
+    const parts = [first];
+    let fetched = first.length;
+    if (token !== null && reportedSize > fetched) {
+      if (!CODE_SEARCH_RG_TOKEN.test(token)) {
+        throw new ChannelAUnavailableError("code search output frame is malformed");
+      }
+      const target = Math.min(reportedSize, maxTransferBytes);
+      const maxCalls = Math.ceil(maxTransferBytes / CODE_SEARCH_RG_CHUNK_BYTES);
+      for (let call = 0; call < maxCalls && fetched < target; call++) {
+        const length = Math.min(CODE_SEARCH_RG_CHUNK_BYTES, target - fetched);
+        const chunk = await this.codeSearchRipgrepChunk(
+          token,
+          fetched,
+          length,
+          fetched + length >= target
+        );
+        if (chunk === null) break;
+        parts.push(chunk);
+        fetched += chunk.length;
+        if (chunk.length < length) break;
+      }
+    }
+    const transferCut = fetched < reportedSize;
+    const compressed = Buffer.concat(parts);
+    const raw = compressed.length ? await gunzipCodeSearchPrefix(compressed, maxBytes + 1) : Buffer.alloc(0);
+    const rawCut = raw.length > maxBytes;
+    const sizeMismatch = !rawCut && !transferCut && !timedOut && raw.length !== rawSize;
+    const truncated = rawCut || transferCut || sizeMismatch;
+    let text = (rawCut ? raw.subarray(0, maxBytes) : raw).toString("utf8");
+    if (truncated || timedOut) {
+      const lastNewline = text.lastIndexOf("\n");
+      text = lastNewline >= 0 ? text.slice(0, lastNewline + 1) : "";
+    }
+    return {
+      available: true,
+      stdout: text,
+      exitCode: timedOut ? null : exitCode,
+      truncated,
+      timedOut
+    };
+  }
+  /**
+   * Fetch one chunk of compressed ripgrep output kept on the box by a previous
+   * codeSearchRipgrep call. The last fetch deletes the file. Null when the
+   * file is gone.
+   */
+  async codeSearchRipgrepChunk(token, offset, length, last) {
+    const script = [
+      'f="${TMPDIR:-/tmp}/$1"',
+      `if [ ! -f "$f" ]; then printf '${CODE_SEARCH_RG_END}0:0:0:missing__'; exit 0; fi`,
+      `printf '${CODE_SEARCH_RG_BEGIN}'`,
+      `tail -c +"$2" "$f" | head -c "$3" | base64 | tr -d '\\r\\n'`,
+      `printf '${CODE_SEARCH_RG_END}0:0:0:-__'`,
+      'if [ "$4" = 1 ]; then rm -f "$f"; fi'
+    ].join("\n");
+    const { stdout } = await this.runReadOnly({
+      cmd: `${internalBashCommand(script)} opengeni-code-search ${shellQuote3(token)} ${offset + 1} ${length} ${last ? 1 : 0}`,
+      workdir: this.providerWorkspaceRoot(),
+      yieldTimeMs: 3e4,
+      maxOutputTokens: CODE_SEARCH_RG_FRAME_CHARS
+    });
+    const trailer = CODE_SEARCH_RG_TRAILER.exec(stdout);
+    if (!trailer) {
+      throw new ChannelAUnavailableError("code search did not complete in this workspace");
+    }
+    if (trailer[4] === "missing") return null;
+    const chunk = decodeCodeSearchChunk(stdout, trailer.index);
+    if (chunk.length > length) {
+      throw new ChannelAUnavailableError("code search output frame is malformed");
+    }
+    return chunk;
+  }
+  /** Classify workspace-relative paths for `code_search` path filters. */
+  async codeSearchPathKinds(paths) {
+    const checked = paths.map((path) => {
+      if (path.startsWith("-")) throw new ChannelAValidationError(`invalid path: ${path}`);
+      return assertSafeRelPathOrRoot(path, this.workspaceRoot) || ".";
+    });
+    if (checked.length === 0) return {};
+    const script = [
+      `printf '${CODE_SEARCH_KINDS_BEGIN}'`,
+      'for p in "$@"; do if [ -d "$p" ]; then printf d; elif [ -e "$p" ]; then printf f; else printf m; fi; done',
+      `printf '${CODE_SEARCH_KINDS_END}'`
+    ].join("\n");
+    const { stdout } = await this.runReadOnly({
+      cmd: `${internalBashCommand(script)} opengeni-code-search ${checked.map(shellQuote3).join(" ")}`,
+      workdir: this.providerWorkspaceRoot(),
+      yieldTimeMs: 2e4,
+      maxOutputTokens: 4096
+    });
+    const match = new RegExp(`${CODE_SEARCH_KINDS_BEGIN}([dfm]*)${CODE_SEARCH_KINDS_END}`).exec(
+      stdout
+    );
+    if (!match || match[1].length !== checked.length) {
+      throw new ChannelAUnavailableError("code search path check did not complete");
+    }
+    const kinds = {};
+    paths.forEach((path, index) => {
+      const code = match[1][index];
+      kinds[path] = code === "d" ? "directory" : code === "f" ? "file" : "missing";
+    });
+    return kinds;
+  }
   // ════════════════════════ Terminal exec + PTY (A2) ════════════════════════
   /** Run a bounded command to physical completion and return buffered output.
    *  A deadline cancels the exact provider operation, proves its process group
@@ -22716,183 +23246,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 +23416,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 +23683,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 +23704,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 +23721,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 +23739,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 +33399,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 +33414,8 @@ import {
   BrowserDownloadExportReceipt,
   BrowserDownloadExportRequest,
   BrowserDownloadListResponse,
+  BrowserDomReadRequest,
+  BrowserDomReadResponse,
   BrowserExternalAuthCommand,
   BrowserExternalAuthResult,
   BrowserObservation,
@@ -33070,6 +33423,7 @@ import {
   BrowserProtectedAuthFillReceipt,
   BrowserRevisionMaterialization,
   BrowserTarget,
+  BrowserTargetState,
   BrowserWorkspaceFileStageRequest,
   BrowserWorkspaceFileStageResponse,
   ComputerActionCommand,
@@ -33536,7 +33890,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 +34129,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 +34280,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 +34682,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 = new Uint8Array(await response.arrayBuffer());
-  return computerControlFrame(data, response.headers, input.expectedFrameEvidence);
+  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(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 +35419,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 +35438,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) {
@@ -38353,6 +38836,8 @@ export {
   ChannelAUnsupportedError,
   ChannelAPartialMutationError,
   REPOSITORY_DISCOVERY_LIMIT,
+  CODE_SEARCH_RG_MAX_BYTES,
+  validateCodeSearchRipgrepArgs,
   SandboxChannelAService,
   stripExecBanner,
   isDefinitePathNotFoundError,
@@ -38388,7 +38873,7 @@ export {
   assertDescriptorRegistryInvariants,
   modalSandboxAttributionEnvironment,
   modalSandboxAttributionTags,
-  isModalTaskExecStartDnsResolutionError,
+  isModalTaskExecStartPreDispatchUnavailableError,
   ensureModalRegistryImage,
   resolveModalCheckpointProviderBindingForSession,
   modalSessionMatchesCheckpointProviderBinding,
@@ -38571,4 +39056,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-J5AR5XAJ.js.map
+//# sourceMappingURL=chunk-FAFZCSN7.js.map