@tagadapay/plugin-sdk 3.1.11 → 3.1.22

package/dist/external-tracker.js

@@ -1,16 +1,18 @@
 /**
- * TagadaPay External Tracker v3.1.11
+ * TagadaPay External Tracker v3.1.22
  * CDN Bundle - Standalone tracking for external pages (Debug Build)
  * @license MIT
  */
 "use strict";
 var TagadaTrackerBundle = (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __defProps = Object.defineProperties;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __propIsEnum = Object.prototype.propertyIsEnumerable;
   var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
@@ -33,6 +35,9 @@ var TagadaTrackerBundle = (() => {
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __export = (target, all3) => {
     for (var name in all3)
       __defProp(target, name, { get: all3[name], enumerable: true });
@@ -45,6 +50,14 @@ var TagadaTrackerBundle = (() => {
     }
     return to;
   };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
   var __await = function(promise, isYieldStar) {
     this[0] = promise;
@@ -1140,7 +1153,7 @@ var TagadaTrackerBundle = (() => {
         TrackingProvider2["FACEBOOK"] = "facebook";
         TrackingProvider2["TIKTOK"] = "tiktok";
         TrackingProvider2["SNAPCHAT"] = "snapchat";
-        TrackingProvider2["META_CONVERSION"] = "meta_conversion";
+        TrackingProvider2["PINTEREST"] = "pinterest";
         TrackingProvider2["GTM"] = "gtm";
         return TrackingProvider2;
       })(TrackingProvider || {});
@@ -1549,9 +1562,365 @@ var TagadaTrackerBundle = (() => {
     }
   });
 
+  // ../../node_modules/.pnpm/path-to-regexp@8.3.0/node_modules/path-to-regexp/dist/index.js
+  var require_dist = __commonJS({
+    "../../node_modules/.pnpm/path-to-regexp@8.3.0/node_modules/path-to-regexp/dist/index.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.PathError = exports.TokenData = void 0;
+      exports.parse = parse;
+      exports.compile = compile;
+      exports.match = match2;
+      exports.pathToRegexp = pathToRegexp;
+      exports.stringify = stringify;
+      var DEFAULT_DELIMITER = "/";
+      var NOOP_VALUE = (value) => value;
+      var ID_START = new RegExp("^[$_\\p{ID_Start}]$", "u");
+      var ID_CONTINUE = new RegExp("^[$\\u200c\\u200d\\p{ID_Continue}]$", "u");
+      var SIMPLE_TOKENS = {
+        // Groups.
+        "{": "{",
+        "}": "}",
+        // Reserved.
+        "(": "(",
+        ")": ")",
+        "[": "[",
+        "]": "]",
+        "+": "+",
+        "?": "?",
+        "!": "!"
+      };
+      function escapeText(str) {
+        return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
+      }
+      function escape(str) {
+        return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+      }
+      var TokenData = class {
+        constructor(tokens, originalPath) {
+          this.tokens = tokens;
+          this.originalPath = originalPath;
+        }
+      };
+      exports.TokenData = TokenData;
+      var PathError = class extends TypeError {
+        constructor(message, originalPath) {
+          let text = message;
+          if (originalPath)
+            text += ": ".concat(originalPath);
+          text += "; visit https://git.new/pathToRegexpError for info";
+          super(text);
+          this.originalPath = originalPath;
+        }
+      };
+      exports.PathError = PathError;
+      function parse(str, options = {}) {
+        const { encodePath = NOOP_VALUE } = options;
+        const chars = [...str];
+        const tokens = [];
+        let index = 0;
+        let pos = 0;
+        function name() {
+          let value = "";
+          if (ID_START.test(chars[index])) {
+            do {
+              value += chars[index++];
+            } while (ID_CONTINUE.test(chars[index]));
+          } else if (chars[index] === '"') {
+            let quoteStart = index;
+            while (index++ < chars.length) {
+              if (chars[index] === '"') {
+                index++;
+                quoteStart = 0;
+                break;
+              }
+              if (chars[index] === "\\")
+                index++;
+              value += chars[index];
+            }
+            if (quoteStart) {
+              throw new PathError("Unterminated quote at index ".concat(quoteStart), str);
+            }
+          }
+          if (!value) {
+            throw new PathError("Missing parameter name at index ".concat(index), str);
+          }
+          return value;
+        }
+        while (index < chars.length) {
+          const value = chars[index];
+          const type = SIMPLE_TOKENS[value];
+          if (type) {
+            tokens.push({ type, index: index++, value });
+          } else if (value === "\\") {
+            tokens.push({ type: "escape", index: index++, value: chars[index++] });
+          } else if (value === ":") {
+            tokens.push({ type: "param", index: index++, value: name() });
+          } else if (value === "*") {
+            tokens.push({ type: "wildcard", index: index++, value: name() });
+          } else {
+            tokens.push({ type: "char", index: index++, value });
+          }
+        }
+        tokens.push({ type: "end", index, value: "" });
+        function consumeUntil(endType) {
+          const output = [];
+          while (true) {
+            const token = tokens[pos++];
+            if (token.type === endType)
+              break;
+            if (token.type === "char" || token.type === "escape") {
+              let path = token.value;
+              let cur = tokens[pos];
+              while (cur.type === "char" || cur.type === "escape") {
+                path += cur.value;
+                cur = tokens[++pos];
+              }
+              output.push({
+                type: "text",
+                value: encodePath(path)
+              });
+              continue;
+            }
+            if (token.type === "param" || token.type === "wildcard") {
+              output.push({
+                type: token.type,
+                name: token.value
+              });
+              continue;
+            }
+            if (token.type === "{") {
+              output.push({
+                type: "group",
+                tokens: consumeUntil("}")
+              });
+              continue;
+            }
+            throw new PathError("Unexpected ".concat(token.type, " at index ").concat(token.index, ", expected ").concat(endType), str);
+          }
+          return output;
+        }
+        return new TokenData(consumeUntil("end"), str);
+      }
+      function compile(path, options = {}) {
+        const { encode: encode3 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+        const data = typeof path === "object" ? path : parse(path, options);
+        const fn = tokensToFunction(data.tokens, delimiter, encode3);
+        return function path2(params = {}) {
+          const [path3, ...missing] = fn(params);
+          if (missing.length) {
+            throw new TypeError("Missing parameters: ".concat(missing.join(", ")));
+          }
+          return path3;
+        };
+      }
+      function tokensToFunction(tokens, delimiter, encode3) {
+        const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode3));
+        return (data) => {
+          const result = [""];
+          for (const encoder of encoders) {
+            const [value, ...extras] = encoder(data);
+            result[0] += value;
+            result.push(...extras);
+          }
+          return result;
+        };
+      }
+      function tokenToFunction(token, delimiter, encode3) {
+        if (token.type === "text")
+          return () => [token.value];
+        if (token.type === "group") {
+          const fn = tokensToFunction(token.tokens, delimiter, encode3);
+          return (data) => {
+            const [value, ...missing] = fn(data);
+            if (!missing.length)
+              return [value];
+            return [""];
+          };
+        }
+        const encodeValue = encode3 || NOOP_VALUE;
+        if (token.type === "wildcard" && encode3 !== false) {
+          return (data) => {
+            const value = data[token.name];
+            if (value == null)
+              return ["", token.name];
+            if (!Array.isArray(value) || value.length === 0) {
+              throw new TypeError('Expected "'.concat(token.name, '" to be a non-empty array'));
+            }
+            return [
+              value.map((value2, index) => {
+                if (typeof value2 !== "string") {
+                  throw new TypeError('Expected "'.concat(token.name, "/").concat(index, '" to be a string'));
+                }
+                return encodeValue(value2);
+              }).join(delimiter)
+            ];
+          };
+        }
+        return (data) => {
+          const value = data[token.name];
+          if (value == null)
+            return ["", token.name];
+          if (typeof value !== "string") {
+            throw new TypeError('Expected "'.concat(token.name, '" to be a string'));
+          }
+          return [encodeValue(value)];
+        };
+      }
+      function match2(path, options = {}) {
+        const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+        const { regexp, keys } = pathToRegexp(path, options);
+        const decoders = keys.map((key) => {
+          if (decode === false)
+            return NOOP_VALUE;
+          if (key.type === "param")
+            return decode;
+          return (value) => value.split(delimiter).map(decode);
+        });
+        return function match3(input) {
+          const m = regexp.exec(input);
+          if (!m)
+            return false;
+          const path2 = m[0];
+          const params = /* @__PURE__ */ Object.create(null);
+          for (let i = 1; i < m.length; i++) {
+            if (m[i] === void 0)
+              continue;
+            const key = keys[i - 1];
+            const decoder = decoders[i - 1];
+            params[key.name] = decoder(m[i]);
+          }
+          return { path: path2, params };
+        };
+      }
+      function pathToRegexp(path, options = {}) {
+        const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
+        const keys = [];
+        const flags = sensitive ? "" : "i";
+        const sources = [];
+        for (const input of pathsToArray(path, [])) {
+          const data = typeof input === "object" ? input : parse(input, options);
+          for (const tokens of flatten(data.tokens, 0, [])) {
+            sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
+          }
+        }
+        let pattern = "^(?:".concat(sources.join("|"), ")");
+        if (trailing)
+          pattern += "(?:".concat(escape(delimiter), "$)?");
+        pattern += end ? "$" : "(?=".concat(escape(delimiter), "|$)");
+        const regexp = new RegExp(pattern, flags);
+        return { regexp, keys };
+      }
+      function pathsToArray(paths, init) {
+        if (Array.isArray(paths)) {
+          for (const p of paths)
+            pathsToArray(p, init);
+        } else {
+          init.push(paths);
+        }
+        return init;
+      }
+      function* flatten(tokens, index, init) {
+        if (index === tokens.length) {
+          return yield init;
+        }
+        const token = tokens[index];
+        if (token.type === "group") {
+          for (const seq of flatten(token.tokens, 0, init.slice())) {
+            yield* __yieldStar(flatten(tokens, index + 1, seq));
+          }
+        } else {
+          init.push(token);
+        }
+        yield* __yieldStar(flatten(tokens, index + 1, init));
+      }
+      function toRegExpSource(tokens, delimiter, keys, originalPath) {
+        let result = "";
+        let backtrack = "";
+        let isSafeSegmentParam = true;
+        for (const token of tokens) {
+          if (token.type === "text") {
+            result += escape(token.value);
+            backtrack += token.value;
+            isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+            continue;
+          }
+          if (token.type === "param" || token.type === "wildcard") {
+            if (!isSafeSegmentParam && !backtrack) {
+              throw new PathError('Missing text before "'.concat(token.name, '" ').concat(token.type), originalPath);
+            }
+            if (token.type === "param") {
+              result += "(".concat(negate(delimiter, isSafeSegmentParam ? "" : backtrack), "+)");
+            } else {
+              result += "([\\s\\S]+)";
+            }
+            keys.push(token);
+            backtrack = "";
+            isSafeSegmentParam = false;
+            continue;
+          }
+        }
+        return result;
+      }
+      function negate(delimiter, backtrack) {
+        if (backtrack.length < 2) {
+          if (delimiter.length < 2)
+            return "[^".concat(escape(delimiter + backtrack), "]");
+          return "(?:(?!".concat(escape(delimiter), ")[^").concat(escape(backtrack), "])");
+        }
+        if (delimiter.length < 2) {
+          return "(?:(?!".concat(escape(backtrack), ")[^").concat(escape(delimiter), "])");
+        }
+        return "(?:(?!".concat(escape(backtrack), "|").concat(escape(delimiter), ")[\\s\\S])");
+      }
+      function stringifyTokens(tokens) {
+        let value = "";
+        let i = 0;
+        function name(value2) {
+          const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
+          return isSafe ? value2 : JSON.stringify(value2);
+        }
+        while (i < tokens.length) {
+          const token = tokens[i++];
+          if (token.type === "text") {
+            value += escapeText(token.value);
+            continue;
+          }
+          if (token.type === "group") {
+            value += "{".concat(stringifyTokens(token.tokens), "}");
+            continue;
+          }
+          if (token.type === "param") {
+            value += ":".concat(name(token.name));
+            continue;
+          }
+          if (token.type === "wildcard") {
+            value += "*".concat(name(token.name));
+            continue;
+          }
+          throw new TypeError("Unknown token type: ".concat(token.type));
+        }
+        return value;
+      }
+      function stringify(data) {
+        return stringifyTokens(data.tokens);
+      }
+      function isNameSafe(name) {
+        const [first, ...rest] = name;
+        return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
+      }
+      function isNextNameSafe(token) {
+        if (token && token.type === "text")
+          return !ID_CONTINUE.test(token.value[0]);
+        return true;
+      }
+    }
+  });
+
   // src/v2/standalone/external-tracker.ts
   var external_tracker_exports = {};
   __export(external_tracker_exports, {
+    TRACKER_VERSION: () => TRACKER_VERSION,
     TagadaExternalTracker: () => TagadaExternalTracker,
     TagadaTracker: () => TagadaTracker
   });
@@ -2160,8 +2529,8 @@ var TagadaTrackerBundle = (() => {
       "%20": "+",
       "%00": "\0"
     };
-    return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
-      return charMap[match];
+    return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match2) {
+      return charMap[match2];
     });
   }
   function AxiosURLSearchParams(params, options) {
@@ -2340,8 +2709,8 @@ var TagadaTrackerBundle = (() => {
 
   // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/helpers/formDataToJSON.js
   function parsePropPath(name) {
-    return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
-      return match[0] === "[]" ? "" : match[1] || match[0];
+    return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match2) => {
+      return match2[0] === "[]" ? "" : match2[1] || match2[0];
     });
   }
   function arrayToObject(arr) {
@@ -2559,9 +2928,9 @@ var TagadaTrackerBundle = (() => {
   function parseTokens(str) {
     const tokens = /* @__PURE__ */ Object.create(null);
     const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
-    let match;
-    while (match = tokensRE.exec(str)) {
-      tokens[match[1]] = match[2];
+    let match2;
+    while (match2 = tokensRE.exec(str)) {
+      tokens[match2[1]] = match2[2];
     }
     return tokens;
   }
@@ -2820,8 +3189,8 @@ var TagadaTrackerBundle = (() => {
 
   // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/helpers/parseProtocol.js
   function parseProtocol(url) {
-    const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
-    return match && match[1] || "";
+    const match2 = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+    return match2 && match2[1] || "";
   }
 
   // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/helpers/speedometer.js
@@ -2965,8 +3334,8 @@ var TagadaTrackerBundle = (() => {
       },
       read(name) {
         if (typeof document === "undefined") return null;
-        const match = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
-        return match ? decodeURIComponent(match[1]) : null;
+        const match2 = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
+        return match2 ? decodeURIComponent(match2[1]) : null;
       },
       remove(name) {
         this.write(name, "", Date.now() - 864e5, "/");
@@ -4177,6 +4546,75 @@ var TagadaTrackerBundle = (() => {
     mergeConfig: mergeConfig2
   } = axios_default;
 
+  // src/v2/core/errors.ts
+  var TagadaErrorCode = {
+    NETWORK_ERROR: "network_error",
+    API_ERROR: "api_error",
+    AUTH_REQUIRED: "auth_required",
+    TOKEN_EXPIRED: "token_expired",
+    NOT_FOUND: "not_found",
+    VALIDATION_ERROR: "validation_error",
+    CIRCUIT_BREAKER: "circuit_breaker",
+    PAYMENT_FAILED: "payment_failed",
+    CARD_DECLINED: "card_declined",
+    SESSION_EXPIRED: "session_expired",
+    RATE_LIMITED: "rate_limited",
+    TIMEOUT: "timeout",
+    UNKNOWN: "unknown"
+  };
+  var TagadaError = class extends Error {
+    constructor(message, options) {
+      var _a;
+      super(message);
+      this.name = "TagadaError";
+      this.code = options.code;
+      this.statusCode = options.statusCode;
+      this.retryable = (_a = options.retryable) != null ? _a : false;
+      this.details = options.details;
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  };
+  var TagadaApiError = class extends TagadaError {
+    constructor(message, statusCode, options) {
+      var _a, _b;
+      super(message, {
+        code: (_a = options == null ? void 0 : options.code) != null ? _a : TagadaErrorCode.API_ERROR,
+        statusCode,
+        retryable: (_b = options == null ? void 0 : options.retryable) != null ? _b : statusCode >= 500,
+        details: options == null ? void 0 : options.details
+      });
+      this.name = "TagadaApiError";
+    }
+  };
+  var TagadaNetworkError = class extends TagadaError {
+    constructor(message = "Network request failed") {
+      super(message, {
+        code: TagadaErrorCode.NETWORK_ERROR,
+        retryable: true
+      });
+      this.name = "TagadaNetworkError";
+    }
+  };
+  var TagadaAuthError = class extends TagadaError {
+    constructor(message = "Authentication required", statusCode = 401) {
+      super(message, {
+        code: TagadaErrorCode.AUTH_REQUIRED,
+        statusCode,
+        retryable: false
+      });
+      this.name = "TagadaAuthError";
+    }
+  };
+  var TagadaCircuitBreakerError = class extends TagadaError {
+    constructor(message) {
+      super(message, {
+        code: TagadaErrorCode.CIRCUIT_BREAKER,
+        retryable: false
+      });
+      this.name = "TagadaCircuitBreakerError";
+    }
+  };
+
   // src/v2/core/resources/apiClient.ts
   var ApiClient = class {
     // Max 30 requests per endpoint in window
@@ -4234,12 +4672,18 @@ var TagadaTrackerBundle = (() => {
         }
       );
       this.axios.interceptors.response.use(
-        (response) => {
-          return response;
-        },
+        (response) => response,
         (error) => {
           console.error("[SDK] Response error:", error.message);
-          return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+          if (error instanceof TagadaError) {
+            return Promise.reject(error);
+          }
+          if (axios_default.isAxiosError(error)) {
+            return Promise.reject(this.toTagadaError(error));
+          }
+          return Promise.reject(
+            error instanceof Error ? error : new Error(String(error))
+          );
         }
       );
     }
@@ -4305,30 +4749,66 @@ var TagadaTrackerBundle = (() => {
     // Circuit Breaker Implementation
     checkRequestLimit(key) {
       const now = Date.now();
-      const history = this.requestHistory.get(key);
-      if (!history) {
+      const history2 = this.requestHistory.get(key);
+      if (!history2) {
         this.requestHistory.set(key, { count: 1, firstRequestTime: now });
         return;
       }
-      if (now - history.firstRequestTime > this.WINDOW_MS) {
+      if (now - history2.firstRequestTime > this.WINDOW_MS) {
         this.requestHistory.set(key, { count: 1, firstRequestTime: now });
         return;
       }
-      history.count++;
-      if (history.count > this.MAX_REQUESTS) {
-        const error = new Error("Circuit Breaker: Too many requests to ".concat(key, " (").concat(history.count, " in ").concat(this.WINDOW_MS, "ms)"));
-        error.isCircuitBreaker = true;
-        throw error;
+      history2.count++;
+      if (history2.count > this.MAX_REQUESTS) {
+        throw new TagadaCircuitBreakerError(
+          "Circuit Breaker: Too many requests to ".concat(key, " (").concat(history2.count, " in ").concat(this.WINDOW_MS, "ms)")
+        );
       }
     }
     cleanupHistory() {
       const now = Date.now();
-      for (const [key, history] of this.requestHistory.entries()) {
-        if (now - history.firstRequestTime > this.WINDOW_MS) {
+      for (const [key, history2] of this.requestHistory.entries()) {
+        if (now - history2.firstRequestTime > this.WINDOW_MS) {
           this.requestHistory.delete(key);
         }
       }
     }
+    /** Convert an AxiosError into the appropriate TagadaError subclass. */
+    toTagadaError(error) {
+      var _a, _b, _c, _d, _e;
+      const status = (_a = error.response) == null ? void 0 : _a.status;
+      const data = (_b = error.response) == null ? void 0 : _b.data;
+      const serverMessage = (_d = (_c = data == null ? void 0 : data.message) != null ? _c : data == null ? void 0 : data.error) != null ? _d : error.message;
+      if (!error.response) {
+        if (error.code === "ECONNABORTED") {
+          return new TagadaApiError("Request timed out", 0, {
+            code: TagadaErrorCode.TIMEOUT,
+            retryable: true
+          });
+        }
+        return new TagadaNetworkError(serverMessage);
+      }
+      if (status === 401 || status === 403) {
+        return new TagadaAuthError(serverMessage, status);
+      }
+      if (status === 429) {
+        return new TagadaApiError(serverMessage, 429, {
+          code: TagadaErrorCode.RATE_LIMITED,
+          retryable: true
+        });
+      }
+      if (status === 404) {
+        return new TagadaApiError(serverMessage, 404, {
+          code: TagadaErrorCode.NOT_FOUND,
+          retryable: false
+        });
+      }
+      return new TagadaApiError(serverMessage, status != null ? status : 0, {
+        code: (_e = data == null ? void 0 : data.code) != null ? _e : TagadaErrorCode.API_ERROR,
+        details: data,
+        retryable: (status != null ? status : 0) >= 500
+      });
+    }
   };
 
   // ../../node_modules/.pnpm/@ua-parser-js+pro-enterprise@2.0.6/node_modules/@ua-parser-js/pro-enterprise/src/main/ua-parser.mjs
@@ -4497,7 +4977,7 @@ var TagadaTrackerBundle = (() => {
   };
   var rgxMapper = function(ua, arrays) {
     if (!ua || !arrays) return;
-    var i = 0, j, k, p, q, matches, match;
+    var i = 0, j, k, p, q, matches, match2;
     while (i < arrays.length && !matches) {
       var regex = arrays[i], props = arrays[i + 1];
       j = k = 0;
@@ -4508,34 +4988,34 @@ var TagadaTrackerBundle = (() => {
         matches = regex[j++].exec(ua);
         if (!!matches) {
           for (p = 0; p < props.length; p++) {
-            match = matches[++k];
+            match2 = matches[++k];
             q = props[p];
             if (typeof q === TYPEOF.OBJECT && q.length > 0) {
               if (q.length === 2) {
                 if (typeof q[1] == TYPEOF.FUNCTION) {
-                  this[q[0]] = q[1].call(this, match);
+                  this[q[0]] = q[1].call(this, match2);
                 } else {
                   this[q[0]] = q[1];
                 }
               } else if (q.length >= 3) {
                 if (typeof q[1] === TYPEOF.FUNCTION && !(q[1].exec && q[1].test)) {
                   if (q.length > 3) {
-                    this[q[0]] = match ? q[1].apply(this, q.slice(2)) : void 0;
+                    this[q[0]] = match2 ? q[1].apply(this, q.slice(2)) : void 0;
                   } else {
-                    this[q[0]] = match ? q[1].call(this, match, q[2]) : void 0;
+                    this[q[0]] = match2 ? q[1].call(this, match2, q[2]) : void 0;
                   }
                 } else {
                   if (q.length == 3) {
-                    this[q[0]] = match ? match.replace(q[1], q[2]) : void 0;
+                    this[q[0]] = match2 ? match2.replace(q[1], q[2]) : void 0;
                   } else if (q.length == 4) {
-                    this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : void 0;
+                    this[q[0]] = match2 ? q[3].call(this, match2.replace(q[1], q[2])) : void 0;
                   } else if (q.length > 4) {
-                    this[q[0]] = match ? q[3].apply(this, [match.replace(q[1], q[2])].concat(q.slice(4))) : void 0;
+                    this[q[0]] = match2 ? q[3].apply(this, [match2.replace(q[1], q[2])].concat(q.slice(4))) : void 0;
                   }
                 }
               }
             } else {
-              this[q] = match ? match : void 0;
+              this[q] = match2 ? match2 : void 0;
             }
           }
         }
@@ -8652,7 +9132,7 @@ var TagadaTrackerBundle = (() => {
       }
     }
     updateSessionState(response, sessionData) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
       if (response.store) {
         const storeData = response.store;
         const storeConfig = __spreadProps(__spreadValues({}, response.store), {
@@ -8690,8 +9170,10 @@ var TagadaTrackerBundle = (() => {
         customer: (_g = response.customer) != null ? _g : null,
         auth: authState
       });
-      if (this.funnel && sessionData.customerId && ((_h = response.store) == null ? void 0 : _h.id)) {
-        const accountId = response.store.accountId || ((_i = this.state.pluginConfig) == null ? void 0 : _i.accountId) || sessionData.accountId || "";
+      const funnelFeature = (_h = this.config.features) == null ? void 0 : _h.funnel;
+      const skipAutoInit = typeof funnelFeature === "object" && funnelFeature.skipAutoInit;
+      if (this.funnel && !skipAutoInit && sessionData.customerId && ((_i = response.store) == null ? void 0 : _i.id)) {
+        const accountId = response.store.accountId || ((_j = this.state.pluginConfig) == null ? void 0 : _j.accountId) || sessionData.accountId || "";
         if (accountId) {
           const urlParams = new URLSearchParams(typeof window !== "undefined" ? window.location.search : "");
           const funnelId = urlParams.get("funnelId") || void 0;
@@ -9017,19 +9499,275 @@ var TagadaTrackerBundle = (() => {
     }
   };
 
+  // src/v2/standalone/index.ts
+  init_funnelClient();
+
+  // src/data/iso3166.ts
+  var GEODATA_CDN_BASE = "https://cvwnizdbugpz6jwk.public.blob.vercel-storage.com/geodata/v1";
+  var countriesCache = /* @__PURE__ */ new Map();
+  var regionsCache = /* @__PURE__ */ new Map();
+  var inflightCountries = /* @__PURE__ */ new Map();
+  var inflightRegions = /* @__PURE__ */ new Map();
+  async function fetchCountriesRaw(language) {
+    const cached = countriesCache.get(language);
+    if (cached) return cached;
+    let inflight = inflightCountries.get(language);
+    if (inflight) return inflight;
+    inflight = (async () => {
+      const url = "".concat(GEODATA_CDN_BASE, "/").concat(language, "/countries.json");
+      const res = await fetch(url);
+      if (!res.ok) throw new Error("Geodata fetch failed: ".concat(url, " (").concat(res.status, ")"));
+      const data = await res.json();
+      countriesCache.set(language, data);
+      inflightCountries.delete(language);
+      return data;
+    })();
+    inflightCountries.set(language, inflight);
+    return inflight;
+  }
+  async function fetchRegionsRaw(language) {
+    const cached = regionsCache.get(language);
+    if (cached) return cached;
+    let inflight = inflightRegions.get(language);
+    if (inflight) return inflight;
+    inflight = (async () => {
+      const url = "".concat(GEODATA_CDN_BASE, "/").concat(language, "/regions.json");
+      const res = await fetch(url);
+      if (!res.ok) throw new Error("Geodata fetch failed: ".concat(url, " (").concat(res.status, ")"));
+      const data = await res.json();
+      regionsCache.set(language, data);
+      inflightRegions.delete(language);
+      return data;
+    })();
+    inflightRegions.set(language, inflight);
+    return inflight;
+  }
+  async function ensureGeoDataLoaded(language = "en") {
+    await Promise.all([fetchCountriesRaw(language), fetchRegionsRaw(language)]);
+  }
+  if (typeof globalThis !== "undefined" && typeof fetch !== "undefined") {
+    ensureGeoDataLoaded("en").catch(() => {
+    });
+  }
+
+  // src/v2/core/googleAutocomplete.ts
+  var GoogleAutocompleteCore = class {
+    /**
+     * Initialize Google Places API
+     */
+    static initialize(apiKey) {
+      var _a, _b;
+      this.apiKey = apiKey;
+      if (typeof window !== "undefined" && ((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places)) {
+        this.service = new window.google.maps.places.AutocompleteService();
+      }
+    }
+    /**
+     * Search for places
+     */
+    static async searchPlaces(input, options = {}) {
+      if (!this.service || !input.trim()) {
+        return [];
+      }
+      return new Promise((resolve, reject) => {
+        this.service.getPlacePredictions(
+          {
+            input,
+            types: options.types || ["address"],
+            componentRestrictions: options.componentRestrictions
+          },
+          (predictions, status) => {
+            var _a, _b, _c;
+            if (status === ((_c = (_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && predictions) {
+              resolve(predictions);
+            } else {
+              resolve([]);
+            }
+          }
+        );
+      });
+    }
+    /**
+     * Get place details
+     */
+    static async getPlaceDetails(placeId) {
+      var _a, _b;
+      if (typeof window === "undefined" || !((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places)) {
+        return null;
+      }
+      return new Promise((resolve, reject) => {
+        const service = new window.google.maps.places.PlacesService(
+          document.createElement("div")
+        );
+        service.getDetails(
+          {
+            placeId,
+            fields: ["place_id", "formatted_address", "address_components", "geometry"]
+          },
+          (place, status) => {
+            var _a2, _b2, _c;
+            if (status === ((_c = (_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && place) {
+              resolve(place);
+            } else {
+              resolve(null);
+            }
+          }
+        );
+      });
+    }
+    /**
+     * Extract address components from place details
+     */
+    static extractAddressComponents(placeDetails) {
+      const components = {};
+      for (const component of placeDetails.address_components) {
+        const types = component.types;
+        if (types.includes("street_number")) {
+          components.streetNumber = component.long_name;
+        } else if (types.includes("route")) {
+          components.route = component.long_name;
+        } else if (types.includes("locality")) {
+          components.city = component.long_name;
+          components.locality = component.long_name;
+        } else if (types.includes("administrative_area_level_2")) {
+          components.administrativeAreaLevel2 = component.short_name;
+          components.administrativeAreaLevel2Long = component.long_name;
+          if (!components.city) {
+            components.city = component.long_name;
+            components.locality = component.long_name;
+          }
+        } else if (types.includes("administrative_area_level_1")) {
+          components.state = component.long_name;
+          components.administrativeAreaLevel1 = component.short_name;
+          components.administrativeAreaLevel1Long = component.long_name;
+        } else if (types.includes("postal_code")) {
+          components.postalCode = component.long_name;
+        } else if (types.includes("country")) {
+          components.country = component.long_name;
+          components.countryCode = component.short_name;
+          components.iso = component.short_name;
+        }
+      }
+      if (!components.administrativeAreaLevel1 && components.administrativeAreaLevel2) {
+        components.state = components.administrativeAreaLevel2Long || components.administrativeAreaLevel2;
+        components.administrativeAreaLevel1 = components.administrativeAreaLevel2;
+        components.administrativeAreaLevel1Long = components.administrativeAreaLevel2Long;
+      }
+      return components;
+    }
+  };
+  GoogleAutocompleteCore.apiKey = null;
+  GoogleAutocompleteCore.service = null;
+
   // src/v2/standalone/index.ts
   init_funnel();
 
   // src/v2/core/utils/index.ts
   init_sessionStorage();
 
+  // src/v2/core/pathRemapping.ts
+  var import_path_to_regexp = __toESM(require_dist());
+  var internalPathCache = void 0;
+  var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+  var originalPushState = isBrowser ? history.pushState.bind(history) : null;
+  var originalReplaceState = isBrowser ? history.replaceState.bind(history) : null;
+  function clearCache() {
+    internalPathCache = void 0;
+  }
+  if (isBrowser) {
+    window.addEventListener("popstate", clearCache);
+    window.addEventListener("hashchange", clearCache);
+    history.pushState = function(...args) {
+      clearCache();
+      return originalPushState.apply(this, args);
+    };
+    history.replaceState = function(...args) {
+      clearCache();
+      return originalReplaceState.apply(this, args);
+    };
+  }
+
   // src/v2/standalone/index.ts
+  function parseStepConfigScripts() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return [];
+    }
+    const stepConfig = getAssignedStepConfig();
+    if (stepConfig == null ? void 0 : stepConfig.scripts) {
+      return stepConfig.scripts.filter((s) => s.enabled);
+    }
+    return [];
+  }
+  function injectScript(script, index) {
+    const position = script.position || "body-end";
+    const scriptId = "tagada-stepconfig-script-".concat(index);
+    if (document.getElementById(scriptId)) {
+      return;
+    }
+    let scriptBody = script.content.trim();
+    const scriptTagMatch = scriptBody.match(/^<script[^>]*>([\s\S]*)<\/script>$/i);
+    if (scriptTagMatch) {
+      scriptBody = scriptTagMatch[1].trim();
+    }
+    if (!scriptBody) return;
+    const wrappedScript = "(function() {\n  try {\n    // Script: " + script.name + "\n" + scriptBody + '\n  } catch (error) {\n    console.error("[TagadaPay] StepConfig script error:", error);\n  }\n})();';
+    const scriptElement = document.createElement("script");
+    scriptElement.id = scriptId;
+    scriptElement.setAttribute("data-tagada-stepconfig-script", "true");
+    scriptElement.setAttribute("data-script-name", script.name);
+    scriptElement.textContent = wrappedScript;
+    switch (position) {
+      case "head-start":
+        if (document.head.firstChild) {
+          document.head.insertBefore(scriptElement, document.head.firstChild);
+        } else {
+          document.head.appendChild(scriptElement);
+        }
+        break;
+      case "head-end":
+        document.head.appendChild(scriptElement);
+        break;
+      case "body-start":
+        if (document.body.firstChild) {
+          document.body.insertBefore(scriptElement, document.body.firstChild);
+        } else {
+          document.body.appendChild(scriptElement);
+        }
+        break;
+      case "body-end":
+      default:
+        document.body.appendChild(scriptElement);
+        break;
+    }
+  }
+  function injectStepConfigScripts() {
+    const scripts = parseStepConfigScripts();
+    if (scripts.length === 0) return;
+    scripts.forEach((script, index) => {
+      injectScript(script, index);
+    });
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    const runInjection = () => {
+      if (document.body) {
+        injectStepConfigScripts();
+      } else {
+        document.addEventListener("DOMContentLoaded", injectStepConfigScripts, { once: true });
+      }
+    };
+    if ("requestIdleCallback" in window) {
+      window.requestIdleCallback(runInjection, { timeout: 100 });
+    } else {
+      setTimeout(runInjection, 0);
+    }
+  }
   function createTagadaClient(config = {}) {
     return new TagadaClient(config);
   }
 
   // src/v2/standalone/external-tracker.ts
   init_tokenStorage();
+  var TRACKER_VERSION = "1.0.0";
   function getUrlParam(name) {
     if (typeof window === "undefined") return null;
     const params = new URLSearchParams(window.location.search);
@@ -9040,58 +9778,133 @@ var TagadaTrackerBundle = (() => {
       console.log("[TagadaTracker]", ...args);
     }
   }
+  function warn(...args) {
+    console.warn("[TagadaTracker]", ...args);
+  }
+  function validate(config) {
+    if (!config.storeId || typeof config.storeId !== "string") {
+      throw new Error("TagadaTracker: storeId is required and must be a non-empty string.");
+    }
+    if (!config.accountId || typeof config.accountId !== "string") {
+      throw new Error("TagadaTracker: accountId is required and must be a non-empty string.");
+    }
+    if (!config.stepId || typeof config.stepId !== "string") {
+      throw new Error("TagadaTracker: stepId is required and must be a non-empty string.");
+    }
+    if (config.apiBaseUrl) {
+      try {
+        new URL(config.apiBaseUrl);
+      } catch (e) {
+        throw new Error('TagadaTracker: apiBaseUrl is not a valid URL: "'.concat(config.apiBaseUrl, '"'));
+      }
+    }
+  }
+  async function retryWithBackoff(fn, maxRetries, debug) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < maxRetries) {
+          const delay = Math.min(1e3 * 2 ** attempt, 8e3);
+          log(debug, "Retry ".concat(attempt + 1, "/").concat(maxRetries, " in ").concat(delay, "ms..."));
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
   var TagadaExternalTracker = class {
     constructor() {
       this.config = null;
       this.client = null;
       this.initialized = false;
       this.initializing = false;
+      this.unsubscribe = null;
+      /** Tracker version */
+      this.version = TRACKER_VERSION;
     }
     /**
-     * Initialize the tracker using SDK infrastructure
+     * Initialize the tracker.
+     * When `onError` is provided, errors are passed to the callback and init()
+     * resolves to `null` instead of throwing.
      */
     async init(config) {
-      var _a, _b, _c, _d;
-      if (this.initialized || this.initializing) {
-        log(config.debug || false, "Already initialized or initializing");
+      var _a, _b;
+      if (this.initialized) {
+        log(config.debug || false, "Already initialized \u2014 returning existing session.");
         return this.getSession();
       }
+      if (this.initializing) {
+        log(config.debug || false, "Initialization in progress \u2014 skipping duplicate call.");
+        return null;
+      }
       this.initializing = true;
-      this.config = __spreadValues({
-        debug: false
-      }, config);
-      log(this.config.debug, "\u{1F680} Initializing external tracker with SDK...", config);
+      this.config = __spreadValues({ debug: false }, config);
+      const debug = this.config.debug;
+      try {
+        validate(this.config);
+      } catch (err) {
+        this.initializing = false;
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (this.config.onError) {
+          this.config.onError(error);
+          return null;
+        }
+        throw error;
+      }
+      log(debug, "\u{1F680} Initializing external tracker v".concat(TRACKER_VERSION), {
+        storeId: config.storeId,
+        accountId: config.accountId,
+        stepId: config.stepId,
+        funnelId: config.funnelId
+      });
       try {
         const urlToken = getUrlParam("token");
         if (urlToken) {
           setClientToken(urlToken);
-          log(this.config.debug, "\u{1F511} Bootstrapped token from URL");
+          log(debug, "\u{1F511} Bootstrapped token from URL");
         }
         this.client = createTagadaClient({
-          debugMode: this.config.debug,
-          features: { funnel: true }
+          debugMode: debug,
+          features: { funnel: { skipAutoInit: true } },
+          rawPluginConfig: {
+            storeId: this.config.storeId,
+            accountId: this.config.accountId
+          },
+          customApiConfig: this.config.apiBaseUrl ? {
+            apiConfig: {
+              baseUrl: this.config.apiBaseUrl.trim()
+            }
+          } : void 0
         });
         await this.waitForClientReady();
-        const funnelContext = await this.initializeFunnel();
-        log(this.config.debug, "\u2705 Session initialized (tracking handled by orchestrator):", funnelContext);
+        const funnelContext = await retryWithBackoff(
+          () => this.initializeFunnel(),
+          2,
+          debug
+        );
+        log(debug, "\u2705 Session initialized:", funnelContext);
         this.initialized = true;
         const session = this.getSession();
         if (session) {
           (_b = (_a = this.config).onReady) == null ? void 0 : _b.call(_a, session);
         }
         return session;
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        log(this.config.debug, "\u274C Initialization failed:", err);
-        (_d = (_c = this.config).onError) == null ? void 0 : _d.call(_c, err);
-        throw err;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        log(debug, "\u274C Initialization failed:", error);
+        if (this.config.onError) {
+          this.config.onError(error);
+          return null;
+        }
+        throw error;
       } finally {
         this.initializing = false;
       }
     }
-    /**
-     * Get current session from SDK state
-     */
+    /** Get current session data. */
     getSession() {
       var _a, _b;
       if (!((_b = (_a = this.client) == null ? void 0 : _a.funnel) == null ? void 0 : _b.state.context)) return null;
@@ -9105,19 +9918,18 @@ var TagadaTrackerBundle = (() => {
         cmsToken: this.client.state.token || void 0
       };
     }
-    /**
-     * Check if tracker is ready
-     */
+    /** Whether the tracker is fully initialized and ready. */
     isReady() {
       var _a, _b;
       return this.initialized && !!((_b = (_a = this.client) == null ? void 0 : _a.funnel) == null ? void 0 : _b.state.context);
     }
     /**
-     * Navigate to next step in funnel using SDK's funnel client
+     * Navigate to the next step in the funnel.
+     * By default, auto-redirects the browser window.
      */
     async navigate(options) {
       if (!this.isReady()) {
-        throw new Error("Tracker not initialized. Call init() first.");
+        throw new Error("TagadaTracker: not initialized. Call init() first.");
       }
       log(this.config.debug, "\u{1F680} Navigating:", options);
       const shouldAutoRedirect = options.autoRedirect !== false;
@@ -9128,7 +9940,6 @@ var TagadaTrackerBundle = (() => {
             data: options.eventData || {}
           },
           { autoRedirect: false }
-          // Always disable SDK auto-redirect, we handle it here
         );
         if (result == null ? void 0 : result.url) {
           log(this.config.debug, "\u2705 Navigation result:", result.url);
@@ -9144,36 +9955,48 @@ var TagadaTrackerBundle = (() => {
       }
     }
     /**
-     * Get customer ID (for identifying the user)
+     * Track a custom event (e.g., button click, scroll depth, video play).
+     * Events are sent through the funnel orchestrator for unified analytics.
      */
+    async trackEvent(options) {
+      if (!this.isReady()) {
+        warn("trackEvent called before init \u2014 event dropped:", options.name);
+        return;
+      }
+      log(this.config.debug, "\u{1F4CA} Tracking event:", options.name, options.data);
+      try {
+        await this.client.funnel.navigate(
+          {
+            type: options.name,
+            data: options.data || {}
+          },
+          { autoRedirect: false }
+        );
+      } catch (e) {
+        log(this.config.debug, "\u26A0\uFE0F Event tracking failed (non-critical):", options.name);
+      }
+    }
+    /** Get customer ID. */
     getCustomerId() {
       var _a, _b, _c, _d, _e;
       return ((_b = (_a = this.client) == null ? void 0 : _a.state.auth.customer) == null ? void 0 : _b.id) || ((_e = (_d = (_c = this.client) == null ? void 0 : _c.funnel) == null ? void 0 : _d.state.context) == null ? void 0 : _e.customerId) || null;
     }
-    /**
-     * Get funnel session ID
-     */
+    /** Get funnel session ID. */
     getFunnelSessionId() {
       var _a, _b, _c;
       return ((_c = (_b = (_a = this.client) == null ? void 0 : _a.funnel) == null ? void 0 : _b.state.context) == null ? void 0 : _c.sessionId) || null;
     }
     /**
-     * Build a URL with funnel context parameters
-     * Useful for linking to other external pages while preserving session
+     * Build a URL that preserves funnel session context.
+     * Use this to link to other external pages within the same funnel.
      */
     buildUrl(baseUrl, additionalParams) {
       const session = this.getSession();
-      if (!session) {
-        return baseUrl;
-      }
+      if (!session) return baseUrl;
       const url = new URL(baseUrl, typeof window !== "undefined" ? window.location.origin : void 0);
       url.searchParams.set("funnelSessionId", session.sessionId);
-      if (session.cmsToken) {
-        url.searchParams.set("token", session.cmsToken);
-      }
-      if (session.funnelId) {
-        url.searchParams.set("funnelId", session.funnelId);
-      }
+      if (session.cmsToken) url.searchParams.set("token", session.cmsToken);
+      if (session.funnelId) url.searchParams.set("funnelId", session.funnelId);
       url.searchParams.set("storeId", session.storeId);
       if (additionalParams) {
         Object.entries(additionalParams).forEach(([key, value]) => {
@@ -9182,55 +10005,98 @@ var TagadaTrackerBundle = (() => {
       }
       return url.toString();
     }
-    /**
-     * Get the underlying SDK client (for advanced usage)
-     */
+    /** Get the underlying SDK client (advanced usage). */
     getClient() {
       return this.client;
     }
+    /**
+     * Reset the tracker to a new step without re-creating the session.
+     * Useful for SPAs that navigate between funnel steps client-side.
+     */
+    async reset(newStepId) {
+      var _a, _b;
+      if (!this.client || !this.config) {
+        throw new Error("TagadaTracker: not initialized. Call init() first.");
+      }
+      log(this.config.debug, "\u{1F504} Resetting to step:", newStepId);
+      this.config.stepId = newStepId;
+      const ctx = await this.initializeFunnel();
+      const session = this.getSession();
+      if (session) (_b = (_a = this.config).onReady) == null ? void 0 : _b.call(_a, session);
+      return session;
+    }
+    /**
+     * Destroy the tracker, clean up event listeners and state.
+     * Call this when the tracker is no longer needed (e.g., SPA teardown).
+     */
+    destroy() {
+      var _a, _b;
+      if (this.unsubscribe) {
+        this.unsubscribe();
+        this.unsubscribe = null;
+      }
+      if (this.client) {
+        (_b = (_a = this.client).destroy) == null ? void 0 : _b.call(_a);
+      }
+      this.client = null;
+      this.config = null;
+      this.initialized = false;
+      this.initializing = false;
+      log(false, "\u{1F5D1}\uFE0F Tracker destroyed");
+    }
     // ========================================================================
     // PRIVATE METHODS
     // ========================================================================
     async waitForClientReady() {
       if (!this.client) return;
       return new Promise((resolve) => {
-        let retries = 0;
-        const checkReady = () => {
-          var _a, _b;
-          if (((_a = this.client) == null ? void 0 : _a.state.isInitialized) || ((_b = this.client) == null ? void 0 : _b.state.token)) {
+        var _a;
+        if ((_a = this.client) == null ? void 0 : _a.state.isInitialized) {
+          resolve();
+          return;
+        }
+        let resolved = false;
+        const timeout = setTimeout(() => {
+          var _a2;
+          if (!resolved) {
+            resolved = true;
+            log(((_a2 = this.config) == null ? void 0 : _a2.debug) || false, "\u23F1\uFE0F Client ready timeout \u2014 proceeding");
             resolve();
-          } else if (retries > 40) {
+          }
+        }, 1e4);
+        this.unsubscribe = this.client.subscribe(() => {
+          var _a2;
+          if (!resolved && ((_a2 = this.client) == null ? void 0 : _a2.state.isInitialized)) {
+            resolved = true;
+            clearTimeout(timeout);
             resolve();
-          } else {
-            retries++;
-            setTimeout(checkReady, 50);
           }
-        };
-        checkReady();
+        });
       });
     }
     async initializeFunnel() {
       var _a, _b, _c;
       if (!((_a = this.client) == null ? void 0 : _a.funnel)) return null;
+      const customerId = (_b = this.client.state.auth.customer) == null ? void 0 : _b.id;
+      const sessionId = (_c = this.client.state.auth.session) == null ? void 0 : _c.sessionId;
+      if (!customerId && !sessionId) {
+        warn("No auth session available \u2014 funnel init may fail.");
+      }
       const authSession = {
-        customerId: ((_b = this.client.state.auth.customer) == null ? void 0 : _b.id) || "anon_placeholder",
-        sessionId: ((_c = this.client.state.auth.session) == null ? void 0 : _c.sessionId) || "sess_placeholder"
+        customerId: customerId || "anon_placeholder",
+        sessionId: sessionId || "sess_placeholder"
       };
       const store = {
         id: this.config.storeId,
-        accountId: this.config.accountId || ""
+        accountId: this.config.accountId
       };
       const entryStepId = this.config.stepId;
-      if (!entryStepId) {
-        throw new Error("stepId is required for external page tracking (URL mapping does not work for external pages)");
-      }
-      log(this.config.debug, "\u{1F50D} Initializing external page at step:", entryStepId);
+      log(this.config.debug, "\u{1F50D} Initializing funnel at step:", entryStepId);
       return this.client.funnel.initialize(
         authSession,
         store,
         this.config.funnelId || getUrlParam("funnelId") || void 0,
         entryStepId
-        // ✅ Explicitly tell orchestrator which step we're on
       );
     }
   };