@conto_finance/sdk 0.3.1 → 0.5.0

package/dist/browserbase.js

@@ -0,0 +1,1985 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browserbase.ts
+var browserbase_exports = {};
+__export(browserbase_exports, {
+  BROWSERBASE_CONNECT_ORIGINS: () => BROWSERBASE_CONNECT_ORIGINS,
+  BrowserbaseSessionError: () => BrowserbaseSessionError,
+  createBrowserbaseGuardedPlaywrightCheckoutRuntimeHost: () => createBrowserbaseGuardedPlaywrightCheckoutRuntimeHost,
+  createBrowserbaseSessionHandoffAssertion: () => createBrowserbaseSessionHandoffAssertion
+});
+module.exports = __toCommonJS(browserbase_exports);
+var import_node_crypto3 = require("crypto");
+
+// src/playwright.ts
+var import_node_crypto2 = require("crypto");
+
+// src/browser-checkout.ts
+var import_node_crypto = require("crypto");
+var MAX_URL_LENGTH = 2048;
+var MAX_LOCATOR_LENGTH = 1024;
+var MAX_TEXT_LENGTH = 500;
+var BrowserCheckoutTargetVerificationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BrowserCheckoutTargetVerificationError";
+  }
+};
+function invalid(message) {
+  throw new BrowserCheckoutTargetVerificationError("BROWSER_CHECKOUT_TARGET_INVALID", message);
+}
+function canonicalHttpsUrl(value, field) {
+  if (typeof value !== "string" || !value || value.length > MAX_URL_LENGTH) {
+    invalid(`${field} is invalid.`);
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    invalid(`${field} is invalid.`);
+  }
+  if (url.protocol !== "https:" || url.username || url.password) {
+    invalid(`${field} must use HTTPS without credentials.`);
+  }
+  url.hostname = url.hostname.toLowerCase();
+  url.hash = "";
+  return url.toString();
+}
+function canonicalText(value, field, options = {}) {
+  if (value === void 0) {
+    if (options.required) invalid(`${field} is required.`);
+    return null;
+  }
+  if (typeof value !== "string") invalid(`${field} is invalid.`);
+  const trimmed = value.trim();
+  const normalized = options.collapseWhitespace === false ? trimmed : trimmed.replace(/\s+/g, " ");
+  if (options.required && !normalized || normalized.length > (options.maxLength ?? MAX_TEXT_LENGTH)) {
+    invalid(`${field} is invalid.`);
+  }
+  return normalized || null;
+}
+function canonicalizeBrowserCheckoutTarget(snapshot) {
+  if (!snapshot || typeof snapshot !== "object") {
+    invalid("The browser checkout target is invalid.");
+  }
+  if (typeof snapshot.disabled !== "boolean") {
+    invalid("target.disabled is invalid.");
+  }
+  const tagName = canonicalText(snapshot.tagName, "target.tagName", {
+    required: true,
+    maxLength: 80
+  });
+  return Object.freeze({
+    pageUrl: canonicalHttpsUrl(snapshot.pageUrl, "target.pageUrl"),
+    locator: canonicalText(snapshot.locator, "target.locator", {
+      collapseWhitespace: false,
+      required: true,
+      maxLength: MAX_LOCATOR_LENGTH
+    }) ?? "",
+    tagName: (tagName ?? "").toLowerCase(),
+    role: canonicalText(snapshot.role, "target.role", { maxLength: 80 })?.toLowerCase() ?? null,
+    accessibleName: canonicalText(snapshot.accessibleName, "target.accessibleName"),
+    targetUrl: snapshot.targetUrl ? canonicalHttpsUrl(snapshot.targetUrl, "target.targetUrl") : null,
+    formAction: snapshot.formAction ? canonicalHttpsUrl(snapshot.formAction, "target.formAction") : null,
+    opensNewPage: snapshot.opensNewPage === true,
+    disabled: snapshot.disabled
+  });
+}
+function fingerprintBrowserCheckoutTarget(snapshot) {
+  const canonical = canonicalizeBrowserCheckoutTarget(snapshot);
+  const digest = (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
+  return `browser_target_sha256_${digest}`;
+}
+function createVerifiedBrowserCheckoutDriver(resolver) {
+  if (!resolver || typeof resolver.resolve !== "function") {
+    invalid("A browser checkout target resolver is required.");
+  }
+  return Object.freeze({
+    async dispatch(input) {
+      const target = await resolver.resolve(input);
+      if (!target) {
+        throw new BrowserCheckoutTargetVerificationError(
+          "BROWSER_CHECKOUT_TARGET_NOT_FOUND",
+          "The approved browser checkout target was not found."
+        );
+      }
+      if (typeof target.dispatch !== "function") {
+        invalid("The resolved browser checkout target cannot be dispatched.");
+      }
+      const canonical = canonicalizeBrowserCheckoutTarget(target.snapshot);
+      const approvedPageUrl = canonicalHttpsUrl(input.action.pageUrl, "action.pageUrl");
+      const approvedTargetUrl = input.action.targetUrl ? canonicalHttpsUrl(input.action.targetUrl, "action.targetUrl") : null;
+      const observedDestinations = [canonical.targetUrl, canonical.formAction].filter(
+        (value) => value !== null
+      );
+      const destinationsAreBound = approvedTargetUrl === null ? observedDestinations.length === 0 : observedDestinations.length > 0 && observedDestinations.every((value) => value === approvedTargetUrl);
+      if (canonical.pageUrl !== approvedPageUrl || !destinationsAreBound || fingerprintBrowserCheckoutTarget(target.snapshot) !== input.action.targetFingerprint.trim()) {
+        throw new BrowserCheckoutTargetVerificationError(
+          "BROWSER_CHECKOUT_TARGET_CHANGED",
+          "The browser checkout target changed after Conto authorization."
+        );
+      }
+      if (canonical.disabled) {
+        throw new BrowserCheckoutTargetVerificationError(
+          "BROWSER_CHECKOUT_TARGET_DISABLED",
+          "The approved browser checkout target is disabled."
+        );
+      }
+      return target.dispatch();
+    }
+  });
+}
+
+// src/playwright.ts
+var DEFAULT_CLICK_TIMEOUT_MS = 3e4;
+var MAX_CLICK_TIMEOUT_MS = 12e4;
+var DEFAULT_POPUP_TIMEOUT_MS = 5e3;
+var MAX_POPUP_TIMEOUT_MS = 3e4;
+var DEFAULT_TARGET_TTL_MS = 10 * 6e4;
+var MAX_TARGET_TTL_MS = 60 * 6e4;
+var TARGET_STORE_ENVELOPE_VERSION = 1;
+var DEFAULT_HTTP_BODY_LIMIT_BYTES = 64 * 1024;
+var MAX_HTTP_BODY_LIMIT_BYTES = 1024 * 1024;
+var DEFAULT_CDP_SESSION_LIMIT = 100;
+var MAX_CDP_SESSION_LIMIT = 1e3;
+var SESSION_OBSERVATION_TARGET_LIMIT = 50;
+var SESSION_OBSERVATION_LABEL_LIMIT = 160;
+var SESSION_OBSERVATION_TITLE_LIMIT = 240;
+var SESSION_OBSERVATION_SELECTOR = 'a[href], button, input[type="submit"], input[type="button"], [role="button"], [role="link"]';
+function verificationError(code, message) {
+  return new BrowserCheckoutTargetVerificationError(code, message);
+}
+function requiredText(value, field, maxLength) {
+  if (typeof value !== "string") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", `${field} is required.`);
+  }
+  const normalized = value.trim();
+  if (!normalized || normalized.length > maxLength) {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", `${field} is invalid.`);
+  }
+  return normalized;
+}
+function clickTimeout(value) {
+  const resolved = value ?? DEFAULT_CLICK_TIMEOUT_MS;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0 || resolved > MAX_CLICK_TIMEOUT_MS) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "clickTimeoutMs must be a positive integer no greater than 120000."
+    );
+  }
+  return resolved;
+}
+function targetTtl(value) {
+  const resolved = value ?? DEFAULT_TARGET_TTL_MS;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0 || resolved > MAX_TARGET_TTL_MS) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "targetTtlMs must be a positive integer no greater than 3600000."
+    );
+  }
+  return resolved;
+}
+function popupTimeout(value) {
+  const resolved = value ?? DEFAULT_POPUP_TIMEOUT_MS;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0 || resolved > MAX_POPUP_TIMEOUT_MS) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "popupTimeoutMs must be a positive integer no greater than 30000."
+    );
+  }
+  return resolved;
+}
+function currentDate(now) {
+  const value = now();
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "The Playwright checkout clock returned an invalid date."
+    );
+  }
+  return value;
+}
+function observedHttpsPageUrl(value) {
+  if (typeof value !== "string" || !value || value.length > 2048) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "The observed checkout page URL is invalid."
+    );
+  }
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.username || url.password) throw new Error("unsafe URL");
+    return value;
+  } catch {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "The observed checkout page URL must use HTTPS without credentials."
+    );
+  }
+}
+function targetStoreKey(input) {
+  return `${input.browserSessionId}\0${input.targetFingerprint}`;
+}
+function createInMemoryPlaywrightCheckoutTargetStore() {
+  const registrations = /* @__PURE__ */ new Map();
+  return Object.freeze({
+    async put(registration) {
+      registrations.set(targetStoreKey(registration), Object.freeze({ ...registration }));
+    },
+    async get(input) {
+      return registrations.get(targetStoreKey(input)) ?? null;
+    },
+    async delete(input) {
+      registrations.delete(targetStoreKey(input));
+    }
+  });
+}
+function encryptedStoreKey(namespace, input) {
+  const digest = (0, import_node_crypto2.createHash)("sha256").update(namespace).update("\0").update(input.browserSessionId).update("\0").update(input.targetFingerprint).digest("hex");
+  return `${namespace}:${digest}`;
+}
+function validRegistration(value, expected) {
+  if (!value || typeof value !== "object") return false;
+  const registration = value;
+  return typeof registration.browserSessionId === "string" && registration.browserSessionId.length > 0 && registration.browserSessionId.length <= 255 && typeof registration.targetFingerprint === "string" && /^browser_target_sha256_[0-9a-f]{64}$/.test(registration.targetFingerprint) && typeof registration.locator === "string" && registration.locator.trim().length > 0 && registration.locator.length <= 1024 && typeof registration.expiresAt === "string" && !Number.isNaN(Date.parse(registration.expiresAt)) && (!expected || registration.browserSessionId === expected.browserSessionId && registration.targetFingerprint === expected.targetFingerprint);
+}
+function createEncryptedPlaywrightCheckoutTargetStore(config) {
+  if (!config || !config.blobStore || typeof config.blobStore.put !== "function" || typeof config.blobStore.get !== "function" || typeof config.blobStore.delete !== "function") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "blobStore is required.");
+  }
+  const key = Buffer.from(config.encryptionKey ?? []);
+  if (key.length !== 32) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "encryptionKey must contain exactly 32 bytes."
+    );
+  }
+  const namespace = requiredText(
+    config.namespace ?? "conto:playwright-target:v1",
+    "namespace",
+    120
+  );
+  const now = config.now ?? (() => /* @__PURE__ */ new Date());
+  return Object.freeze({
+    async put(registration) {
+      if (!validRegistration(registration)) {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The Playwright checkout target registration is invalid."
+        );
+      }
+      if (Date.parse(registration.expiresAt) <= currentDate(now).getTime()) {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The Playwright checkout target registration is already expired."
+        );
+      }
+      const storageKey = encryptedStoreKey(namespace, registration);
+      const iv = (0, import_node_crypto2.randomBytes)(12);
+      const cipher = (0, import_node_crypto2.createCipheriv)("aes-256-gcm", key, iv);
+      cipher.setAAD(Buffer.from(storageKey));
+      const ciphertext = Buffer.concat([
+        cipher.update(JSON.stringify(registration), "utf8"),
+        cipher.final()
+      ]);
+      const envelope = JSON.stringify({
+        version: TARGET_STORE_ENVELOPE_VERSION,
+        iv: iv.toString("base64url"),
+        ciphertext: ciphertext.toString("base64url"),
+        tag: cipher.getAuthTag().toString("base64url")
+      });
+      await config.blobStore.put({
+        key: storageKey,
+        value: envelope,
+        expiresAt: registration.expiresAt
+      });
+    },
+    async get(input) {
+      const storageKey = encryptedStoreKey(namespace, input);
+      const envelopeText = await config.blobStore.get(storageKey);
+      if (envelopeText === null) return null;
+      try {
+        const envelope = JSON.parse(envelopeText);
+        if (envelope.version !== TARGET_STORE_ENVELOPE_VERSION || typeof envelope.iv !== "string" || typeof envelope.ciphertext !== "string" || typeof envelope.tag !== "string") {
+          throw new Error("invalid envelope");
+        }
+        const decipher = (0, import_node_crypto2.createDecipheriv)(
+          "aes-256-gcm",
+          key,
+          Buffer.from(envelope.iv, "base64url")
+        );
+        decipher.setAAD(Buffer.from(storageKey));
+        decipher.setAuthTag(Buffer.from(envelope.tag, "base64url"));
+        const plaintext = Buffer.concat([
+          decipher.update(Buffer.from(envelope.ciphertext, "base64url")),
+          decipher.final()
+        ]).toString("utf8");
+        const registration = JSON.parse(plaintext);
+        if (!validRegistration(registration, input)) throw new Error("invalid registration");
+        if (Date.parse(registration.expiresAt) <= currentDate(now).getTime()) {
+          await config.blobStore.delete(storageKey);
+          return null;
+        }
+        return Object.freeze({ ...registration });
+      } catch (error) {
+        if (error instanceof BrowserCheckoutTargetVerificationError) throw error;
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The encrypted Playwright checkout target registration cannot be verified."
+        );
+      }
+    },
+    async delete(input) {
+      await config.blobStore.delete(encryptedStoreKey(namespace, input));
+    }
+  });
+}
+async function exactElementHandle(page, locatorExpression) {
+  const locator = page.locator(locatorExpression);
+  const count = await locator.count();
+  if (count === 0) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_NOT_FOUND",
+      "The Playwright checkout target was not found."
+    );
+  }
+  if (count !== 1) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "The Playwright checkout locator must resolve to exactly one element."
+    );
+  }
+  const handle = await locator.elementHandle();
+  if (!handle) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_NOT_FOUND",
+      "The Playwright checkout target became unavailable."
+    );
+  }
+  return handle;
+}
+async function snapshotPlaywrightTarget(input) {
+  const handle = input.handle;
+  if (!handle) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_NOT_FOUND",
+      "The Playwright checkout target became unavailable."
+    );
+  }
+  const element = await handle.evaluate((node) => {
+    const html = node;
+    const tagName = html.tagName.toLowerCase();
+    const explicitRole = html.getAttribute("role")?.trim();
+    const inputType = html.getAttribute("type")?.trim().toLowerCase();
+    const implicitRole = tagName === "a" && html.href ? "link" : tagName === "button" || tagName === "input" && ["button", "image", "reset", "submit"].includes(inputType ?? "") ? "button" : void 0;
+    const accessibleName = html.getAttribute("aria-label")?.trim() || html.textContent?.trim() || html.value?.trim() || html.getAttribute("title")?.trim() || void 0;
+    const targetUrl = tagName === "a" && html.href ? html.href : void 0;
+    const explicitFormAction = html.getAttribute("formaction")?.trim();
+    const formAction = tagName === "button" || tagName === "input" && inputType === "submit" ? explicitFormAction ? new URL(explicitFormAction, document.baseURI).toString() : html.form?.action || void 0 : void 0;
+    const target = html.getAttribute("target")?.trim().toLowerCase() || html.getAttribute("formtarget")?.trim().toLowerCase() || html.form?.getAttribute("target")?.trim().toLowerCase();
+    return {
+      tagName,
+      role: explicitRole || implicitRole,
+      accessibleName,
+      targetUrl,
+      formAction,
+      opensNewPage: target === "_blank",
+      disabled: Boolean(html.disabled) || html.getAttribute("aria-disabled") === "true"
+    };
+  });
+  return {
+    pageUrl: input.page.url(),
+    locator: input.locator,
+    ...element
+  };
+}
+function boundDestination(snapshot) {
+  const destinations = [snapshot.targetUrl, snapshot.formAction].filter(
+    (value) => Boolean(value)
+  );
+  const unique = new Set(destinations);
+  if (unique.size > 1) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "The checkout target exposes conflicting navigation and form destinations."
+    );
+  }
+  return destinations[0];
+}
+function createPlaywrightCheckoutAdapter(config) {
+  if (!config || typeof config.pageForSession !== "function") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "pageForSession is required.");
+  }
+  const store = config.targetStore ?? createInMemoryPlaywrightCheckoutTargetStore();
+  const timeout = clickTimeout(config.clickTimeoutMs);
+  const popupWait = popupTimeout(config.popupTimeoutMs);
+  const ttl = targetTtl(config.targetTtlMs);
+  const now = config.now ?? (() => /* @__PURE__ */ new Date());
+  async function pageForSession(browserSessionId) {
+    const page = await config.pageForSession(browserSessionId);
+    if (!page) {
+      throw verificationError(
+        "BROWSER_CHECKOUT_TARGET_NOT_FOUND",
+        "The privileged Playwright page was not found for this browser session."
+      );
+    }
+    return page;
+  }
+  const driver = createVerifiedBrowserCheckoutDriver({
+    resolve: async ({ authorization, browserSessionId, action }) => {
+      const registration = await store.get({
+        browserSessionId,
+        targetFingerprint: action.targetFingerprint
+      });
+      if (!registration || !validRegistration(registration) || registration.browserSessionId !== browserSessionId || registration.browserSessionId !== authorization.browserSessionId || registration.targetFingerprint !== action.targetFingerprint) {
+        return null;
+      }
+      if (Date.parse(registration.expiresAt) <= currentDate(now).getTime()) {
+        await store.delete({ browserSessionId, targetFingerprint: action.targetFingerprint });
+        return null;
+      }
+      await store.delete({ browserSessionId, targetFingerprint: action.targetFingerprint });
+      const page = await pageForSession(browserSessionId);
+      const pageUrlBeforeClick = page.url();
+      const handle = await exactElementHandle(page, registration.locator);
+      const snapshot = await snapshotPlaywrightTarget({
+        page,
+        locator: registration.locator,
+        handle
+      });
+      return {
+        snapshot,
+        dispatch: async () => {
+          let popupPage = null;
+          let resolvePopup;
+          const popupEvent = new Promise((resolve) => {
+            resolvePopup = resolve;
+          });
+          const capturePopup = (popup) => {
+            popupPage = popup;
+            resolvePopup?.(popup);
+          };
+          page.on("popup", capturePopup);
+          try {
+            await handle.click({ timeout });
+            if (snapshot.opensNewPage && !popupPage) {
+              let timer;
+              try {
+                popupPage = await Promise.race([
+                  popupEvent,
+                  new Promise((_resolve, reject) => {
+                    timer = setTimeout(
+                      () => reject(
+                        verificationError(
+                          "BROWSER_CHECKOUT_TARGET_NOT_FOUND",
+                          "The approved checkout target did not open its declared page."
+                        )
+                      ),
+                      popupWait
+                    );
+                  })
+                ]);
+              } finally {
+                if (timer) clearTimeout(timer);
+              }
+            }
+          } finally {
+            page.off("popup", capturePopup);
+          }
+          const observedAt = currentDate(now);
+          const observedPage = popupPage ?? page;
+          const pageUrl = observedHttpsPageUrl(observedPage.url());
+          const kind = popupPage ? "NEW_PAGE" : pageUrl === pageUrlBeforeClick ? "SAME_PAGE" : "PAGE_NAVIGATION";
+          return {
+            result: {
+              clicked: true,
+              pageUrl,
+              targetFingerprint: action.targetFingerprint,
+              browserOutcome: {
+                kind,
+                observedAt: observedAt.toISOString(),
+                settlement: "UNVERIFIED"
+              }
+            },
+            observation: {
+              reference: `browser_dispatch_${authorization.authorizationId}`,
+              observedAt: observedAt.toISOString(),
+              pageUrl
+            }
+          };
+        }
+      };
+    }
+  });
+  return Object.freeze({
+    async discover(input) {
+      const browserSessionId = requiredText(input.browserSessionId, "browserSessionId", 255);
+      const locator = requiredText(input.locator, "locator", 1024);
+      const page = await pageForSession(browserSessionId);
+      const handle = await exactElementHandle(page, locator);
+      const snapshot = await snapshotPlaywrightTarget({ page, locator, handle });
+      if (!snapshot.accessibleName) {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The Playwright checkout target must have an accessible name."
+        );
+      }
+      const targetFingerprint = fingerprintBrowserCheckoutTarget(snapshot);
+      const targetUrl = boundDestination(snapshot);
+      const action = Object.freeze({
+        kind: input.kind,
+        checkoutMethod: input.checkoutMethod,
+        pageUrl: snapshot.pageUrl,
+        targetFingerprint,
+        ...targetUrl ? { targetUrl } : {},
+        targetLabel: snapshot.accessibleName
+      });
+      const discoveredAt = currentDate(now);
+      await store.put({
+        browserSessionId,
+        targetFingerprint,
+        locator,
+        expiresAt: new Date(discoveredAt.getTime() + ttl).toISOString()
+      });
+      return Object.freeze({ action, targetFingerprint });
+    },
+    driver
+  });
+}
+function createGuardedPlaywrightCheckoutRuntime(config) {
+  if (!config || !config.conto || typeof config.conto.runGuardedCheckoutWithDriver !== "function") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "conto client is required.");
+  }
+  if (typeof config.dispatchAttemptFor !== "function") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "dispatchAttemptFor is required.");
+  }
+  const adapter = createPlaywrightCheckoutAdapter(config);
+  return Object.freeze({
+    discover: adapter.discover,
+    async run(input) {
+      const dispatchAttemptId = requiredText(
+        await config.dispatchAttemptFor({
+          idempotencyKey: input.idempotencyKey,
+          browserSessionId: input.browserSessionId,
+          targetFingerprint: input.action.targetFingerprint
+        }),
+        "dispatchAttemptId",
+        255
+      );
+      return config.conto.runGuardedCheckoutWithDriver(input, {
+        dispatchAttemptId,
+        driver: adapter.driver
+      });
+    }
+  });
+}
+function cdpSessionLimit(value) {
+  const resolved = value ?? DEFAULT_CDP_SESSION_LIMIT;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0 || resolved > MAX_CDP_SESSION_LIMIT) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "maxSessions must be a positive integer no greater than 1000."
+    );
+  }
+  return resolved;
+}
+function cdpSessionId(value) {
+  const normalized = requiredText(value, "browserSessionId", 255);
+  if (!/^[A-Za-z0-9._:-]+$/.test(normalized)) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "browserSessionId contains unsupported characters."
+    );
+  }
+  return normalized;
+}
+function secureCdpOrigin(value, field) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "wss:" && url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash || value !== url.origin) {
+      throw new Error("unsafe origin");
+    }
+    return url.origin;
+  } catch {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      `${field} must be an exact WSS or HTTPS origin.`
+    );
+  }
+}
+function secureCdpConnectUrl(value, allowedOrigins) {
+  const normalized = requiredText(value, "connectUrl", 4096);
+  try {
+    const url = new URL(normalized);
+    if (url.protocol !== "wss:" && url.protocol !== "https:" || url.username || url.password || url.hash || !allowedOrigins.has(url.origin)) {
+      throw new Error("unsafe connect URL");
+    }
+    return url.toString();
+  } catch {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "The remote browser connection URL is not permitted."
+    );
+  }
+}
+function isBrowser(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.contexts === "function" && typeof candidate.isConnected === "function" && typeof candidate.close === "function" && typeof candidate.on === "function";
+}
+function openBrowserPages(browser) {
+  return browser.contexts().flatMap((context) => context.pages()).filter((page) => !page.isClosed());
+}
+function createPlaywrightCdpSessionRegistry(config) {
+  if (!config || typeof config.connectUrlForSession !== "function") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "connectUrlForSession is required.");
+  }
+  if (typeof config.connectOverCDP !== "function") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "connectOverCDP is required.");
+  }
+  if (!Array.isArray(config.allowedConnectOrigins) || config.allowedConnectOrigins.length === 0) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "allowedConnectOrigins must contain at least one exact origin."
+    );
+  }
+  const allowedOrigins = new Set(
+    config.allowedConnectOrigins.map(
+      (origin, index) => secureCdpOrigin(origin, `allowedConnectOrigins[${index}]`)
+    )
+  );
+  if (allowedOrigins.size !== config.allowedConnectOrigins.length) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "allowedConnectOrigins must not contain duplicates."
+    );
+  }
+  const maximumSessions = cdpSessionLimit(config.maxSessions);
+  const connections = /* @__PURE__ */ new Map();
+  async function browserForSession(browserSessionId) {
+    let candidate;
+    try {
+      candidate = await config.connectUrlForSession(browserSessionId);
+    } catch {
+      throw verificationError(
+        "BROWSER_CHECKOUT_TARGET_INVALID",
+        "Remote browser session ownership could not be verified."
+      );
+    }
+    if (candidate === null) {
+      const revoked = connections.get(browserSessionId);
+      connections.delete(browserSessionId);
+      if (revoked) {
+        try {
+          const browser = await revoked;
+          if (browser?.isConnected()) await browser.close();
+        } catch {
+        }
+      }
+      return null;
+    }
+    const connectUrl = secureCdpConnectUrl(candidate, allowedOrigins);
+    const existing = connections.get(browserSessionId);
+    if (existing) {
+      const browser = await existing;
+      if (browser?.isConnected()) return browser;
+      connections.delete(browserSessionId);
+    }
+    if (connections.size >= maximumSessions) {
+      throw verificationError(
+        "BROWSER_CHECKOUT_TARGET_INVALID",
+        "The remote browser session limit has been reached."
+      );
+    }
+    const pending = (async () => {
+      let browser;
+      try {
+        browser = await config.connectOverCDP(connectUrl);
+      } catch {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The remote browser connection failed."
+        );
+      }
+      if (!isBrowser(browser) || !browser.isConnected()) {
+        try {
+          if (isBrowser(browser)) await browser.close();
+        } catch {
+        }
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The remote browser connection is invalid."
+        );
+      }
+      browser.on("disconnected", () => {
+        if (connections.get(browserSessionId) === pending) connections.delete(browserSessionId);
+      });
+      return browser;
+    })();
+    connections.set(browserSessionId, pending);
+    try {
+      const browser = await pending;
+      if (!browser) connections.delete(browserSessionId);
+      return browser;
+    } catch (error) {
+      if (connections.get(browserSessionId) === pending) connections.delete(browserSessionId);
+      throw error;
+    }
+  }
+  async function pageForSession(browserSessionIdValue) {
+    const browserSessionId = cdpSessionId(browserSessionIdValue);
+    const browser = await browserForSession(browserSessionId);
+    if (!browser) return null;
+    const pages = openBrowserPages(browser);
+    if (!config.selectPage) {
+      if (pages.length === 0) return null;
+      if (pages.length !== 1) {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The remote browser session has multiple open pages; configure an exact page selector."
+        );
+      }
+      return pages[0] ?? null;
+    }
+    const selected = await config.selectPage({
+      browserSessionId,
+      pages: Object.freeze([...pages])
+    });
+    if (selected === null) return null;
+    if (!pages.includes(selected) || selected.isClosed()) {
+      throw verificationError(
+        "BROWSER_CHECKOUT_TARGET_INVALID",
+        "The selected page does not belong to the requested browser session."
+      );
+    }
+    return selected;
+  }
+  async function closeSession(browserSessionIdValue) {
+    const browserSessionId = cdpSessionId(browserSessionIdValue);
+    const pending = connections.get(browserSessionId);
+    connections.delete(browserSessionId);
+    const browser = await pending;
+    if (browser?.isConnected()) await browser.close();
+  }
+  return Object.freeze({
+    pageForSession,
+    closeSession,
+    async close() {
+      const pending = [...connections.values()];
+      connections.clear();
+      const browsers = await Promise.allSettled(pending);
+      await Promise.allSettled(
+        browsers.flatMap(
+          (result) => result.status === "fulfilled" && result.value?.isConnected() ? [result.value.close()] : []
+        )
+      );
+    }
+  });
+}
+function boundedObservationText(value, maximum) {
+  if (typeof value !== "string") return "";
+  return value.replace(/[\u0000-\u001f\u007f\s]+/g, " ").trim().slice(0, maximum);
+}
+function observedHttpsOrigin(value) {
+  if (typeof value !== "string" || !value) return void 0;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.username || url.password || url.port && url.port !== "443") {
+      return void 0;
+    }
+    return url.origin;
+  } catch {
+    return void 0;
+  }
+}
+function createPlaywrightSessionObserver(config) {
+  if (!config || typeof config.pageForSession !== "function") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "pageForSession is required.");
+  }
+  const now = config.now ?? (() => /* @__PURE__ */ new Date());
+  return Object.freeze({
+    async observe(browserSessionIdValue) {
+      const browserSessionId = cdpSessionId(browserSessionIdValue);
+      const page = await config.pageForSession(browserSessionId);
+      if (!page || page.isClosed()) {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_NOT_FOUND",
+          "The owned browser page is unavailable."
+        );
+      }
+      const beforeUrl = page.url();
+      const pageOrigin = beforeUrl === "about:blank" ? null : observedHttpsOrigin(beforeUrl);
+      if (beforeUrl !== "about:blank" && !pageOrigin) {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The owned browser page is not at a trusted HTTPS origin."
+        );
+      }
+      let title;
+      let rawTargets;
+      try {
+        [title, rawTargets] = await Promise.all([
+          page.title(),
+          page.locator(SESSION_OBSERVATION_SELECTOR).evaluateAll((nodes, limit) => {
+            const candidates = [];
+            for (const [index, node] of nodes.entries()) {
+              const element = node;
+              const style = window.getComputedStyle(element);
+              if (element.hidden || style.display === "none" || style.visibility === "hidden" || element.getClientRects().length === 0) {
+                continue;
+              }
+              const tagName = element.tagName.toUpperCase();
+              const declaredRole = element.getAttribute("role")?.toLowerCase();
+              const role = tagName === "A" || declaredRole === "link" ? "LINK" : "BUTTON";
+              const inputValue = tagName === "INPUT" ? element.value : void 0;
+              const label = element.getAttribute("aria-label") || element.getAttribute("title") || inputValue || element.textContent || "";
+              const disabled = (tagName === "BUTTON" || tagName === "INPUT" ? element.disabled : false) || element.getAttribute("aria-disabled") === "true";
+              const href = tagName === "A" ? element.href : void 0;
+              candidates.push({
+                index,
+                role,
+                label,
+                disabled,
+                ...href ? { href } : {}
+              });
+              if (candidates.length > limit) break;
+            }
+            return candidates;
+          }, SESSION_OBSERVATION_TARGET_LIMIT)
+        ]);
+      } catch {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_INVALID",
+          "The owned browser page could not be observed."
+        );
+      }
+      const currentPage = await config.pageForSession(browserSessionId);
+      if (!currentPage || currentPage !== page || page.isClosed() || page.url() !== beforeUrl) {
+        throw verificationError(
+          "BROWSER_CHECKOUT_TARGET_CHANGED",
+          "The owned browser page changed while it was being observed."
+        );
+      }
+      const truncated = rawTargets.length > SESSION_OBSERVATION_TARGET_LIMIT;
+      const targets = rawTargets.slice(0, SESSION_OBSERVATION_TARGET_LIMIT).map((target) => {
+        const destinationOrigin = observedHttpsOrigin(target.href);
+        return Object.freeze({
+          locator: `:nth-match(${SESSION_OBSERVATION_SELECTOR}, ${target.index + 1})`,
+          role: target.role,
+          label: boundedObservationText(target.label, SESSION_OBSERVATION_LABEL_LIMIT),
+          disabled: target.disabled,
+          ...destinationOrigin ? { destinationOrigin } : {}
+        });
+      });
+      return Object.freeze({
+        browserSessionId,
+        pageOrigin: pageOrigin ?? null,
+        title: boundedObservationText(title, SESSION_OBSERVATION_TITLE_LIMIT),
+        targets: Object.freeze(targets),
+        truncated,
+        observedAt: now().toISOString()
+      });
+    }
+  });
+}
+function createGuardedPlaywrightCheckoutRuntimeHost(config) {
+  if (!config || typeof config !== "object") {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "The guarded Playwright runtime host configuration is required."
+    );
+  }
+  const browserSessions = createPlaywrightCdpSessionRegistry(config.browserSessions);
+  const observer = createPlaywrightSessionObserver({
+    pageForSession: browserSessions.pageForSession,
+    now: config.now
+  });
+  const targetStore = createEncryptedPlaywrightCheckoutTargetStore(config.targetStore);
+  const runtime = createGuardedPlaywrightCheckoutRuntime({
+    conto: config.conto,
+    pageForSession: browserSessions.pageForSession,
+    targetStore,
+    dispatchAttemptFor: config.dispatchAttemptFor,
+    clickTimeoutMs: config.clickTimeoutMs,
+    popupTimeoutMs: config.popupTimeoutMs,
+    targetTtlMs: config.targetTtlMs,
+    now: config.now
+  });
+  const handler = createGuardedPlaywrightCheckoutHttpHandler({
+    runtime,
+    token: config.token,
+    maxBodyBytes: config.maxBodyBytes
+  });
+  return Object.freeze({
+    handler,
+    observeSession: observer.observe,
+    closeSession: browserSessions.closeSession,
+    close: browserSessions.close
+  });
+}
+var GuardedCheckoutHttpInputError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "GuardedCheckoutHttpInputError";
+  }
+};
+var HTTP_ACTION_KINDS = [
+  "INITIATE_CHECKOUT",
+  "OPEN_LINK",
+  "CONFIRM_PAYMENT",
+  "PLACE_ORDER"
+];
+var HTTP_CHECKOUT_METHODS = ["LINK", "CARD", "SHOP_PAY", "PAYPAL"];
+var HTTP_TOTAL_TYPES = [
+  "subtotal",
+  "tax",
+  "total",
+  "items_base_amount",
+  "items_discount",
+  "discount",
+  "fulfillment",
+  "shipping",
+  "fee",
+  "gift_wrap",
+  "tip",
+  "store_credit"
+];
+var SAFE_RUNTIME_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ACTION_REQUIRED",
+  "AUTH_FAILED",
+  "BROWSER_ACTION_DISPATCH_INDETERMINATE",
+  "BROWSER_ACTION_FINALIZATION_PENDING",
+  "BROWSER_ACTION_OBSERVATION_INVALID",
+  "BROWSER_CHECKOUT_TARGET_CHANGED",
+  "BROWSER_CHECKOUT_TARGET_DISABLED",
+  "BROWSER_CHECKOUT_TARGET_INVALID",
+  "BROWSER_CHECKOUT_TARGET_NOT_FOUND",
+  "CHECKOUT_UNAVAILABLE",
+  "COMMERCE_EXECUTION_NOT_READY",
+  "CONFLICT",
+  "INSUFFICIENT_SCOPE",
+  "INVALID_BROWSER_CHECKOUT",
+  "INVALID_REQUEST",
+  "POLICY_DENIED",
+  "RATE_LIMITED",
+  "REQUIRES_APPROVAL",
+  "SERVER_ERROR"
+]);
+function httpRecord(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new GuardedCheckoutHttpInputError(400, "INVALID_BROWSER_CHECKOUT", `${field} is invalid`);
+  }
+  return value;
+}
+function httpClosedObject(value, field, allowedKeys) {
+  const record = httpRecord(value, field);
+  if (Object.keys(record).some((key) => !allowedKeys.includes(key))) {
+    throw new GuardedCheckoutHttpInputError(
+      400,
+      "INVALID_BROWSER_CHECKOUT",
+      `${field} contains an unsupported field`
+    );
+  }
+  return record;
+}
+function httpText(value, field, maxLength) {
+  if (typeof value !== "string") {
+    throw new GuardedCheckoutHttpInputError(
+      400,
+      "INVALID_BROWSER_CHECKOUT",
+      `${field} is required`
+    );
+  }
+  const normalized = value.trim();
+  if (!normalized || normalized.length > maxLength) {
+    throw new GuardedCheckoutHttpInputError(400, "INVALID_BROWSER_CHECKOUT", `${field} is invalid`);
+  }
+  return normalized;
+}
+function httpInteger(value, field, minimum) {
+  if (!Number.isSafeInteger(value) || value < minimum) {
+    throw new GuardedCheckoutHttpInputError(400, "INVALID_BROWSER_CHECKOUT", `${field} is invalid`);
+  }
+  return value;
+}
+function httpEnum(value, field, choices) {
+  if (typeof value !== "string" || !choices.includes(value)) {
+    throw new GuardedCheckoutHttpInputError(400, "INVALID_BROWSER_CHECKOUT", `${field} is invalid`);
+  }
+  return value;
+}
+function httpHttpsUrl(value, field) {
+  const text = httpText(value, field, 2048);
+  try {
+    const url = new URL(text);
+    if (url.protocol !== "https:" || url.username || url.password) throw new Error("unsafe URL");
+    return url.toString();
+  } catch {
+    throw new GuardedCheckoutHttpInputError(
+      400,
+      "INVALID_BROWSER_CHECKOUT",
+      `${field} must use HTTPS without credentials`
+    );
+  }
+}
+function httpArray(value, field, maxItems) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > maxItems) {
+    throw new GuardedCheckoutHttpInputError(400, "INVALID_BROWSER_CHECKOUT", `${field} is invalid`);
+  }
+  return value;
+}
+function parseGuardedCheckoutHttpInput(value) {
+  const input = httpClosedObject(value, "body", [
+    "idempotencyKey",
+    "browserSessionId",
+    "locator",
+    "actionKind",
+    "checkoutMethod",
+    "amountMinor",
+    "currency",
+    "purpose",
+    "category",
+    "counterparty",
+    "cart",
+    "providerPresentation"
+  ]);
+  const counterparty = httpClosedObject(input.counterparty, "counterparty", [
+    "canonicalId",
+    "displayName",
+    "checkoutUrl"
+  ]);
+  const cart = httpClosedObject(input.cart, "cart", ["lineItems", "totals", "fulfillment"]);
+  const presentation = httpClosedObject(input.providerPresentation, "providerPresentation", [
+    "approvalSummary",
+    "lineItemLabels"
+  ]);
+  const amountMinor = httpInteger(input.amountMinor, "amountMinor", 1);
+  const lineItems = httpArray(cart.lineItems, "cart.lineItems", 100).map((value2, index) => {
+    const item = httpClosedObject(value2, `cart.lineItems[${index}]`, [
+      "name",
+      "quantity",
+      "unitAmountMinor",
+      "description",
+      "sku",
+      "productUrl"
+    ]);
+    return {
+      name: httpText(item.name, `cart.lineItems[${index}].name`, 500),
+      quantity: httpInteger(item.quantity, `cart.lineItems[${index}].quantity`, 1),
+      unitAmountMinor: httpInteger(
+        item.unitAmountMinor,
+        `cart.lineItems[${index}].unitAmountMinor`,
+        0
+      ),
+      ...item.description !== void 0 ? { description: httpText(item.description, `cart.lineItems[${index}].description`, 500) } : {},
+      ...item.sku !== void 0 ? { sku: httpText(item.sku, `cart.lineItems[${index}].sku`, 200) } : {},
+      ...item.productUrl !== void 0 ? { productUrl: httpHttpsUrl(item.productUrl, `cart.lineItems[${index}].productUrl`) } : {}
+    };
+  });
+  const totals = httpArray(cart.totals, "cart.totals", 25).map((value2, index) => {
+    const total = httpClosedObject(value2, `cart.totals[${index}]`, [
+      "type",
+      "label",
+      "amountMinor"
+    ]);
+    return {
+      type: httpEnum(total.type, `cart.totals[${index}].type`, HTTP_TOTAL_TYPES),
+      label: httpText(total.label, `cart.totals[${index}].label`, 200),
+      amountMinor: httpInteger(total.amountMinor, `cart.totals[${index}].amountMinor`, 0)
+    };
+  });
+  const finalTotals = totals.filter((total) => total.type === "total");
+  if (finalTotals.length !== 1 || finalTotals[0].amountMinor !== amountMinor) {
+    throw new GuardedCheckoutHttpInputError(
+      400,
+      "INVALID_BROWSER_CHECKOUT",
+      "cart total must match amountMinor"
+    );
+  }
+  let fulfillment;
+  if (cart.fulfillment !== void 0) {
+    const source = httpClosedObject(cart.fulfillment, "cart.fulfillment", [
+      "recipient",
+      "addressLine1",
+      "addressLine2",
+      "locality",
+      "region",
+      "postalCode",
+      "countryCode"
+    ]);
+    const fields = [
+      "recipient",
+      "addressLine1",
+      "addressLine2",
+      "locality",
+      "region",
+      "postalCode",
+      "countryCode"
+    ];
+    const values = Object.fromEntries(
+      fields.filter((field) => source[field] !== void 0).map((field) => [field, httpText(source[field], `cart.fulfillment.${field}`, 500)])
+    );
+    if (Object.keys(values).length === 0) {
+      throw new GuardedCheckoutHttpInputError(
+        400,
+        "INVALID_BROWSER_CHECKOUT",
+        "cart.fulfillment cannot be empty"
+      );
+    }
+    if (values.countryCode && !/^[A-Za-z]{2}$/.test(values.countryCode)) {
+      throw new GuardedCheckoutHttpInputError(
+        400,
+        "INVALID_BROWSER_CHECKOUT",
+        "cart.fulfillment.countryCode is invalid"
+      );
+    }
+    fulfillment = {
+      ...values,
+      ...values.countryCode ? { countryCode: values.countryCode.toUpperCase() } : {}
+    };
+  }
+  const labels = httpArray(
+    presentation.lineItemLabels,
+    "providerPresentation.lineItemLabels",
+    100
+  ).map((label, index) => httpText(label, `providerPresentation.lineItemLabels[${index}]`, 500));
+  return {
+    idempotencyKey: httpText(input.idempotencyKey, "idempotencyKey", 255),
+    browserSessionId: httpText(input.browserSessionId, "browserSessionId", 255),
+    locator: httpText(input.locator, "locator", 1024),
+    actionKind: httpEnum(input.actionKind, "actionKind", HTTP_ACTION_KINDS),
+    checkoutMethod: httpEnum(input.checkoutMethod, "checkoutMethod", HTTP_CHECKOUT_METHODS),
+    amountMinor,
+    currency: httpEnum(input.currency, "currency", ["USD"]),
+    purpose: httpText(input.purpose, "purpose", 500),
+    ...input.category !== void 0 ? { category: httpText(input.category, "category", 100) } : {},
+    counterparty: {
+      canonicalId: httpText(counterparty.canonicalId, "counterparty.canonicalId", 255),
+      displayName: httpText(counterparty.displayName, "counterparty.displayName", 200),
+      checkoutUrl: httpHttpsUrl(counterparty.checkoutUrl, "counterparty.checkoutUrl")
+    },
+    cart: { lineItems, totals, ...fulfillment ? { fulfillment } : {} },
+    providerPresentation: {
+      approvalSummary: httpText(
+        presentation.approvalSummary,
+        "providerPresentation.approvalSummary",
+        500
+      ),
+      lineItemLabels: labels
+    }
+  };
+}
+function httpJson(status, body, headers) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      "cache-control": "no-store",
+      "content-type": "application/json; charset=utf-8",
+      ...headers
+    }
+  });
+}
+async function readBoundedHttpBody(request, maxBodyBytes) {
+  if (!request.body) return "";
+  const reader = request.body.getReader();
+  const chunks = [];
+  let length = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.byteLength;
+      if (length > maxBodyBytes) {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        throw new GuardedCheckoutHttpInputError(413, "INVALID_REQUEST", "body is too large");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new GuardedCheckoutHttpInputError(400, "INVALID_REQUEST", "body is not valid UTF-8");
+  }
+}
+function safeRuntimeIdentifier(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 255 && /^[A-Za-z0-9._:@/-]+$/.test(value) ? value : void 0;
+}
+function safeRuntimeError(error) {
+  if (error instanceof GuardedCheckoutHttpInputError) {
+    return httpJson(error.status, { code: error.code });
+  }
+  const record = error && typeof error === "object" ? error : void 0;
+  const candidateCode = record?.code;
+  const code = typeof candidateCode === "string" && SAFE_RUNTIME_ERROR_CODES.has(candidateCode) ? candidateCode : "SERVER_ERROR";
+  let status = typeof record?.status === "number" ? record.status : code.startsWith("BROWSER_") ? 409 : 500;
+  if (!Number.isInteger(status) || status < 400 || status > 599) status = 409;
+  if (code === "SERVER_ERROR") status = 500;
+  const requestId = safeRuntimeIdentifier(record?.requestId);
+  return httpJson(status, { code, ...requestId ? { requestId } : {} });
+}
+function validRuntimeToken(value) {
+  return value.length >= 32 && value.length <= 1024 && /^[\x21-\x7e]+$/.test(value) && !value.startsWith("conto_");
+}
+function authorizedRuntimeRequest(request, token) {
+  const header = request.headers.get("authorization");
+  if (!header?.startsWith("Bearer ")) return false;
+  const supplied = Buffer.from(header.slice(7));
+  const expected = Buffer.from(token);
+  return supplied.length === expected.length && (0, import_node_crypto2.timingSafeEqual)(supplied, expected);
+}
+function projectedRuntimeResult(value, expected) {
+  const result = httpRecord(value, "runtime result");
+  const execution = httpRecord(result.execution, "runtime execution");
+  const dispatched = httpRecord(result.result, "runtime dispatch result");
+  const outcome = httpRecord(dispatched.browserOutcome, "runtime browser outcome");
+  const evidence = httpRecord(execution.evidence, "runtime evidence");
+  const executionId = safeRuntimeIdentifier(execution.id);
+  const traceId = safeRuntimeIdentifier(evidence.traceId);
+  if (!executionId) throw new Error("invalid runtime execution ID");
+  const status = httpEnum(execution.status, "runtime execution status", [
+    "READY",
+    "PROCESSING",
+    "NEEDS_RECONCILIATION"
+  ]);
+  const amountMinor = httpInteger(execution.amountMinor, "runtime execution amountMinor", 1);
+  const currency = httpEnum(execution.currency, "runtime execution currency", ["USD"]);
+  const checkoutMethod = httpEnum(
+    execution.checkoutMethod,
+    "runtime execution checkoutMethod",
+    HTTP_CHECKOUT_METHODS
+  );
+  if (amountMinor !== expected.amountMinor || currency !== expected.currency || checkoutMethod !== expected.checkoutMethod) {
+    throw new Error("runtime result does not match request");
+  }
+  const pageUrl = new URL(httpHttpsUrl(dispatched.pageUrl, "runtime result pageUrl")).origin;
+  const observedAt = httpText(outcome.observedAt, "runtime result observedAt", 100);
+  if (Number.isNaN(Date.parse(observedAt))) throw new Error("invalid runtime observedAt");
+  return {
+    execution: {
+      id: executionId,
+      status,
+      amountMinor,
+      currency,
+      checkoutMethod,
+      evidence: { ...traceId ? { traceId } : {} }
+    },
+    result: {
+      pageUrl,
+      browserOutcome: {
+        kind: httpEnum(outcome.kind, "runtime result kind", [
+          "NEW_PAGE",
+          "PAGE_NAVIGATION",
+          "SAME_PAGE"
+        ]),
+        observedAt,
+        settlement: httpEnum(outcome.settlement, "runtime result settlement", ["UNVERIFIED"])
+      }
+    }
+  };
+}
+function createGuardedPlaywrightCheckoutHttpHandler(config) {
+  if (!config || !config.runtime || typeof config.runtime.discover !== "function" || typeof config.runtime.run !== "function") {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "runtime is required.");
+  }
+  if (!validRuntimeToken(config.token)) {
+    throw verificationError(
+      "BROWSER_CHECKOUT_TARGET_INVALID",
+      "token must be a dedicated credential containing 32 to 1024 non-space characters."
+    );
+  }
+  const maxBodyBytes = config.maxBodyBytes ?? DEFAULT_HTTP_BODY_LIMIT_BYTES;
+  if (!Number.isSafeInteger(maxBodyBytes) || maxBodyBytes <= 0 || maxBodyBytes > MAX_HTTP_BODY_LIMIT_BYTES) {
+    throw verificationError("BROWSER_CHECKOUT_TARGET_INVALID", "maxBodyBytes is invalid.");
+  }
+  const runtime = config.runtime;
+  const token = config.token;
+  return async (request) => {
+    if (request.method !== "POST") {
+      return httpJson(405, { code: "INVALID_REQUEST" }, { allow: "POST" });
+    }
+    if (!authorizedRuntimeRequest(request, token)) {
+      return httpJson(401, { code: "AUTH_FAILED" }, { "www-authenticate": "Bearer" });
+    }
+    const mediaType = request.headers.get("content-type")?.split(";", 1)[0].trim().toLowerCase();
+    if (mediaType !== "application/json") {
+      return httpJson(415, { code: "INVALID_REQUEST" });
+    }
+    const declaredLength = Number(request.headers.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
+      return httpJson(413, { code: "INVALID_REQUEST" });
+    }
+    try {
+      const text = await readBoundedHttpBody(request, maxBodyBytes);
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        throw new GuardedCheckoutHttpInputError(400, "INVALID_REQUEST", "body is invalid JSON");
+      }
+      const input = parseGuardedCheckoutHttpInput(parsed);
+      const discovered = await runtime.discover({
+        browserSessionId: input.browserSessionId,
+        locator: input.locator,
+        kind: input.actionKind,
+        checkoutMethod: input.checkoutMethod
+      });
+      const result = await runtime.run({
+        executionMethod: "BROWSER_CHECKOUT",
+        idempotencyKey: input.idempotencyKey,
+        browserSessionId: input.browserSessionId,
+        amountMinor: input.amountMinor,
+        currency: input.currency,
+        purpose: input.purpose,
+        ...input.category ? { category: input.category } : {},
+        counterparty: input.counterparty,
+        cart: input.cart,
+        providerPresentation: input.providerPresentation,
+        action: discovered.action
+      });
+      let output;
+      try {
+        output = projectedRuntimeResult(result, input);
+      } catch {
+        return httpJson(500, { code: "SERVER_ERROR" });
+      }
+      return httpJson(200, output);
+    } catch (error) {
+      return safeRuntimeError(error);
+    }
+  };
+}
+
+// src/browserbase.ts
+var BROWSERBASE_API_ORIGIN = "https://api.browserbase.com";
+var BROWSERBASE_CONNECT_ORIGINS = Object.freeze([
+  "wss://connect.browserbase.com",
+  "wss://connect.usw2.browserbase.com"
+]);
+var BROWSERBASE_LIVE_VIEW_DOMAIN = "browserbase.com";
+var DEFAULT_SESSION_TIMEOUT_SECONDS = 900;
+var MIN_SESSION_TIMEOUT_SECONDS = 60;
+var MAX_SESSION_TIMEOUT_SECONDS = 21600;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var MAX_REQUEST_TIMEOUT_MS = 6e4;
+var MAX_PROVIDER_RESPONSE_BYTES = 64 * 1024;
+var MAX_HANDOFF_ASSERTION_TTL_MS = 5 * 60 * 1e3;
+var HANDOFF_ASSERTION_VERSION = "bbh1";
+var BrowserbaseSessionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BrowserbaseSessionError";
+  }
+};
+function handoffKey(value) {
+  if (value === void 0) return void 0;
+  const key = Buffer.from(value);
+  if (key.length !== 32) {
+    fail("BROWSERBASE_CONFIG_INVALID", "browserbase.handoffKey must contain exactly 32 bytes.");
+  }
+  return key;
+}
+function handoffExpiresAt(value) {
+  const normalized = requiredText2(value, "handoff.expiresAt", 100);
+  const milliseconds = Date.parse(normalized);
+  if (!Number.isFinite(milliseconds)) {
+    fail("BROWSERBASE_CONFIG_INVALID", "handoff.expiresAt is invalid.");
+  }
+  return new Date(milliseconds).toISOString();
+}
+function handoffPayload(input) {
+  return JSON.stringify([
+    HANDOFF_ASSERTION_VERSION,
+    sessionId(input.browserSessionId),
+    requiredText2(input.projectId, "handoff.projectId"),
+    requiredText2(input.organizationId, "handoff.organizationId"),
+    requiredText2(input.agentId, "handoff.agentId"),
+    handoffExpiresAt(input.expiresAt)
+  ]);
+}
+function createBrowserbaseSessionHandoffAssertion(input, keyValue) {
+  const key = handoffKey(keyValue);
+  if (!key) fail("BROWSERBASE_CONFIG_INVALID", "A Browserbase handoff key is required.");
+  const expiresAt = handoffExpiresAt(input.expiresAt);
+  const signature = (0, import_node_crypto3.createHmac)("sha256", key).update(handoffPayload({ ...input, expiresAt })).digest("base64url");
+  return `${HANDOFF_ASSERTION_VERSION}.${Date.parse(expiresAt)}.${signature}`;
+}
+function verifyBrowserbaseSessionHandoffAssertion(assertionValue, input, key, now) {
+  if (typeof assertionValue !== "string" || assertionValue.length > 512) return false;
+  const match = /^bbh1\.([0-9]{13})\.([A-Za-z0-9_-]{43})$/.exec(assertionValue);
+  if (!match) return false;
+  const expiresAtMilliseconds = Number(match[1]);
+  if (!Number.isSafeInteger(expiresAtMilliseconds) || expiresAtMilliseconds <= now.getTime() || expiresAtMilliseconds > now.getTime() + MAX_HANDOFF_ASSERTION_TTL_MS) {
+    return false;
+  }
+  const expiresAt = new Date(expiresAtMilliseconds).toISOString();
+  const expected = (0, import_node_crypto3.createHmac)("sha256", key).update(handoffPayload({ ...input, expiresAt })).digest();
+  const received = Buffer.from(match[2], "base64url");
+  return received.length === expected.length && (0, import_node_crypto3.timingSafeEqual)(received, expected);
+}
+function lifecycleOwner(binding) {
+  return binding.lifecycleOwner === "AGENT_HOST" ? "AGENT_HOST" : "CONTO_RUNTIME";
+}
+function fail(code, message) {
+  throw new BrowserbaseSessionError(code, message);
+}
+function requiredText2(value, field, maxLength = 255) {
+  if (typeof value !== "string") fail("BROWSERBASE_CONFIG_INVALID", `${field} is invalid.`);
+  const normalized = value.trim();
+  if (!normalized || normalized.length > maxLength || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    fail("BROWSERBASE_CONFIG_INVALID", `${field} is invalid.`);
+  }
+  return normalized;
+}
+function providerText(value, field, maxLength = 255) {
+  if (typeof value !== "string") {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", `Browserbase returned an invalid ${field}.`);
+  }
+  const normalized = value.trim();
+  if (!normalized || normalized.length > maxLength || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", `Browserbase returned an invalid ${field}.`);
+  }
+  return normalized;
+}
+function sessionId(value, source = "config") {
+  const code = source === "config" ? "BROWSERBASE_CONFIG_INVALID" : "BROWSERBASE_PROVIDER_RESPONSE_INVALID";
+  if (typeof value !== "string" || !/^[A-Za-z0-9_-]{1,200}$/.test(value)) {
+    fail(code, "The Browserbase session ID is invalid.");
+  }
+  return value;
+}
+function timestamp(value, field) {
+  const normalized = providerText(value, field, 100);
+  const milliseconds = Date.parse(normalized);
+  if (!Number.isFinite(milliseconds)) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", `Browserbase returned an invalid ${field}.`);
+  }
+  return new Date(milliseconds).toISOString();
+}
+function timeoutSeconds(value) {
+  const normalized = value ?? DEFAULT_SESSION_TIMEOUT_SECONDS;
+  if (!Number.isSafeInteger(normalized) || normalized < MIN_SESSION_TIMEOUT_SECONDS || normalized > MAX_SESSION_TIMEOUT_SECONDS) {
+    fail(
+      "BROWSERBASE_CONFIG_INVALID",
+      `timeoutSeconds must be an integer from ${MIN_SESSION_TIMEOUT_SECONDS} to ${MAX_SESSION_TIMEOUT_SECONDS}.`
+    );
+  }
+  return normalized;
+}
+function requestTimeoutMs(value) {
+  const normalized = value ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  if (!Number.isSafeInteger(normalized) || normalized < 1 || normalized > MAX_REQUEST_TIMEOUT_MS) {
+    fail(
+      "BROWSERBASE_CONFIG_INVALID",
+      `requestTimeoutMs must be an integer from 1 to ${MAX_REQUEST_TIMEOUT_MS}.`
+    );
+  }
+  return normalized;
+}
+function secureConnectUrl(value) {
+  const normalized = providerText(value, "connectUrl", 4096);
+  try {
+    const url = new URL(normalized);
+    if (url.protocol !== "wss:" || !BROWSERBASE_CONNECT_ORIGINS.includes(url.origin) || url.username || url.password || url.hash) {
+      throw new Error("unsafe Browserbase connect URL");
+    }
+    return url.toString();
+  } catch {
+    fail(
+      "BROWSERBASE_PROVIDER_RESPONSE_INVALID",
+      "Browserbase returned an untrusted connection URL."
+    );
+  }
+}
+function secureLiveViewUrl(value) {
+  const normalized = providerText(value, "debuggerFullscreenUrl", 8192);
+  try {
+    const url = new URL(normalized);
+    const trustedHostname = url.hostname === BROWSERBASE_LIVE_VIEW_DOMAIN || url.hostname.endsWith(`.${BROWSERBASE_LIVE_VIEW_DOMAIN}`);
+    if (url.protocol !== "https:" || !trustedHostname || url.username || url.password || url.port && url.port !== "443") {
+      throw new Error("unsafe Browserbase live view URL");
+    }
+    return url.toString();
+  } catch {
+    fail(
+      "BROWSERBASE_PROVIDER_RESPONSE_INVALID",
+      "Browserbase returned an untrusted live view URL."
+    );
+  }
+}
+function parseProviderSession(value, expectedProjectId, expectedSessionId) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an invalid session.");
+  }
+  const record = value;
+  const id = sessionId(record.id, "provider");
+  const projectId = providerText(record.projectId, "projectId");
+  const status = record.status;
+  if (!["PENDING", "RUNNING", "ERROR", "TIMED_OUT", "COMPLETED"].includes(
+    typeof status === "string" ? status : ""
+  )) {
+    fail(
+      "BROWSERBASE_PROVIDER_RESPONSE_INVALID",
+      "Browserbase returned an invalid session status."
+    );
+  }
+  if (projectId !== expectedProjectId || expectedSessionId && id !== expectedSessionId) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned a mismatched session.");
+  }
+  const createdAt = timestamp(record.createdAt, "createdAt");
+  const expiresAt = timestamp(record.expiresAt, "expiresAt");
+  if (Date.parse(expiresAt) <= Date.parse(createdAt)) {
+    fail(
+      "BROWSERBASE_PROVIDER_RESPONSE_INVALID",
+      "Browserbase returned invalid session timestamps."
+    );
+  }
+  return Object.freeze({
+    id,
+    projectId,
+    status,
+    createdAt,
+    expiresAt,
+    connectUrl: secureConnectUrl(record.connectUrl)
+  });
+}
+async function readProviderJson(response) {
+  let body;
+  try {
+    body = await response.text();
+  } catch {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an unreadable response.");
+  }
+  if (body.length > MAX_PROVIDER_RESPONSE_BYTES) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an oversized response.");
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned invalid JSON.");
+  }
+}
+function activeProviderSession(session, now) {
+  return (session.status === "PENDING" || session.status === "RUNNING") && Date.parse(session.expiresAt) > now.getTime();
+}
+function validBinding(value, ownership, expectedSessionId, now) {
+  if (!value || typeof value !== "object") return false;
+  return value.browserSessionId === expectedSessionId && value.organizationId === ownership.organizationId && value.agentId === ownership.agentId && value.projectId === ownership.projectId && value.state === "ACTIVE" && Number.isFinite(Date.parse(value.expiresAt)) && Date.parse(value.expiresAt) > now.getTime();
+}
+function createBrowserbaseSessionManager(config) {
+  if (!config || typeof config !== "object") {
+    fail("BROWSERBASE_CONFIG_INVALID", "The Browserbase configuration is required.");
+  }
+  const apiKey = requiredText2(config.apiKey, "browserbase.apiKey", 1024);
+  if (apiKey.startsWith("conto_")) {
+    fail("BROWSERBASE_CONFIG_INVALID", "A Browserbase API key is required.");
+  }
+  const projectId = requiredText2(config.projectId, "browserbase.projectId");
+  const organizationId = requiredText2(config.organizationId, "browserbase.organizationId");
+  const agentId = requiredText2(config.agentId, "browserbase.agentId");
+  const contextId = config.contextId === void 0 ? void 0 : requiredText2(config.contextId, "browserbase.contextId");
+  const sessionHandoffKey = handoffKey(config.handoffKey);
+  if (!config.bindingStore || typeof config.bindingStore.create !== "function" || typeof config.bindingStore.get !== "function" || typeof config.bindingStore.revoke !== "function") {
+    fail("BROWSERBASE_CONFIG_INVALID", "A durable Browserbase session binding store is required.");
+  }
+  if (contextId && typeof config.bindingStore.releaseContextLease !== "function") {
+    fail(
+      "BROWSERBASE_CONFIG_INVALID",
+      "A durable Browserbase Context lease store is required when contextId is configured."
+    );
+  }
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    fail("BROWSERBASE_CONFIG_INVALID", "A fetch implementation is required.");
+  }
+  const durationSeconds = timeoutSeconds(config.timeoutSeconds);
+  const providerRequestTimeoutMs = requestTimeoutMs(config.requestTimeoutMs);
+  const now = config.now ?? (() => /* @__PURE__ */ new Date());
+  const ownership = Object.freeze({ organizationId, agentId, projectId });
+  async function providerRequest(path, init) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), providerRequestTimeoutMs);
+    try {
+      return await fetchImpl(`${BROWSERBASE_API_ORIGIN}${path}`, {
+        ...init,
+        redirect: "error",
+        cache: "no-store",
+        signal: controller.signal,
+        headers: {
+          Accept: "application/json",
+          "X-BB-API-Key": apiKey,
+          ...init.headers
+        }
+      });
+    } catch {
+      fail("BROWSERBASE_PROVIDER_UNAVAILABLE", "Browserbase could not be reached.");
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async function releaseProviderSession(browserSessionId) {
+    const response = await providerRequest(`/v1/sessions/${encodeURIComponent(browserSessionId)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ status: "REQUEST_RELEASE" })
+    });
+    if (!response.ok) {
+      fail("BROWSERBASE_SESSION_RELEASE_FAILED", "Browserbase did not release the session.");
+    }
+  }
+  return Object.freeze({
+    async createSession() {
+      const response = await providerRequest("/v1/sessions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          projectId,
+          timeout: durationSeconds,
+          keepAlive: true,
+          ...contextId ? {
+            browserSettings: {
+              context: { id: contextId, persist: true }
+            }
+          } : {}
+        })
+      });
+      if (response.status !== 201) {
+        fail("BROWSERBASE_PROVIDER_UNAVAILABLE", "Browserbase did not create a session.");
+      }
+      const providerSession = parseProviderSession(await readProviderJson(response), projectId);
+      if (!activeProviderSession(providerSession, now())) {
+        try {
+          await releaseProviderSession(providerSession.id);
+        } catch {
+        }
+        fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an inactive session.");
+      }
+      const binding = Object.freeze({
+        browserSessionId: providerSession.id,
+        ...ownership,
+        lifecycleOwner: "CONTO_RUNTIME",
+        state: "ACTIVE",
+        createdAt: providerSession.createdAt,
+        expiresAt: providerSession.expiresAt
+      });
+      let created = false;
+      try {
+        created = await config.bindingStore.create(binding);
+      } catch {
+      }
+      if (!created) {
+        try {
+          await releaseProviderSession(providerSession.id);
+        } catch {
+        }
+        fail(
+          "BROWSERBASE_SESSION_BINDING_FAILED",
+          "The Browserbase session ownership binding could not be stored."
+        );
+      }
+      return Object.freeze({
+        browserSessionId: providerSession.id,
+        status: providerSession.status,
+        expiresAt: providerSession.expiresAt
+      });
+    },
+    async attachSession(input) {
+      if (!sessionHandoffKey) {
+        fail(
+          "BROWSERBASE_SESSION_HANDOFF_DISABLED",
+          "Browserbase session handoff is not configured."
+        );
+      }
+      if (!input || typeof input !== "object") {
+        fail("BROWSERBASE_SESSION_HANDOFF_INVALID", "The Browserbase session handoff is invalid.");
+      }
+      if (typeof input.browserSessionId !== "string" || !/^[A-Za-z0-9_-]{1,200}$/.test(input.browserSessionId)) {
+        fail("BROWSERBASE_SESSION_HANDOFF_INVALID", "The Browserbase session handoff is invalid.");
+      }
+      const browserSessionId = input.browserSessionId;
+      if (!verifyBrowserbaseSessionHandoffAssertion(
+        input.handoffAssertion,
+        { browserSessionId, ...ownership },
+        sessionHandoffKey,
+        now()
+      )) {
+        fail("BROWSERBASE_SESSION_HANDOFF_INVALID", "The Browserbase session handoff is invalid.");
+      }
+      const response = await providerRequest(
+        `/v1/sessions/${encodeURIComponent(browserSessionId)}`,
+        { method: "GET" }
+      );
+      if (response.status === 404) {
+        fail("BROWSERBASE_SESSION_NOT_OWNED", "The Browserbase session is not owned.");
+      }
+      if (!response.ok) {
+        fail("BROWSERBASE_PROVIDER_UNAVAILABLE", "Browserbase could not verify the session.");
+      }
+      const providerSession = parseProviderSession(
+        await readProviderJson(response),
+        projectId,
+        browserSessionId
+      );
+      const currentTime = now();
+      if (!activeProviderSession(providerSession, currentTime)) {
+        fail("BROWSERBASE_SESSION_NOT_OWNED", "The Browserbase session is not active.");
+      }
+      const binding = Object.freeze({
+        browserSessionId,
+        ...ownership,
+        lifecycleOwner: "AGENT_HOST",
+        state: "ACTIVE",
+        createdAt: providerSession.createdAt,
+        expiresAt: providerSession.expiresAt
+      });
+      let created = false;
+      try {
+        created = await config.bindingStore.create(binding);
+      } catch {
+      }
+      if (!created) {
+        let existing = null;
+        try {
+          existing = await config.bindingStore.get(browserSessionId);
+        } catch {
+        }
+        if (!validBinding(existing, ownership, browserSessionId, currentTime) || lifecycleOwner(existing) !== "AGENT_HOST" || existing.createdAt !== providerSession.createdAt || existing.expiresAt !== providerSession.expiresAt) {
+          fail(
+            "BROWSERBASE_SESSION_BINDING_FAILED",
+            "The Browserbase session ownership binding could not be stored."
+          );
+        }
+      }
+      return Object.freeze({
+        browserSessionId,
+        status: providerSession.status,
+        expiresAt: providerSession.expiresAt,
+        lifecycleOwner: "AGENT_HOST"
+      });
+    },
+    async connectUrlForSession(browserSessionIdValue) {
+      const browserSessionId = sessionId(browserSessionIdValue);
+      let binding;
+      try {
+        binding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        return null;
+      }
+      if (!validBinding(binding, ownership, browserSessionId, now())) return null;
+      const response = await providerRequest(
+        `/v1/sessions/${encodeURIComponent(browserSessionId)}`,
+        {
+          method: "GET"
+        }
+      );
+      if (!response.ok) return null;
+      const providerSession = parseProviderSession(
+        await readProviderJson(response),
+        projectId,
+        browserSessionId
+      );
+      if (!activeProviderSession(providerSession, now())) return null;
+      let currentBinding;
+      try {
+        currentBinding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        return null;
+      }
+      if (!validBinding(currentBinding, ownership, browserSessionId, now()) || providerSession.expiresAt !== binding.expiresAt || providerSession.expiresAt !== currentBinding.expiresAt) {
+        return null;
+      }
+      return providerSession.connectUrl;
+    },
+    async liveViewForSession(browserSessionIdValue) {
+      const browserSessionId = sessionId(browserSessionIdValue);
+      let binding;
+      try {
+        binding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        fail("BROWSERBASE_LIVE_VIEW_UNAVAILABLE", "The Browserbase live view is unavailable.");
+      }
+      if (!validBinding(binding, ownership, browserSessionId, now())) {
+        fail("BROWSERBASE_SESSION_NOT_OWNED", "The Browserbase session is not owned.");
+      }
+      const response = await providerRequest(
+        `/v1/sessions/${encodeURIComponent(browserSessionId)}/debug`,
+        { method: "GET" }
+      );
+      if (!response.ok) {
+        fail("BROWSERBASE_LIVE_VIEW_UNAVAILABLE", "The Browserbase live view is unavailable.");
+      }
+      const value = await readProviderJson(response);
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an invalid live view.");
+      }
+      const liveViewUrl = secureLiveViewUrl(
+        value.debuggerFullscreenUrl
+      );
+      let currentBinding;
+      try {
+        currentBinding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        fail("BROWSERBASE_LIVE_VIEW_UNAVAILABLE", "The Browserbase live view is unavailable.");
+      }
+      if (!validBinding(currentBinding, ownership, browserSessionId, now()) || currentBinding.expiresAt !== binding.expiresAt) {
+        fail("BROWSERBASE_SESSION_NOT_OWNED", "The Browserbase session is not owned.");
+      }
+      return Object.freeze({
+        browserSessionId,
+        liveViewUrl,
+        expiresAt: currentBinding.expiresAt
+      });
+    },
+    async revokeSession(browserSessionIdValue, expectedLifecycleOwner) {
+      const browserSessionId = sessionId(browserSessionIdValue);
+      let binding;
+      try {
+        binding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        return false;
+      }
+      if (!validBinding(binding, ownership, browserSessionId, now()) || lifecycleOwner(binding) !== expectedLifecycleOwner) {
+        return false;
+      }
+      try {
+        return await config.bindingStore.revoke({
+          browserSessionId,
+          ...ownership,
+          revokedAt: now().toISOString()
+        });
+      } catch {
+        fail(
+          "BROWSERBASE_SESSION_RELEASE_FAILED",
+          "The Browserbase session ownership binding could not be revoked."
+        );
+      }
+    },
+    async releaseContextLease(browserSessionIdValue) {
+      if (!contextId) return true;
+      const browserSessionId = sessionId(browserSessionIdValue);
+      try {
+        return await config.bindingStore.releaseContextLease({
+          browserSessionId,
+          ...ownership
+        });
+      } catch {
+        return false;
+      }
+    },
+    releaseProviderSession
+  });
+}
+function createBrowserbaseGuardedPlaywrightCheckoutRuntimeHost(config) {
+  if (!config || typeof config !== "object") {
+    fail(
+      "BROWSERBASE_CONFIG_INVALID",
+      "The Browserbase guarded runtime configuration is required."
+    );
+  }
+  if (config.token === config.browserbase?.apiKey) {
+    fail("BROWSERBASE_CONFIG_INVALID", "Use a dedicated browser runtime token.");
+  }
+  const manager = createBrowserbaseSessionManager(config.browserbase);
+  const host = createGuardedPlaywrightCheckoutRuntimeHost({
+    conto: config.conto,
+    browserSessions: {
+      allowedConnectOrigins: BROWSERBASE_CONNECT_ORIGINS,
+      connectUrlForSession: manager.connectUrlForSession,
+      connectOverCDP: config.connectOverCDP,
+      selectPage: config.selectPage,
+      maxSessions: config.maxSessions
+    },
+    targetStore: config.targetStore,
+    dispatchAttemptFor: config.dispatchAttemptFor,
+    token: config.token,
+    maxBodyBytes: config.maxBodyBytes,
+    clickTimeoutMs: config.clickTimeoutMs,
+    popupTimeoutMs: config.popupTimeoutMs,
+    targetTtlMs: config.targetTtlMs,
+    now: config.now
+  });
+  return Object.freeze({
+    handler: host.handler,
+    createSession: manager.createSession,
+    attachSession: manager.attachSession,
+    observeSession: host.observeSession,
+    liveViewForSession: manager.liveViewForSession,
+    async releaseSession(browserSessionId) {
+      const revoked = await manager.revokeSession(browserSessionId, "CONTO_RUNTIME");
+      if (!revoked) {
+        fail(
+          "BROWSERBASE_SESSION_NOT_OWNED",
+          "The Browserbase session is not active for this organization and agent."
+        );
+      }
+      const results = await Promise.allSettled([
+        host.closeSession(browserSessionId),
+        manager.releaseProviderSession(browserSessionId)
+      ]);
+      const contextLeaseReleased = results[1].status === "fulfilled" ? await manager.releaseContextLease(browserSessionId) : false;
+      if (results.some((result) => result.status === "rejected") || !contextLeaseReleased) {
+        fail(
+          "BROWSERBASE_SESSION_RELEASE_FAILED",
+          "The Browserbase session could not be released."
+        );
+      }
+    },
+    async detachSession(browserSessionId) {
+      const revoked = await manager.revokeSession(browserSessionId, "AGENT_HOST");
+      if (!revoked) {
+        fail(
+          "BROWSERBASE_SESSION_NOT_OWNED",
+          "The Browserbase session is not active for this organization and agent."
+        );
+      }
+      try {
+        await host.closeSession(browserSessionId);
+      } catch {
+        fail(
+          "BROWSERBASE_SESSION_RELEASE_FAILED",
+          "The Browserbase session handoff could not be detached."
+        );
+      }
+    },
+    close: host.close
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BROWSERBASE_CONNECT_ORIGINS,
+  BrowserbaseSessionError,
+  createBrowserbaseGuardedPlaywrightCheckoutRuntimeHost,
+  createBrowserbaseSessionHandoffAssertion
+});