@deflectbot/deflect-sdk 1.4.4-beta.0 → 1.4.5

package/dist/index.js

@@ -0,0 +1,929 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+  // src/pulse.ts
+  var REPORT_CONFIG = {
+    endpoint: "https://service.yabadabado.top/pulse",
+    projectId: "deflect-sdk",
+    deploymentId: "688529b539803661332b3f70",
+    service: "deflect-sdk",
+    release: "unknown"
+  };
+  var PULSE_SDK_INFO = {
+    name: "deflect-js-sdk",
+    version: REPORT_CONFIG.release || "unknown",
+    language: "javascript"
+  };
+  var PulseReporter = class {
+    static {
+      __name(this, "PulseReporter");
+    }
+    constructor(config) {
+      this.config = {
+        ...REPORT_CONFIG,
+        ...config,
+        endpoint: (config?.endpoint || REPORT_CONFIG.endpoint).replace(/\/$/, "")
+      };
+      this.enabled = Boolean(
+        this.config.endpoint && this.config.projectId && this.config.deploymentId
+      );
+    }
+    captureException(error, options = {}) {
+      if (!this.enabled || typeof fetch !== "function") {
+        return;
+      }
+      const event = this.buildErrorEvent(error, options);
+      fetch(`${this.config.endpoint}/capture`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          project_id: this.config.projectId
+        },
+        body: JSON.stringify(event),
+        keepalive: true
+      }).catch(() => {
+      });
+    }
+    buildErrorEvent(error, options) {
+      const normalizedError = this.normalizeError(error);
+      const environment = this.config.environment || (typeof window !== "undefined" ? window.location.hostname || "unknown" : "unknown");
+      const runtimeInfo = typeof navigator === "undefined" ? void 0 : {
+        name: navigator.userAgent || "browser",
+        version: navigator.appVersion
+      };
+      const osInfo = typeof navigator === "undefined" ? void 0 : {
+        name: navigator.platform
+      };
+      const deviceInfo = typeof window === "undefined" ? void 0 : {
+        model: `${window.screen.width}x${window.screen.height}`,
+        arch: typeof navigator !== "undefined" ? navigator.platform : void 0
+      };
+      const requestInfo = typeof window === "undefined" ? void 0 : {
+        method: "GET",
+        url: window.location.href,
+        headers: typeof navigator !== "undefined" ? {
+          "User-Agent": navigator.userAgent,
+          ...typeof document !== "undefined" && document.referrer ? { Referer: document.referrer } : {}
+        } : void 0
+      };
+      const eventId = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : Math.random().toString(16).slice(2) + Date.now().toString(16);
+      return {
+        event_type: "error",
+        event_id: eventId,
+        deployment_id: this.config.deploymentId,
+        project_id: this.config.projectId,
+        environment,
+        service: this.config.service,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        release: this.config.release,
+        sdk: {
+          ...PULSE_SDK_INFO,
+          version: this.config.release || PULSE_SDK_INFO.version
+        },
+        tags: options.tags,
+        context: options.context,
+        error: {
+          level: options.level || "error",
+          message: normalizedError.message,
+          exception: this.buildExceptionPayload(normalizedError),
+          request: requestInfo,
+          runtime: runtimeInfo,
+          os: osInfo,
+          device: deviceInfo
+        }
+      };
+    }
+    normalizeError(error) {
+      if (error instanceof Error) {
+        return error;
+      }
+      const message = typeof error === "string" ? error : "Unknown error";
+      return new Error(message);
+    }
+    buildExceptionPayload(error) {
+      const frames = this.parseStack(error);
+      return {
+        type: error.name || "Error",
+        value: error.message,
+        stacktrace: frames.length ? { frames } : void 0
+      };
+    }
+    parseStack(error) {
+      if (!error.stack) {
+        return [];
+      }
+      const frames = [];
+      const raw = error.stack.split("\n").slice(1);
+      for (const line of raw) {
+        const cleaned = line.trim().replace(/^at\s+/, "");
+        const hasLocation = cleaned.includes("(") && cleaned.endsWith(")");
+        const functionName = hasLocation ? cleaned.slice(0, cleaned.indexOf("(")).trim() : "";
+        const location = hasLocation ? cleaned.slice(cleaned.indexOf("(") + 1, cleaned.length - 1) : cleaned;
+        const parts = location.split(":");
+        const filename = parts[0] || void 0;
+        const lineno = parts.length > 1 ? Number(parts[1]) : void 0;
+        const colno = parts.length > 2 ? Number(parts[2]) : void 0;
+        if (!filename) {
+          continue;
+        }
+        frames.push({
+          filename,
+          abs_path: filename,
+          function: functionName || void 0,
+          lineno: Number.isFinite(lineno) ? lineno : void 0,
+          colno: Number.isFinite(colno) ? colno : void 0,
+          in_app: !filename.includes("node_modules")
+        });
+      }
+      return frames;
+    }
+  };
+  var pulse_default = PulseReporter;
+
+  // src/scriptClient.ts
+  function buildScriptUrl(actionId, scriptUrl, extraArgs) {
+    const baseUrl = scriptUrl || "https://js.deflect.bot/main.js";
+    const url = new URL(baseUrl);
+    const params = url.searchParams;
+    params.set("action_id", actionId);
+    params.set("_", Date.now().toString());
+    if (extraArgs && typeof extraArgs === "object") {
+      for (const key in extraArgs) {
+        if (Object.prototype.hasOwnProperty.call(extraArgs, key)) {
+          const value = extraArgs[key];
+          params.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  __name(buildScriptUrl, "buildScriptUrl");
+  async function fetchScript(actionId, scriptUrl, extraArgs) {
+    const url = buildScriptUrl(actionId, scriptUrl, extraArgs);
+    const response = await fetch(url, {
+      cache: "no-store",
+      mode: "cors",
+      credentials: "omit"
+    });
+    const content = await response.text();
+    const error = parseErrorJson(content);
+    if (error) throw error;
+    return {
+      content,
+      sessionId: response.headers.get("session_id") || void 0
+    };
+  }
+  __name(fetchScript, "fetchScript");
+  function parseErrorJson(content) {
+    try {
+      const maybeError = JSON.parse(content);
+      if (maybeError.success === false || maybeError.error) {
+        const errorMessage = maybeError.error || "Script fetch failed";
+        const error = new Error(errorMessage);
+        if (errorMessage === "action_does_not_exist" || errorMessage.includes("invalid action")) {
+          error.isUserError = true;
+        }
+        return error;
+      }
+    } catch (err) {
+      if (!(err instanceof SyntaxError)) {
+        throw err;
+      }
+    }
+    return null;
+  }
+  __name(parseErrorJson, "parseErrorJson");
+
+  // src/scriptRunner.ts
+  function createBlobUrl(content) {
+    const blob = new Blob([content], { type: "text/javascript" });
+    return URL.createObjectURL(blob);
+  }
+  __name(createBlobUrl, "createBlobUrl");
+  function loadModuleScript(blobUrl) {
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.type = "module";
+      script.src = blobUrl;
+      script.onload = () => resolve(script);
+      script.onerror = () => reject(new Error("Script failed to load"));
+      document.head.appendChild(script);
+    });
+  }
+  __name(loadModuleScript, "loadModuleScript");
+  function waitForGlobalFunction(fnName, timeout = 1e4) {
+    return new Promise((resolve, reject) => {
+      const checkInterval = setInterval(() => {
+        if (typeof window !== "undefined" && typeof window.Deflect?.[fnName] === "function") {
+          clearInterval(checkInterval);
+          resolve();
+        }
+      }, 50);
+      setTimeout(() => {
+        clearInterval(checkInterval);
+        reject(new Error(`Timeout: ${fnName} did not become available within ${timeout / 1e3} seconds`));
+      }, timeout);
+    });
+  }
+  __name(waitForGlobalFunction, "waitForGlobalFunction");
+  async function getTokenFromGlobal(fnName) {
+    if (typeof window === "undefined" || typeof window.Deflect?.[fnName] !== "function") {
+      throw new Error(`${fnName} not available on window.Deflect`);
+    }
+    return window.Deflect[fnName]();
+  }
+  __name(getTokenFromGlobal, "getTokenFromGlobal");
+  function cleanup(blobUrl, scriptElement, fnName) {
+    URL.revokeObjectURL(blobUrl);
+    scriptElement.remove();
+    if (typeof window !== "undefined" && window.Deflect?.[fnName]) {
+      delete window.Deflect[fnName];
+    }
+  }
+  __name(cleanup, "cleanup");
+
+  // src/index.ts
+  var ERROR_COOLDOWN_MS = 2e3;
+  var MAX_CONSECUTIVE_ERRORS = 5;
+  var MAX_FETCHES_PER_WINDOW = 15;
+  var FETCH_WINDOW_MS = 6e4;
+  var DeflectClient = class _DeflectClient {
+    constructor(config, pulseReporter) {
+      this.scriptCache = null;
+      this.isWarmupInProgress = false;
+      this.hasWarmupError = false;
+      this.warmupPromise = null;
+      // Guards against infinite loading
+      this.getTokenPromise = null;
+      this.lastErrorTime = 0;
+      this.consecutiveErrorCount = 0;
+      this.fetchCountInWindow = 0;
+      this.fetchWindowStart = 0;
+      if (!config.actionId?.trim()) {
+        throw new Error("actionId is required and cannot be empty");
+      }
+      this.validateActionId(config.actionId);
+      this.config = { prefetch: true, ...config };
+      this.pulseReporter = pulseReporter || new pulse_default(_DeflectClient.resolvePulseConfig());
+      if (this.config.prefetch !== false && !this.isTestMode()) {
+        this.scheduleWarmup();
+      }
+    }
+    static {
+      __name(this, "DeflectClient");
+    }
+    /** Get the actionId this client is configured for */
+    getActionId() {
+      return this.config.actionId;
+    }
+    scheduleWarmup() {
+      if (typeof window === "undefined") return;
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", () => this.tryWarmup(), { once: true });
+      } else {
+        setTimeout(() => this.tryWarmup(), 100);
+      }
+    }
+    static resolvePulseConfig() {
+      const runtimeConfig = typeof window !== "undefined" && typeof window.Deflect === "object" && window.Deflect?.pulseConfig && typeof window.Deflect.pulseConfig === "object" ? window.Deflect.pulseConfig : {};
+      return {
+        ...runtimeConfig,
+        environment: runtimeConfig.environment || (typeof window !== "undefined" ? window.location.hostname : void 0)
+      };
+    }
+    reportError(error, tags, context) {
+      this.pulseReporter.captureException(error, { tags, context });
+    }
+    isInErrorCooldown() {
+      if (this.consecutiveErrorCount === 0) return false;
+      const backoffMs = Math.min(
+        ERROR_COOLDOWN_MS * Math.pow(2, this.consecutiveErrorCount - 1),
+        3e4
+      );
+      return Date.now() - this.lastErrorTime < backoffMs;
+    }
+    isRateLimited() {
+      const now = Date.now();
+      if (now - this.fetchWindowStart > FETCH_WINDOW_MS) {
+        this.fetchCountInWindow = 0;
+        this.fetchWindowStart = now;
+        return false;
+      }
+      return this.fetchCountInWindow >= MAX_FETCHES_PER_WINDOW;
+    }
+    hasExceededMaxErrors() {
+      return this.consecutiveErrorCount >= MAX_CONSECUTIVE_ERRORS;
+    }
+    recordFetchSuccess() {
+      this.consecutiveErrorCount = 0;
+      this.lastErrorTime = 0;
+    }
+    recordFetchError() {
+      this.consecutiveErrorCount++;
+      this.lastErrorTime = Date.now();
+    }
+    incrementFetchCount() {
+      const now = Date.now();
+      if (now - this.fetchWindowStart > FETCH_WINDOW_MS) {
+        this.fetchCountInWindow = 0;
+        this.fetchWindowStart = now;
+      }
+      this.fetchCountInWindow++;
+    }
+    async tryWarmup() {
+      if (this.config.prefetch === false || this.isWarmupInProgress || this.scriptCache || this.hasWarmupError) {
+        return;
+      }
+      if (this.isRateLimited() || this.isInErrorCooldown() || this.hasExceededMaxErrors()) {
+        return;
+      }
+      this.isWarmupInProgress = true;
+      this.incrementFetchCount();
+      this.warmupPromise = (async () => {
+        try {
+          this.scriptCache = await fetchScript(
+            this.config.actionId,
+            this.config.scriptUrl,
+            this.config.extraArgs
+          );
+          this.hasWarmupError = false;
+          this.recordFetchSuccess();
+        } catch {
+          this.hasWarmupError = true;
+          this.recordFetchError();
+        } finally {
+          this.isWarmupInProgress = false;
+        }
+      })();
+      await this.warmupPromise.catch(() => {
+      });
+    }
+    validateActionId(actionId) {
+      const sanitized = actionId.trim();
+      const validPattern = /^[a-zA-Z0-9/_-]+$/;
+      if (!validPattern.test(sanitized)) {
+        throw new Error("Invalid actionId format: contains disallowed characters");
+      }
+      return encodeURIComponent(sanitized);
+    }
+    prefetchNextScript() {
+      if (!this.hasWarmupError && this.config.prefetch !== false) {
+        this.tryWarmup().catch(() => {
+        });
+      }
+    }
+    isTestMode() {
+      if (this.config.actionId === "PULSE_TEST" || this.config.actionId === "SENTRY_TEST") {
+        throw new Error("PULSE_TEST: This is a test error to verify Pulse integration is working");
+      }
+      return this.config.actionId === "t/FFFFFFFFFFFFF/111111111" || this.config.actionId === "t/FFFFFFFFFFFFF/000000000";
+    }
+    /** Get a challenge token for this client's actionId */
+    async getToken() {
+      if (this.getTokenPromise) {
+        return this.getTokenPromise;
+      }
+      this.getTokenPromise = this.getTokenInternal();
+      try {
+        return await this.getTokenPromise;
+      } finally {
+        this.getTokenPromise = null;
+      }
+    }
+    async getTokenInternal() {
+      try {
+        if (this.isTestMode()) {
+          return "TESTTOKEN";
+        }
+        if (this.hasExceededMaxErrors()) {
+          throw new Error(
+            `Too many consecutive errors (${this.consecutiveErrorCount}). Create a new client or wait before retrying.`
+          );
+        }
+        if (this.isRateLimited()) {
+          throw new Error(
+            `Rate limit exceeded: ${MAX_FETCHES_PER_WINDOW} requests per minute. Please wait before retrying.`
+          );
+        }
+        if (this.isInErrorCooldown()) {
+          const backoffMs = Math.min(
+            ERROR_COOLDOWN_MS * Math.pow(2, this.consecutiveErrorCount - 1),
+            3e4
+          );
+          const remainingMs = backoffMs - (Date.now() - this.lastErrorTime);
+          throw new Error(
+            `In error cooldown. Please wait ${Math.ceil(remainingMs / 1e3)} seconds before retrying.`
+          );
+        }
+        let script;
+        if (this.warmupPromise) {
+          await this.warmupPromise.catch(() => {
+          });
+        }
+        if (this.scriptCache && !this.isWarmupInProgress) {
+          script = this.scriptCache;
+          this.scriptCache = null;
+        } else {
+          this.incrementFetchCount();
+          script = await fetchScript(
+            this.config.actionId,
+            this.config.scriptUrl,
+            this.config.extraArgs
+          );
+        }
+        return this.executeScript(script);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "";
+        const isGuardError = errorMessage.includes("cooldown") || errorMessage.includes("Rate limit") || errorMessage.includes("Too many consecutive");
+        if (!isGuardError) {
+          this.recordFetchError();
+        }
+        const isUserError = error && typeof error === "object" && "isUserError" in error && error.isUserError === true;
+        this.reportError(
+          error,
+          {
+            deflect_sdk_error: "true",
+            deflect_user_error: isUserError ? "true" : "false",
+            method: "getToken",
+            action_id: this.config.actionId,
+            has_cache: this.scriptCache !== null ? "true" : "false",
+            has_warmup_error: this.hasWarmupError ? "true" : "false",
+            consecutive_errors: this.consecutiveErrorCount.toString(),
+            stage: "call"
+          },
+          {
+            actionId: this.config.actionId,
+            hasCache: this.scriptCache !== null,
+            hasWarmupError: this.hasWarmupError,
+            consecutiveErrorCount: this.consecutiveErrorCount,
+            fetchCountInWindow: this.fetchCountInWindow
+          }
+        );
+        throw error;
+      }
+    }
+    async executeScript(script) {
+      if (script.sessionId && typeof window !== "undefined") {
+        window.Deflect = window.Deflect || {};
+        window.Deflect.sessionId = script.sessionId;
+      }
+      const blobUrl = createBlobUrl(script.content);
+      let scriptElement = null;
+      try {
+        scriptElement = await loadModuleScript(blobUrl);
+        await waitForGlobalFunction("getChallengeToken");
+        const token = await getTokenFromGlobal("getChallengeToken");
+        this.recordFetchSuccess();
+        this.prefetchNextScript();
+        return token;
+      } catch (error) {
+        this.reportError(
+          error,
+          {
+            deflect_sdk_error: "true",
+            method: "executeScript",
+            stage: "load_or_execute",
+            action_id: this.config.actionId
+          },
+          {
+            hasCache: this.scriptCache !== null,
+            hasWarmupError: this.hasWarmupError
+          }
+        );
+        throw error;
+      } finally {
+        if (scriptElement) {
+          cleanup(blobUrl, scriptElement, "getChallengeToken");
+        } else {
+          URL.revokeObjectURL(blobUrl);
+        }
+      }
+    }
+    /** Manually trigger warmup/prefetch */
+    async warmup() {
+      try {
+        if (this.config.prefetch === false) {
+          return false;
+        }
+        await this.tryWarmup();
+        return this.scriptCache !== null;
+      } catch {
+        return false;
+      }
+    }
+    /** Clear the cached script */
+    clearCache() {
+      this.scriptCache = null;
+    }
+    /** Reset error state to allow retries */
+    resetErrorState() {
+      this.hasWarmupError = false;
+      this.consecutiveErrorCount = 0;
+      this.lastErrorTime = 0;
+      this.getTokenPromise = null;
+    }
+    /** Get current rate limit and error status for debugging */
+    getStatus() {
+      return {
+        actionId: this.config.actionId,
+        isRateLimited: this.isRateLimited(),
+        isInCooldown: this.isInErrorCooldown(),
+        consecutiveErrors: this.consecutiveErrorCount,
+        fetchesInWindow: this.fetchCountInWindow,
+        canFetch: !this.isRateLimited() && !this.isInErrorCooldown() && !this.hasExceededMaxErrors()
+      };
+    }
+    /** Inject token into a form and submit */
+    async injectToken(event) {
+      if (!event || !event.target || !(event.target instanceof HTMLFormElement)) {
+        throw new Error("injectToken: must be called from a form submit event");
+      }
+      event.preventDefault();
+      const form = event.target;
+      const token = await this.getToken();
+      Array.from(form.querySelectorAll('input[name="deflect_token"]')).forEach(
+        (el) => el.remove()
+      );
+      const hidden = document.createElement("input");
+      hidden.type = "hidden";
+      hidden.name = "deflect_token";
+      hidden.value = token;
+      form.appendChild(hidden);
+      form.submit();
+    }
+  };
+  var Deflect = class {
+    constructor() {
+      this.config = null;
+      this.scriptCache = null;
+      this.isWarmupInProgress = false;
+      this.hasWarmupError = false;
+      this.warmupPromise = null;
+      // Guards against infinite loading
+      this.getTokenPromise = null;
+      this.lastErrorTime = 0;
+      this.consecutiveErrorCount = 0;
+      this.fetchCountInWindow = 0;
+      this.fetchWindowStart = 0;
+      this.initializeGlobalState();
+      this.pulseReporter = new pulse_default(this.resolvePulseConfig());
+      this.setupAutomaticWarmup();
+    }
+    static {
+      __name(this, "Deflect");
+    }
+    initializeGlobalState() {
+      if (typeof window === "undefined") return;
+      window.Deflect = window.Deflect || {};
+    }
+    setupAutomaticWarmup() {
+      if (typeof window === "undefined") return;
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", () => this.tryWarmup());
+      } else {
+        setTimeout(() => this.tryWarmup(), 100);
+      }
+    }
+    resolvePulseConfig() {
+      const runtimeConfig = typeof window !== "undefined" && typeof window.Deflect === "object" && window.Deflect?.pulseConfig && typeof window.Deflect.pulseConfig === "object" ? window.Deflect.pulseConfig : {};
+      return {
+        ...runtimeConfig,
+        environment: runtimeConfig.environment || (typeof window !== "undefined" ? window.location.hostname : void 0)
+      };
+    }
+    reportError(error, tags, context) {
+      this.pulseReporter.captureException(error, { tags, context });
+    }
+    /** Check if we're in error cooldown period */
+    isInErrorCooldown() {
+      if (this.consecutiveErrorCount === 0) return false;
+      const backoffMs = Math.min(
+        ERROR_COOLDOWN_MS * Math.pow(2, this.consecutiveErrorCount - 1),
+        3e4
+        // Max 30 second backoff
+      );
+      return Date.now() - this.lastErrorTime < backoffMs;
+    }
+    /** Check if we've exceeded the rate limit */
+    isRateLimited() {
+      const now = Date.now();
+      if (now - this.fetchWindowStart > FETCH_WINDOW_MS) {
+        this.fetchCountInWindow = 0;
+        this.fetchWindowStart = now;
+        return false;
+      }
+      return this.fetchCountInWindow >= MAX_FETCHES_PER_WINDOW;
+    }
+    /** Check if we've hit max consecutive errors */
+    hasExceededMaxErrors() {
+      return this.consecutiveErrorCount >= MAX_CONSECUTIVE_ERRORS;
+    }
+    /** Record a successful fetch - resets error state */
+    recordFetchSuccess() {
+      this.consecutiveErrorCount = 0;
+      this.lastErrorTime = 0;
+    }
+    /** Record a failed fetch - increments error tracking */
+    recordFetchError() {
+      this.consecutiveErrorCount++;
+      this.lastErrorTime = Date.now();
+    }
+    /** Increment fetch counter for rate limiting */
+    incrementFetchCount() {
+      const now = Date.now();
+      if (now - this.fetchWindowStart > FETCH_WINDOW_MS) {
+        this.fetchCountInWindow = 0;
+        this.fetchWindowStart = now;
+      }
+      this.fetchCountInWindow++;
+    }
+    async tryWarmup() {
+      if (!this.config?.actionId || this.config.prefetch === false || this.isWarmupInProgress || this.scriptCache || this.hasWarmupError) {
+        return;
+      }
+      if (this.isRateLimited() || this.isInErrorCooldown() || this.hasExceededMaxErrors()) {
+        return;
+      }
+      this.validateActionId(this.config.actionId);
+      this.isWarmupInProgress = true;
+      this.incrementFetchCount();
+      this.warmupPromise = (async () => {
+        try {
+          this.scriptCache = await fetchScript(
+            this.config.actionId,
+            this.config.scriptUrl,
+            this.config.extraArgs
+          );
+          this.hasWarmupError = false;
+          this.recordFetchSuccess();
+        } catch {
+          this.hasWarmupError = true;
+          this.recordFetchError();
+        } finally {
+          this.isWarmupInProgress = false;
+        }
+      })();
+      await this.warmupPromise.catch(() => {
+      });
+    }
+    validateActionId(actionId) {
+      const sanitized = actionId.trim();
+      const validPattern = /^[a-zA-Z0-9/_-]+$/;
+      if (!validPattern.test(sanitized)) {
+        throw new Error("Invalid actionId format: contains disallowed characters");
+      }
+      return encodeURIComponent(sanitized);
+    }
+    prefetchNextScript() {
+      if (!this.hasWarmupError && this.config?.prefetch !== false) {
+        this.tryWarmup().catch(() => {
+        });
+      }
+    }
+    isTestMode() {
+      if (this.config?.actionId === "PULSE_TEST" || this.config?.actionId === "SENTRY_TEST") {
+        throw new Error("PULSE_TEST: This is a test error to verify Pulse integration is working");
+      }
+      return this.config?.actionId === "t/FFFFFFFFFFFFF/111111111" || this.config?.actionId === "t/FFFFFFFFFFFFF/000000000";
+    }
+    configure(params) {
+      try {
+        if (!params.actionId?.trim()) {
+          throw new Error("actionId is required and cannot be empty");
+        }
+        this.validateActionId(params.actionId);
+        if (this.config?.actionId === params.actionId && this.config.prefetch === params.prefetch && this.config.scriptUrl === params.scriptUrl) {
+          return;
+        }
+        const actionIdChanged = this.config?.actionId !== params.actionId;
+        if (actionIdChanged) {
+          this.hasWarmupError = false;
+          this.consecutiveErrorCount = 0;
+          this.lastErrorTime = 0;
+        }
+        this.scriptCache = null;
+        this.getTokenPromise = null;
+        this.config = { prefetch: true, ...params };
+        if (typeof window !== "undefined") {
+          window.Deflect.actionId = params.actionId;
+        }
+        if (!this.isTestMode() && this.config.prefetch !== false) {
+          this.tryWarmup();
+        }
+      } catch (error) {
+        const isUserError = error && typeof error === "object" && "isUserError" in error && error.isUserError === true;
+        this.reportError(
+          error,
+          {
+            deflect_sdk_error: "true",
+            deflect_user_error: isUserError ? "true" : "false",
+            method: "configure",
+            action_id: params?.actionId || "unknown"
+          },
+          {
+            actionId: params?.actionId,
+            hasCache: this.scriptCache !== null,
+            hasWarmupError: this.hasWarmupError
+          }
+        );
+        throw error;
+      }
+    }
+    async getToken() {
+      if (this.getTokenPromise) {
+        return this.getTokenPromise;
+      }
+      this.getTokenPromise = this.getTokenInternal();
+      try {
+        return await this.getTokenPromise;
+      } finally {
+        this.getTokenPromise = null;
+      }
+    }
+    async getTokenInternal() {
+      try {
+        if (!this.config?.actionId) {
+          throw new Error("Must call configure() before getToken()");
+        }
+        this.validateActionId(this.config.actionId);
+        if (this.isTestMode()) {
+          return "TESTTOKEN";
+        }
+        if (this.hasExceededMaxErrors()) {
+          throw new Error(
+            `Too many consecutive errors (${this.consecutiveErrorCount}). Call configure() with a new actionId or wait before retrying.`
+          );
+        }
+        if (this.isRateLimited()) {
+          throw new Error(
+            `Rate limit exceeded: ${MAX_FETCHES_PER_WINDOW} requests per minute. Please wait before retrying.`
+          );
+        }
+        if (this.isInErrorCooldown()) {
+          const backoffMs = Math.min(
+            ERROR_COOLDOWN_MS * Math.pow(2, this.consecutiveErrorCount - 1),
+            3e4
+          );
+          const remainingMs = backoffMs - (Date.now() - this.lastErrorTime);
+          throw new Error(
+            `In error cooldown. Please wait ${Math.ceil(remainingMs / 1e3)} seconds before retrying.`
+          );
+        }
+        let script;
+        if (this.warmupPromise) {
+          await this.warmupPromise.catch(() => {
+          });
+        }
+        if (this.scriptCache && !this.isWarmupInProgress) {
+          script = this.scriptCache;
+          this.scriptCache = null;
+        } else {
+          this.incrementFetchCount();
+          script = await fetchScript(
+            this.config.actionId,
+            this.config.scriptUrl,
+            this.config.extraArgs
+          );
+        }
+        return this.executeScript(script);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "";
+        const isGuardError = errorMessage.includes("cooldown") || errorMessage.includes("Rate limit") || errorMessage.includes("Too many consecutive");
+        if (!isGuardError) {
+          this.recordFetchError();
+        }
+        const isUserError = error && typeof error === "object" && "isUserError" in error && error.isUserError === true;
+        this.reportError(
+          error,
+          {
+            deflect_sdk_error: "true",
+            deflect_user_error: isUserError ? "true" : "false",
+            method: "getToken",
+            action_id: this.config?.actionId || "unknown",
+            has_cache: this.scriptCache !== null ? "true" : "false",
+            has_warmup_error: this.hasWarmupError ? "true" : "false",
+            consecutive_errors: this.consecutiveErrorCount.toString(),
+            stage: "call"
+          },
+          {
+            actionId: this.config?.actionId,
+            hasCache: this.scriptCache !== null,
+            hasWarmupError: this.hasWarmupError,
+            consecutiveErrorCount: this.consecutiveErrorCount,
+            fetchCountInWindow: this.fetchCountInWindow
+          }
+        );
+        throw error;
+      }
+    }
+    async executeScript(script) {
+      if (script.sessionId && typeof window !== "undefined") {
+        window.Deflect.sessionId = script.sessionId;
+      }
+      const blobUrl = createBlobUrl(script.content);
+      let scriptElement = null;
+      try {
+        scriptElement = await loadModuleScript(blobUrl);
+        await waitForGlobalFunction("getChallengeToken");
+        const token = await getTokenFromGlobal("getChallengeToken");
+        this.recordFetchSuccess();
+        this.prefetchNextScript();
+        return token;
+      } catch (error) {
+        this.reportError(
+          error,
+          {
+            deflect_sdk_error: "true",
+            method: "executeScript",
+            stage: "load_or_execute",
+            action_id: this.config?.actionId || "unknown"
+          },
+          {
+            hasCache: this.scriptCache !== null,
+            hasWarmupError: this.hasWarmupError
+          }
+        );
+        throw error;
+      } finally {
+        if (scriptElement) {
+          cleanup(blobUrl, scriptElement, "getChallengeToken");
+        } else {
+          URL.revokeObjectURL(blobUrl);
+        }
+      }
+    }
+    async warmup() {
+      if (!this.config?.actionId) {
+        return false;
+      }
+      try {
+        if (this.config.prefetch === false) {
+          return false;
+        }
+        await this.tryWarmup();
+        return this.scriptCache !== null;
+      } catch {
+        return false;
+      }
+    }
+    clearCache() {
+      this.scriptCache = null;
+    }
+    /** Reset error state to allow retries. Use after fixing configuration issues. */
+    resetErrorState() {
+      this.hasWarmupError = false;
+      this.consecutiveErrorCount = 0;
+      this.lastErrorTime = 0;
+      this.getTokenPromise = null;
+    }
+    /** Get current rate limit and error status for debugging */
+    getStatus() {
+      return {
+        isRateLimited: this.isRateLimited(),
+        isInCooldown: this.isInErrorCooldown(),
+        consecutiveErrors: this.consecutiveErrorCount,
+        fetchesInWindow: this.fetchCountInWindow,
+        canFetch: !this.isRateLimited() && !this.isInErrorCooldown() && !this.hasExceededMaxErrors()
+      };
+    }
+    async injectToken(event) {
+      if (!event || !event.target || !(event.target instanceof HTMLFormElement)) {
+        throw new Error("injectToken: must be called from a form submit event");
+      }
+      event.preventDefault();
+      const form = event.target;
+      const token = await this.getToken();
+      Array.from(form.querySelectorAll('input[name="deflect_token"]')).forEach(
+        (el) => el.remove()
+      );
+      const hidden = document.createElement("input");
+      hidden.type = "hidden";
+      hidden.name = "deflect_token";
+      hidden.value = token;
+      form.appendChild(hidden);
+      form.submit();
+    }
+    /**
+     * Create a new Deflect client instance with its own configuration.
+     * Use this when you need multiple actionIds on the same page.
+     * 
+     * @example
+     * const loginClient = Deflect.createClient({ actionId: 'login-form' });
+     * const signupClient = Deflect.createClient({ actionId: 'signup-form' });
+     * 
+     * // Each client manages its own state
+     * const loginToken = await loginClient.getToken();
+     * const signupToken = await signupClient.getToken();
+     */
+    createClient(config) {
+      return new DeflectClient(config, this.pulseReporter);
+    }
+  };
+  var DeflectInstance = new Deflect();
+  if (typeof window !== "undefined") {
+    window.Deflect = DeflectInstance;
+  }
+  var src_default = DeflectInstance;
+})();