@basis-theory/web-elements 2.11.1 → 3.0.0-beta.2

package/dist/index-oREjBjga.js

@@ -0,0 +1,2317 @@
+const PAN_PATTERNS = [
+  /cardnumber/i,
+  /^pan$/i,
+  /accountnumber/i,
+  /^number$/i
+  // Common in card objects
+];
+const REDACT_PATTERNS = [
+  /cvv/i,
+  /cvc/i,
+  /cvv2/i,
+  /securitycode/i,
+  /pin/i,
+  /password/i,
+  /secret/i,
+  /token/i,
+  /ssn/i,
+  /track/i
+];
+const isPANField = (key) => {
+  return PAN_PATTERNS.some((pattern) => pattern.test(key));
+};
+const isRedactField = (key) => {
+  return REDACT_PATTERNS.some((pattern) => pattern.test(key));
+};
+const maskPAN = (value) => {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length < 10) {
+    return "***";
+  }
+  const first6 = digits.substring(0, 6);
+  const last4 = digits.substring(digits.length - 4);
+  const maskedLength = Math.max(digits.length - 10, 6);
+  const masked = "*".repeat(maskedLength);
+  return `${first6}${masked}${last4}`;
+};
+const looksLikePAN = (value) => {
+  const digits = value.replace(/[\s-]/g, "");
+  return /^\d{13,19}$/.test(digits);
+};
+const sanitizeValue = (key, value) => {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (typeof value === "symbol") {
+    return "[Symbol]";
+  }
+  if (value instanceof RegExp) {
+    return "[RegExp]";
+  }
+  if (value instanceof Date) {
+    return value;
+  }
+  if (isPANField(key)) {
+    if (typeof value === "string") {
+      return maskPAN(value);
+    }
+    return "***";
+  }
+  if (isRedactField(key)) {
+    return "***";
+  }
+  if (typeof value === "string" && looksLikePAN(value)) {
+    return maskPAN(value);
+  }
+  return value;
+};
+const sanitizeDeep = (data, depth = 0, ancestors = /* @__PURE__ */ new WeakSet()) => {
+  if (depth >= 5) {
+    return "[Max Depth]";
+  }
+  if (data === null || data === void 0) {
+    return data;
+  }
+  if (typeof data === "string") {
+    return looksLikePAN(data) ? maskPAN(data) : data;
+  }
+  if (typeof data !== "object") {
+    return data;
+  }
+  if (data instanceof RegExp) {
+    return "[RegExp]";
+  }
+  if (data instanceof Date) {
+    return data;
+  }
+  if (ancestors.has(data)) {
+    return "[Circular]";
+  }
+  ancestors.add(data);
+  let result;
+  if (Array.isArray(data)) {
+    result = data.map((item) => sanitizeDeep(item, depth + 1, ancestors));
+  } else {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(data)) {
+      const sanitizedValue = sanitizeValue(key, value);
+      if (sanitizedValue !== null && typeof sanitizedValue === "object") {
+        sanitized[key] = sanitizeDeep(sanitizedValue, depth + 1, ancestors);
+      } else {
+        sanitized[key] = sanitizedValue;
+      }
+    }
+    result = sanitized;
+  }
+  ancestors.delete(data);
+  return result;
+};
+const sanitizeMetadata = (metadata) => {
+  const result = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (isPANField(key) || isRedactField(key)) {
+      const len = typeof value === "string" ? value.length : typeof value === "number" ? String(value).length : 0;
+      result[`${key}_length`] = len;
+    } else {
+      result[key] = sanitizeDeep(value);
+    }
+  }
+  return result;
+};
+const formatTimestamp = () => {
+  const now = /* @__PURE__ */ new Date();
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  const milliseconds = String(now.getMilliseconds()).padStart(3, "0");
+  return `${hours}:${minutes}:${seconds}.${milliseconds}`;
+};
+const createDebugLogger = (packageName, enabled) => {
+  if (!enabled) {
+    return () => {
+    };
+  }
+  return (action, metadata) => {
+    const timestamp = formatTimestamp();
+    const sanitized = metadata ? sanitizeMetadata(metadata) : {};
+    console.log(`🔍 [${timestamp}] [${packageName}] ${action}`, sanitized);
+  };
+};
+const createBasisTheoryError = (code, message, details) => {
+  const error = new Error(message);
+  error.name = "BasisTheoryError";
+  error.code = code;
+  error.details = details;
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(error, createBasisTheoryError);
+  }
+  error.toJSON = () => ({
+    name: error.name,
+    code: error.code,
+    message: error.message,
+    ...error.details && { details: error.details }
+  });
+  return error;
+};
+const BasisTheoryError = (code, message, details) => {
+  const error = createBasisTheoryError(code, message, details);
+  error.name = "BasisTheoryError";
+  return error;
+};
+const ValidationError = (message, field, details) => {
+  const error = createBasisTheoryError("VALIDATION_ERROR", message, details);
+  error.name = "ValidationError";
+  error.field = field;
+  return error;
+};
+const CoordinatorError = (message, details) => {
+  const error = createBasisTheoryError("COORDINATOR_ERROR", message, details);
+  error.name = "CoordinatorError";
+  return error;
+};
+const ElementError = (message, elementId, details) => {
+  const error = createBasisTheoryError("ELEMENT_ERROR", message, elementId ? { elementId, ...details } : details);
+  error.name = "ElementError";
+  error.elementId = elementId;
+  return error;
+};
+const ConfigurationError = (message, details) => {
+  const error = createBasisTheoryError("CONFIGURATION_ERROR", message, details);
+  error.name = "ConfigurationError";
+  return error;
+};
+const log = (action, metadata) => {
+};
+const DEFAULT_RETRY_CONFIG = {
+  maxRetries: 2,
+  initialDelay: 500,
+  maxDelay: 3e3,
+  backoffFactor: 2
+};
+const getRetryDelay = (attempt, config) => {
+  const delay = config.initialDelay * Math.pow(config.backoffFactor, attempt);
+  return Math.min(delay, config.maxDelay);
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const createPostMessageClient = (iframe, config) => {
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const eventSubscribers = /* @__PURE__ */ new Map();
+  const log2 = createDebugLogger("PostMessageClient", config.debug || false);
+  const isValidOrigin = (origin) => {
+    return origin === config.targetOrigin;
+  };
+  const handleMessage = (event) => {
+    const { nonce, type, payload, error } = event.data || {};
+    if (!type) {
+      return;
+    }
+    if (!isValidOrigin(event.origin)) {
+      log2("Rejected message (origin mismatch)", {
+        receivedOrigin: event.origin,
+        expectedOrigin: config.targetOrigin,
+        messageType: type
+      });
+      return;
+    }
+    if (event.source !== iframe.contentWindow) {
+      return;
+    }
+    if (nonce) {
+      const pending = pendingRequests.get(nonce);
+      if (pending) {
+        log2("Message received", {
+          origin: event.origin,
+          expectedOrigin: config.targetOrigin,
+          type,
+          nonce
+        });
+        clearTimeout(pending.timeout);
+        pendingRequests.delete(nonce);
+        if (error) {
+          const reconstructedError = BasisTheoryError(error.code, `[${error.code}] ${error.message}`);
+          Object.assign(reconstructedError, {
+            ...error.status !== void 0 && { status: error.status },
+            ...error.statusCode !== void 0 && {
+              statusCode: error.statusCode
+            },
+            ...error.validationErrors && {
+              validationErrors: error.validationErrors
+            },
+            ...error.body && { body: error.body },
+            ...error.retryCount !== void 0 && {
+              retryCount: error.retryCount
+            },
+            ...error.details && { details: error.details }
+          });
+          pending.reject(reconstructedError);
+        } else {
+          pending.resolve(payload);
+        }
+        return;
+      }
+      return;
+    }
+    const subscribers = eventSubscribers.get(type);
+    if (subscribers && subscribers.size > 0) {
+      log2("Event received", {
+        origin: event.origin,
+        expectedOrigin: config.targetOrigin,
+        type,
+        nonce,
+        subscriberCount: subscribers.size
+      });
+      subscribers.forEach((callback) => {
+        try {
+          callback(payload);
+        } catch (err) {
+          if (config.debug) {
+            console.error(`[PostMessage Client] Error in event subscriber for ${type}:`, err);
+          }
+        }
+      });
+    } else if (!nonce) {
+      log2("Event received but no subscribers", {
+        type,
+        availableSubscribers: Array.from(eventSubscribers.keys())
+      });
+    }
+  };
+  window.addEventListener("message", handleMessage);
+  const retryConfig = typeof config.retries === "number" ? { ...DEFAULT_RETRY_CONFIG, maxRetries: config.retries } : typeof config.retries === "object" ? config.retries : DEFAULT_RETRY_CONFIG;
+  const sendRequestOnce = (type, payload) => {
+    return new Promise((resolve, reject) => {
+      const nonce = crypto.randomUUID();
+      const timestamp = Date.now();
+      if (!iframe.contentWindow) {
+        reject(BasisTheoryError("IFRAME_NOT_READY", "Iframe not ready"));
+        return;
+      }
+      const timeout = setTimeout(() => {
+        pendingRequests.delete(nonce);
+        reject(BasisTheoryError("REQUEST_TIMEOUT", `Request timeout: ${type} (${config.timeout || 5e3}ms)`));
+      }, config.timeout || 5e3);
+      pendingRequests.set(nonce, { resolve, reject, timeout, timestamp });
+      log2("Sending request", { type, nonce });
+      iframe.contentWindow.postMessage({ type, nonce, timestamp, payload }, config.targetOrigin);
+    });
+  };
+  const sendRequest = async (type, payload) => {
+    let lastError = null;
+    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+      try {
+        return await sendRequestOnce(type, payload);
+      } catch (error) {
+        lastError = error;
+        const errorMessage = error.message;
+        const isHandlerError = errorMessage.startsWith("[HANDLER_ERROR]");
+        const isClientDestroyed = errorMessage === "Client destroyed";
+        const isIframeNotReady = errorMessage === "Iframe not ready";
+        if (isHandlerError || isClientDestroyed || isIframeNotReady) {
+          log2("Not retrying error", {
+            error: errorMessage,
+            reason: "Non-retriable error"
+          });
+          throw error;
+        }
+        if (attempt < retryConfig.maxRetries) {
+          const delay = getRetryDelay(attempt, retryConfig);
+          log2("Retrying request", {
+            attempt: attempt + 1,
+            maxRetries: retryConfig.maxRetries,
+            delayMs: delay,
+            error: errorMessage
+          });
+          await sleep(delay);
+        }
+      }
+    }
+    throw lastError || new Error(`Request failed after ${retryConfig.maxRetries} retries: ${type}`);
+  };
+  const ping = async (timeout = 1e3) => {
+    const start = Date.now();
+    log2("Starting health check", {
+      timeoutMs: timeout,
+      iframeReady: !!iframe.contentWindow,
+      targetOrigin: config.targetOrigin
+    });
+    try {
+      await sendRequestOnce("SYS_PING", void 0);
+      const latency = Date.now() - start;
+      log2("Health check passed", { latencyMs: latency });
+      return latency;
+    } catch (error) {
+      const errorMsg = `Health check failed after ${Date.now() - start}ms: ${error.message}. Target: ${config.targetOrigin}`;
+      if (config.debug) {
+        log2(`❌ [PostMessage Client] ${errorMsg}`);
+        log2(`📊 [PostMessage Client] Pending requests: ${pendingRequests.size}`);
+      }
+      throw BasisTheoryError("HEALTH_CHECK_FAILED", errorMsg);
+    }
+  };
+  const subscribe = (type, callback) => {
+    if (!eventSubscribers.has(type)) {
+      eventSubscribers.set(type, /* @__PURE__ */ new Set());
+    }
+    eventSubscribers.get(type).add(callback);
+    return () => {
+      const subscribers = eventSubscribers.get(type);
+      if (subscribers) {
+        subscribers.delete(callback);
+        if (subscribers.size === 0) {
+          eventSubscribers.delete(type);
+        }
+      }
+    };
+  };
+  const destroy = () => {
+    window.removeEventListener("message", handleMessage);
+    pendingRequests.forEach(({ timeout, reject }) => {
+      clearTimeout(timeout);
+      reject(BasisTheoryError("CLIENT_DESTROYED", "Client destroyed"));
+    });
+    pendingRequests.clear();
+    eventSubscribers.clear();
+  };
+  return {
+    sendRequest,
+    ping,
+    subscribe,
+    destroy,
+    getPendingCount: () => pendingRequests.size
+  };
+};
+const createMounter = () => {
+  const applyIframeStyles = (iframe) => {
+    iframe.style.border = "none";
+    iframe.style.width = "100%";
+    iframe.style.height = "100%";
+    iframe.style.display = "block";
+  };
+  return {
+    mount: async (container, iframe, _config) => {
+      applyIframeStyles(iframe);
+      container.appendChild(iframe);
+    },
+    unmount: (iframe) => {
+      iframe.remove();
+    }
+  };
+};
+const createIframe = (config) => {
+  const iframe = document.createElement("iframe");
+  iframe.src = config.src;
+  iframe.setAttribute("sandbox", config.sandbox);
+  iframe.title = config.title;
+  iframe.setAttribute("allow", "payment *");
+  iframe.setAttribute("importance", "high");
+  iframe.style.opacity = "0";
+  return iframe;
+};
+const createEventDispatcher = (config) => {
+  const { elementType, elementId, client, eventTarget } = config;
+  const createBaseDetail = () => ({
+    elementType,
+    elementId,
+    timestamp: Date.now()
+  });
+  const dispatch = (eventType, detail) => {
+    const event = new CustomEvent(eventType, {
+      detail: {
+        ...createBaseDetail(),
+        ...detail
+      }
+    });
+    eventTarget.dispatchEvent(event);
+  };
+  const setupSubscriptions = () => {
+    client.subscribe("EVENT_READY", () => {
+      dispatch("ready", {});
+    });
+    client.subscribe("EVENT_VALUE_CHANGED", (payload) => {
+      const changeDetail = {
+        isValid: payload.isValid,
+        isEmpty: payload.isEmpty,
+        error: payload.error || null
+      };
+      if (elementType === "cardNumber") {
+        const cardDetail = {
+          ...changeDetail,
+          cardBrand: payload.cardBrand,
+          last4: payload.last4,
+          bin: payload.bin,
+          cvvLengths: payload.cvvLengths,
+          potentialBrands: payload.potentialBrands,
+          matchStrength: payload.matchStrength
+        };
+        dispatch("change", cardDetail);
+      } else if (elementType === "card") {
+        dispatch("change", {
+          ...changeDetail,
+          cardBrand: payload.cardBrand,
+          last4: payload.last4,
+          bin: payload.bin,
+          errors: payload.errors || null
+        });
+      } else {
+        dispatch("change", changeDetail);
+      }
+    });
+    client.subscribe("EVENT_FOCUS", () => {
+      dispatch("focus", {});
+    });
+    client.subscribe("EVENT_BLUR", () => {
+      dispatch("blur", {});
+    });
+    client.subscribe("EVENT_ERROR", (payload) => {
+      dispatch("error", {
+        code: payload.code,
+        message: payload.message,
+        status: payload.status,
+        validationErrors: payload.validationErrors,
+        metadata: payload.metadata || {}
+      });
+    });
+  };
+  const dispatchError = (code, message, error) => {
+    dispatch("error", {
+      code,
+      message,
+      metadata: {
+        source: "initialization",
+        originalError: error
+      }
+    });
+  };
+  return {
+    setupSubscriptions,
+    dispatchError
+  };
+};
+const createCardNumberElement = (apiKey, sdkConfig, options = {}, coordinatorElementId, ensureCoordinatorReady) => {
+  let iframe = null;
+  let client = null;
+  let mounter = null;
+  let isMounted = false;
+  let container = null;
+  let eventDispatcher = null;
+  const eventTarget = new EventTarget();
+  const id = coordinatorElementId;
+  const type = "cardNumber";
+  const setupEventListeners = () => {
+    if (!client) {
+      return;
+    }
+    eventDispatcher = createEventDispatcher({
+      elementType: type,
+      elementId: id,
+      client,
+      eventTarget
+    });
+    eventDispatcher.setupSubscriptions();
+  };
+  return {
+    id,
+    type,
+    get mounted() {
+      return isMounted;
+    },
+    mount: async (selector) => {
+      if (isMounted) {
+        throw ElementError("Element is already mounted");
+      }
+      container = typeof selector === "string" ? document.querySelector(selector) : selector;
+      if (!container) {
+        throw ElementError(`Container not found: ${selector}`);
+      }
+      const parentOrigin = window.location.origin;
+      const iframeUrl = new URL(
+        `${sdkConfig.elementsBaseUrl}/card-number.html`
+      );
+      iframeUrl.searchParams.set("parentOrigin", parentOrigin);
+      iframeUrl.searchParams.set("elementId", id);
+      iframeUrl.searchParams.set(
+        "measurePerformance",
+        String(sdkConfig.measurePerformance || false)
+      );
+      iframeUrl.searchParams.set("debug", String(sdkConfig.debug || false));
+      iframe = createIframe({
+        src: iframeUrl.toString(),
+        sandbox: "allow-scripts allow-same-origin",
+        title: options.ariaLabel || "Card Number Input"
+      });
+      iframe.setAttribute("data-bt-element-id", id);
+      iframe.setAttribute("data-theme-mode", sdkConfig.themeMode || "auto");
+      client = createPostMessageClient(iframe, {
+        targetOrigin: sdkConfig.iframeOrigin,
+        timeout: sdkConfig.timeoutMs,
+        retries: sdkConfig.retryConfig.maxRetries,
+        debug: sdkConfig.debug
+      });
+      mounter = createMounter();
+      setupEventListeners();
+      const readyPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(
+            ElementError(
+              `Iframe EVENT_READY not received within ${sdkConfig.timeoutMs}ms`,
+              id,
+              { elementType: type, timeoutMs: sdkConfig.timeoutMs }
+            )
+          );
+        }, sdkConfig.timeoutMs);
+        const handleReady = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        eventTarget.addEventListener("ready", handleReady, { once: true });
+      });
+      mounter.mount(container, iframe, {
+        timeoutMs: sdkConfig.timeoutMs
+      });
+      isMounted = true;
+      try {
+        await ensureCoordinatorReady();
+        await readyPromise;
+        await client.sendRequest("CMD_SET_CONFIG", {
+          elementId: id,
+          // Include element ID for validation
+          apiKey,
+          apiTimeout: sdkConfig.timeoutMs,
+          apiRetries: sdkConfig.retryConfig.maxRetries,
+          theme: sdkConfig.theme,
+          darkTheme: sdkConfig.darkTheme,
+          themeMode: sdkConfig.themeMode,
+          placeholder: options.placeholder,
+          disabled: options.disabled,
+          readOnly: options.readOnly,
+          debug: sdkConfig.debug
+        });
+        if (iframe) iframe.style.opacity = "1";
+      } catch (error) {
+        if (eventDispatcher) {
+          eventDispatcher.dispatchError(
+            "MOUNT_ERROR",
+            error.message,
+            error
+          );
+        }
+        isMounted = false;
+        if (client) {
+          client.destroy();
+          client = null;
+        }
+        if (mounter && iframe) {
+          mounter.unmount(iframe);
+          iframe = null;
+          mounter = null;
+        }
+        eventDispatcher = null;
+        container = null;
+        throw error;
+      }
+    },
+    unmount: () => {
+      if (!isMounted) {
+        throw ElementError("Element is not mounted");
+      }
+      if (client) {
+        client.sendRequest("CMD_CLEAR_CACHE", {}).catch((error) => {
+          log("Failed to send clear cache command", {
+            error: error.message
+          });
+        });
+        client.destroy();
+        client = null;
+      }
+      if (mounter && iframe) {
+        mounter.unmount(iframe);
+        iframe = null;
+        mounter = null;
+      }
+      eventDispatcher = null;
+      container = null;
+      isMounted = false;
+    },
+    update: async (newOptions) => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before updating");
+      }
+      const updatePayload = {
+        placeholder: newOptions.placeholder,
+        disabled: newOptions.disabled,
+        readOnly: newOptions.readOnly
+      };
+      if (newOptions.themeMode !== void 0) {
+        updatePayload.themeMode = newOptions.themeMode;
+        updatePayload.theme = sdkConfig.theme;
+        updatePayload.darkTheme = sdkConfig.darkTheme;
+      }
+      await client.sendRequest("CMD_UPDATE_CONFIG", updatePayload);
+    },
+    focus: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before focusing");
+      }
+      client.sendRequest("CMD_FOCUS", {});
+    },
+    blur: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before blurring");
+      }
+      client.sendRequest("CMD_BLUR", {});
+    },
+    clear: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before clearing");
+      }
+      client.sendRequest("CMD_CLEAR", {});
+    },
+    on: (eventType, listener) => {
+      eventTarget.addEventListener(
+        eventType,
+        listener
+      );
+      return () => eventTarget.removeEventListener(
+        eventType,
+        listener
+      );
+    }
+  };
+};
+const createCVVElement = (apiKey, sdkConfig, options = {}, coordinatorElementId, ensureCoordinatorReady) => {
+  let iframe = null;
+  let client = null;
+  let mounter = null;
+  let isMounted = false;
+  let container = null;
+  let eventDispatcher = null;
+  const eventTarget = new EventTarget();
+  const id = coordinatorElementId;
+  const type = "cvv";
+  const setupEventListeners = () => {
+    if (!client) return;
+    eventDispatcher = createEventDispatcher({
+      elementType: type,
+      elementId: id,
+      client,
+      eventTarget
+    });
+    eventDispatcher.setupSubscriptions();
+  };
+  return {
+    id,
+    type,
+    get mounted() {
+      return isMounted;
+    },
+    mount: async (selector) => {
+      if (isMounted) {
+        throw ElementError("Element is already mounted", id);
+      }
+      container = typeof selector === "string" ? document.querySelector(selector) : selector;
+      if (!container) {
+        throw ElementError(`Container not found: ${selector}`);
+      }
+      const parentOrigin = window.location.origin;
+      const iframeUrl = new URL(`${sdkConfig.elementsBaseUrl}/cvv.html`);
+      iframeUrl.searchParams.set("parentOrigin", parentOrigin);
+      iframeUrl.searchParams.set("elementId", id);
+      iframeUrl.searchParams.set(
+        "measurePerformance",
+        String(sdkConfig.measurePerformance || false)
+      );
+      iframeUrl.searchParams.set("debug", String(sdkConfig.debug || false));
+      iframe = createIframe({
+        src: iframeUrl.toString(),
+        sandbox: "allow-scripts allow-same-origin",
+        title: options.ariaLabel || "CVV Input"
+      });
+      iframe.setAttribute("data-bt-element-id", id);
+      client = createPostMessageClient(iframe, {
+        targetOrigin: sdkConfig.iframeOrigin,
+        timeout: sdkConfig.timeoutMs,
+        retries: sdkConfig.retryConfig.maxRetries,
+        debug: sdkConfig.debug
+      });
+      mounter = createMounter();
+      setupEventListeners();
+      const readyPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(
+            ElementError(
+              `Iframe EVENT_READY not received within ${sdkConfig.timeoutMs}ms`,
+              id,
+              { elementType: type, timeoutMs: sdkConfig.timeoutMs }
+            )
+          );
+        }, sdkConfig.timeoutMs);
+        const handleReady = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        eventTarget.addEventListener("ready", handleReady, { once: true });
+      });
+      mounter.mount(container, iframe, {
+        timeoutMs: sdkConfig.timeoutMs
+      });
+      isMounted = true;
+      try {
+        await ensureCoordinatorReady();
+        await readyPromise;
+        await client.sendRequest("CMD_SET_CONFIG", {
+          elementId: id,
+          // Include element ID for validation
+          theme: sdkConfig.theme,
+          darkTheme: sdkConfig.darkTheme,
+          themeMode: sdkConfig.themeMode,
+          apiKey,
+          apiTimeout: sdkConfig.timeoutMs,
+          apiRetries: sdkConfig.retryConfig.maxRetries,
+          placeholder: options.placeholder,
+          disabled: options.disabled,
+          readOnly: options.readOnly,
+          showToggle: options.showToggle,
+          debug: sdkConfig.debug
+        });
+        if (iframe) iframe.style.opacity = "1";
+      } catch (error) {
+        if (eventDispatcher) {
+          eventDispatcher.dispatchError(
+            "MOUNT_ERROR",
+            error.message,
+            error
+          );
+        }
+        isMounted = false;
+        if (client) {
+          client.destroy();
+          client = null;
+        }
+        if (mounter && iframe) {
+          mounter.unmount(iframe);
+          iframe = null;
+          mounter = null;
+        }
+        eventDispatcher = null;
+        container = null;
+        throw error;
+      }
+    },
+    unmount: () => {
+      if (!isMounted) {
+        throw ElementError("Element is not mounted");
+      }
+      if (client) {
+        client.sendRequest("CMD_CLEAR_CACHE", {}).catch((error) => {
+          log("Failed to send clear cache command", {
+            error: error.message
+          });
+        });
+        client.destroy();
+        client = null;
+      }
+      if (mounter && iframe) {
+        mounter.unmount(iframe);
+        iframe = null;
+        mounter = null;
+      }
+      eventDispatcher = null;
+      container = null;
+      isMounted = false;
+    },
+    update: async (newOptions) => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before updating", id);
+      }
+      const updatePayload = {
+        placeholder: newOptions.placeholder,
+        disabled: newOptions.disabled,
+        readOnly: newOptions.readOnly,
+        // ✅ SDK auto-coordination: Pass brand info for dynamic maxlength
+        cardBrand: newOptions.cardBrand,
+        cvvLengths: newOptions.cvvLengths
+      };
+      if (newOptions.themeMode !== void 0) {
+        updatePayload.themeMode = newOptions.themeMode;
+        updatePayload.theme = sdkConfig.theme;
+        updatePayload.darkTheme = sdkConfig.darkTheme;
+      }
+      await client.sendRequest("CMD_UPDATE_CONFIG", updatePayload);
+    },
+    focus: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before focusing", id);
+      }
+      client.sendRequest("CMD_FOCUS", {});
+    },
+    blur: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before blurring", id);
+      }
+      client.sendRequest("CMD_BLUR", {});
+    },
+    clear: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before clearing", id);
+      }
+      client.sendRequest("CMD_CLEAR", {});
+    },
+    on: (eventType, listener) => {
+      eventTarget.addEventListener(
+        eventType,
+        listener
+      );
+      return () => eventTarget.removeEventListener(
+        eventType,
+        listener
+      );
+    }
+  };
+};
+const createExpiryElement = (apiKey, sdkConfig, options = {}, coordinatorElementId, ensureCoordinatorReady) => {
+  let iframe = null;
+  let client = null;
+  let mounter = null;
+  let isMounted = false;
+  let container = null;
+  let eventDispatcher = null;
+  const eventTarget = new EventTarget();
+  const id = coordinatorElementId;
+  const type = "expiry";
+  const setupEventListeners = () => {
+    if (!client) return;
+    eventDispatcher = createEventDispatcher({
+      elementType: type,
+      elementId: id,
+      client,
+      eventTarget
+    });
+    eventDispatcher.setupSubscriptions();
+  };
+  return {
+    id,
+    type,
+    get mounted() {
+      return isMounted;
+    },
+    mount: async (selector) => {
+      if (isMounted) {
+        throw ElementError("Element is already mounted", id);
+      }
+      container = typeof selector === "string" ? document.querySelector(selector) : selector;
+      if (!container) {
+        throw ElementError(`Container not found: ${selector}`);
+      }
+      const parentOrigin = window.location.origin;
+      const iframeUrl = new URL(`${sdkConfig.elementsBaseUrl}/expiry.html`);
+      iframeUrl.searchParams.set("parentOrigin", parentOrigin);
+      iframeUrl.searchParams.set("elementId", id);
+      iframeUrl.searchParams.set(
+        "measurePerformance",
+        String(sdkConfig.measurePerformance || false)
+      );
+      iframeUrl.searchParams.set("debug", String(sdkConfig.debug || false));
+      iframe = createIframe({
+        src: iframeUrl.toString(),
+        sandbox: "allow-scripts allow-same-origin",
+        title: options.ariaLabel || "Expiry Date Input"
+      });
+      iframe.setAttribute("data-bt-element-id", id);
+      client = createPostMessageClient(iframe, {
+        targetOrigin: sdkConfig.iframeOrigin,
+        timeout: sdkConfig.timeoutMs,
+        retries: sdkConfig.retryConfig.maxRetries,
+        debug: sdkConfig.debug
+      });
+      mounter = createMounter();
+      setupEventListeners();
+      const readyPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(
+            ElementError(
+              `Iframe EVENT_READY not received within ${sdkConfig.timeoutMs}ms`,
+              id,
+              { elementType: type, timeoutMs: sdkConfig.timeoutMs }
+            )
+          );
+        }, sdkConfig.timeoutMs);
+        const handleReady = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        eventTarget.addEventListener("ready", handleReady, { once: true });
+      });
+      mounter.mount(container, iframe, {
+        timeoutMs: sdkConfig.timeoutMs
+      });
+      isMounted = true;
+      try {
+        await ensureCoordinatorReady();
+        await readyPromise;
+        await client.sendRequest("CMD_SET_CONFIG", {
+          elementId: id,
+          // Include element ID for validation
+          theme: sdkConfig.theme,
+          darkTheme: sdkConfig.darkTheme,
+          themeMode: sdkConfig.themeMode,
+          apiKey,
+          apiTimeout: sdkConfig.timeoutMs,
+          apiRetries: sdkConfig.retryConfig.maxRetries,
+          placeholder: options.placeholder,
+          disabled: options.disabled,
+          readOnly: options.readOnly,
+          debug: sdkConfig.debug
+        });
+        if (iframe) iframe.style.opacity = "1";
+      } catch (error) {
+        if (eventDispatcher) {
+          eventDispatcher.dispatchError(
+            "MOUNT_ERROR",
+            error.message,
+            error
+          );
+        }
+        isMounted = false;
+        if (client) {
+          client.destroy();
+          client = null;
+        }
+        if (mounter && iframe) {
+          mounter.unmount(iframe);
+          iframe = null;
+          mounter = null;
+        }
+        eventDispatcher = null;
+        container = null;
+        throw error;
+      }
+    },
+    unmount: () => {
+      if (!isMounted) {
+        throw ElementError("Element is not mounted");
+      }
+      if (client) {
+        client.sendRequest("CMD_CLEAR_CACHE", {}).catch((error) => {
+          log("Failed to send clear cache command", {
+            error: error.message
+          });
+        });
+        client.destroy();
+        client = null;
+      }
+      if (mounter && iframe) {
+        mounter.unmount(iframe);
+        iframe = null;
+        mounter = null;
+      }
+      eventDispatcher = null;
+      container = null;
+      isMounted = false;
+    },
+    update: async (newOptions) => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before updating", id);
+      }
+      const updatePayload = {
+        placeholder: newOptions.placeholder,
+        disabled: newOptions.disabled,
+        readOnly: newOptions.readOnly
+      };
+      if (newOptions.themeMode !== void 0) {
+        updatePayload.themeMode = newOptions.themeMode;
+        updatePayload.theme = sdkConfig.theme;
+        updatePayload.darkTheme = sdkConfig.darkTheme;
+      }
+      await client.sendRequest("CMD_UPDATE_CONFIG", updatePayload);
+    },
+    focus: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before focusing", id);
+      }
+      client.sendRequest("CMD_FOCUS", {});
+    },
+    blur: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before blurring", id);
+      }
+      client.sendRequest("CMD_BLUR", {});
+    },
+    clear: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before clearing", id);
+      }
+      client.sendRequest("CMD_CLEAR", {});
+    },
+    on: (eventType, listener) => {
+      eventTarget.addEventListener(
+        eventType,
+        listener
+      );
+      return () => eventTarget.removeEventListener(
+        eventType,
+        listener
+      );
+    }
+  };
+};
+const createTextElement = (apiKey, sdkConfig, options = {}, coordinatorElementId, ensureCoordinatorReady) => {
+  let iframe = null;
+  let client = null;
+  let mounter = null;
+  let isMounted = false;
+  let container = null;
+  let eventDispatcher = null;
+  const eventTarget = new EventTarget();
+  const id = coordinatorElementId;
+  const type = "text";
+  if (options.transform) {
+    if (!Array.isArray(options.transform) || options.transform.length !== 2 || !(options.transform[0] instanceof RegExp) || typeof options.transform[1] !== "string") {
+      throw new TypeError(
+        'transform must be a tuple of [RegExp, string]. Example: [/-/g, ""]'
+      );
+    }
+  }
+  const setupEventListeners = () => {
+    if (!client) return;
+    eventDispatcher = createEventDispatcher({
+      elementType: type,
+      elementId: id,
+      client,
+      eventTarget
+    });
+    eventDispatcher.setupSubscriptions();
+  };
+  return {
+    id,
+    type,
+    get mounted() {
+      return isMounted;
+    },
+    mount: async (selector) => {
+      if (isMounted) {
+        throw ElementError("Element is already mounted", id);
+      }
+      container = typeof selector === "string" ? document.querySelector(selector) : selector;
+      if (!container) {
+        throw ElementError(`Container not found: ${selector}`);
+      }
+      const parentOrigin = window.location.origin;
+      const iframeUrl = new URL(`${sdkConfig.elementsBaseUrl}/text.html`);
+      iframeUrl.searchParams.set("parentOrigin", parentOrigin);
+      iframeUrl.searchParams.set("elementId", id);
+      iframeUrl.searchParams.set(
+        "measurePerformance",
+        String(sdkConfig.measurePerformance || false)
+      );
+      iframeUrl.searchParams.set("debug", String(sdkConfig.debug || false));
+      iframe = createIframe({
+        src: iframeUrl.toString(),
+        sandbox: "allow-scripts allow-same-origin",
+        title: options.ariaLabel || "Text Input"
+      });
+      iframe.setAttribute("data-bt-element-id", id);
+      client = createPostMessageClient(iframe, {
+        targetOrigin: sdkConfig.iframeOrigin,
+        timeout: sdkConfig.timeoutMs,
+        retries: sdkConfig.retryConfig.maxRetries,
+        debug: sdkConfig.debug
+      });
+      mounter = createMounter();
+      setupEventListeners();
+      const readyPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(
+            ElementError(
+              `Iframe EVENT_READY not received within ${sdkConfig.timeoutMs}ms`,
+              id,
+              { elementType: type, timeoutMs: sdkConfig.timeoutMs }
+            )
+          );
+        }, sdkConfig.timeoutMs);
+        const handleReady = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        eventTarget.addEventListener("ready", handleReady, { once: true });
+      });
+      mounter.mount(container, iframe, {
+        timeoutMs: sdkConfig.timeoutMs
+      });
+      isMounted = true;
+      try {
+        await ensureCoordinatorReady();
+        await readyPromise;
+        const serializedTransform = options.transform ? {
+          pattern: options.transform[0].source,
+          flags: options.transform[0].flags,
+          replacement: options.transform[1]
+        } : void 0;
+        const serializedMask = options.mask ? options.mask.map((item) => {
+          if (typeof item === "string") {
+            return item;
+          } else if (item instanceof RegExp) {
+            return { source: item.source, flags: item.flags };
+          }
+          return item;
+        }) : void 0;
+        await client.sendRequest("CMD_SET_CONFIG", {
+          elementId: id,
+          // Include element ID for validation
+          theme: sdkConfig.theme,
+          darkTheme: sdkConfig.darkTheme,
+          themeMode: sdkConfig.themeMode,
+          apiKey,
+          apiTimeout: sdkConfig.timeoutMs,
+          apiRetries: sdkConfig.retryConfig.maxRetries,
+          placeholder: options.placeholder,
+          disabled: options.disabled,
+          readOnly: options.readOnly,
+          // Text-specific options
+          validation: options.validation,
+          required: options.required,
+          maxLength: options.maxLength,
+          password: options.password,
+          inputMode: options.inputMode,
+          mask: serializedMask,
+          transform: serializedTransform,
+          debug: sdkConfig.debug
+        });
+        if (iframe) iframe.style.opacity = "1";
+      } catch (error) {
+        if (eventDispatcher) {
+          eventDispatcher.dispatchError(
+            "MOUNT_ERROR",
+            error.message,
+            error
+          );
+        }
+        isMounted = false;
+        if (client) {
+          client.destroy();
+          client = null;
+        }
+        if (mounter && iframe) {
+          mounter.unmount(iframe);
+          iframe = null;
+          mounter = null;
+        }
+        eventDispatcher = null;
+        container = null;
+        throw error;
+      }
+    },
+    unmount: () => {
+      if (!isMounted) {
+        throw ElementError("Element is not mounted");
+      }
+      if (client) {
+        client.sendRequest("CMD_CLEAR_CACHE", {}).catch((error) => {
+          log("Failed to send clear cache command", {
+            error: error.message
+          });
+        });
+        client.destroy();
+        client = null;
+      }
+      if (mounter && iframe) {
+        mounter.unmount(iframe);
+        iframe = null;
+        mounter = null;
+      }
+      eventDispatcher = null;
+      container = null;
+      isMounted = false;
+    },
+    update: async (newOptions) => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before updating", id);
+      }
+      const updatePayload = {
+        placeholder: newOptions.placeholder,
+        disabled: newOptions.disabled,
+        readOnly: newOptions.readOnly,
+        // Text-specific UI updates (not data schema)
+        required: newOptions.required,
+        maxLength: newOptions.maxLength,
+        password: newOptions.password,
+        inputMode: newOptions.inputMode
+      };
+      if (newOptions.themeMode !== void 0) {
+        updatePayload.themeMode = newOptions.themeMode;
+        updatePayload.theme = sdkConfig.theme;
+        updatePayload.darkTheme = sdkConfig.darkTheme;
+      }
+      await client.sendRequest("CMD_UPDATE_CONFIG", updatePayload);
+    },
+    focus: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before focusing", id);
+      }
+      client.sendRequest("CMD_FOCUS", {});
+    },
+    blur: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before blurring", id);
+      }
+      client.sendRequest("CMD_BLUR", {});
+    },
+    clear: () => {
+      if (!isMounted || !client) {
+        throw ElementError("Element must be mounted before clearing", id);
+      }
+      client.sendRequest("CMD_CLEAR", {});
+    },
+    on: (eventType, listener) => {
+      eventTarget.addEventListener(
+        eventType,
+        listener
+      );
+      return () => eventTarget.removeEventListener(
+        eventType,
+        listener
+      );
+    }
+  };
+};
+const isPrimitive = (value) => value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+const isElement = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.mount === "function" && typeof v.update === "function" && typeof v.on === "function";
+};
+const resolveElementReferences = (value) => {
+  if (isPrimitive(value)) return value;
+  if (isElement(value)) {
+    if (!value.id) {
+      throw ElementError(
+        "Element is missing id property. Ensure createElement is called after the SDK loads and all elements are mounted before calling tokenize()."
+      );
+    }
+    return value.id;
+  }
+  if (Array.isArray(value)) return value.map(resolveElementReferences);
+  if (typeof value === "object" && value !== null) {
+    const resolved = {};
+    for (const [key, v] of Object.entries(value)) {
+      resolved[key] = resolveElementReferences(v);
+    }
+    return resolved;
+  }
+  return value;
+};
+const DEFAULT_THEME = {
+  colors: {
+    primary: "#3b82f6",
+    // blue-500
+    error: "#ef4444",
+    // red-500
+    success: "#10b981",
+    // emerald-500
+    text: {
+      primary: "#1f2937",
+      // gray-800
+      secondary: "#6b7280",
+      // gray-500
+      placeholder: "#9ca3af",
+      // gray-400
+      disabled: "#d1d5db"
+      // gray-300
+    },
+    background: {
+      default: "#ffffff",
+      hover: "#f9fafb",
+      // gray-50
+      focus: "#eff6ff",
+      // blue-50
+      disabled: "#f9fafb"
+      // gray-50
+    },
+    border: {
+      default: "#d1d5db",
+      // gray-300
+      hover: "#9ca3af",
+      // gray-400
+      focus: "#3b82f6",
+      // blue-500
+      error: "#ef4444"
+      // red-500
+    }
+  },
+  typography: {
+    fontFamily: '"Inter", ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+    fontSize: {
+      sm: "14px",
+      base: "16px",
+      lg: "18px"
+    },
+    fontWeight: {
+      normal: "400",
+      medium: "500",
+      semibold: "600"
+    },
+    lineHeight: {
+      tight: "1.25",
+      normal: "1.5",
+      relaxed: "1.75"
+    }
+  },
+  spacing: {
+    xs: "4px",
+    sm: "8px",
+    md: "12px",
+    lg: "16px",
+    xl: "24px"
+  },
+  borders: {
+    radius: {
+      none: "0",
+      sm: "2px",
+      base: "4px",
+      md: "6px",
+      lg: "8px",
+      full: "9999px"
+    },
+    width: {
+      thin: "1px",
+      base: "2px",
+      thick: "3px"
+    }
+  },
+  shadows: {
+    none: "none",
+    sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+    base: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)",
+    md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+    lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+    focus: "0 0 0 3px rgba(59, 130, 246, 0.1)"
+    // blue-500 with alpha
+  },
+  transitions: {
+    fast: "150ms cubic-bezier(0.4, 0, 0.2, 1)",
+    base: "200ms cubic-bezier(0.4, 0, 0.2, 1)",
+    slow: "300ms cubic-bezier(0.4, 0, 0.2, 1)"
+  }
+};
+const mergeWithDefaultTheme = (userTheme) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  if (!userTheme) return DEFAULT_THEME;
+  return {
+    colors: {
+      primary: ((_a = userTheme.colors) == null ? void 0 : _a.primary) ?? DEFAULT_THEME.colors.primary,
+      error: ((_b = userTheme.colors) == null ? void 0 : _b.error) ?? DEFAULT_THEME.colors.error,
+      success: ((_c = userTheme.colors) == null ? void 0 : _c.success) ?? DEFAULT_THEME.colors.success,
+      text: {
+        ...DEFAULT_THEME.colors.text,
+        ...(_d = userTheme.colors) == null ? void 0 : _d.text
+      },
+      background: {
+        ...DEFAULT_THEME.colors.background,
+        ...(_e = userTheme.colors) == null ? void 0 : _e.background
+      },
+      border: {
+        ...DEFAULT_THEME.colors.border,
+        ...(_f = userTheme.colors) == null ? void 0 : _f.border
+      }
+    },
+    typography: {
+      ...DEFAULT_THEME.typography,
+      ...userTheme.typography,
+      fontSize: {
+        ...DEFAULT_THEME.typography.fontSize,
+        ...(_g = userTheme.typography) == null ? void 0 : _g.fontSize
+      },
+      fontWeight: {
+        ...DEFAULT_THEME.typography.fontWeight,
+        ...(_h = userTheme.typography) == null ? void 0 : _h.fontWeight
+      },
+      lineHeight: {
+        ...DEFAULT_THEME.typography.lineHeight,
+        ...(_i = userTheme.typography) == null ? void 0 : _i.lineHeight
+      }
+    },
+    spacing: { ...DEFAULT_THEME.spacing, ...userTheme.spacing },
+    borders: {
+      radius: {
+        ...DEFAULT_THEME.borders.radius,
+        ...(_j = userTheme.borders) == null ? void 0 : _j.radius
+      },
+      width: {
+        ...DEFAULT_THEME.borders.width,
+        ...(_k = userTheme.borders) == null ? void 0 : _k.width
+      }
+    },
+    shadows: { ...DEFAULT_THEME.shadows, ...userTheme.shadows },
+    transitions: { ...DEFAULT_THEME.transitions, ...userTheme.transitions }
+  };
+};
+const warnUnknownKeys = (label, obj, knownKeys, deprecatedKeys) => {
+  for (const key of Object.keys(obj)) {
+    if (knownKeys.has(key)) {
+      continue;
+    }
+    if (deprecatedKeys == null ? void 0 : deprecatedKeys.has(key)) {
+      console.warn(
+        `[BasisTheory] Deprecated option "${key}" in ${label}. ${deprecatedKeys.get(key)}`
+      );
+      continue;
+    }
+    console.warn(
+      `[BasisTheory] Unknown option "${key}" in ${label}. This option will be ignored. See https://developers.basistheory.com/docs/ for supported options.`
+    );
+  }
+};
+const KNOWN_SDK_KEYS = /* @__PURE__ */ new Set([
+  "elementsBaseUrl",
+  "apiBaseUrl",
+  "debug",
+  "measurePerformance",
+  "timeoutMs",
+  "retryConfig",
+  "themeMode",
+  "theme",
+  "darkTheme"
+]);
+const DEPRECATED_SDK_KEYS = /* @__PURE__ */ new Map([
+  ["iframeOrigin", 'Use "elementsBaseUrl" instead.']
+]);
+const validateAPIKey = (apiKey) => {
+  if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
+    throw ConfigurationError("API key is required");
+  }
+};
+const validateSDKConfig = (options = {}) => {
+  var _a, _b, _c;
+  warnUnknownKeys(
+    "SDKOptions",
+    options,
+    KNOWN_SDK_KEYS,
+    DEPRECATED_SDK_KEYS
+  );
+  const baseUrl = options.elementsBaseUrl || options.iframeOrigin;
+  if (baseUrl !== void 0) {
+    if (typeof baseUrl !== "string" || baseUrl.trim().length === 0) {
+      throw ConfigurationError("elementsBaseUrl must be a non-empty string");
+    }
+    try {
+      new URL(baseUrl);
+    } catch {
+      throw ConfigurationError("elementsBaseUrl must be a valid URL");
+    }
+  }
+  if (options.apiBaseUrl !== void 0) {
+    if (typeof options.apiBaseUrl !== "string" || options.apiBaseUrl.trim().length === 0) {
+      throw ConfigurationError("apiBaseUrl must be a non-empty string");
+    }
+    try {
+      new URL(options.apiBaseUrl);
+    } catch {
+      throw ConfigurationError("apiBaseUrl must be a valid URL");
+    }
+  }
+  if (options.debug !== void 0 && typeof options.debug !== "boolean") {
+    throw ConfigurationError("debug must be a boolean");
+  }
+  if (options.measurePerformance !== void 0 && typeof options.measurePerformance !== "boolean") {
+    throw ConfigurationError("measurePerformance must be a boolean");
+  }
+  if (options.timeoutMs !== void 0) {
+    if (typeof options.timeoutMs !== "number" || options.timeoutMs <= 0) {
+      throw ConfigurationError("timeoutMs must be a positive number");
+    }
+  }
+  const retryConfig = {
+    maxRetries: ((_a = options.retryConfig) == null ? void 0 : _a.maxRetries) ?? 3,
+    delayMs: ((_b = options.retryConfig) == null ? void 0 : _b.delayMs) ?? 1e3,
+    backoffFactor: ((_c = options.retryConfig) == null ? void 0 : _c.backoffFactor) ?? 2
+  };
+  if (typeof retryConfig.maxRetries !== "number" || retryConfig.maxRetries < 0) {
+    throw ConfigurationError("maxRetries must be a non-negative number");
+  }
+  if (typeof retryConfig.delayMs !== "number" || retryConfig.delayMs <= 0) {
+    throw ConfigurationError("retryConfig.delayMs must be a positive number");
+  }
+  if (typeof retryConfig.backoffFactor !== "number" || retryConfig.backoffFactor < 1) {
+    throw ConfigurationError("retryConfig.backoffFactor must be >= 1");
+  }
+  const themeMode = options.themeMode || "auto";
+  if (!["light", "dark", "auto"].includes(themeMode)) {
+    throw ConfigurationError('themeMode must be "light", "dark", or "auto"');
+  }
+  const finalBaseUrl = baseUrl || "https://js.basistheory.com/3.0.0-beta.2/elements";
+  const iframeOrigin = new URL(finalBaseUrl).origin;
+  return {
+    iframeOrigin,
+    elementsBaseUrl: finalBaseUrl,
+    apiBaseUrl: options.apiBaseUrl,
+    // Optional - auto-detects if not provided
+    debug: options.debug ?? false,
+    measurePerformance: options.measurePerformance ?? false,
+    timeoutMs: options.timeoutMs || 3e4,
+    // 30s default for slow 3G connections
+    themeMode,
+    theme: mergeWithDefaultTheme(options.theme),
+    // Light theme or only theme
+    darkTheme: options.darkTheme ? mergeWithDefaultTheme(options.darkTheme) : void 0,
+    // Optional dark theme
+    retryConfig
+  };
+};
+const COMMON_ELEMENT_KEYS = /* @__PURE__ */ new Set([
+  "placeholder",
+  "ariaLabel",
+  "disabled",
+  "readOnly"
+]);
+const ELEMENT_TYPE_KEYS = {
+  cardNumber: /* @__PURE__ */ new Set([...COMMON_ELEMENT_KEYS]),
+  cvv: /* @__PURE__ */ new Set([...COMMON_ELEMENT_KEYS, "cardBrand", "cvvLengths"]),
+  // Internal coordination props
+  expiry: /* @__PURE__ */ new Set([...COMMON_ELEMENT_KEYS]),
+  text: /* @__PURE__ */ new Set([
+    ...COMMON_ELEMENT_KEYS,
+    "validation",
+    "required",
+    "maxLength",
+    "password",
+    "inputMode",
+    "mask",
+    "transform"
+  ]),
+  card: /* @__PURE__ */ new Set([
+    ...COMMON_ELEMENT_KEYS,
+    "layout",
+    "stackAt",
+    "iconPosition",
+    "cardBrands"
+  ])
+};
+const validateElementOptions = (type, options = {}) => {
+  const validKeys = ELEMENT_TYPE_KEYS[type];
+  warnUnknownKeys(
+    `ElementOptions (${type})`,
+    options,
+    validKeys
+  );
+  if (options.placeholder !== void 0) {
+    if (type === "card") {
+      if (typeof options.placeholder !== "object" || options.placeholder === null) {
+        throw ConfigurationError("placeholder for card element must be an object with cardNumber, expiryDate, and cvv keys");
+      }
+    } else if (typeof options.placeholder !== "string") {
+      throw ConfigurationError("placeholder must be a string");
+    }
+  }
+  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") {
+    throw ConfigurationError("disabled must be a boolean");
+  }
+  if (options.readOnly !== void 0 && typeof options.readOnly !== "boolean") {
+    throw ConfigurationError("readOnly must be a boolean");
+  }
+  if (options.ariaLabel !== void 0 && typeof options.ariaLabel !== "string") {
+    throw ConfigurationError("ariaLabel must be a string");
+  }
+  if (type === "text") {
+    if (options.maxLength !== void 0) {
+      if (typeof options.maxLength !== "number" || options.maxLength <= 0) {
+        throw ConfigurationError("maxLength must be a positive number");
+      }
+    }
+    if (options.password !== void 0 && typeof options.password !== "boolean") {
+      throw ConfigurationError("password must be a boolean");
+    }
+    if (options.required !== void 0 && typeof options.required !== "boolean") {
+      throw ConfigurationError("required must be a boolean");
+    }
+    if (options.validation !== void 0 && !(options.validation instanceof RegExp)) {
+      throw ConfigurationError("validation must be a RegExp");
+    }
+    if (options.transform) {
+      if (!Array.isArray(options.transform) || options.transform.length !== 2 || !(options.transform[0] instanceof RegExp) || typeof options.transform[1] !== "string") {
+        throw ConfigurationError(
+          'transform must be a tuple of [RegExp, string]. Example: [/-/g, ""]'
+        );
+      }
+    }
+  }
+  if (type === "card") {
+    const cardOptions = options;
+    if (cardOptions.layout !== void 0) {
+      if (!["row", "column", "auto"].includes(cardOptions.layout)) {
+        throw ConfigurationError('layout must be "row", "column", or "auto"');
+      }
+    }
+    if (cardOptions.stackAt !== void 0) {
+      if (typeof cardOptions.stackAt !== "number" || cardOptions.stackAt <= 0) {
+        throw ConfigurationError("stackAt must be a positive number");
+      }
+    }
+    if (cardOptions.iconPosition !== void 0) {
+      if (!["left", "right", "none"].includes(cardOptions.iconPosition)) {
+        throw ConfigurationError('iconPosition must be "left", "right", or "none"');
+      }
+    }
+    if (cardOptions.cardBrands !== void 0) {
+      if (!Array.isArray(cardOptions.cardBrands)) {
+        throw ConfigurationError("cardBrands must be an array of strings");
+      }
+      if (cardOptions.cardBrands.some((brand) => typeof brand !== "string")) {
+        throw ConfigurationError("All cardBrands must be strings");
+      }
+    }
+  }
+};
+const BasisTheory = (apiKey, options = {}, queuedCommands) => {
+  validateAPIKey(apiKey);
+  const config = validateSDKConfig(options);
+  const log2 = createDebugLogger("SDK", config.debug || false);
+  log2("SDK initialized", {
+    apiKeyPrefix: apiKey.substring(0, 7) + "...",
+    elementsBaseUrl: config.elementsBaseUrl,
+    iframeOrigin: config.iframeOrigin,
+    debug: config.debug || false
+  });
+  const elements = /* @__PURE__ */ new Map();
+  let coordinatorIframe = null;
+  let coordinatorClient = null;
+  let coordinatorReadyPromise = null;
+  let coordinatorInitStarted = false;
+  let currentThemeMode = options.themeMode || "auto";
+  let cardElementFactory = null;
+  const lazyCardElement = async () => {
+    if (!cardElementFactory) {
+      const module = await import("./create-card-BuOvimjH.js");
+      cardElementFactory = module.createCardElement;
+    }
+    return cardElementFactory;
+  };
+  const syncFactories = {
+    cardNumber: createCardNumberElement,
+    cvv: createCVVElement,
+    expiry: createExpiryElement,
+    text: createTextElement
+  };
+  const lazyFactories = {
+    card: lazyCardElement
+  };
+  const ensureCoordinatorInitialized = () => {
+    if (coordinatorReadyPromise) {
+      return coordinatorReadyPromise;
+    }
+    if (coordinatorInitStarted) {
+      return coordinatorReadyPromise;
+    }
+    coordinatorInitStarted = true;
+    coordinatorReadyPromise = initializeCoordinator();
+    return coordinatorReadyPromise;
+  };
+  const initializeCoordinator = async () => {
+    if (coordinatorIframe) {
+      log2("Coordinator already initialized", {
+        loaded: coordinatorIframe.contentWindow !== null
+      });
+      return;
+    }
+    log2("Initializing coordinator iframe", {
+      elementsBaseUrl: config.elementsBaseUrl
+    });
+    coordinatorIframe = document.createElement("iframe");
+    coordinatorIframe.setAttribute("name", "bt-coordinator");
+    coordinatorIframe.setAttribute("title", "BasisTheory Coordinator");
+    coordinatorIframe.setAttribute("role", "none");
+    coordinatorIframe.style.border = "none";
+    coordinatorIframe.style.width = "0";
+    coordinatorIframe.style.height = "0";
+    coordinatorIframe.style.position = "absolute";
+    coordinatorIframe.style.top = "-9999px";
+    coordinatorIframe.style.left = "-9999px";
+    const baseUrl = config.elementsBaseUrl.endsWith("/") ? config.elementsBaseUrl : `${config.elementsBaseUrl}/`;
+    const coordinatorUrl = new URL("coordinator.html", baseUrl);
+    coordinatorUrl.searchParams.set("parentOrigin", window.location.origin);
+    coordinatorIframe.src = coordinatorUrl.toString();
+    document.body.appendChild(coordinatorIframe);
+    log2("Coordinator iframe mounted", {
+      url: coordinatorIframe.src
+    });
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(
+          new Error(
+            `Coordinator load timeout (${config.timeoutMs}ms). Try increasing timeoutMs for slow connections.`
+          )
+        );
+      }, config.timeoutMs);
+      coordinatorIframe.addEventListener(
+        "load",
+        () => {
+          clearTimeout(timeout);
+          log2("Coordinator iframe loaded");
+          resolve();
+        },
+        { once: true }
+      );
+    });
+    coordinatorClient = createPostMessageClient(coordinatorIframe, {
+      targetOrigin: new URL(config.elementsBaseUrl).origin,
+      timeout: 3e4,
+      retries: 3,
+      debug: config.debug || false
+    });
+    log2("Coordinator PostMessage client created");
+    await coordinatorClient.sendRequest("CMD_SET_CONFIG", {
+      apiKey,
+      apiBaseUrl: config.apiBaseUrl,
+      // Optional - auto-detects if not provided
+      apiTimeout: 3e4,
+      apiRetries: 3,
+      debug: config.debug || false,
+      theme: config.theme,
+      darkTheme: config.darkTheme,
+      themeMode: config.themeMode
+    });
+    log2("Coordinator initialized successfully");
+  };
+  const sdk = {
+    /**
+     * PERFORMANCE OPTIMIZATION (Step 2 & 3):
+     * createElement is now SYNCHRONOUS - returns Element instantly
+     * Coordinator initialization starts on first element (but doesn't block)
+     */
+    createElement: (type, elementOptions) => {
+      const syncFactory = syncFactories[type];
+      const lazyFactory = lazyFactories[type];
+      if (!syncFactory && !lazyFactory) {
+        throw ConfigurationError(`Unknown element type: ${type}`);
+      }
+      if (elementOptions) {
+        validateElementOptions(type, elementOptions);
+      }
+      const localElementId = `${type}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+      log2("Creating element (sync)", {
+        type,
+        elementId: localElementId,
+        coordinatorInitialized: coordinatorIframe !== null,
+        isLazyLoaded: !!lazyFactory
+      });
+      let element;
+      if (syncFactory) {
+        element = syncFactory(
+          apiKey,
+          config,
+          elementOptions,
+          localElementId,
+          ensureCoordinatorInitialized
+        );
+      } else {
+        let realElement = null;
+        let loadPromise = null;
+        const loadRealElement = async () => {
+          if (!loadPromise) {
+            loadPromise = (async () => {
+              const factory = await lazyFactory();
+              realElement = factory(
+                apiKey,
+                config,
+                elementOptions,
+                localElementId,
+                ensureCoordinatorInitialized
+              );
+            })();
+          }
+          await loadPromise;
+        };
+        element = {
+          id: localElementId,
+          type,
+          get mounted() {
+            return (realElement == null ? void 0 : realElement.mounted) ?? false;
+          },
+          get fields() {
+            return realElement == null ? void 0 : realElement.fields;
+          },
+          mount: async (selector) => {
+            await loadRealElement();
+            return realElement.mount(selector);
+          },
+          unmount: () => {
+            if (!realElement) throw ElementError("Element not initialized");
+            return realElement.unmount();
+          },
+          update: async (opts) => {
+            if (!realElement) throw ElementError("Element not initialized");
+            return realElement.update(opts);
+          },
+          focus: () => {
+            if (!realElement) throw ElementError("Element not initialized");
+            return realElement.focus();
+          },
+          blur: () => {
+            if (!realElement) throw ElementError("Element not initialized");
+            return realElement.blur();
+          },
+          clear: () => {
+            if (!realElement) throw ElementError("Element not initialized");
+            return realElement.clear();
+          },
+          on: (eventType, listener) => {
+            if (!realElement) {
+              loadRealElement().then(() => realElement.on(eventType, listener));
+              return () => {
+              };
+            }
+            return realElement.on(eventType, listener);
+          }
+        };
+      }
+      elements.set(element.id, element);
+      if (type === "cardNumber") {
+        element.on("change", (event) => {
+          const { cardBrand, cvvLengths } = event.detail;
+          log2("Card number change event received", {
+            cardBrand,
+            cvvLengths,
+            cvvElementsCount: Array.from(elements.values()).filter(
+              (el) => el.type === "cvv"
+            ).length
+          });
+          if (cardBrand && cardBrand !== "Unknown" && cvvLengths) {
+            for (const [id, cvvElement] of elements) {
+              if (cvvElement.type === "cvv" && cvvElement.mounted) {
+                log2("Coordinating CVV element with card brand", {
+                  cvvElementId: id,
+                  cardBrand,
+                  cvvLengths,
+                  mounted: cvvElement.mounted
+                });
+                cvvElement.update({
+                  cardBrand,
+                  cvvLengths
+                  // Send cvvLengths array instead of full brandDefinition
+                }).catch((error) => {
+                  log2("Failed to update CVV element with card brand", {
+                    cvvElementId: id,
+                    cardBrand,
+                    error: error.message
+                  });
+                });
+              }
+            }
+          }
+        });
+      }
+      return element;
+    },
+    tokenize: async (payload, options2) => {
+      log2("tokenize called", {
+        hasPayload: !!payload,
+        hasOptions: !!options2,
+        coordinatorReady: !!coordinatorClient
+      });
+      if (!coordinatorClient) {
+        log2("Waiting for coordinator initialization");
+        await initializeCoordinator();
+      }
+      if (!coordinatorClient) {
+        throw CoordinatorError("Coordinator failed to initialize");
+      }
+      try {
+        const resolvedPayload = payload ? resolveElementReferences(payload) : {};
+        log2("Element references resolved", {
+          originalPayload: !!payload,
+          resolvedPayload: !!resolvedPayload
+        });
+        log2("Delegating tokenization to coordinator");
+        const token = await coordinatorClient.sendRequest(
+          "CMD_TOKENIZE",
+          {
+            payload: resolvedPayload,
+            options: options2
+          }
+        );
+        log2("tokenize successful", {
+          tokenId: token.id
+        });
+        return token;
+      } catch (error) {
+        log2("tokenize failed", {
+          error: error.message
+        });
+        throw error;
+      }
+    },
+    /**
+     * Token CRUD operations
+     * Supports Element references - automatically resolves to secure values
+     */
+    tokens: {
+      /**
+       * Create a new token
+       * Supports Element references in data (same as tokenize)
+       */
+      create: async (request) => {
+        if (!request || typeof request !== "object" || Array.isArray(request)) {
+          throw ValidationError("Token data must be a non-null object");
+        }
+        log2("tokens.create called", {
+          type: request.type,
+          hasData: !!request.data
+        });
+        if (!coordinatorClient) {
+          log2("Waiting for coordinator initialization");
+          await initializeCoordinator();
+        }
+        if (!coordinatorClient) {
+          throw new Error("Coordinator failed to initialize");
+        }
+        try {
+          const resolvedRequest = {
+            ...request,
+            data: resolveElementReferences(request.data)
+          };
+          log2("Element references resolved for tokens.create", {
+            resolvedData: !!resolvedRequest
+          });
+          const token = await coordinatorClient.sendRequest(
+            "CMD_TOKENS_CREATE",
+            { data: resolvedRequest }
+          );
+          log2("tokens.create successful", { tokenId: token.id });
+          return token;
+        } catch (error) {
+          log2("tokens.create failed", {
+            error: error.message
+          });
+          throw error;
+        }
+      },
+      /**
+       * Retrieve a token by ID
+       *
+       * @param id - Token ID to retrieve
+       * @param options - Optional configuration
+       * @param options.apiKey - Optional session key for authorized access (from sessions.create + authorize)
+       */
+      retrieve: async (id, options2) => {
+        log2("tokens.retrieve called", {
+          tokenId: id,
+          hasSessionKey: !!(options2 == null ? void 0 : options2.apiKey)
+        });
+        if (!coordinatorClient) {
+          await initializeCoordinator();
+        }
+        if (!coordinatorClient) {
+          throw new Error("Coordinator failed to initialize");
+        }
+        try {
+          const token = await coordinatorClient.sendRequest(
+            "CMD_TOKENS_RETRIEVE",
+            {
+              id,
+              apiKey: options2 == null ? void 0 : options2.apiKey
+              // Pass session key to coordinator
+            }
+          );
+          log2("tokens.retrieve successful", {
+            tokenId: token.id
+          });
+          return token;
+        } catch (error) {
+          log2("tokens.retrieve failed", {
+            error: error.message
+          });
+          throw error;
+        }
+      },
+      /**
+       * Update a token
+       * Supports Element references in data
+       */
+      update: async (id, request) => {
+        log2("tokens.update called", { tokenId: id });
+        if (!coordinatorClient) {
+          await initializeCoordinator();
+        }
+        if (!coordinatorClient) {
+          throw new Error("Coordinator failed to initialize");
+        }
+        try {
+          const resolvedRequest = request.data ? { ...request, data: resolveElementReferences(request.data) } : request;
+          const token = await coordinatorClient.sendRequest(
+            "CMD_TOKENS_UPDATE",
+            { id, data: resolvedRequest }
+          );
+          log2("tokens.update successful", { tokenId: token.id });
+          return token;
+        } catch (error) {
+          log2("tokens.update failed", {
+            error: error.message
+          });
+          throw error;
+        }
+      },
+      /**
+       * Encrypt token data with client-side JWE
+       * Uses ECDH-ES key agreement and A256GCM authenticated encryption
+       * Supports Element references - automatically resolves to secure values
+       *
+       * @param tokenData - Single token or multiple tokens to encrypt
+       * @param publicKeyPEM - X25519 public key in PEM format
+       * @param keyId - Key identifier for decryption lookup
+       * @returns Encrypted JWE token(s)
+       */
+      encrypt: async (tokenData, publicKeyPEM, keyId) => {
+        log2("tokens.encrypt called", {
+          isSingleToken: "type" in tokenData && "data" in tokenData,
+          keyId
+        });
+        if (!tokenData || typeof tokenData !== "object") {
+          throw ValidationError("tokenData must be an object");
+        }
+        if (!publicKeyPEM || typeof publicKeyPEM !== "string") {
+          throw ValidationError("publicKeyPEM is required");
+        }
+        if (!keyId || typeof keyId !== "string") {
+          throw ValidationError("keyId is required");
+        }
+        if (!coordinatorClient) {
+          await initializeCoordinator();
+        }
+        if (!coordinatorClient) {
+          throw new Error("Coordinator failed to initialize");
+        }
+        try {
+          const resolvedTokenData = resolveElementReferences(tokenData);
+          log2("Element references resolved for tokens.encrypt", {
+            originalData: !!tokenData,
+            resolvedData: !!resolvedTokenData
+          });
+          const encrypted = await coordinatorClient.sendRequest("CMD_TOKENS_ENCRYPT", {
+            tokenRequests: resolvedTokenData,
+            publicKeyPEM,
+            keyId
+          });
+          log2("tokens.encrypt successful", {
+            isSingleToken: "encrypted" in encrypted && "type" in encrypted
+          });
+          return encrypted;
+        } catch (error) {
+          log2("tokens.encrypt failed", {
+            error: error.message
+          });
+          throw error;
+        }
+      }
+    },
+    sessions: {
+      /**
+       * Create a new session for temporary elevated access
+       * Note: Session must be authorized by a Private Application on your backend
+       */
+      create: async () => {
+        log2("sessions.create called");
+        if (!coordinatorClient) {
+          await initializeCoordinator();
+        }
+        if (!coordinatorClient) {
+          throw new Error("Coordinator failed to initialize");
+        }
+        try {
+          const session = await coordinatorClient.sendRequest(
+            "CMD_SESSIONS_CREATE",
+            {}
+          );
+          log2("sessions.create successful", {
+            nonce: session.nonce,
+            expiresAt: session.expires_at
+          });
+          return session;
+        } catch (error) {
+          log2("sessions.create failed", {
+            error: error.message
+          });
+          throw error;
+        }
+      }
+    },
+    tokenIntents: {
+      /**
+       * Create a token intent with element reference support
+       */
+      create: async (data, options2) => {
+        log2("tokenIntents.create called", {
+          type: data.type,
+          hasData: !!data.data,
+          hasOptions: !!options2
+        });
+        if (!coordinatorClient) {
+          await initializeCoordinator();
+        }
+        if (!coordinatorClient) {
+          throw new Error("Coordinator failed to initialize");
+        }
+        try {
+          const resolvedData = resolveElementReferences(data.data);
+          log2("Element references resolved for token intent");
+          const intent = await coordinatorClient.sendRequest(
+            "CMD_TOKEN_INTENTS_CREATE",
+            {
+              type: data.type,
+              data: resolvedData,
+              options: options2
+            }
+          );
+          log2("tokenIntents.create successful", {
+            intentId: intent.id
+          });
+          return intent;
+        } catch (error) {
+          log2("tokenIntents.create failed", {
+            error: error.message
+          });
+          throw error;
+        }
+      },
+      /**
+       * Get a token intent by ID
+       */
+      get: async (id, options2) => {
+        log2("tokenIntents.get called", {
+          intentId: id
+        });
+        if (!coordinatorClient) {
+          await initializeCoordinator();
+        }
+        if (!coordinatorClient) {
+          throw new Error("Coordinator failed to initialize");
+        }
+        try {
+          const intent = await coordinatorClient.sendRequest(
+            "CMD_TOKEN_INTENTS_GET",
+            {
+              id,
+              options: options2
+            }
+          );
+          log2("tokenIntents.get successful", {
+            intentId: intent.id
+          });
+          return intent;
+        } catch (error) {
+          log2("tokenIntents.get failed", {
+            error: error.message
+          });
+          throw error;
+        }
+      }
+    },
+    updateThemeMode: async (mode) => {
+      log2("updateThemeMode called", {
+        oldMode: currentThemeMode,
+        newMode: mode,
+        mountedElements: Array.from(elements.values()).filter(
+          (el) => el.mounted
+        ).length
+      });
+      currentThemeMode = mode;
+      const updatePromises = [];
+      for (const [id, element] of elements) {
+        if (element.mounted) {
+          log2("Sending theme mode update to element", {
+            elementId: id,
+            elementType: element.type,
+            mode
+          });
+          const iframe = document.querySelector(
+            `iframe[data-bt-element-id="${element.id}"]`
+          );
+          if (iframe) {
+            iframe.setAttribute("data-theme-mode", mode);
+          }
+          const updatePromise = element.update({
+            themeMode: mode
+          }).catch((error) => {
+            log2("Failed to update theme mode for element", {
+              elementId: id,
+              error: error.message
+            });
+          });
+          updatePromises.push(updatePromise);
+        }
+      }
+      await Promise.all(updatePromises);
+      log2("Theme mode updated for all mounted elements", {
+        mode,
+        updatedCount: Array.from(elements.values()).filter((el) => el.mounted).length
+      });
+    }
+  };
+  if (queuedCommands && queuedCommands.length > 0) {
+    log2("Draining command queue from loader", {
+      queueLength: queuedCommands.length,
+      commands: queuedCommands.map((cmd) => cmd.method)
+    });
+    for (const cmd of queuedCommands) {
+      try {
+        const method = sdk[cmd.method];
+        if (!method) {
+          throw new Error(`Unknown method: ${cmd.method}`);
+        }
+        log2("Replaying queued command", {
+          method: cmd.method,
+          argsCount: cmd.args.length
+        });
+        const result = method(...cmd.args);
+        if (result && typeof result.then === "function") {
+          result.then((value) => {
+            log2("Queued command completed (async)", {
+              method: cmd.method
+            });
+            cmd.resolve(value);
+          }).catch((error) => {
+            log2("Queued command failed (async)", {
+              method: cmd.method,
+              error: error.message
+            });
+            cmd.reject(error);
+          });
+        } else {
+          log2("Queued command completed (sync)", {
+            method: cmd.method
+          });
+          cmd.resolve(result);
+        }
+      } catch (error) {
+        log2("Queued command failed (sync)", {
+          method: cmd.method,
+          error: error.message
+        });
+        cmd.reject(error);
+      }
+    }
+    log2("Command queue drain complete", {
+      processedCount: queuedCommands.length
+    });
+  }
+  return sdk;
+};
+if (typeof window !== "undefined" && typeof document !== "undefined" && document.currentScript && !window.BasisTheory) {
+  window.BasisTheory = BasisTheory;
+}
+const version = "3.0.0-beta.2";
+const buildDate = "2026-04-13T17:05:21.283Z";
+if (typeof window !== "undefined") {
+  window.__BasisTheorySDK__ = BasisTheory;
+}
+export {
+  BasisTheory as B,
+  ElementError as E,
+  createPostMessageClient as a,
+  createEventDispatcher as b,
+  createIframe as c,
+  createMounter as d,
+  buildDate as e,
+  log as l,
+  version as v
+};