@effect-agent/platform-cloudflare 0.1.0-beta.121 → 0.1.0-beta.122

package/package.json

@@ -1 +1 @@
-{"name":"@effect-agent/platform-cloudflare","version":"0.1.0-beta.121","dependencies":{"@effect-agent/storage-cloudflare":"0.1.0-beta.121","@effect/platform-browser":"4.0.0-rc.116","@effect/sql-sqlite-do":"4.0.0-rc.116","effect-agent":"0.1.0-beta.121","puppeteer-core":"24.29.0"},"devDependencies":{"@cloudflare/vitest-pool-workers":"0.21.3","@cloudflare/workers-types":"5.20260825.1","@effect-agent/testing":"0.1.0-beta.121","@effect/platform-node":"4.0.0-rc.116","@effect/sql-d1":"4.0.0-rc.116","@effect/vitest":"4.0.0-rc.116","effect":"4.0.0-rc.116","effect-cf":"0.44.1","esbuild":"0.28.1","miniflare":"5.20260811.1-alpha","typescript":"7.0.2","vite-plus":"0.3.2","vitest":"4.1.11"},"peerDependencies":{"effect":"^4.0.0-rc.116","effect-cf":"^0.44.1 || ^0.45.0"},"exports":{".":{"types":"./dist/index.d.mts","default":"./dist/index.mjs"},"./alarm":{"types":"./dist/Alarm.d.mts","default":"./dist/Alarm.mjs"},"./browser-rest-capture":{"types":"./dist/BrowserRestCapture.d.mts","default":"./dist/BrowserRestCapture.mjs"},"./browser-rest-crawl":{"types":"./dist/BrowserRestCrawl.d.mts","default":"./dist/BrowserRestCrawl.mjs"},"./cloudflare-bindings":{"types":"./dist/CloudflareBindings.d.mts","default":"./dist/CloudflareBindings.mjs"},"./cloudflare-browser":{"types":"./dist/CloudflareBrowser.d.mts","default":"./dist/CloudflareBrowser.mjs"},"./cloudflare-code-mode":{"types":"./dist/CloudflareCodeMode.d.mts","default":"./dist/CloudflareCodeMode.mjs"},"./cloudflare-config":{"types":"./dist/CloudflareConfig.d.mts","default":"./dist/CloudflareConfig.mjs"},"./cloudflare-memory":{"types":"./dist/CloudflareMemory.d.mts","default":"./dist/CloudflareMemory.mjs"},"./cloudflare-scheduling":{"types":"./dist/CloudflareScheduling.d.mts","default":"./dist/CloudflareScheduling.mjs"},"./cloudflare-subscriptions":{"types":"./dist/CloudflareSubscriptions.d.mts","default":"./dist/CloudflareSubscriptions.mjs"},"./cloudflare-thread-client":{"types":"./dist/CloudflareThreadClient.d.mts","default":"./dist/CloudflareThreadClient.mjs"},"./interactive-browser":{"types":"./dist/InteractiveBrowser.d.mts","default":"./dist/InteractiveBrowser.mjs"},"./protected-browser":{"types":"./dist/ProtectedBrowser.d.mts","default":"./dist/ProtectedBrowser.mjs"},"./thread-object":{"types":"./dist/ThreadObject.d.mts","default":"./dist/ThreadObject.mjs"},"./wake-scheduler":{"types":"./dist/WakeScheduler.d.mts","default":"./dist/WakeScheduler.mjs"},"./cloudflare-ai-gateway":{"types":"./dist/CloudflareAiGateway.d.mts","default":"./dist/CloudflareAiGateway.mjs"}},"description":"Cloudflare Layer assembly for Effect Agent: Durable Objects and Browser Run adapters.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/danieljvdm/effect-agent.git","directory":"packages/platform-cloudflare"},"files":["dist","src"],"type":"module","sideEffects":[],"publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json"}}
+{"name":"@effect-agent/platform-cloudflare","version":"0.1.0-beta.122","dependencies":{"@effect-agent/storage-cloudflare":"0.1.0-beta.122","@effect/platform-browser":"4.0.0-rc.116","@effect/sql-sqlite-do":"4.0.0-rc.116","effect-agent":"0.1.0-beta.122","puppeteer-core":"24.29.0"},"devDependencies":{"@cloudflare/vitest-pool-workers":"0.21.3","@cloudflare/workers-types":"5.20260825.1","@effect-agent/testing":"0.1.0-beta.122","@effect/platform-node":"4.0.0-rc.116","@effect/sql-d1":"4.0.0-rc.116","@effect/vitest":"4.0.0-rc.116","effect":"4.0.0-rc.116","effect-cf":"0.44.1","esbuild":"0.28.1","miniflare":"5.20260811.1-alpha","typescript":"7.0.2","vite-plus":"0.3.2","vitest":"4.1.11"},"peerDependencies":{"effect":"^4.0.0-rc.116","effect-cf":"^0.44.1 || ^0.45.0"},"exports":{".":{"types":"./dist/index.d.mts","default":"./dist/index.mjs"},"./alarm":{"types":"./dist/Alarm.d.mts","default":"./dist/Alarm.mjs"},"./browser-rest-capture":{"types":"./dist/BrowserRestCapture.d.mts","default":"./dist/BrowserRestCapture.mjs"},"./browser-rest-crawl":{"types":"./dist/BrowserRestCrawl.d.mts","default":"./dist/BrowserRestCrawl.mjs"},"./cloudflare-bindings":{"types":"./dist/CloudflareBindings.d.mts","default":"./dist/CloudflareBindings.mjs"},"./cloudflare-browser":{"types":"./dist/CloudflareBrowser.d.mts","default":"./dist/CloudflareBrowser.mjs"},"./cloudflare-code-mode":{"types":"./dist/CloudflareCodeMode.d.mts","default":"./dist/CloudflareCodeMode.mjs"},"./cloudflare-config":{"types":"./dist/CloudflareConfig.d.mts","default":"./dist/CloudflareConfig.mjs"},"./cloudflare-memory":{"types":"./dist/CloudflareMemory.d.mts","default":"./dist/CloudflareMemory.mjs"},"./cloudflare-scheduling":{"types":"./dist/CloudflareScheduling.d.mts","default":"./dist/CloudflareScheduling.mjs"},"./cloudflare-subscriptions":{"types":"./dist/CloudflareSubscriptions.d.mts","default":"./dist/CloudflareSubscriptions.mjs"},"./cloudflare-thread-client":{"types":"./dist/CloudflareThreadClient.d.mts","default":"./dist/CloudflareThreadClient.mjs"},"./interactive-browser":{"types":"./dist/InteractiveBrowser.d.mts","default":"./dist/InteractiveBrowser.mjs"},"./protected-browser":{"types":"./dist/ProtectedBrowser.d.mts","default":"./dist/ProtectedBrowser.mjs"},"./thread-object":{"types":"./dist/ThreadObject.d.mts","default":"./dist/ThreadObject.mjs"},"./wake-scheduler":{"types":"./dist/WakeScheduler.d.mts","default":"./dist/WakeScheduler.mjs"},"./cloudflare-ai-gateway":{"types":"./dist/CloudflareAiGateway.d.mts","default":"./dist/CloudflareAiGateway.mjs"}},"description":"Cloudflare Layer assembly for Effect Agent: Durable Objects and Browser Run adapters.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/danieljvdm/effect-agent.git","directory":"packages/platform-cloudflare"},"files":["dist","src"],"type":"module","sideEffects":[],"publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json"}}

