libretto 0.5.5 → 0.6.0

package/dist/cli/core/deploy-artifact.js

@@ -10,11 +10,16 @@ import {
   rmSync,
   writeFileSync
 } from "node:fs";
+import { createRequire, Module } from "node:module";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gzipSync } from "node:zlib";
 import { build } from "esbuild";
+import {
+  getWorkflowsFromModuleExports,
+  LIBRETTO_WORKFLOW_BRAND
+} from "../../shared/workflow/workflow.js";
 const DEFAULT_RUNTIME_EXTERNALS = [
   "libretto",
   "playwright",
@@ -43,6 +48,7 @@ const CURRENT_LIBRETTO_VERSION = readCurrentLibrettoVersion();
 const CURRENT_LIBRETTO_PACKAGE_DIR = fileURLToPath(
   new URL("../../..", import.meta.url)
 );
+const require2 = createRequire(import.meta.url);
 function readCurrentLibrettoVersion() {
   const packageJsonPath = fileURLToPath(
     new URL("../../../package.json", import.meta.url)
@@ -464,36 +470,114 @@ function formatBuildError(error) {
     return `${location} ${entry.text ?? error.message}`;
   }).join("\n");
 }
-function extractExportNamesFromEsmBundle(bundleSource) {
-  const exportNames = /* @__PURE__ */ new Set();
-  for (const entry of bundleSource.matchAll(
-    /export\s+(?:const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g
-  )) {
-    exportNames.add(entry[1]);
-  }
-  for (const entry of bundleSource.matchAll(/export\s+\{([^}]+)\};/g)) {
-    const specifiers = entry[1]?.split(",") ?? [];
-    for (const specifier of specifiers) {
-      const trimmed = specifier.trim();
-      if (!trimmed) {
-        continue;
+function getGeneratedWorkflowExportName(index) {
+  return `workflow_${index}`;
+}
+function getPackageNameFromImportPath(importPath) {
+  if (importPath.startsWith("@")) {
+    return importPath.split("/").slice(0, 2).join("/");
+  }
+  return importPath.split("/")[0] ?? importPath;
+}
+function createExternalDiscoveryStub() {
+  const stub = (() => createExternalDiscoveryStub());
+  return new Proxy(stub, {
+    apply: () => createExternalDiscoveryStub(),
+    construct: () => createExternalDiscoveryStub(),
+    get: (_target, property) => {
+      if (property === "__esModule") {
+        return true;
       }
-      const aliasMatch = trimmed.match(
-        /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*|default)$/
-      );
-      if (aliasMatch?.[2]) {
-        exportNames.add(aliasMatch[2]);
-        continue;
+      if (property === "default") {
+        return createExternalDiscoveryStub();
       }
-      if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
-        exportNames.add(trimmed);
+      if (property === Symbol.toPrimitive) {
+        return () => "";
       }
+      return createExternalDiscoveryStub();
     }
+  });
+}
+function createDiscoveryLibrettoModule(workflowNames) {
+  const moduleShape = {
+    LIBRETTO_WORKFLOW_BRAND,
+    workflow: (name) => {
+      workflowNames.add(name);
+      return {
+        [LIBRETTO_WORKFLOW_BRAND]: true,
+        name,
+        async run() {
+          return void 0;
+        }
+      };
+    }
+  };
+  return new Proxy(moduleShape, {
+    get(target, property) {
+      if (property in target) {
+        return target[property];
+      }
+      if (property === "__esModule") {
+        return true;
+      }
+      return createExternalDiscoveryStub();
+    }
+  });
+}
+function discoverBundledWorkflowNames(args) {
+  const discoveryPath = join(
+    args.absSourceDir,
+    `.libretto-deploy-discovery-${process.pid}-${Date.now()}.cjs`
+  );
+  const originalRequire = Module.prototype.require;
+  const workflowNames = /* @__PURE__ */ new Set();
+  const discoveryLibrettoModule = createDiscoveryLibrettoModule(workflowNames);
+  let loadedModuleExports = null;
+  try {
+    writeFileSync(discoveryPath, args.bundleBuffer);
+    Module.prototype.require = function patchedRequire(id) {
+      const packageName = getPackageNameFromImportPath(id);
+      if (packageName === "libretto") {
+        return discoveryLibrettoModule;
+      }
+      if (packageName !== "libretto" && args.externalPackages.has(packageName)) {
+        return createExternalDiscoveryStub();
+      }
+      return originalRequire.call(this, id);
+    };
+    loadedModuleExports = require2(discoveryPath);
+  } catch (error) {
+    throw new Error(
+      `Failed to evaluate deploy entry point ${args.absEntryPoint} while discovering workflows.
+${formatBuildError(error)}`
+    );
+  } finally {
+    Module.prototype.require = originalRequire;
+    delete require2.cache?.[discoveryPath];
+    rmSync(discoveryPath, { force: true });
   }
-  if (/\bexport\s+default\b/m.test(bundleSource)) {
-    exportNames.add("default");
+  const discoveredWorkflowNames = [...workflowNames].sort(
+    (left, right) => left.localeCompare(right)
+  );
+  if (discoveredWorkflowNames.length === 0) {
+    throw new Error(
+      `No workflows were found in ${args.absEntryPoint}. Import the workflow files you want to deploy from the entry point, or export a workflow directly from it.`
+    );
+  }
+  const exportedWorkflowNames = new Set(
+    getWorkflowsFromModuleExports(loadedModuleExports ?? {}).map(
+      (workflow) => workflow.name
+    )
+  );
+  const nonExportedWorkflowNames = discoveredWorkflowNames.filter(
+    (name) => !exportedWorkflowNames.has(name)
+  );
+  if (nonExportedWorkflowNames.length > 0) {
+    throw new Error(
+      `Workflows discovered in ${args.absEntryPoint} must be exported from the deploy entry point. Re-export them from the entry point or export them through a \`workflows\` object. Non-exported workflows: ${nonExportedWorkflowNames.join(", ")}`
+    );
   }
-  return [...exportNames];
+  return discoveredWorkflowNames;
 }
 function createBootstrapSource(args) {
   const bundleHash = createHash("sha256").update(args.bundleBuffer).digest("hex").slice(0, 16);
@@ -501,17 +585,15 @@ function createBootstrapSource(args) {
     "base64"
   );
   const outputPrefix = `${normalizePackageName(args.deploymentName)}-`;
-  const hasDefaultExport = args.exportNames.includes("default");
-  const exportLines = args.exportNames.filter((name) => name !== "default").map(
-    (name) => `export const ${name} = createWorkflowProxy(${JSON.stringify(name)});`
+  const exportLines = args.workflowNames.map(
+    (name, index) => `export const ${getGeneratedWorkflowExportName(index)} = createWorkflowProxy(${JSON.stringify(name)});`
   ).join("\n");
-  const defaultExportLine = hasDefaultExport ? 'export default createWorkflowProxy("default");' : "";
   return `import { createRequire } from "node:module";
 import { existsSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { gunzipSync } from "node:zlib";
-import { workflow } from "libretto";
+import { getWorkflowFromModuleExports, workflow } from "libretto";
 
 const BUNDLE_HASH = ${JSON.stringify(bundleHash)};
 const BUNDLE_GZIP_BASE64 = ${JSON.stringify(bundleBase64)};
@@ -534,13 +616,13 @@ function ensureBundleFile() {
   return BUNDLE_FILENAME;
 }
 
-function createWorkflowProxy(exportName) {
-  return workflow(exportName, async (ctx, input) => {
+function createWorkflowProxy(workflowName) {
+  return workflow(workflowName, async (ctx, input) => {
     const impl = nativeRequire(ensureBundleFile());
-    const target = impl[exportName];
+    const target = getWorkflowFromModuleExports(impl, workflowName);
     if (!target || typeof target.run !== "function") {
       throw new Error(
-        \`Expected workflow export "\${exportName}" to be available in the bundled deployment implementation.\`,
+        \`Expected exported workflow "\${workflowName}" to be available in the bundled deployment implementation.\`,
       );
     }
     return await target.run(ctx, input);
@@ -548,7 +630,6 @@ function createWorkflowProxy(exportName) {
 }
 
 ${exportLines}
-${defaultExportLine}
 `;
 }
 async function writeBundledDeployEntrypoint(args) {
@@ -576,39 +657,18 @@ async function writeBundledDeployEntrypoint(args) {
         "Bundler did not produce a deployment implementation file."
       );
     }
-    const exportBuild = await build({
-      absWorkingDir: args.absSourceDir,
-      bundle: true,
-      entryPoints: [args.absEntryPoint],
-      external: [...args.externalPackages],
-      format: "esm",
-      outfile: "entry-exports.js",
-      platform: "node",
-      plugins: [
-        workspaceSourcePlugin(args.workspacePackages, args.externalPackages)
-      ],
-      splitting: false,
-      target: "node20",
-      write: false
+    const workflowNames = discoverBundledWorkflowNames({
+      absEntryPoint: args.absEntryPoint,
+      absSourceDir: args.absSourceDir,
+      bundleBuffer: Buffer.from(bundledImplementation.contents),
+      externalPackages: args.externalPackages
     });
-    const bundledExports = exportBuild.outputFiles?.find(
-      (file) => file.path.endsWith("entry-exports.js")
-    );
-    if (!bundledExports) {
-      throw new Error("Bundler did not produce an export analysis file.");
-    }
-    const exportNames = extractExportNamesFromEsmBundle(bundledExports.text);
-    if (exportNames.length === 0) {
-      throw new Error(
-        `No named exports were found in ${args.absEntryPoint}. Hosted deploy expects the entry point to export one or more workflows.`
-      );
-    }
     writeFileSync(
       join(args.outputDir, "index.js"),
       createBootstrapSource({
         bundleBuffer: Buffer.from(bundledImplementation.contents),
         deploymentName: args.deploymentName,
-        exportNames
+        workflowNames
       })
     );
   } catch (error) {

package/dist/cli/core/providers/browserbase.js

@@ -0,0 +1,53 @@
+function createBrowserbaseProvider() {
+  const apiKey = process.env.BROWSERBASE_API_KEY;
+  if (!apiKey)
+    throw new Error(
+      "BROWSERBASE_API_KEY is required for Browserbase provider."
+    );
+  const projectId = process.env.BROWSERBASE_PROJECT_ID;
+  if (!projectId)
+    throw new Error(
+      "BROWSERBASE_PROJECT_ID is required for Browserbase provider."
+    );
+  const endpoint = process.env.BROWSERBASE_ENDPOINT ?? "https://api.browserbase.com";
+  return {
+    async createSession() {
+      const resp = await fetch(`${endpoint}/v1/sessions`, {
+        method: "POST",
+        headers: {
+          "X-BB-API-Key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ projectId })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(`Browserbase API error (${resp.status}): ${body}`);
+      }
+      const json = await resp.json();
+      return {
+        sessionId: json.id,
+        cdpEndpoint: json.connectUrl
+      };
+    },
+    async closeSession(sessionId) {
+      const resp = await fetch(`${endpoint}/v1/sessions/${sessionId}`, {
+        method: "POST",
+        headers: {
+          "X-BB-API-Key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ status: "REQUEST_RELEASE" })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(
+          `Browserbase API error closing session ${sessionId} (${resp.status}): ${body}`
+        );
+      }
+    }
+  };
+}
+export {
+  createBrowserbaseProvider
+};

package/dist/cli/core/providers/index.js

@@ -0,0 +1,48 @@
+import { readLibrettoConfig } from "../config.js";
+import { createBrowserbaseProvider } from "./browserbase.js";
+import { createKernelProvider } from "./kernel.js";
+import { createLibrettoCloudProvider } from "./libretto-cloud.js";
+const VALID_PROVIDERS = /* @__PURE__ */ new Set(["local", "kernel", "browserbase", "libretto-cloud"]);
+function assertValidProviderName(value, source) {
+  if (!VALID_PROVIDERS.has(value)) {
+    throw new Error(
+      `Invalid provider "${value}" from ${source}. Valid providers: ${[...VALID_PROVIDERS].join(", ")}`
+    );
+  }
+  return value;
+}
+function resolveProviderName(cliFlag) {
+  if (cliFlag) {
+    return assertValidProviderName(cliFlag, "--provider flag");
+  }
+  const envVar = process.env.LIBRETTO_PROVIDER;
+  if (envVar) {
+    return assertValidProviderName(envVar, "LIBRETTO_PROVIDER env var");
+  }
+  const config = readLibrettoConfig();
+  if (config.provider) {
+    return assertValidProviderName(config.provider, "config file");
+  }
+  return "local";
+}
+function getCloudProviderApi(name) {
+  switch (name) {
+    case "kernel":
+      return createKernelProvider();
+    case "browserbase":
+      return createBrowserbaseProvider();
+    case "libretto-cloud":
+      console.warn(
+        "Note: The libretto-cloud provider is in alpha."
+      );
+      return createLibrettoCloudProvider();
+    default:
+      throw new Error(
+        `Unknown provider "${name}". Valid cloud providers: kernel, browserbase`
+      );
+  }
+}
+export {
+  getCloudProviderApi,
+  resolveProviderName
+};

package/dist/cli/core/providers/kernel.js

@@ -0,0 +1,46 @@
+function createKernelProvider() {
+  const apiKey = process.env.KERNEL_API_KEY;
+  if (!apiKey)
+    throw new Error("KERNEL_API_KEY is required for Kernel provider.");
+  const endpoint = process.env.KERNEL_ENDPOINT ?? "https://api.onkernel.com";
+  return {
+    async createSession() {
+      const resp = await fetch(`${endpoint}/browsers`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          headless: process.env.KERNEL_HEADLESS !== "false",
+          stealth: process.env.KERNEL_STEALTH === "true",
+          timeout_seconds: Number(process.env.KERNEL_TIMEOUT_SECONDS ?? 300)
+        })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(`Kernel API error (${resp.status}): ${body}`);
+      }
+      const json = await resp.json();
+      return {
+        sessionId: json.session_id,
+        cdpEndpoint: json.cdp_ws_url
+      };
+    },
+    async closeSession(sessionId) {
+      const resp = await fetch(`${endpoint}/browsers/${sessionId}`, {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(
+          `Kernel API error closing session ${sessionId} (${resp.status}): ${body}`
+        );
+      }
+    }
+  };
+}
+export {
+  createKernelProvider
+};

package/dist/cli/core/providers/libretto-cloud.js

@@ -0,0 +1,58 @@
+function createLibrettoCloudProvider() {
+  const apiKey = process.env.LIBRETTO_API_KEY;
+  if (!apiKey)
+    throw new Error(
+      "LIBRETTO_API_KEY is required for the Libretto Cloud provider."
+    );
+  const apiUrl = process.env.LIBRETTO_API_URL;
+  if (!apiUrl)
+    throw new Error(
+      "LIBRETTO_API_URL is required for the Libretto Cloud provider."
+    );
+  const endpoint = apiUrl.replace(/\/$/, "");
+  return {
+    async createSession() {
+      const timeoutSeconds = Number(
+        process.env.LIBRETTO_TIMEOUT_SECONDS ?? 7200
+      );
+      const resp = await fetch(`${endpoint}/v1/sessions/create`, {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ timeout_seconds: timeoutSeconds })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(
+          `Libretto Cloud API error (${resp.status}): ${body}`
+        );
+      }
+      const json = await resp.json();
+      return {
+        sessionId: json.session_id,
+        cdpEndpoint: json.cdp_url
+      };
+    },
+    async closeSession(sessionId) {
+      const resp = await fetch(`${endpoint}/v1/sessions/close`, {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ session_id: sessionId })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(
+          `Libretto Cloud API error closing session ${sessionId} (${resp.status}): ${body}`
+        );
+      }
+    }
+  };
+}
+export {
+  createLibrettoCloudProvider
+};

package/dist/cli/core/readonly-exec.js

@@ -0,0 +1,231 @@
+const PAGE_READ_METHODS = /* @__PURE__ */ new Set([
+  "url",
+  "title",
+  "content",
+  "pageErrors",
+  "viewportSize",
+  "waitForLoadState",
+  "waitForRequest",
+  "waitForResponse",
+  "waitForURL"
+]);
+const PAGE_LOCATOR_FACTORY_METHODS = /* @__PURE__ */ new Set([
+  "locator",
+  "getByRole",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "getByTestId"
+]);
+const PAGE_ALLOWED_PROPERTIES = /* @__PURE__ */ new Set([]);
+const LOCATOR_READ_METHODS = /* @__PURE__ */ new Set([
+  "textContent",
+  "innerText",
+  "allTextContents",
+  "allInnerTexts",
+  "ariaSnapshot",
+  "boundingBox",
+  "count",
+  "getAttribute",
+  "inputValue",
+  "isChecked",
+  "isDisabled",
+  "isEditable",
+  "isEnabled",
+  "isVisible",
+  "isHidden",
+  "waitFor"
+]);
+const LOCATOR_FACTORY_METHODS = /* @__PURE__ */ new Set([
+  "locator",
+  "getByRole",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "getByTestId",
+  "filter",
+  "and",
+  "or",
+  "first",
+  "last",
+  "nth"
+]);
+const LOCATOR_COLLECTION_FACTORY_METHODS = /* @__PURE__ */ new Set(["all"]);
+const LOCATOR_SCROLL_METHODS = /* @__PURE__ */ new Set(["scrollIntoViewIfNeeded"]);
+const LOCATOR_ALLOWED_PROPERTIES = /* @__PURE__ */ new Set([]);
+const readonlyPageCache = /* @__PURE__ */ new WeakMap();
+const readonlyLocatorCache = /* @__PURE__ */ new WeakMap();
+function markActivity(onActivity) {
+  onActivity?.();
+}
+class ReadonlyExecDeniedError extends Error {
+  constructor(message) {
+    super(`ReadonlyExecDenied: ${message}`);
+    this.name = "ReadonlyExecDenied";
+  }
+}
+function denyOperation(targetName, method) {
+  throw new ReadonlyExecDeniedError(
+    `${targetName}.${method} is blocked in readonly-exec`
+  );
+}
+function wrapLocatorForReadonlyExec(locator, options = {}) {
+  const cached = readonlyLocatorCache.get(locator);
+  if (cached) return cached;
+  const proxy = new Proxy(locator, {
+    get(target, prop, receiver) {
+      if (typeof prop !== "string") {
+        return Reflect.get(target, prop, receiver);
+      }
+      const value = Reflect.get(target, prop, target);
+      if (typeof value !== "function") {
+        if (LOCATOR_ALLOWED_PROPERTIES.has(prop)) {
+          return value;
+        }
+        return denyOperation("locator", prop);
+      }
+      if (LOCATOR_READ_METHODS.has(prop)) {
+        return (...args) => {
+          const result = value.apply(target, args);
+          markActivity(options.onActivity);
+          return result;
+        };
+      }
+      if (LOCATOR_FACTORY_METHODS.has(prop)) {
+        return (...args) => {
+          const nextLocator = value.apply(target, args);
+          markActivity(options.onActivity);
+          return wrapLocatorForReadonlyExec(nextLocator, options);
+        };
+      }
+      if (LOCATOR_COLLECTION_FACTORY_METHODS.has(prop)) {
+        return async (...args) => {
+          const locators = await value.apply(target, args);
+          markActivity(options.onActivity);
+          return locators.map(
+            (locator2) => wrapLocatorForReadonlyExec(locator2, options)
+          );
+        };
+      }
+      if (LOCATOR_SCROLL_METHODS.has(prop)) {
+        return async (...args) => {
+          await value.apply(target, args);
+          markActivity(options.onActivity);
+        };
+      }
+      return (..._args) => denyOperation("locator", prop);
+    }
+  });
+  readonlyLocatorCache.set(locator, proxy);
+  return proxy;
+}
+function wrapPageForReadonlyExec(page, options = {}) {
+  const cached = readonlyPageCache.get(page);
+  if (cached) return cached;
+  const proxy = new Proxy(page, {
+    get(target, prop, receiver) {
+      if (typeof prop !== "string") {
+        return Reflect.get(target, prop, receiver);
+      }
+      const value = Reflect.get(target, prop, target);
+      if (typeof value !== "function") {
+        if (PAGE_ALLOWED_PROPERTIES.has(prop)) {
+          return value;
+        }
+        return denyOperation("page", prop);
+      }
+      if (PAGE_READ_METHODS.has(prop)) {
+        return (...args) => {
+          const result = value.apply(target, args);
+          markActivity(options.onActivity);
+          return result;
+        };
+      }
+      if (PAGE_LOCATOR_FACTORY_METHODS.has(prop)) {
+        return (...args) => {
+          const locator = value.apply(target, args);
+          markActivity(options.onActivity);
+          return wrapLocatorForReadonlyExec(locator, options);
+        };
+      }
+      return (..._args) => denyOperation("page", prop);
+    }
+  });
+  readonlyPageCache.set(page, proxy);
+  return proxy;
+}
+function resolveRequestMethod(input, init) {
+  const requestMethod = typeof Request !== "undefined" && input instanceof Request ? input.method : void 0;
+  return (init?.method ?? requestMethod ?? "GET").toUpperCase();
+}
+function assertReadonlyRequestBodyAllowed(input, init) {
+  if (init?.body !== void 0) {
+    throw new ReadonlyExecDeniedError(
+      "request bodies are blocked in readonly-exec"
+    );
+  }
+  if (typeof Request !== "undefined" && input instanceof Request && input.body !== null) {
+    throw new ReadonlyExecDeniedError(
+      "request bodies are blocked in readonly-exec"
+    );
+  }
+}
+function createReadonlyExecHelpers(page, options = {}) {
+  const readonlyPage = wrapPageForReadonlyExec(page, options);
+  const execState = {};
+  return {
+    page: readonlyPage,
+    state: execState,
+    // Playwright has no native viewport scroll method — only locator.scrollIntoViewIfNeeded().
+    // Arbitrary scrolling requires page.evaluate(), which is blocked by the readonly proxy
+    // since it can run arbitrary code. This helper calls evaluate on the raw (unwrapped) page,
+    // scoped to just window.scrollBy.
+    scrollBy: async (deltaX, deltaY) => {
+      await page.evaluate(
+        ([x, y]) => {
+          window.scrollBy(x, y);
+        },
+        [deltaX, deltaY]
+      );
+      markActivity(options.onActivity);
+    },
+    get: async (input, init) => {
+      const method = resolveRequestMethod(input, init);
+      if (method !== "GET" && method !== "HEAD") {
+        throw new ReadonlyExecDeniedError(
+          `${method} requests are blocked in readonly-exec`
+        );
+      }
+      assertReadonlyRequestBodyAllowed(input, init);
+      markActivity(options.onActivity);
+      return await fetch(input, {
+        ...init,
+        method
+      });
+    },
+    // Shadows the global Node.js fetch to prevent unrestricted HTTP access.
+    // Without this, agent code would fall through to the global fetch (POST, PUT, DELETE, etc.).
+    fetch: () => {
+      throw new ReadonlyExecDeniedError(
+        "fetch is blocked in readonly-exec; use get() instead"
+      );
+    },
+    console,
+    setTimeout,
+    setInterval,
+    clearTimeout,
+    clearInterval,
+    URL,
+    Buffer
+  };
+}
+export {
+  ReadonlyExecDeniedError,
+  createReadonlyExecHelpers,
+  wrapLocatorForReadonlyExec,
+  wrapPageForReadonlyExec
+};