@opengeni/runtime 3.2.2 → 3.4.0

package/dist/{chunk-HJSIPTFA.js → chunk-4XDJ4TJA.js}

@@ -18,7 +18,7 @@ import {
   shellQuote,
   tool,
   withSandboxSpan
-} from "./chunk-7LJ7KDPI.js";
+} from "./chunk-ERD4ICVB.js";
 
 // ../../node_modules/.bun/@openai+agents-core@0.14.3+933c5e7db4cd33c2/node_modules/@openai/agents-core/dist/sandbox/capabilities/transport.mjs
 function supportsResponsesCompactionTransport(modelInstance) {
@@ -999,4 +999,4 @@ export {
   probeSandboxPathExists,
   SandboxAgent
 };
-//# sourceMappingURL=chunk-HJSIPTFA.js.map
+//# sourceMappingURL=chunk-4XDJ4TJA.js.map

package/dist/{chunk-XQ23VCZ4.js → chunk-6FQ6KEII.js}

@@ -1,9 +1,9 @@
 import {
   connectorAttachmentFileName
-} from "./chunk-Z5U6WE22.js";
+} from "./chunk-PRZPGRIK.js";
 import {
   isRoutingMutationOutcomeUnknownError
-} from "./chunk-5WJOPANS.js";
+} from "./chunk-Y5THZH5N.js";
 
 // src/gmail-rest-mcp.ts
 import {
@@ -2258,4 +2258,4 @@ export {
   gmailRestToolIsMutation,
   gmailRestResultOutcome
 };
-//# sourceMappingURL=chunk-XQ23VCZ4.js.map
+//# sourceMappingURL=chunk-6FQ6KEII.js.map

package/dist/{chunk-7LJ7KDPI.js → chunk-ERD4ICVB.js}

@@ -27556,7 +27556,7 @@ var SandboxMemoryGenerationManager = class {
     if (!transcript) {
       throw new UserError(`Memory rollout transcript was not found: ${transcriptPath}`);
     }
-    const { SandboxAgent } = await import("./agent-CTPLA3HP.js");
+    const { SandboxAgent } = await import("./agent-LJT5NPWT.js");
     const phaseOneAgent = new SandboxAgent({
       name: "sandbox-memory-phase-one",
       instructions: renderRolloutExtractionInstructions(generate.extraPrompt),
@@ -27617,7 +27617,7 @@ var SandboxMemoryGenerationManager = class {
     })) {
       return;
     }
-    const { SandboxAgent } = await import("./agent-CTPLA3HP.js");
+    const { SandboxAgent } = await import("./agent-LJT5NPWT.js");
     const phaseTwoAgent = new SandboxAgent({
       name: "sandbox-memory-phase-two",
       model: generate.phaseTwoModel,
@@ -43273,6 +43273,7 @@ export {
   setTraceProcessors,
   setTracingDisabled,
   normalizeHostedMcpRequireApproval,
+  defineToolInputGuardrail,
   ToolGuardrailFunctionOutputFactory,
   applyPatchTool,
   attachClientToolSearchExecutor,
@@ -43358,4 +43359,4 @@ export {
   Runner,
   Agent
 };
-//# sourceMappingURL=chunk-7LJ7KDPI.js.map
+//# sourceMappingURL=chunk-ERD4ICVB.js.map

package/dist/{chunk-462CH77G.js → chunk-ETTCGPBT.js}

@@ -107,7 +107,7 @@ import {
   withNativeSynchronousCommandCollection,
   withProviderError,
   withSandboxProviderCapture
-} from "./chunk-5WJOPANS.js";
+} from "./chunk-Y5THZH5N.js";
 import {
   applyLocalSourceManifestEntryToState,
   applyLocalSourceManifestToState,
@@ -122,13 +122,13 @@ import {
   truncateOutput,
   validateCredentialPair,
   validateRemoteSandboxPathForManifest
-} from "./chunk-YG26XE7B.js";
+} from "./chunk-JYDG2A7H.js";
 import {
   NoopSnapshotSpec,
   normalizeSandboxClientCreateArgs,
   resolveSandboxArchiveLimits,
   validateSandboxArchiveLimits
-} from "./chunk-NWS4HPB7.js";
+} from "./chunk-MIAL5I4O.js";
 import {
   Manifest,
   Permissions,
@@ -160,7 +160,7 @@ import {
   serializeRuntimeEnvironmentForPersistence,
   shellQuote,
   withSandboxSpan
-} from "./chunk-7LJ7KDPI.js";
+} from "./chunk-ERD4ICVB.js";
 
 // src/sandbox/index.ts
 import { collectSandboxEnvironment, parseExposedPorts } from "@opengeni/config";
@@ -9697,6 +9697,9 @@ async function transferEditorFile(input) {
   return { recovered: false };
 }
 
+// src/sandbox/browser-control-http.ts
+var BROWSER_CONTROL_HTTP_REPLY_GRACE_MS = 5e3;
+
 // src/sandbox/selfhosted/retry-policy.ts
 var SELFHOSTED_IDEMPOTENT_READONLY_OPS = /* @__PURE__ */ new Set([
   "ping",
@@ -10920,6 +10923,7 @@ var SelfhostedSession = class {
   resourcePolicySupported;
   operationCpuQuotaSupported;
   transactionalFsWriteSupported;
+  browserControlHttpSupported;
   defaultOpStream;
   connectionInstanceId;
   resolveOperationAdmission;
@@ -10980,6 +10984,7 @@ var SelfhostedSession = class {
     this.resourcePolicySupported = deps.operationResourcePolicySupported === true;
     this.operationCpuQuotaSupported = deps.operationCpuQuotaSupported === true;
     this.transactionalFsWriteSupported = deps.transactionalFsWriteSupported === true;
+    this.browserControlHttpSupported = deps.browserControlHttpSupported === true;
     this.defaultOpStream = deps.opStream;
     this.connectionInstanceId = deps.connectionInstanceId;
     this.resolveOperationAdmission = deps.resolveOperationAdmission;
@@ -10992,7 +10997,8 @@ var SelfhostedSession = class {
       subject: this.subject,
       resourcePolicy: this.resourcePolicy,
       opStream: deps.opStream,
-      transactionalFsWriteSupported: this.transactionalFsWriteSupported
+      transactionalFsWriteSupported: this.transactionalFsWriteSupported,
+      browserControlHttpSupported: this.browserControlHttpSupported
     }) : void 0;
     this.state = {
       agentId: deps.agentId,
@@ -11053,7 +11059,8 @@ var SelfhostedSession = class {
         subject: this.subject,
         resourcePolicy: commandPolicy ? this.resourcePolicy : void 0,
         opStream: this.defaultOpStream,
-        transactionalFsWriteSupported: this.transactionalFsWriteSupported
+        transactionalFsWriteSupported: this.transactionalFsWriteSupported,
+        browserControlHttpSupported: this.browserControlHttpSupported
       };
     }
     const resolved = await this.resolveOperationAdmission();
@@ -11087,7 +11094,8 @@ var SelfhostedSession = class {
       ),
       resourcePolicy: commandPolicy ? resourcePolicy : void 0,
       opStream: resolved.opStream,
-      transactionalFsWriteSupported: resolved.transactionalFsWriteSupported === true
+      transactionalFsWriteSupported: resolved.transactionalFsWriteSupported === true,
+      browserControlHttpSupported: resolved.browserControlHttpSupported === true
     };
   }
   async admitCommand() {
@@ -11564,6 +11572,23 @@ var SelfhostedSession = class {
         reason: null,
         retryable: false
       });
+      if (!terminalProof && !adoptedCommandId && !controlError.neverSent && machineStoppedAnswering(controlError) && this.adoptBackgroundCommand) {
+        try {
+          notifyDurableOpOwnershipTransferStarted(opId);
+          const abandoned = await this.adoptBackgroundCommand({
+            controlWorkspaceId: admission.controlWorkspaceId,
+            enrollmentId: this.agentId,
+            connectionInstanceId: admission.connectionInstanceId,
+            opId,
+            command,
+            abandoned: true
+          });
+          adoptedCommandId = abandoned.commandId;
+          notifyDurableOpOwnershipTransferred(opId);
+        } catch {
+          notifyDurableOpOwnershipTransferFailed(opId);
+        }
+      }
       this.emitOp({
         op: "exec",
         outcome: "failed",
@@ -12078,6 +12103,90 @@ var SelfhostedSession = class {
     }
     return result.browserControlEnsure;
   }
+  /** Send one request to the agent-owned controller of an exact authority
+   * scope, served inside the runner over loopback without starting a process.
+   * `unsupported` means this connection's runner does not serve it and nothing
+   * was sent. `controller_absent` means no controller for that scope and
+   * generation accepted the request, so it was not delivered and the caller may
+   * ensure the controller and send again. A body too large for one reply is
+   * drained from the runner's spool; the request is never repeated. */
+  async browserControlHttp(request) {
+    const admission = await this.admitOperation(false);
+    if (!admission.browserControlHttpSupported) return { kind: "unsupported" };
+    const rpcTimeoutMs = request.timeoutMs + BROWSER_CONTROL_HTTP_REPLY_GRACE_MS;
+    let result;
+    try {
+      result = await this.call(
+        {
+          $case: "browserControlHttp",
+          browserControlHttp: {
+            scopeId: request.scopeId,
+            scopeGeneration: request.scopeGeneration,
+            method: request.method,
+            path: request.path,
+            bearerToken: request.bearerToken,
+            body: request.body ?? new Uint8Array(),
+            hasBody: request.body !== void 0,
+            timeoutMs: request.timeoutMs,
+            maxResponseBytes: String(request.maxResponseBytes)
+          }
+        },
+        rpcTimeoutMs,
+        admission
+      );
+    } catch (error) {
+      if (error instanceof SelfhostedControlError && error.code === ErrorCode2.ERROR_CODE_NOT_FOUND) {
+        return { kind: "controller_absent" };
+      }
+      throw error;
+    }
+    if (result.$case !== "browserControlHttp") {
+      throw new Error(`selfhosted browserControlHttp: unexpected result ${result.$case}`);
+    }
+    const response = result.browserControlHttp;
+    const totalBytes = Number(response.totalBytes);
+    if (!Number.isSafeInteger(totalBytes) || totalBytes < response.body.byteLength || totalBytes > request.maxResponseBytes) {
+      throw new Error("selfhosted browserControlHttp: response length is invalid");
+    }
+    let body = response.body;
+    if (response.spoolId) {
+      const complete = new Uint8Array(totalBytes);
+      complete.set(response.body, 0);
+      let offset = response.body.byteLength;
+      for (; ; ) {
+        const read = await this.call(
+          {
+            $case: "browserControlHttpRead",
+            browserControlHttpRead: { spoolId: response.spoolId, offset: String(offset) }
+          },
+          this.timeoutMs,
+          admission
+        );
+        if (read.$case !== "browserControlHttpRead") {
+          throw new Error(`selfhosted browserControlHttpRead: unexpected result ${read.$case}`);
+        }
+        const part = read.browserControlHttpRead;
+        if (offset + part.data.byteLength > totalBytes) {
+          throw new Error("selfhosted browserControlHttpRead: response exceeds its length");
+        }
+        complete.set(part.data, offset);
+        offset += part.data.byteLength;
+        if (part.done) break;
+        if (part.data.byteLength === 0) {
+          throw new Error("selfhosted browserControlHttpRead: spool made no progress");
+        }
+      }
+      if (offset !== totalBytes) {
+        throw new Error("selfhosted browserControlHttpRead: response is incomplete");
+      }
+      body = complete;
+    } else if (response.body.byteLength !== totalBytes) {
+      throw new Error("selfhosted browserControlHttp: response is incomplete");
+    }
+    const headers = /* @__PURE__ */ new Map();
+    for (const header of response.headers) headers.set(header.name.toLowerCase(), header.value);
+    return { kind: "response", status: response.status, headers, body };
+  }
   /** Open one browser-native frame producer and return its canonical relay
    * endpoint. This does not route through `resolveExposedPort`: that legacy
    * method allocates PTY/desktop resources based on fixed ports, while this op
@@ -12222,6 +12331,7 @@ var SelfhostedSandboxClient = class {
   operationResourcePolicySupported;
   operationCpuQuotaSupported;
   transactionalFsWriteSupported;
+  browserControlHttpSupported;
   resolveOperationAdmission;
   adoptBackgroundCommand;
   settleBackgroundCommand;
@@ -12245,6 +12355,7 @@ var SelfhostedSandboxClient = class {
     this.operationResourcePolicySupported = opts.operationResourcePolicySupported;
     this.operationCpuQuotaSupported = opts.operationCpuQuotaSupported;
     this.transactionalFsWriteSupported = opts.transactionalFsWriteSupported;
+    this.browserControlHttpSupported = opts.browserControlHttpSupported;
     this.resolveOperationAdmission = opts.resolveOperationAdmission;
     this.adoptBackgroundCommand = opts.adoptBackgroundCommand;
     this.settleBackgroundCommand = opts.settleBackgroundCommand;
@@ -12279,6 +12390,7 @@ var SelfhostedSandboxClient = class {
       } : {},
       ...this.operationCpuQuotaSupported !== void 0 ? { operationCpuQuotaSupported: this.operationCpuQuotaSupported } : {},
       transactionalFsWriteSupported: this.transactionalFsWriteSupported === true,
+      browserControlHttpSupported: this.browserControlHttpSupported === true,
       ...this.resolveOperationAdmission !== void 0 ? { resolveOperationAdmission: this.resolveOperationAdmission } : {},
       ...this.adoptBackgroundCommand !== void 0 ? { adoptBackgroundCommand: this.adoptBackgroundCommand } : {},
       ...this.settleBackgroundCommand !== void 0 ? { settleBackgroundCommand: this.settleBackgroundCommand } : {},
@@ -12350,6 +12462,7 @@ async function buildSelfhostedBackendSession(deps) {
     } : {},
     ...deps.operationCpuQuotaSupported !== void 0 ? { operationCpuQuotaSupported: deps.operationCpuQuotaSupported } : {},
     transactionalFsWriteSupported: deps.transactionalFsWriteSupported === true,
+    browserControlHttpSupported: deps.browserControlHttpSupported === true,
     ...deps.resolveOperationAdmission !== void 0 ? { resolveOperationAdmission: deps.resolveOperationAdmission } : {},
     ...deps.adoptBackgroundCommand !== void 0 ? { adoptBackgroundCommand: deps.adoptBackgroundCommand } : {},
     ...deps.settleBackgroundCommand !== void 0 ? { settleBackgroundCommand: deps.settleBackgroundCommand } : {},
@@ -12444,6 +12557,10 @@ function mediaTypeFromPath(path) {
   if (p.endsWith(".svg") || p.endsWith(".svgz")) return "image/svg+xml";
   return void 0;
 }
+function machineStoppedAnswering(error) {
+  const faultClass = selfhostedFaultClass(error);
+  return faultClass === "offline" || faultClass === "reconnecting" || faultClass === "draining";
+}
 function randomNonce() {
   return String(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER));
 }
@@ -14466,6 +14583,28 @@ function placementControllerWorkdir(session) {
   if (!session.ensureBrowserControl) return MANAGED_PLACEMENT_CONTROLLER_WORKDIR;
   return session.controllerHostOs?.() === "windows" ? "." : NATIVE_PLACEMENT_CONTROLLER_WORKDIR;
 }
+var BROWSER_WORKING_COPY_REFUSALS = [
+  "unsupported_platform",
+  "browser_running",
+  "working_copy_invalid",
+  "receipt_not_adoptable",
+  "authority_changed",
+  "process_state_unknown",
+  "adoption_not_needed",
+  "adoption_unresolved"
+];
+var BROWSER_WORKING_COPY_ADOPTION_PHASES = [
+  "intent",
+  "copied",
+  "receipt",
+  "source_preserved",
+  "adopted",
+  "interrupted",
+  "failed",
+  "collision",
+  "reverting",
+  "reverted"
+];
 var BrowserControlTransportError = class extends Error {
   name = "BrowserControlTransportError";
   retryable = true;
@@ -14647,7 +14786,8 @@ var BrowserControlClient = class {
     }
     return {
       ...returnedReference,
-      observation: BrowserObservation.parse(data.observation)
+      observation: BrowserObservation.parse(data.observation),
+      ...creationTargets(data.targets, returnedReference)
     };
   }
   async createComputerSession(input) {
@@ -14830,6 +14970,86 @@ var BrowserControlClient = class {
     }
     return receipt;
   }
+  /** Read-only evidence about a preserved working copy whose controller
+   * memory was lost: the exact digest of its bytes and whether it can be
+   * adopted. Hashing a large profile can take minutes. */
+  async inspectWorkingCopy(input) {
+    const reference = parseReference(input);
+    const data = await this.requestJson({
+      method: "POST",
+      path: `/v1/browser-sessions/${reference.browserSessionId}/working-copy/inspection`,
+      token: this.adminToken,
+      body: workingCopyAuthorityBody(reference, input),
+      timeoutMs: BROWSER_STATE_TRANSFER_TIMEOUT_MS
+    });
+    return parseWorkingCopyInspection(data, reference);
+  }
+  /** Adopt the exact inspected bytes of a preserved working copy. A lost reply
+   * is checked with {@link workingCopyAdoption}. Sending the same operation id
+   * again never repeats a side effect: it only settles what that operation
+   * already did, under the authority that approved it. */
+  async adoptWorkingCopy(input) {
+    const reference = parseReference(input);
+    const operationId = requireUuid(input.operationId, "working copy adoption id");
+    const data = await this.requestJson({
+      method: "POST",
+      path: `/v1/browser-sessions/${reference.browserSessionId}/working-copy/adoptions`,
+      token: this.adminToken,
+      body: {
+        ...workingCopyAuthorityBody(reference, input),
+        operationId,
+        manifestDigest: sha2563(input.manifestDigest, "working copy manifest digest")
+      },
+      timeoutMs: BROWSER_STATE_TRANSFER_TIMEOUT_MS
+    });
+    const adoption = parseWorkingCopyAdoption(data, reference, "current");
+    if (adoption.operationId !== operationId) {
+      throw new BrowserControlProtocolError("browser controller returned another adoption");
+    }
+    return adoption;
+  }
+  /** The recorded state of one adoption, read without changing it. */
+  async workingCopyAdoption(reference, operationId) {
+    const binding2 = parseReference(reference);
+    const id = requireUuid(operationId, "working copy adoption id");
+    const data = await this.requestJson({
+      method: "GET",
+      path: `/v1/browser-sessions/${binding2.browserSessionId}/working-copy/adoptions/${id}`,
+      token: this.adminToken
+    });
+    if (!isRecord2(data) || typeof data.inFlight !== "boolean") {
+      throw new BrowserControlProtocolError(
+        "browser controller returned malformed adoption status"
+      );
+    }
+    const adoption = data.adoption === null ? null : parseWorkingCopyAdoption(data.adoption, binding2, "recorded");
+    if (adoption && adoption.operationId !== id) {
+      throw new BrowserControlProtocolError("browser controller returned another adoption");
+    }
+    return { inFlight: data.inFlight, adoption };
+  }
+  /** Revert one unfinished adoption under the browser's current authority:
+   * its own directory goes back to the live path and the staged copy is
+   * kept. Retrying the same revert finishes one that stopped part way. */
+  async revertWorkingCopyAdoption(input) {
+    const reference = parseReference(input);
+    const id = requireUuid(input.operationId, "working copy adoption id");
+    const data = await this.requestJson({
+      method: "POST",
+      path: `/v1/browser-sessions/${reference.browserSessionId}/working-copy/adoptions/${id}/revert`,
+      token: this.adminToken,
+      body: workingCopyAuthorityBody(reference, input),
+      timeoutMs: BROWSER_STATE_TRANSFER_TIMEOUT_MS
+    });
+    if (!isRecord2(data) || typeof data.inFlight !== "boolean") {
+      throw new BrowserControlProtocolError("browser controller returned malformed revert status");
+    }
+    const adoption = data.adoption === null ? null : parseWorkingCopyAdoption(data.adoption, reference, "recorded");
+    if (adoption && adoption.operationId !== id) {
+      throw new BrowserControlProtocolError("browser controller returned another adoption");
+    }
+    return { inFlight: data.inFlight, adoption };
+  }
   sessionClient(input) {
     return new BrowserControlSessionClient(this, input);
   }
@@ -15000,6 +15220,18 @@ var BrowserControlClient = class {
         "signed Channel B requires a host-fetch controller endpoint"
       );
     }
+    const native = await this.requestNative(input, BROWSER_CONTROL_MAX_JSON_BYTES);
+    if (native) {
+      let text;
+      try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(native.body);
+      } catch (error) {
+        throw new BrowserControlProtocolError("browser controller response is not UTF-8", {
+          cause: error
+        });
+      }
+      return parseEnvelope(text, native.status);
+    }
     if (this.session.execWithInput && (input.body === void 0 || Buffer.byteLength(JSON.stringify(input.body)) <= 32 * 1024)) {
       try {
         const response = await this.requestStream(input, BROWSER_CONTROL_MAX_JSON_BYTES);
@@ -15144,6 +15376,17 @@ var BrowserControlClient = class {
         "signed Channel B requires a host-fetch controller endpoint"
       );
     }
+    const nativeFrame = await this.requestNative(
+      input,
+      input.surface === "browser" ? 24 * 1024 * 1024 : COMPUTER_SCREENSHOT_MAX_BYTES
+    );
+    if (nativeFrame) {
+      if (nativeFrame.status < 200 || nativeFrame.status >= 300) {
+        parseEnvelope(new TextDecoder().decode(nativeFrame.body), nativeFrame.status);
+        throw new BrowserControlProtocolError("browser controller image response is invalid");
+      }
+      return controllerImageFrame(nativeFrame.body, nativeFrame.headers, input);
+    }
     if (this.session.execWithInput) {
       try {
         const response = await this.requestStream(
@@ -15286,8 +15529,61 @@ var BrowserControlClient = class {
     }
   }
   async controllerPort() {
+    if (!this.nativeAuthority || !this.session.ensureBrowserControl) return this.port;
+    return await this.ensureControllerPort(false);
+  }
+  /** The agent-native transport: one in-process loopback request on the
+   * Connected Machine, addressed by authority scope, with no process started.
+   * Null when the placement does not serve it; the caller then keeps its
+   * command transport. A controller that is not running receives nothing, so
+   * it is ensured and the request sent once more whatever its method. */
+  async requestNative(input, maxResponseBytes, retry = true) {
+    const authority = this.nativeAuthority;
+    if (!authority || !this.session.browserControlHttp || !this.session.ensureBrowserControl) {
+      return null;
+    }
+    const method = input.method;
+    if (method !== "GET" && method !== "POST" && method !== "PUT" && method !== "DELETE") {
+      throw new BrowserControlProtocolError("browser controller request method is invalid");
+    }
+    localControllerUrl(this.port, input.path);
+    const body = input.body === void 0 ? void 0 : new TextEncoder().encode(JSON.stringify(input.body));
+    if (body !== void 0 && body.byteLength > BROWSER_CONTROL_MAX_JSON_BYTES) {
+      throw new RangeError("browser controller request body is too large");
+    }
+    let outcome;
+    try {
+      outcome = await this.session.browserControlHttp({
+        scopeId: authority.scopeId,
+        scopeGeneration: authority.scopeGeneration,
+        method,
+        path: input.path,
+        bearerToken: requireToken(input.token, "browser controller token"),
+        ...body === void 0 ? {} : { body },
+        timeoutMs: boundedTimeout2(input.timeoutMs ?? this.timeoutMs),
+        maxResponseBytes
+      });
+    } catch (error) {
+      if (retry && method === "GET") {
+        await this.ensureControllerPort(true);
+        return await this.requestNative(input, maxResponseBytes, false);
+      }
+      throw new BrowserControlTransportError("browser controller request transport failed", {
+        cause: error
+      });
+    }
+    if (outcome.kind === "unsupported") return null;
+    if (outcome.kind === "controller_absent") {
+      if (!retry) throw new BrowserControlTransportError("browser controller is not running");
+      await this.ensureControllerPort(true);
+      return await this.requestNative(input, maxResponseBytes, false);
+    }
+    return outcome;
+  }
+  async ensureControllerPort(replace) {
     if (!this.nativeAuthority || !this.session.ensureBrowserControl) return this.port;
     const key = nativeControllerKey(this.nativeAuthority);
+    if (replace) nativeControllerPorts.delete(key);
     const cached = nativeControllerPorts.get(key);
     if (cached !== void 0) return cached;
     const ensured = await this.session.ensureBrowserControl({
@@ -16119,6 +16415,17 @@ function parseReference(value) {
     controllerGeneration: requireGeneration(value.controllerGeneration)
   };
 }
+function creationTargets(value, reference) {
+  if (!Array.isArray(value) || value.length > 1e4) return {};
+  const targets = [];
+  for (const entry of value) {
+    const parsed = BrowserTarget.safeParse(entry);
+    if (!parsed.success || parsed.data.browserSessionId !== reference.browserSessionId || parsed.data.controllerGeneration !== reference.controllerGeneration)
+      return {};
+    targets.push(parsed.data);
+  }
+  return { targets };
+}
 function parseComputerReference(value) {
   if (!isRecord2(value)) {
     throw new BrowserControlProtocolError("computer session binding is invalid");
@@ -16255,6 +16562,81 @@ function boundedProxyUrl(value) {
   }
   return url.toString();
 }
+function workingCopyAuthorityBody(reference, input) {
+  return {
+    controllerGeneration: reference.controllerGeneration,
+    tokenGeneration: positiveSafeInteger(input.tokenGeneration, "token generation"),
+    controlToken: requireToken(input.controlToken, "control token"),
+    viewToken: requireToken(input.viewToken, "view token")
+  };
+}
+function parseWorkingCopyAdoption(value, reference, generation) {
+  if (!isRecord2(value) || value.browserSessionId !== reference.browserSessionId || generation === "current" && value.controllerGeneration !== reference.controllerGeneration || !BROWSER_WORKING_COPY_ADOPTION_PHASES.includes(
+    value.phase
+  ) || !(value.failureCode === null || typeof value.failureCode === "string") || !Array.isArray(value.retainedDirectories) || value.retainedDirectories.length > 64 || !value.retainedDirectories.every(
+    (name) => typeof name === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/u.test(name)
+  )) {
+    throw new BrowserControlProtocolError("browser controller returned a malformed adoption");
+  }
+  return {
+    browserSessionId: reference.browserSessionId,
+    controllerGeneration: generation === "current" ? reference.controllerGeneration : requireGeneration(value.controllerGeneration),
+    operationId: requireUuid(value.operationId, "working copy adoption id"),
+    manifestDigest: sha2563(value.manifestDigest, "working copy manifest digest"),
+    phase: value.phase,
+    failureCode: value.failureCode === null ? null : requireOpaqueId(value.failureCode, "failure code"),
+    retainedDirectories: value.retainedDirectories,
+    createdAt: timestamp(value.createdAt, "adoption created at"),
+    updatedAt: timestamp(value.updatedAt, "adoption updated at")
+  };
+}
+function parseWorkingCopyInspection(value, reference) {
+  if (!isRecord2(value) || value.browserSessionId !== reference.browserSessionId || value.controllerGeneration !== reference.controllerGeneration || typeof value.platformSupported !== "boolean" || typeof value.profileIdentityMatches !== "boolean" || !(value.profileInUse === null || typeof value.profileInUse === "boolean") || !(value.refusal === null || BROWSER_WORKING_COPY_REFUSALS.includes(value.refusal))) {
+    throw new BrowserControlProtocolError("browser controller returned a malformed inspection");
+  }
+  let manifest = null;
+  if (value.manifest !== null) {
+    if (!isRecord2(value.manifest)) {
+      throw new BrowserControlProtocolError("browser controller returned a malformed manifest");
+    }
+    manifest = {
+      digest: sha2563(value.manifest.digest, "working copy manifest digest"),
+      entries: nonnegativeSafeInteger(value.manifest.entries, "working copy entries"),
+      bytes: nonnegativeSafeInteger(value.manifest.bytes, "working copy bytes"),
+      excluded: excludedWorkingCopyEntries(value.manifest.excluded)
+    };
+  }
+  let receipt = null;
+  if (value.receipt !== null) {
+    const raw = value.receipt;
+    if (!isRecord2(raw) || !["launch", "suspend", "retire", "adopt"].includes(raw.intent) || typeof raw.state !== "string" || typeof raw.directoryLaunchAllowed !== "boolean" || typeof raw.authorityMatches !== "boolean" || !(raw.restoreAuthorityDigest === null || typeof raw.restoreAuthorityDigest === "string") || !(raw.adoption === null || isRecord2(raw.adoption))) {
+      throw new BrowserControlProtocolError("browser controller returned a malformed receipt");
+    }
+    receipt = {
+      operationId: requireUuid(raw.operationId, "working runtime receipt id"),
+      intent: raw.intent,
+      state: requireOpaqueId(raw.state, "working runtime receipt state"),
+      directoryLaunchAllowed: raw.directoryLaunchAllowed,
+      authorityMatches: raw.authorityMatches,
+      launchedFromCheckpoint: raw.restoreAuthorityDigest !== null,
+      adoption: isRecord2(raw.adoption) ? {
+        operationId: requireUuid(raw.adoption.operationId, "working copy adoption id"),
+        manifestDigest: sha2563(raw.adoption.manifestDigest, "working copy manifest digest")
+      } : null
+    };
+  }
+  return {
+    browserSessionId: reference.browserSessionId,
+    controllerGeneration: reference.controllerGeneration,
+    platformSupported: value.platformSupported,
+    refusal: value.refusal,
+    manifest,
+    profileIdentityMatches: value.profileIdentityMatches,
+    profileInUse: value.profileInUse,
+    receipt,
+    activeAdoption: value.activeAdoption === null || value.activeAdoption === void 0 ? null : parseWorkingCopyAdoption(value.activeAdoption, reference, "recorded")
+  };
+}
 function parseStateCaptureReceipt(value) {
   if (!isRecord2(value) || !isRecord2(value.manifest)) {
     throw new BrowserControlProtocolError(
@@ -16850,6 +17232,14 @@ function nonnegativeSafeInteger(value, label) {
   }
   return value;
 }
+function excludedWorkingCopyEntries(value) {
+  if (!Array.isArray(value) || value.length > 16 || !value.every((entry) => typeof entry === "string" && entry.length > 0 && entry.length <= 256)) {
+    throw new BrowserControlProtocolError(
+      "browser controller returned malformed working copy exclusions"
+    );
+  }
+  return [...value];
+}
 function parseUnsignedInteger(value, label) {
   const trimmed = value.trim();
   if (!/^(0|[1-9][0-9]*)$/u.test(trimmed)) {
@@ -18876,6 +19266,7 @@ function makeActiveBackendResolver(deps) {
         operationResourcePolicySupported: connection.operationResourcePolicySupported,
         operationCpuQuotaSupported: connection.operationCpuQuotaSupported,
         transactionalFsWriteSupported: connection.transactionalFsWriteSupported === true,
+        browserControlHttpSupported: connection.browserControlHttpSupported === true,
         // The routing proxy caches this session by sandbox+epoch, but command
         // policy and runner authority are mutable. Re-read one coherent DB
         // snapshot only when a new exec/Git is admitted.
@@ -20381,4 +20772,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-462CH77G.js.map
+//# sourceMappingURL=chunk-ETTCGPBT.js.map