package/src/InteractiveBrowser.ts

@@ -411,7 +411,7 @@ export class BrowserRunInteractiveBinding extends Context.Service<
             binding.acquire(keepAliveMillis, "interactive.acquire"),
           connect: async (sessionId: string, signal?: AbortSignal) =>
             makeProductionBrowser(
-              await binding.connect(sessionId, "interactive.connect", signal),
+              await binding.connect(sessionId, "interactive.connect", signal).browser,
               sessionId,
               viewport,
             ),

package/src/internal/browser-binding.ts

@@ -1,14 +1,39 @@
 /// <reference types="@cloudflare/workers-types" />
-import { Context, Layer, Schema } from "effect";
+import { Cause, Context, Effect, Layer, Schema } from "effect";
 import puppeteer, {
   type Browser,
   type ConnectionTransport,
 } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
 
-import { browserFailure, BrowserRunFailure, reportedBrowserError } from "./browser-failure.ts";
+import {
+  browserFailure,
+  BrowserRunFailure,
+  reportBrowserCause,
+  reportedBrowserError,
+} from "./browser-failure.ts";
 
 const Acquired = Schema.Struct({ sessionId: Schema.String.check(Schema.isUUID()) });
 
+const VersionReply = Schema.fromJsonString(
+  Schema.Struct({
+    id: Schema.optionalKey(Schema.Int),
+    result: Schema.optionalKey(Schema.Unknown),
+    error: Schema.optionalKey(Schema.Unknown),
+  }),
+);
+
+const Version = Schema.Struct({
+  product: Schema.NonEmptyString,
+  protocolVersion: Schema.NonEmptyString,
+});
+
+/** Private attachment ownership is available before asynchronous SDK initialization completes. */
+export interface BrowserRunAttachment {
+  readonly browser: Promise<Browser>;
+  /** Fence SDK dispatch/callbacks and await local socket closure; never terminate the provider. */
+  readonly retire: Effect.Effect<void, BrowserRunFailure>;
+}
+
 /** Native transport port shared by both scoped adapters; the Layer owns the foreign binding. */
 export class BrowserRunBinding extends Context.Service<
   BrowserRunBinding,
