@ricsam/isolate 0.1.10 → 0.1.11

package/README.md

@@ -1,6 +1,6 @@
 # @ricsam/isolate
 
-`@ricsam/isolate` is a runtime-centric JavaScript sandbox built on an async-context-enabled [`@ricsam/isolated-vm`](https://github.com/ricsam/isolated-vm) engine build. It gives you a single host API for running isolated code with web-style capabilities such as `fetch`, files, streams, server handlers, module loading, and Playwright-backed browser tests.
+`@ricsam/isolate` is a runtime-centric JavaScript sandbox built on an async-context-enabled [`@ricsam/isolated-vm`](https://github.com/ricsam/isolated-vm) engine build. It gives you a single host API for running isolated code with web-style capabilities such as `fetch`, files, streams, server handlers, nested sandboxes, module loading, and Playwright-backed browser tests.
 
 ## Installation
 
@@ -10,7 +10,7 @@ npm add @ricsam/isolate @ricsam/isolated-vm
 
 The `@ricsam/isolated-vm` peer includes the `createContext({ asyncContext: true })` support required by this repo. Upstream `isolated-vm` will fail fast during runtime boot with a clear AsyncContext error.
 
-Install Playwright when you want browser runtimes:
+Install Playwright when you want browser-enabled runtimes or test runtimes:
 
 ```bash
 npm add playwright
@@ -29,7 +29,9 @@ The host can create three runtime styles:
 
 - `host.createRuntime()` for scripts, agents, and ad hoc execution
 - `host.createAppServer()` for `serve()`-based request handlers
-- `host.createBrowserRuntime()` for Playwright-backed execution
+- `host.createTestRuntime()` for test suites with optional Playwright-backed browser access
+
+Inside sandbox code, `@ricsam/isolate` is also available as a synthetic module. It exports a sandbox-only `createIsolateHost()` that lets a runtime create nested runtimes, app servers, and test runtimes without exposing daemon configuration to the sandbox.
 
 ## Host Bindings
 
@@ -40,9 +42,12 @@ Each runtime is configured through `bindings`, which describe how sandboxed code
 - `files` exposes a safe, root-scoped filesystem
 - `modules` resolves virtual modules, source trees, and mounted packages
 - `tools` exposes async host functions and async iterators
+- `browser` exposes a Playwright-like browser factory backed by host `createContext()` and `createPage()` callbacks
 
 Every host callback receives a `HostCallContext` with an `AbortSignal`, runtime identity, resource identity, and request metadata.
 
+`bindings.browser` is intentionally smaller than a full Playwright browser. It injects a global `browser` object with `browser.newContext()` and `browser.contexts()`, and returned contexts expose `context.newPage()` and `context.pages()`. Browser-level shutdown stays on the host side, while the sandbox can still close pages and contexts that it created.
+
 ## Async Context
 
 Runtimes created by `@ricsam/isolate` enable the TC39 proposal-style `AsyncContext` global inside the sandbox. This is an experimental surface for now, and the proposal API is used to implement the `node:async_hooks` shim exported to sandboxed code.
@@ -145,6 +150,51 @@ try {
 }
 ```
 
+## Nested Hosts Inside The Sandbox
+
+Sandbox code can import `@ricsam/isolate` and create child runtimes against the same top-level host connection.
+
+```ts
+const runtime = await host.createRuntime({
+  bindings: {
+    console: {
+      onEntry(entry) {
+        if (entry.type === "output") {
+          console.log(entry.stdout);
+        }
+      },
+    },
+  },
+});
+
+await runtime.eval(`
+  import { createIsolateHost } from "@ricsam/isolate";
+
+  const nestedHost = createIsolateHost();
+  const child = await nestedHost.createRuntime({
+    bindings: {
+      tools: {
+        greet: async (name) => "hello " + name,
+      },
+    },
+  });
+
+  await child.eval('console.log(await greet("nested"))');
+  await child.dispose();
+  await nestedHost.close();
+`);
+```
+
+Nested hosts support:
+
+- `createRuntime()`
+- `createAppServer()`
+- `createTestRuntime()`
+- `diagnostics()`
+- `close()`
+
+Child runtimes can reuse the same binding shapes as top-level runtimes. That includes isolate-authored callbacks, async iterators, module resolvers, file bindings, and browser handles.
+
 ## App Servers
 
 `createAppServer()` is the long-lived server-oriented API. It boots a runtime around an entry module that calls `serve()` and then lets the host dispatch requests into it.
@@ -183,51 +233,151 @@ await host.close();
 
 `server.handle()` returns either a normal HTTP response or WebSocket upgrade metadata. The `server.ws` helpers let the host continue an upgraded connection by sending open, message, close, and error events back into the runtime.
 
-## Browser Runtimes
+## Browser Bindings In Script And Server Runtimes
 
-`createBrowserRuntime()` runs sandboxed code against a Playwright page while keeping the host in control of file access, diagnostics, and browser event collection.
+If you provide `bindings.browser`, script and app runtimes get a global `browser` factory even when they are not full Playwright browser runtimes.
 
 ```ts
 import { chromium } from "playwright";
 import { createIsolateHost } from "@ricsam/isolate";
 
 const browser = await chromium.launch();
-const context = await browser.newContext();
-const page = await context.newPage();
+const host = await createIsolateHost();
+
+const runtime = await host.createRuntime({
+  bindings: {
+    browser: {
+      createContext: async (options) =>
+        await browser.newContext(options ?? undefined),
+      createPage: async (contextInstance) =>
+        await contextInstance.newPage(),
+    },
+  },
+});
+
+await runtime.eval(`
+  const ctx = await browser.newContext({
+    viewport: { width: 1280, height: 720 },
+  });
+  const page = await ctx.newPage();
+
+  await page.goto("https://example.com");
+  console.log(await page.title());
+  console.log(typeof browser.close);
+
+  await page.close();
+  await ctx.close();
+`);
 
+await runtime.dispose();
+await browser.close();
+await host.close();
+```
+
+In these runtimes:
+
+- `browser.newContext()` is available
+- `browser.contexts()` is available
+- `context.newPage()` is available
+- `context.pages()` is available
+- `page.close()` and `context.close()` are available
+- `browser.close()` is not exposed inside the sandbox
+- `page` and `context` are never injected as implicit globals
+
+## Test Runtimes
+
+`createTestRuntime()` enables `describe`, `test`/`it`, hooks, and `expect`. If you also provide `bindings.browser`, the same test runtime gets Playwright-style browser access and matcher support, but you are responsible for explicit page/context lifecycle inside the suite.
+
+```ts
+import { chromium } from "playwright";
+import { createIsolateHost } from "@ricsam/isolate";
+
+const browser = await chromium.launch();
 const host = await createIsolateHost();
-const runtime = await host.createBrowserRuntime({
-  key: "example/browser",
-  bindings: {},
-  features: { tests: true },
-  browser: {
-    page,
-    captureConsole: true,
+const runtime = await host.createTestRuntime({
+  key: "example/browser-test",
+  bindings: {
+    browser: {
+      captureConsole: true,
+      createContext: async (options) =>
+        await browser.newContext(options ?? undefined),
+      createPage: async (contextInstance) =>
+        await contextInstance.newPage(),
+    },
   },
 });
 
 const result = await runtime.run(
   `
+    let ctx;
+    let page;
+
+    beforeAll(async () => {
+      ctx = await browser.newContext();
+      page = await ctx.newPage();
+    });
+
+    afterAll(async () => {
+      await ctx.close();
+    });
+
     test("loads a page", async () => {
-      await page.goto("https://example.com");
+      expect((await browser.contexts()).length).toBe(1);
+      expect((await ctx.pages()).length).toBe(1);
+      await page.goto("https://example.com", {
+        waitUntil: "domcontentloaded",
+      });
       await expect(page).toHaveTitle(/Example Domain/);
     });
   `,
   {
     filename: "/browser-test.ts",
-    asTestSuite: true,
     timeoutMs: 10_000,
   },
 );
 
-console.log(result.tests);
+console.log(result);
 
 await runtime.dispose();
-await context.close();
 await browser.close();
 await host.close();
 ```
 
+From inside another sandbox, `nestedHost.createTestRuntime()` can reuse the sandbox `browser` handle:
+
+```ts
+import { createIsolateHost } from "@ricsam/isolate";
+
+const nestedHost = createIsolateHost();
+const child = await nestedHost.createTestRuntime({
+  bindings: {
+    browser,
+  },
+});
+
+await child.run(`
+  let ctx;
+  let page;
+
+  beforeAll(async () => {
+    ctx = await browser.newContext();
+    page = await ctx.newPage();
+  });
+
+  afterAll(async () => {
+    await ctx.close();
+  });
+
+  test("loads a nested page", async () => {
+    await page.goto("https://example.com");
+    await expect(page).toHaveTitle(/Example Domain/);
+  });
+`);
+
+await child.dispose();
+await nestedHost.close();
+```
+
 ## Module Resolution
 
 `createModuleResolver()` is a fluent builder. You can mix and match:
@@ -278,6 +428,10 @@ Built-in profiles:
 
 Capabilities can extend a profile with `fetch`, `files`, `tests`, `browser`, `tools`, `console`, `encoding`, and `timers`.
 
+- Use `browser` when sandbox code should typecheck `browser.newContext()`, `browser.contexts()`, `context.newPage()`, and `context.pages()`
+- The browser test profile does not assume implicit global `page` or `context`
+- The synthetic sandbox import `import { createIsolateHost } from "@ricsam/isolate"` is included in all type profiles
+
 ## Daemon CLI
 
 The package also exposes an `isolate-daemon` binary:

package/dist/cjs/bridge/diagnostics.cjs

@@ -39,7 +39,8 @@ var __export = (target, all) => {
 // src/bridge/diagnostics.ts
 var exports_diagnostics = {};
 __export(exports_diagnostics, {
-  createRuntimeDiagnostics: () => createRuntimeDiagnostics
+  createRuntimeDiagnostics: () => createRuntimeDiagnostics,
+  createBrowserDiagnostics: () => createBrowserDiagnostics
 });
 module.exports = __toCommonJS(exports_diagnostics);
 function createRuntimeDiagnostics() {
@@ -54,5 +55,39 @@ function createRuntimeDiagnostics() {
     lifecycleState: "idle"
   };
 }
+function createBrowserDiagnostics(collectedData, trackedResources) {
+  const contextIds = new Set;
+  const pageIds = new Set;
+  for (const entry of collectedData.browserConsoleLogs) {
+    contextIds.add(entry.contextId);
+    pageIds.add(entry.pageId);
+  }
+  for (const entry of collectedData.pageErrors) {
+    contextIds.add(entry.contextId);
+    pageIds.add(entry.pageId);
+  }
+  for (const entry of collectedData.networkRequests) {
+    contextIds.add(entry.contextId);
+    pageIds.add(entry.pageId);
+  }
+  for (const entry of collectedData.networkResponses) {
+    contextIds.add(entry.contextId);
+    pageIds.add(entry.pageId);
+  }
+  for (const entry of collectedData.requestFailures) {
+    contextIds.add(entry.contextId);
+    pageIds.add(entry.pageId);
+  }
+  return {
+    contexts: trackedResources?.contexts.length ?? contextIds.size,
+    pages: trackedResources?.pages.length ?? pageIds.size,
+    browserConsoleLogs: collectedData.browserConsoleLogs.length,
+    networkRequests: collectedData.networkRequests.length,
+    networkResponses: collectedData.networkResponses.length,
+    pageErrors: collectedData.pageErrors.length,
+    requestFailures: collectedData.requestFailures.length,
+    collectedData
+  };
+}
 
-//# debugId=40FF8D24B6369A0D64756E2164756E21
+//# debugId=8BF2916FF62F72B164756E2164756E21

package/dist/cjs/bridge/diagnostics.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../src/bridge/diagnostics.ts"],
   "sourcesContent": [
-    "import type { RuntimeDiagnostics } from \"../types.cjs\";\n\nexport interface MutableRuntimeDiagnostics extends RuntimeDiagnostics {\n  activeRequests: number;\n  activeResources: number;\n  pendingFiles: number;\n  pendingFetches: number;\n  pendingModules: number;\n  pendingTools: number;\n  streamCount: number;\n  lifecycleState: \"idle\" | \"active\" | \"reloading\" | \"disposing\";\n}\n\nexport function createRuntimeDiagnostics(): MutableRuntimeDiagnostics {\n  return {\n    activeRequests: 0,\n    activeResources: 0,\n    pendingFiles: 0,\n    pendingFetches: 0,\n    pendingModules: 0,\n    pendingTools: 0,\n    streamCount: 0,\n    lifecycleState: \"idle\",\n  };\n}\n"
+    "import type { CollectedData } from \"../internal/client/index.cjs\";\nimport type { BrowserDiagnostics, RuntimeDiagnostics } from \"../types.cjs\";\n\nexport interface MutableRuntimeDiagnostics extends RuntimeDiagnostics {\n  activeRequests: number;\n  activeResources: number;\n  pendingFiles: number;\n  pendingFetches: number;\n  pendingModules: number;\n  pendingTools: number;\n  streamCount: number;\n  lifecycleState: \"idle\" | \"active\" | \"reloading\" | \"disposing\";\n}\n\nexport function createRuntimeDiagnostics(): MutableRuntimeDiagnostics {\n  return {\n    activeRequests: 0,\n    activeResources: 0,\n    pendingFiles: 0,\n    pendingFetches: 0,\n    pendingModules: 0,\n    pendingTools: 0,\n    streamCount: 0,\n    lifecycleState: \"idle\",\n  };\n}\n\nexport function createBrowserDiagnostics(\n  collectedData: CollectedData,\n  trackedResources?: { contexts: string[]; pages: string[] },\n): BrowserDiagnostics {\n  const contextIds = new Set<string>();\n  const pageIds = new Set<string>();\n  for (const entry of collectedData.browserConsoleLogs) {\n    contextIds.add(entry.contextId);\n    pageIds.add(entry.pageId);\n  }\n  for (const entry of collectedData.pageErrors) {\n    contextIds.add(entry.contextId);\n    pageIds.add(entry.pageId);\n  }\n  for (const entry of collectedData.networkRequests) {\n    contextIds.add(entry.contextId);\n    pageIds.add(entry.pageId);\n  }\n  for (const entry of collectedData.networkResponses) {\n    contextIds.add(entry.contextId);\n    pageIds.add(entry.pageId);\n  }\n  for (const entry of collectedData.requestFailures) {\n    contextIds.add(entry.contextId);\n    pageIds.add(entry.pageId);\n  }\n\n  return {\n    contexts: trackedResources?.contexts.length ?? contextIds.size,\n    pages: trackedResources?.pages.length ?? pageIds.size,\n    browserConsoleLogs: collectedData.browserConsoleLogs.length,\n    networkRequests: collectedData.networkRequests.length,\n    networkResponses: collectedData.networkResponses.length,\n    pageErrors: collectedData.pageErrors.length,\n    requestFailures: collectedData.requestFailures.length,\n    collectedData,\n  };\n}\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaO,SAAS,wBAAwB,GAA8B;AAAA,EACpE,OAAO;AAAA,IACL,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,IACjB,cAAc;AAAA,IACd,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,IAChB,cAAc;AAAA,IACd,aAAa;AAAA,IACb,gBAAgB;AAAA,EAClB;AAAA;",
-  "debugId": "40FF8D24B6369A0D64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcO,SAAS,wBAAwB,GAA8B;AAAA,EACpE,OAAO;AAAA,IACL,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,IACjB,cAAc;AAAA,IACd,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,IAChB,cAAc;AAAA,IACd,aAAa;AAAA,IACb,gBAAgB;AAAA,EAClB;AAAA;AAGK,SAAS,wBAAwB,CACtC,eACA,kBACoB;AAAA,EACpB,MAAM,aAAa,IAAI;AAAA,EACvB,MAAM,UAAU,IAAI;AAAA,EACpB,WAAW,SAAS,cAAc,oBAAoB;AAAA,IACpD,WAAW,IAAI,MAAM,SAAS;AAAA,IAC9B,QAAQ,IAAI,MAAM,MAAM;AAAA,EAC1B;AAAA,EACA,WAAW,SAAS,cAAc,YAAY;AAAA,IAC5C,WAAW,IAAI,MAAM,SAAS;AAAA,IAC9B,QAAQ,IAAI,MAAM,MAAM;AAAA,EAC1B;AAAA,EACA,WAAW,SAAS,cAAc,iBAAiB;AAAA,IACjD,WAAW,IAAI,MAAM,SAAS;AAAA,IAC9B,QAAQ,IAAI,MAAM,MAAM;AAAA,EAC1B;AAAA,EACA,WAAW,SAAS,cAAc,kBAAkB;AAAA,IAClD,WAAW,IAAI,MAAM,SAAS;AAAA,IAC9B,QAAQ,IAAI,MAAM,MAAM;AAAA,EAC1B;AAAA,EACA,WAAW,SAAS,cAAc,iBAAiB;AAAA,IACjD,WAAW,IAAI,MAAM,SAAS;AAAA,IAC9B,QAAQ,IAAI,MAAM,MAAM;AAAA,EAC1B;AAAA,EAEA,OAAO;AAAA,IACL,UAAU,kBAAkB,SAAS,UAAU,WAAW;AAAA,IAC1D,OAAO,kBAAkB,MAAM,UAAU,QAAQ;AAAA,IACjD,oBAAoB,cAAc,mBAAmB;AAAA,IACrD,iBAAiB,cAAc,gBAAgB;AAAA,IAC/C,kBAAkB,cAAc,iBAAiB;AAAA,IACjD,YAAY,cAAc,WAAW;AAAA,IACrC,iBAAiB,cAAc,gBAAgB;AAAA,IAC/C;AAAA,EACF;AAAA;",
+  "debugId": "8BF2916FF62F72B164756E2164756E21",
   "names": []
 }

package/dist/cjs/bridge/runtime-bindings.cjs

@@ -69,7 +69,9 @@ __export(exports_runtime_bindings, {
 });
 module.exports = __toCommonJS(exports_runtime_bindings);
 var import_node_path = __toESM(require("node:path"));
+var import_client = require("../internal/playwright/client.cjs");
 var import_request_context = require("./request-context.cjs");
+var import_sandbox_isolate = require("./sandbox-isolate.cjs");
 function createAbortError(reason) {
   if (reason instanceof Error) {
     return reason;
@@ -171,11 +173,30 @@ async function normalizeModuleResolveResult(specifier, result, fallbackResolveDi
   };
 }
 function isAsyncGeneratorFunction(handler) {
-  return handler.constructor.name === "AsyncGeneratorFunction";
+  return handler.constructor.name === "AsyncGeneratorFunction" || handler.__isolateCallbackKind === "asyncGenerator";
 }
-function createRuntimeBindingsAdapter(bindings, getRuntimeId, diagnostics) {
+function isResponseDescriptor(value) {
+  return Boolean(value && typeof value === "object" && value.__type === "ResponseRef" && Array.isArray(value.headers));
+}
+function normalizeFetchResponse(value) {
+  if (value instanceof Response) {
+    return value;
+  }
+  if (isResponseDescriptor(value)) {
+    const body = value.body ? new Uint8Array(value.body) : null;
+    return new Response(body, {
+      status: value.status,
+      statusText: value.statusText,
+      headers: value.headers
+    });
+  }
+  throw new TypeError("Fetch bindings must return a Response.");
+}
+function createRuntimeBindingsAdapter(bindings, getRuntimeId, diagnostics, options) {
   const contextFactory = createHostCallContextFactory(getRuntimeId);
-  const moduleLoader = createModuleLoader(bindings.modules, contextFactory.createHostCallContext, diagnostics);
+  const moduleLoader = createModuleLoader(bindings.modules, contextFactory.createHostCallContext, diagnostics, options?.nestedHost);
+  const customFunctions = createCustomFunctions(bindings.tools, options?.nestedHost, contextFactory.createHostCallContext, diagnostics);
+  const browserPlaywright = createBrowserPlaywrightOptions(bindings.browser, contextFactory.createHostCallContext);
   return {
     runtimeOptions: {
       console: bindings.console?.onEntry ? {
@@ -195,7 +216,7 @@ function createRuntimeBindingsAdapter(bindings, getRuntimeId, diagnostics) {
             body: init.rawBody ? init.rawBody.slice(0) : null,
             signal: context.signal
           });
-          return await bindings.fetch(request, context);
+          return normalizeFetchResponse(await bindings.fetch(request, context));
         } finally {
           diagnostics.pendingFetches -= 1;
           diagnostics.activeResources -= 1;
@@ -246,12 +267,12 @@ function createRuntimeBindingsAdapter(bindings, getRuntimeId, diagnostics) {
             diagnostics.activeResources -= 1;
           }
         } : undefined,
-        mkdir: bindings.files.mkdir ? async (dirPath, options) => {
+        mkdir: bindings.files.mkdir ? async (dirPath, options2) => {
           diagnostics.pendingFiles += 1;
           diagnostics.activeResources += 1;
           try {
             const context = contextFactory.createHostCallContext(`files:mkdir:${crypto.randomUUID()}`);
-            return await bindings.files.mkdir(dirPath, options, context);
+            return await bindings.files.mkdir(dirPath, options2, context);
           } finally {
             diagnostics.pendingFiles -= 1;
             diagnostics.activeResources -= 1;
@@ -292,62 +313,38 @@ function createRuntimeBindingsAdapter(bindings, getRuntimeId, diagnostics) {
         } : undefined
       } : undefined,
       moduleLoader,
-      customFunctions: bindings.tools ? Object.fromEntries(Object.entries(bindings.tools).map(([name, handler]) => {
-        if (isAsyncGeneratorFunction(handler)) {
-          return [
-            name,
-            {
-              type: "asyncIterator",
-              fn: (...args) => {
-                diagnostics.pendingTools += 1;
-                diagnostics.activeResources += 1;
-                const context = contextFactory.createHostCallContext(`tool:${name}:${crypto.randomUUID()}`);
-                const iterator = handler(...args, context);
-                return async function* () {
-                  try {
-                    yield* iterator;
-                  } finally {
-                    diagnostics.pendingTools -= 1;
-                    diagnostics.activeResources -= 1;
-                  }
-                }();
-              }
-            }
-          ];
-        }
-        return [
-          name,
-          {
-            type: "async",
-            fn: async (...args) => {
-              diagnostics.pendingTools += 1;
-              diagnostics.activeResources += 1;
-              try {
-                const context = contextFactory.createHostCallContext(`tool:${name}:${crypto.randomUUID()}`);
-                return await handler(...args, context);
-              } finally {
-                diagnostics.pendingTools -= 1;
-                diagnostics.activeResources -= 1;
-              }
-            }
-          }
-        ];
-      })) : undefined
+      customFunctions,
+      playwright: browserPlaywright
     },
     abort: contextFactory.abort,
     reset: contextFactory.reset
   };
 }
-function createModuleLoader(resolver, createHostCallContext, diagnostics) {
-  if (!resolver) {
+function createModuleLoader(resolver, createHostCallContext, diagnostics, nestedHost) {
+  if (!resolver && !nestedHost) {
     return;
   }
   return async (specifier, importer) => {
+    if (nestedHost && specifier === import_sandbox_isolate.SANDBOX_ISOLATE_MODULE_SPECIFIER) {
+      return {
+        code: import_sandbox_isolate.SANDBOX_ISOLATE_MODULE_SOURCE,
+        filename: "isolate-sandbox.js",
+        resolveDir: "/",
+        static: true
+      };
+    }
+    if (!resolver) {
+      throw new Error(`Unable to resolve module: ${specifier}`);
+    }
     diagnostics.pendingModules += 1;
     diagnostics.activeResources += 1;
     try {
       const context = createHostCallContext(`module:${crypto.randomUUID()}`);
-      return await resolver.resolve(specifier, importer, context);
+      const resolved = await normalizeExplicitModuleResult(specifier, resolver.resolve(specifier, importer, context), importer.resolveDir);
+      if (!resolved) {
+        throw new Error(`Unable to resolve module: ${specifier}`);
+      }
+      return resolved;
     } finally {
       diagnostics.pendingModules -= 1;
       diagnostics.activeResources -= 1;
@@ -363,5 +360,160 @@ async function tryResolveModule(resolver, specifier, importer, context) {
 async function normalizeExplicitModuleResult(specifier, result, fallbackResolveDir) {
   return normalizeModuleResolveResult(specifier, result, fallbackResolveDir);
 }
+function createBrowserPlaywrightOptions(browser, createHostCallContext) {
+  if (!browser) {
+    return;
+  }
+  return {
+    handler: import_client.createPlaywrightFactoryHandler({
+      createContext: browser.createContext ? async (options) => {
+        const context = createHostCallContext(`browser:createContext:${crypto.randomUUID()}`);
+        return await browser.createContext(options, context);
+      } : undefined,
+      createPage: browser.createPage ? async (contextHandle) => {
+        const context = createHostCallContext(`browser:createPage:${crypto.randomUUID()}`);
+        return await browser.createPage(contextHandle, context);
+      } : undefined,
+      readFile: browser.readFile ? async (filePath) => {
+        const context = createHostCallContext(`browser:readFile:${crypto.randomUUID()}`);
+        const buffer = await browser.readFile(filePath, context);
+        return {
+          name: import_node_path.default.basename(filePath),
+          mimeType: "application/octet-stream",
+          buffer
+        };
+      } : undefined,
+      writeFile: browser.writeFile ? async (filePath, data) => {
+        const context = createHostCallContext(`browser:writeFile:${crypto.randomUUID()}`);
+        await browser.writeFile(filePath, data, context);
+      } : undefined
+    }),
+    hasDefaultPage: false,
+    console: browser.captureConsole ?? false,
+    onEvent: browser.onEvent ? (event) => {
+      const context = createHostCallContext(`browser:event:${event.type}:${crypto.randomUUID()}`);
+      browser.onEvent?.(event, context);
+    } : undefined
+  };
+}
+function createCustomFunctions(tools, nestedHost, createHostCallContext, diagnostics) {
+  const definitions = {};
+  if (tools) {
+    for (const [name, handler] of Object.entries(tools)) {
+      if (isAsyncGeneratorFunction(handler)) {
+        definitions[name] = {
+          type: "asyncIterator",
+          fn: (...args) => {
+            diagnostics.pendingTools += 1;
+            diagnostics.activeResources += 1;
+            const context = createHostCallContext(`tool:${name}:${crypto.randomUUID()}`);
+            const iteratorResult = handler(...args, context);
+            return async function* () {
+              const iterator = await iteratorResult;
+              const iterable = iterator && typeof iterator[Symbol.asyncIterator] === "function" ? iterator : iterator && typeof iterator.next === "function" ? {
+                [Symbol.asyncIterator]() {
+                  return iterator;
+                }
+              } : null;
+              try {
+                if (!iterable) {
+                  throw new TypeError(`Tool ${name} did not return an async iterator.`);
+                }
+                yield* iterable;
+              } finally {
+                diagnostics.pendingTools -= 1;
+                diagnostics.activeResources -= 1;
+              }
+            }();
+          }
+        };
+        continue;
+      }
+      definitions[name] = {
+        type: "async",
+        fn: async (...args) => {
+          diagnostics.pendingTools += 1;
+          diagnostics.activeResources += 1;
+          try {
+            const context = createHostCallContext(`tool:${name}:${crypto.randomUUID()}`);
+            return await handler(...args, context);
+          } finally {
+            diagnostics.pendingTools -= 1;
+            diagnostics.activeResources -= 1;
+          }
+        }
+      };
+    }
+  }
+  if (nestedHost) {
+    const reservedNames = [
+      "__isolateHost_createHost",
+      "__isolateHost_closeHost",
+      "__isolateHost_hostDiagnostics",
+      "__isolateHost_createResource",
+      "__isolateHost_callResource",
+      "__isolateHost_drainCallbacks"
+    ];
+    for (const name of reservedNames) {
+      if (definitions[name]) {
+        throw new Error(`Tool name ${name} is reserved for internal sandbox host bindings.`);
+      }
+    }
+    definitions.__isolateHost_createHost = {
+      type: "async",
+      fn: async () => {
+        const context = createHostCallContext(`nestedHost:createHost:${crypto.randomUUID()}`);
+        return await nestedHost.createHost(context);
+      }
+    };
+    definitions.__isolateHost_closeHost = {
+      type: "async",
+      fn: async (...args) => {
+        const hostId = args[0];
+        const context = createHostCallContext(`nestedHost:closeHost:${crypto.randomUUID()}`);
+        await nestedHost.closeHost(hostId, context);
+      }
+    };
+    definitions.__isolateHost_hostDiagnostics = {
+      type: "async",
+      fn: async (...args) => {
+        const hostId = args[0];
+        const context = createHostCallContext(`nestedHost:diagnostics:${crypto.randomUUID()}`);
+        return await nestedHost.diagnostics(hostId, context);
+      }
+    };
+    definitions.__isolateHost_createResource = {
+      type: "async",
+      fn: async (...args) => {
+        const hostId = args[0];
+        const kind = args[1];
+        const resourceOptions = args[2];
+        const context = createHostCallContext(`nestedHost:createResource:${kind}:${crypto.randomUUID()}`);
+        return await nestedHost.createResource(hostId, kind, resourceOptions, context);
+      }
+    };
+    definitions.__isolateHost_callResource = {
+      type: "async",
+      fn: async (...args) => {
+        const kind = args[0];
+        const resourceId = args[1];
+        const method = args[2];
+        const methodArgs = args[3];
+        const context = createHostCallContext(`nestedHost:callResource:${kind}:${method}:${crypto.randomUUID()}`);
+        return await nestedHost.callResource(kind, resourceId, method, Array.isArray(methodArgs) ? methodArgs : [], context);
+      }
+    };
+    definitions.__isolateHost_drainCallbacks = {
+      type: "async",
+      fn: async (...args) => {
+        const callback = args[0];
+        if (typeof callback === "function") {
+          await callback();
+        }
+      }
+    };
+  }
+  return Object.keys(definitions).length > 0 ? definitions : undefined;
+}
 
-//# debugId=D27BEABC8CB87D9964756E2164756E21
+//# debugId=8146451726A4D1D664756E2164756E21