@@ -21,10 +46,38 @@ export class BrowserRunBinding extends Context.Service<
       sessionId: string,
       operation: string,
       signal?: AbortSignal,
-    ) => Promise<Browser>;
+    ) => BrowserRunAttachment;
+    readonly keepAlive: (sessionId: string) => Effect.Effect<void, BrowserRunFailure>;
   }
 >()("@effect-agent/platform-cloudflare/internal/BrowserRunBinding") {
   static layer(browser: Pick<BrowserRun, "fetch">) {
+    const upgrade = async (sessionId: string, operation: string, signal?: AbortSignal) => {
+      const response = await browser.fetch(
+        `https://browser-rendering.cloudflare.com/v1/devtools/browser/${sessionId}`,
+        { headers: { Upgrade: "websocket" }, ...(signal === undefined ? {} : { signal }) },
+      );
+
+      if (response.status !== 101) {
+        const failure = new BrowserRunFailure({
+          operation,
+          reason: "provider",
+          status: response.status,
+        });
+
+        try {
+          await response.body?.cancel();
+        } catch {
+          // Preserve the provider refusal when local response release also fails.
+        }
+        throw failure;
+      }
+      const socket = response.webSocket;
+
+      if (socket === null) throw new BrowserRunFailure({ operation, reason: "malformed" });
+
+      return socket;
+    };
+
     return Layer.succeed(this)({
       // One allocation path, with recording explicitly disabled for private sessions.
       acquire: async (keepAliveMillis, operation) => {
@@ -50,83 +103,218 @@ export class BrowserRunBinding extends Context.Service<
 
         return Schema.decodeUnknownSync(Acquired)(await response.json()).sessionId;
       },
-      connect: async (sessionId, operation, signal) => {
+      connect: (sessionId, operation, signal) => {
         let socket: WebSocket | undefined;
+        let retired = false;
         let closedByAbort = false;
+        let retirementFailure: BrowserRunFailure | undefined;
 
-        try {
-          const response = await browser.fetch(
-            `https://browser-rendering.cloudflare.com/v1/devtools/browser/${sessionId}`,
-            { headers: { Upgrade: "websocket" }, ...(signal === undefined ? {} : { signal }) },
-          );
+        const disconnectOperation =
+          operation === "protected.connect" ? "protected.disconnect" : "interactive.disconnect";
+
+        const transport: ConnectionTransport = {
+          send: (message) => {
+            if (retired || socket === undefined)
+              throw new BrowserRunFailure({ operation, reason: "provider" });
+            socket.send(message);
+          },
+          close: () => retireNow(),
+        };
+
+        const onMessage = (event: MessageEvent) => {
+          if (!retired) transport.onmessage?.(event.data);
+        };
+
+        const fence = () => {
+          if (retired) return;
+          retired = true;
+          const notify = transport.onclose;
 
-          if (response.status !== 101) {
-            const failure = new BrowserRunFailure({
-              operation,
-              reason: "provider",
-              status: response.status,
-            });
+          transport.onmessage = undefined;
+          transport.onclose = undefined;
+          // Notify the SDK before touching the socket: disposal must reject pending CDP calls
+          // even when the raw transport cannot close. The send fence also covers queued work.
+          try {
+            notify?.();
+          } finally {
+            socket?.removeEventListener("message", onMessage);
+          }
+        };
+
+        const retireNow = () => {
+          try {
+            fence();
+          } catch (cause) {
+            retirementFailure ??= browserFailure(disconnectOperation, cause);
+          }
+          try {
+            if (socket !== undefined && socket.readyState < WebSocket.CLOSING) socket.close();
+          } catch (cause) {
+            retirementFailure ??= browserFailure(disconnectOperation, cause);
+          }
+          if (retirementFailure !== undefined) throw retirementFailure;
+        };
+
+        const abort = () => {
+          closedByAbort = socket?.readyState === WebSocket.OPEN;
+          try {
+            retireNow();
+          } catch {
+            // The attachment owner observes this separately from the initiating failure.
+          }
+        };
+
+        signal?.addEventListener("abort", abort, { once: true });
+
+        const initialized = (async () => {
+          try {
+            signal?.throwIfAborted();
+            socket = await upgrade(sessionId, operation, signal);
+            socket.accept();
+            if (retired || signal?.aborted) {
+              // No SDK command may escape a late upgrade. Preserve a late local-close
+              // failure independently of the cancellation already returned to the owner.
+              retireNow();
+              signal?.throwIfAborted();
+              throw new BrowserRunFailure({ operation, reason: "provider" });
+            }
+            socket.addEventListener("message", onMessage);
+            socket.addEventListener(
+              "close",
+              () => {
+                try {
+                  fence();
+                } catch (cause) {
+                  retirementFailure ??= browserFailure(disconnectOperation, cause);
+                }
+              },
+              { once: true },
+            );
 
+            return await puppeteer.connect({ transport });
+          } catch (cause) {
             try {
-              await response.body?.cancel();
+              retireNow();
             } catch {
-              // Body cancellation cannot replace the provider refusal.
+              // Preserve both facts: initialization failed, and retirement may be unconfirmed.
             }
-            throw failure;
+            const failure = browserFailure(operation, cause);
+
+            const localCancellation =
+              cause instanceof Error &&
+              signal?.aborted === true &&
+              (cause === signal.reason || (closedByAbort && cause.name === "TargetCloseError"));
+
+            throw localCancellation ? reportedBrowserError(failure) : failure;
+          } finally {
+            signal?.removeEventListener("abort", abort);
           }
-          const connected = response.webSocket;
+        })();
+
+        return {
+          browser: initialized,
+          retire: Effect.callback<void, BrowserRunFailure>((resume) => {
+            const connected = socket;
+            const onClose = () => resume(Effect.void);
+
+            try {
+              retireNow();
+              if (connected === undefined || connected.readyState === WebSocket.CLOSED)
+                resume(Effect.void);
+              else connected.addEventListener("close", onClose, { once: true });
+            } catch (cause) {
+              resume(Effect.fail(browserFailure(disconnectOperation, cause)));
+            }
+
+            return Effect.sync(() => connected?.removeEventListener("close", onClose));
+          }),
+        };
+      },
+      keepAlive: Effect.fnUntraced(function* (sessionId: string) {
+        const operation = "protected.keepAlive";
+        const runReport = Effect.runPromiseWith(yield* Effect.context<never>());
+
+        const release = (socket: WebSocket) =>
+          Effect.sync(() => socket.close()).pipe(
+            Effect.catchCause((cause) => reportBrowserCause(operation, cause)),
+          );
+
+        const socket = yield* Effect.acquireRelease(
+          Effect.tryPromise({
+            try: async (signal) => {
+              let acquired: WebSocket | undefined;
+
+              try {
+                acquired = await upgrade(sessionId, operation, signal);
+                acquired.accept();
+                // The binding may resolve an upgrade after the Effect was interrupted.
+                signal.throwIfAborted();
 
-          if (connected === null) throw new BrowserRunFailure({ operation, reason: "malformed" });
-          socket = connected;
+                return acquired;
+              } catch (cause) {
+                if (acquired !== undefined) await runReport(release(acquired));
+                if (signal.aborted && cause !== signal.reason)
+                  await runReport(reportBrowserCause(operation, Cause.fail(cause)));
+                throw cause;
+              }
+            },
+            catch: (cause) => browserFailure(operation, cause),
+          }),
+          release,
+          { interruptible: true },
+        );
 
-          const transport: ConnectionTransport = {
-            send: (message) => connected.send(message),
-            close: () => connected.close(),
+        yield* Effect.callback<void, BrowserRunFailure>((resume) => {
+          const finish = (result: Effect.Effect<void, BrowserRunFailure>) => {
+            removeListeners();
+            resume(result);
           };
 
-          connected.addEventListener("message", (event) => {
-            transport.onmessage?.(event.data);
-          });
-          connected.addEventListener("close", () => transport.onclose?.());
-          connected.accept();
+          const fail = (reason: BrowserRunFailure["reason"]) =>
+            finish(Effect.fail(new BrowserRunFailure({ operation, reason })));
 
-          const abort = () => {
+          const onMessage = (event: MessageEvent) => {
             try {
-              const wasOpen = connected.readyState === WebSocket.OPEN;
+              if (typeof event.data !== "string" || event.data.length > 16_384) {
+                fail("malformed");
+
+                return;
+              }
+              const reply = Schema.decodeSync(VersionReply)(event.data);
+
+              if (reply.id !== 1) return;
+              if (reply.error !== undefined) {
+                fail("provider");
 
-              connected.close();
-              closedByAbort = wasOpen;
+                return;
+              }
+              Schema.decodeUnknownSync(Version)(reply.result);
+              finish(Effect.void);
             } catch {
-              // The local transport may already have closed; never terminate the provider here.
+              fail("malformed");
             }
           };
 
-          signal?.addEventListener("abort", abort, { once: true });
-          try {
-            signal?.throwIfAborted();
+          const onClose = () => fail("provider");
 
-            return await puppeteer.connect({ transport });
-          } finally {
-            signal?.removeEventListener("abort", abort);
-          }
-        } catch (cause) {
+          const removeListeners = () => {
+            socket.removeEventListener("message", onMessage);
+            socket.removeEventListener("close", onClose);
+            socket.removeEventListener("error", onClose);
+          };
+
+          socket.addEventListener("message", onMessage);
+          socket.addEventListener("close", onClose);
+          socket.addEventListener("error", onClose);
           try {
-            socket?.close();
-          } catch {
-            // Preserve the connection failure when local release also fails.
+            socket.send(JSON.stringify({ id: 1, method: "Browser.getVersion" }));
+          } catch (cause) {
+            finish(Effect.fail(browserFailure(operation, cause)));
           }
-          const failure = browserFailure(operation, cause);
-
-          // A local abort can reject SDK initialization as target-closed. Genuine late
-          // provider failures still report, even when the caller's signal has aborted.
-          const localCancellation =
-            cause instanceof Error &&
-            signal?.aborted === true &&
-            (cause === signal.reason || (closedByAbort && cause.name === "TargetCloseError"));
 
-          throw localCancellation ? reportedBrowserError(failure) : failure;
-        }
-      },
+          return Effect.sync(removeListeners);
+        });
+      }, Effect.scoped),
     });
   }
 }

package/src/protected-browser/binding.ts

@@ -9,7 +9,7 @@ import {
   type CDPSession,
 } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
 
-import { BrowserRunBinding } from "../internal/browser-binding.ts";
+import { BrowserRunBinding, type BrowserRunAttachment } from "../internal/browser-binding.ts";
 import {
   browserFailure,
   BrowserRunFailure,
@@ -50,6 +50,9 @@ export class BrowserRunProtectedBinding extends Context.Service<
       policy: InteractiveBrowserPolicy,
       identity?: ProtectedProviderIdentity,
     ) => Effect.Effect<ProtectedProviderSession, ProtectedBrowserError, Scope.Scope>;
+    readonly keepAlive: (
+      sessionId: Redacted.Redacted<string>,
+    ) => Effect.Effect<void, ProtectedBrowserError>;
   }
 >()("@effect-agent/platform-cloudflare/BrowserRunProtectedBinding") {}
 
@@ -83,6 +86,7 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
         let control: CDPSession | undefined;
         let providerIdentity: ProtectedProviderIdentity | undefined;
         let browser: Browser | undefined;
+        let attachment: BrowserRunAttachment | undefined;
         let driver: ProtectedBrowserTransport | undefined;
         let invalid = false;
         // SDK acquisition may finish after interruption. Its late-reply callback must await cleanup,
@@ -96,28 +100,48 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
 
           // A failed resume has not acquired the host's retained provider. Release only
           // this connection; successful attachments and new allocations own termination.
-          const cleanup = yield* identity !== undefined && driver === undefined
-            ? Effect.succeed("unconfirmed" as const)
-            : lifecycle.close(sessionId).pipe(
-                Effect.as("confirmed" as const),
-                Effect.catchCause((cause) =>
-                  reportBrowserCause("protected.close", cause).pipe(
-                    Effect.as("unconfirmed" as const),
-                  ),
-                ),
+          if (identity !== undefined && driver === undefined) {
+            if (attachment !== undefined)
+              yield* attachment.retire.pipe(
                 Effect.interruptible,
                 Effect.timeoutOrElse({
-                  duration: "10 seconds",
+                  duration: "1 second",
                   orElse: () =>
-                    reportBrowserCause(
-                      "protected.close",
-                      Cause.fail(
-                        new BrowserRunFailure({ operation: "protected.close", reason: "timeout" }),
-                      ),
-                    ).pipe(Effect.as("unconfirmed" as const)),
+                    Effect.fail(
+                      new BrowserRunFailure({
+                        operation: "protected.disconnect",
+                        reason: "timeout",
+                      }),
+                    ),
                 }),
+                Effect.catch((error) =>
+                  reportBrowserCause("protected.disconnect", Cause.fail(error)).pipe(
+                    Effect.andThen(() => Effect.die(reportedBrowserError(error))),
+                  ),
+                ),
               );
 
+            return "unconfirmed" as const;
+          }
+
+          const cleanup = yield* lifecycle.close(sessionId).pipe(
+            Effect.as("confirmed" as const),
+            Effect.catchCause((cause) =>
+              reportBrowserCause("protected.close", cause).pipe(Effect.as("unconfirmed" as const)),
+            ),
+            Effect.interruptible,
+            Effect.timeoutOrElse({
+              duration: "10 seconds",
+              orElse: () =>
+                reportBrowserCause(
+                  "protected.close",
+                  Cause.fail(
+                    new BrowserRunFailure({ operation: "protected.close", reason: "timeout" }),
+                  ),
+                ).pipe(Effect.as("unconfirmed" as const)),
+            }),
+          );
+
           // Local disconnect is not remote-closure evidence. Do it even when confirmation fails.
           const connected = browser;
 
@@ -166,7 +190,8 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
               }
               // Resume only a host-persisted exact page. Never open a replacement page or context.
               stage = "protected.connect";
-              browser = await binding.connect(Redacted.value(sessionId), stage, signal);
+              attachment = binding.connect(Redacted.value(sessionId), stage, signal);
+              browser = await attachment.browser;
               if (signal.aborted || invalid) {
                 await runCleanup(terminate);
                 throw new ProtectedTransportError({ reason: "stale-reference" });
@@ -214,32 +239,38 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
                 targetId: Redacted.make(info.targetInfo.targetId),
               });
 
-              stage = "protected.interception";
-              await page.setBypassServiceWorker(true);
-              await page.setRequestInterception(true);
-              page.on("request", (request) => {
-                let allowed = policy.network._tag === "Unrestricted";
-
-                try {
-                  const url = new URL(request.url());
-
-                  allowed ||=
-                    policy.network._tag === "ExactHosts" &&
-                    url.protocol === "https:" &&
-                    !url.username &&
-                    !url.password &&
-                    policy.network.allowedHosts.includes(url.host);
-                } catch {
-                  /* Refuse malformed destinations. */
-                }
-                void (
-                  allowed && !invalid ? request.continue() : request.abort("blockedbyclient")
-                ).catch(async (cause) => {
-                  invalid = true;
-                  driver?.invalidate();
-                  await runCleanup(reportBrowserCause("protected.interception", Cause.fail(cause)));
+              // Unrestricted passes need no attachment-local network enforcement. Leave their
+              // service workers and requests alone, including across host-owned detach/resume.
+              if (policy.network._tag !== "Unrestricted") {
+                stage = "protected.interception";
+                await page.setBypassServiceWorker(true);
+                await page.setRequestInterception(true);
+                page.on("request", (request) => {
+                  let allowed = false;
+
+                  try {
+                    const url = new URL(request.url());
+
+                    allowed =
+                      policy.network._tag === "ExactHosts" &&
+                      url.protocol === "https:" &&
+                      !url.username &&
+                      !url.password &&
+                      policy.network.allowedHosts.includes(url.host);
+                  } catch {
+                    /* Refuse malformed destinations. */
+                  }
+                  void (
+                    allowed && !invalid ? request.continue() : request.abort("blockedbyclient")
+                  ).catch(async (cause) => {
+                    invalid = true;
+                    driver?.invalidate();
+                    await runCleanup(
+                      reportBrowserCause("protected.interception", Cause.fail(cause)),
+                    );
+                  });
                 });
-              });
+              }
               if (signal.aborted || invalid) {
                 await runCleanup(terminate);
                 throw new ProtectedTransportError({ reason: "stale-reference" });
@@ -264,8 +295,26 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
             orElse: () =>
               Effect.fail(new BrowserRunFailure({ operation: stage, reason: "timeout" })),
           }),
-          Effect.catch((error) =>
-            reportBrowserCause(stage, Cause.fail(error)).pipe(
+          Effect.catch((error) => {
+            if (identity !== undefined && driver === undefined)
+              return reportBrowserCause(stage, Cause.fail(error)).pipe(
+                Effect.andThen(
+                  Effect.fail(
+                    reportedBrowserError(
+                      new ProtectedBrowserError({
+                        ...failure(),
+                        reason: error.reason === "timeout" ? "timeout" : "provider",
+                        cleanup: "not-requested",
+                      }),
+                    ),
+                  ),
+                ),
+                // A disposal defect stays alongside the original failure. Only a pure typed
+                // failure proves that this pre-handle attachment is safe to relinquish.
+                Effect.ensuring(close),
+              );
+
+            return reportBrowserCause(stage, Cause.fail(error)).pipe(
               Effect.andThen(close),
               Effect.flatMap((cleanup) =>
                 Effect.fail(
@@ -273,14 +322,13 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
                     new ProtectedBrowserError({
                       ...failure(),
                       reason: error.reason === "timeout" ? "timeout" : "provider",
-                      cleanup:
-                        identity !== undefined && driver === undefined ? "not-requested" : cleanup,
+                      cleanup,
                     }),
                   ),
                 ),
               ),
-            ),
-          ),
+            );
+          }),
         );
 
         driver = yield* makeProtectedNativeTransport(policy).pipe(
@@ -346,7 +394,38 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
         };
       }, Effect.withTracerEnabled(false));
 
-      return { open };
+      const keepAlive = Effect.fn("BrowserRunProtectedBinding.keepAlive")(function* (
+        sessionId: Redacted.Redacted<string>,
+      ) {
+        const failure = (reason: ProtectedBrowserError["reason"]) =>
+          new ProtectedBrowserError({
+            reason,
+            dispatch: "not-dispatched",
+            milestone: "none",
+            observation: "protected",
+            cleanup: "not-requested",
+          });
+
+        const id = yield* Schema.decodeEffect(ProtectedProviderIdentity.fields.sessionId)(
+          sessionId,
+        ).pipe(Effect.mapError(() => failure("denied")));
+
+        yield* binding.keepAlive(Redacted.value(id)).pipe(
+          Effect.timeoutOrElse({
+            duration: "10 seconds",
+            orElse: () =>
+              Effect.fail(
+                new BrowserRunFailure({ operation: "protected.keepAlive", reason: "timeout" }),
+              ),
+          }),
+          Effect.tapError((error) => reportBrowserCause("protected.keepAlive", Cause.fail(error))),
+          Effect.mapError((error) =>
+            reportedBrowserError(failure(error.reason === "timeout" ? "timeout" : "provider")),
+          ),
+        );
+      }, Effect.withTracerEnabled(false));
+
+      return { open, keepAlive };
     }),
   ).pipe(Layer.provide(BrowserRunBinding.layer(options.browser)));