saasco-sdk 0.2.4 → 0.2.6

package/dist/index.cjs

@@ -38,7 +38,187 @@ module.exports = __toCommonJS(index_exports);
 var import_psl = require("psl");
 
 // package.json
-var version = "0.2.4";
+var version = "0.2.6";
+
+// src/lib/deliverOnce.ts
+var sent = /* @__PURE__ */ new Set();
+var pending = /* @__PURE__ */ new Map();
+function deliverOnce(key, send) {
+  if (!key || typeof window === "undefined") {
+    return Promise.resolve().then(send);
+  }
+  if (sent.has(key)) {
+    return Promise.resolve();
+  }
+  try {
+    if (window.sessionStorage.getItem(key)) {
+      return Promise.resolve();
+    }
+  } catch {
+  }
+  const existing = pending.get(key);
+  if (existing) {
+    return existing;
+  }
+  const task = Promise.resolve().then(send).then(() => {
+    sent.add(key);
+    try {
+      window.sessionStorage.setItem(key, "true");
+    } catch {
+    }
+  }).finally(() => pending.delete(key));
+  pending.set(key, task);
+  return task;
+}
+
+// ../shared/src/lib/analyticsIngestError.ts
+var import_zod = require("zod");
+var IDENTIFY_INGEST_ERROR_SOURCE = "saasco-identify";
+var ANALYTICS_INGEST_ERROR_SOURCE = "saasco-analytics";
+var AnalyticsIngestErrorCodeSchema = import_zod.z.enum([
+  "CREDENTIAL_INVALID",
+  "RESOURCE_FORBIDDEN",
+  "RESOURCE_UNSPECIFIED",
+  "ENVIRONMENT_UNREACHABLE",
+  "INGEST_FAILED"
+]);
+var AnalyticsIngestSurfaceSchema = import_zod.z.enum(["identify", "events"]);
+var AnalyticsIngestErrorSchema = import_zod.z.object({
+  affected: import_zod.z.string(),
+  code: AnalyticsIngestErrorCodeSchema,
+  message: import_zod.z.string(),
+  projectId: import_zod.z.string().nullable(),
+  recovery: import_zod.z.string(),
+  resource: import_zod.z.string().nullable(),
+  surface: AnalyticsIngestSurfaceSchema
+});
+var IDENTIFY_AFFECTED = "Saasco identification only: CRM contact properties and identity stitching. Page views, charts, and the host application UI are not this failure.";
+var ANALYTICS_EVENT_AFFECTED = "Saasco event tracking only. The host application UI is not this failure.";
+function analyticsIngestError({
+  code,
+  message,
+  projectId,
+  resource,
+  surface
+}) {
+  const copy = ingestCopy({ code, resource, surface });
+  return {
+    affected: surface === "identify" ? IDENTIFY_AFFECTED : ANALYTICS_EVENT_AFFECTED,
+    code,
+    message: message ?? copy.message,
+    projectId,
+    recovery: copy.recovery,
+    resource,
+    surface
+  };
+}
+function ingestCopy({
+  code,
+  resource,
+  surface
+}) {
+  const named = resource ? `\`${resource}\`` : "the requested analytics resource";
+  const didNotComplete = surface === "identify" ? "Identification did not complete." : "Event tracking did not complete.";
+  switch (code) {
+    case "CREDENTIAL_INVALID": {
+      return {
+        message: "Saasco analytics credentials are invalid or missing. This is not an application login or permissions problem.",
+        recovery: "Check TINYBIRD_ANALYTICS_TOKEN on the Saasco ingest worker. Do not change host-app auth. Charts and UI styling are unrelated."
+      };
+    }
+    case "RESOURCE_FORBIDDEN": {
+      return {
+        message: `Saasco analytics is not allowed to use ${named}. ${didNotComplete}`,
+        recovery: surface === "identify" ? `Grant the ingest worker access to ${named} (PIPES:READ or DATASOURCES:APPEND). Page tracking may still work.` : `Grant the ingest worker access to ${named} (PIPES:READ or DATASOURCES:APPEND).`
+      };
+    }
+    case "RESOURCE_UNSPECIFIED": {
+      return {
+        message: `Saasco analytics was denied access without a named pipe or datasource. ${didNotComplete}`,
+        recovery: "This is a Saasco ingest configuration issue: the worker could not name the Tinybird resource it tried to use. Host-app login is unrelated."
+      };
+    }
+    case "ENVIRONMENT_UNREACHABLE": {
+      return {
+        message: surface === "identify" ? "The Saasco ingest host could not be reached, so identification was not sent." : "The Saasco ingest host could not be reached, so this event was not sent.",
+        recovery: "If `proxy` points at localhost, start the analytics worker (`pnpm worker:dev`) or use https://t.saasco.com/. This does not mean the host app is broken."
+      };
+    }
+    default: {
+      return {
+        message: surface === "identify" ? "Saasco identification could not be completed." : "Saasco event tracking could not be completed.",
+        recovery: "Retry. If it keeps failing, this is a Saasco analytics ingest issue, not host-app login or chart configuration."
+      };
+    }
+  }
+}
+function ingestErrorSource(surface) {
+  return surface === "identify" ? IDENTIFY_INGEST_ERROR_SOURCE : ANALYTICS_INGEST_ERROR_SOURCE;
+}
+function redactSecrets(text) {
+  return text.replaceAll(/Bearer\s+\S+/giu, "Bearer [redacted]").replaceAll(/\bp\.[A-Za-z0-9._-]+/gu, "[redacted]").replaceAll(/token=[^&\s]+/giu, "token=[redacted]");
+}
+function isUnsafeIngestMessage(text) {
+  return /Bearer \[redacted\]|token=\[redacted\]/iu.test(text) || /token you have provided|doesn't have access to this resource|not enough permissions|invalid token/iu.test(
+    text
+  );
+}
+
+// src/lib/formatAnalyticsRequestFailure.ts
+function formatAnalyticsRequestFailure(input) {
+  const surface = input.path === "identify" ? "identify" : "events";
+  const projectId = input.projectId ?? null;
+  if (input.reason === "http") {
+    const parsed = AnalyticsIngestErrorSchema.safeParse(input.body);
+    if (parsed.success) {
+      return parsed.data;
+    }
+  }
+  if (input.reason === "unreachable") {
+    return analyticsIngestError({
+      code: "ENVIRONMENT_UNREACHABLE",
+      projectId,
+      resource: null,
+      surface
+    });
+  }
+  const legacy = input.body && typeof input.body === "object" && !Array.isArray(input.body) && "message" in input.body && typeof input.body.message === "string" ? input.body.message : "";
+  const safeMessage = redactSecrets(legacy).trim();
+  return analyticsIngestError({
+    code: "INGEST_FAILED",
+    message: safeMessage && !isUnsafeIngestMessage(safeMessage) ? safeMessage : void 0,
+    projectId,
+    resource: null,
+    surface
+  });
+}
+function reportIngestFailure({
+  failure,
+  logger,
+  path,
+  seen
+}) {
+  const key = `${path}:${failure.code}:${failure.resource ?? ""}`;
+  if (!seen.has(key)) {
+    seen.add(key);
+    logger.warn(...analyticsFailureLogLines(failure, path));
+  }
+  return {
+    success: false,
+    message: failure.message
+  };
+}
+function analyticsFailureLogLines(failure, path) {
+  const lines = [
+    `${ingestErrorSource(failure.surface)} ${path} failed (${failure.code})`,
+    failure.message,
+    failure.resource ? `Resource: ${failure.resource}` : null,
+    failure.projectId ? `Project: ${failure.projectId}` : null,
+    `Affected: ${failure.affected}`,
+    `Recovery: ${failure.recovery}`
+  ];
+  return lines.filter((line) => line !== null);
+}
 
 // src/lib/timezones.ts
 var timezones = {
@@ -487,6 +667,9 @@ var AnalyticsLogger = class {
   constructor(config) {
     this.config = config;
   }
+  setLevel(level) {
+    this.config.level = level;
+  }
   debug(...args) {
     if (this.config.level < 3 /* DEBUG */) {
       return;
@@ -515,12 +698,10 @@ var AnalyticsLogger = class {
     );
   }
   /**
-   * Log warning information
+   * Warnings always print. Ingest failures use this so they stay visible when
+   * the default log level is ERROR, without `console.error` (Next.js overlays it).
    */
   warn(...args) {
-    if (this.config.level < 1 /* WARN */) {
-      return;
-    }
     const icon = "\u25CD";
     const message = `${icon} ${this.config.label}`;
     console.warn(
@@ -567,9 +748,34 @@ function getIntegrationLoggerLevel(integrationName, debug) {
 }
 
 // src/lib/utils/uuid.ts
-var import_uuid = require("@lukeed/uuid");
+var HEX = [];
+for (let i = 0; i < 256; i++) {
+  HEX[i] = (i + 256).toString(16).slice(1);
+}
 function uuid() {
-  return (0, import_uuid.v4)();
+  const bytes = randomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  let out = "";
+  for (let i = 0; i < 16; i++) {
+    out += HEX[bytes[i]];
+    if (i === 3 || i === 5 || i === 7 || i === 9) {
+      out += "-";
+    }
+  }
+  return out;
+}
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  const webCrypto = globalThis.crypto;
+  if (typeof webCrypto?.getRandomValues === "function") {
+    webCrypto.getRandomValues(bytes);
+    return bytes;
+  }
+  for (let i = 0; i < length; i++) {
+    bytes[i] = Math.random() * 256 | 0;
+  }
+  return bytes;
 }
 
 // src/lib/getBrowserContext.ts
@@ -641,6 +847,50 @@ function resolveAdParams(params) {
 
 // src/lib/integrations/facebook-pixel.ts
 var import_js_sha256 = require("js-sha256");
+
+// src/lib/integrations/loadPixelScript.ts
+var loads = /* @__PURE__ */ new Map();
+function loadPixelScript(src) {
+  const existingLoad = loads.get(src);
+  if (existingLoad) {
+    return existingLoad;
+  }
+  const existingScript = Array.from(document.scripts).find(
+    (script2) => script2.src === src
+  );
+  const script = existingScript ?? document.createElement("script");
+  const task = new Promise((resolve, reject) => {
+    const cleanup = () => {
+      clearTimeout(timeout);
+      script.removeEventListener("load", loaded);
+      script.removeEventListener("error", failed);
+    };
+    const loaded = () => {
+      cleanup();
+      resolve();
+    };
+    const failed = () => {
+      cleanup();
+      script.remove();
+      reject(new Error(`Pixel script unavailable: ${src}`));
+    };
+    const timeout = setTimeout(failed, 1e4);
+    script.addEventListener("load", loaded);
+    script.addEventListener("error", failed);
+    if (!existingScript) {
+      script.async = true;
+      script.src = src;
+      document.head.append(script);
+    }
+  }).catch((error) => {
+    loads.delete(src);
+    throw error;
+  });
+  loads.set(src, task);
+  return task;
+}
+
+// src/lib/integrations/facebook-pixel.ts
 var isBrowser2 = typeof window !== "undefined";
 var isServer2 = !isBrowser2;
 var standardFacebookEvents = [
@@ -682,70 +932,32 @@ function createFacebookPixelIntegration(config, debug) {
         return;
       }
       logger.info("Initializing Facebook Pixel", { pixelId: config.pixelId });
-      if (window.fbq || window._fbq) {
-        logger.warn("Facebook Pixel is already initialized");
-        isPixelReady = true;
-        return;
-      }
-      return new Promise((resolve, reject) => {
-        try {
-          (function init(f, b, e, v, n, t, s) {
-            if (f.fbq) {
-              return;
-            }
-            n = f.fbq = function fbq2() {
-              n.callMethod ? n.callMethod.apply(n, arguments) : n.queue.push(arguments);
-            };
-            if (!f._fbq) {
-              f._fbq = n;
-            }
-            n.push = n;
-            n.loaded = true;
-            n.version = "2.0";
-            n.queue = [];
-            t = b.createElement(e);
-            t.async = true;
-            t.src = v;
-            t.addEventListener("load", () => {
-              isPixelReady = true;
-              logger.info("Facebook Pixel script loaded successfully");
-              resolve();
-            });
-            t.addEventListener("error", () => {
-              logger.error("Failed to load Facebook Pixel script");
-              reject(new Error("Failed to load Facebook Pixel script"));
-            });
-            s = b.getElementsByTagName(e)[0];
-            s.parentNode.insertBefore(t, s);
-          })(
-            window,
-            document,
-            "script",
-            "https://connect.facebook.net/en_US/fbevents.js"
-          );
-          const { fbq } = window;
-          if (!fbq) {
-            reject(new Error("Facebook Pixel failed to initialize"));
-            return;
-          }
-          fbq.disablePushState = true;
-          fbq.allowDuplicatePageViews = true;
-          if (config.automaticConfiguration === false) {
-            logger.debug("Disabling automatic configuration");
-            fbq("set", "autoConfig", false, config.pixelId);
-          }
-          logger.debug("Initializing Facebook Pixel with ID", config.pixelId);
-          fbq("init", config.pixelId);
-          if (typeof fbq === "function") {
-            isPixelReady = true;
-            logger.info("Facebook Pixel initialized synchronously");
-            resolve();
+      if (!window.fbq) {
+        const fbq2 = (...args) => {
+          if (fbq2.callMethod) {
+            fbq2.callMethod(...args);
+          } else {
+            fbq2.queue.push(args);
           }
-        } catch (error) {
-          logger.error("Error during Facebook Pixel initialization", error);
-          reject(error);
-        }
-      });
+        };
+        fbq2.queue = [];
+        fbq2.push = fbq2;
+        fbq2.loaded = true;
+        fbq2.version = "2.0";
+        window.fbq = fbq2;
+        window._fbq = fbq2;
+      }
+      const { fbq } = window;
+      fbq.disablePushState = true;
+      fbq.allowDuplicatePageViews = true;
+      if (config.automaticConfiguration === false) {
+        fbq("set", "autoConfig", false, config.pixelId);
+      }
+      fbq("init", config.pixelId);
+      if (!fbq.callMethod) {
+        await loadPixelScript("https://connect.facebook.net/en_US/fbevents.js");
+      }
+      isPixelReady = true;
     },
     track: (eventName, properties, _context) => {
       const { fbq } = window;
@@ -753,9 +965,11 @@ function createFacebookPixelIntegration(config, debug) {
         logger.warn("Facebook Pixel not ready, skipping track event", {
           eventName
         });
-        return;
+        throw new Error("Facebook Pixel not ready");
       }
       const fbEventName = getFacebookEventName(eventName, config.eventMapping);
+      const eventId = properties?.["event_id"];
+      const eventOptions = typeof eventId === "string" && eventId.trim().length > 0 ? { eventID: eventId } : void 0;
       const eventsWithParams = ["Purchase", "StartTrial", "Subscribe"];
       const isStandardEvent = standardFacebookEvents.includes(
         fbEventName
@@ -783,10 +997,18 @@ function createFacebookPixelIntegration(config, debug) {
           event: fbEventName,
           params: fbParams
         });
-        fbq(trackType, fbEventName, fbParams);
+        if (eventOptions) {
+          fbq(trackType, fbEventName, fbParams, eventOptions);
+        } else {
+          fbq(trackType, fbEventName, fbParams);
+        }
       } else {
         logger.info("Tracking Facebook Pixel event", { event: fbEventName });
-        fbq(trackType, fbEventName);
+        if (eventOptions) {
+          fbq(trackType, fbEventName, {}, eventOptions);
+        } else {
+          fbq(trackType, fbEventName);
+        }
       }
     },
     identify: (userId, properties, _context) => {
@@ -1140,12 +1362,12 @@ var IntegrationManager = class {
   globalQueue = [];
   config;
   logger;
-  initTime;
   currentEnvironment;
   flushTimer;
   unloadHandler;
   constructor(config = {}) {
     this.config = {
+      deduplicationNamespace: config.deduplicationNamespace ?? "default",
       flushInterval: config.flushInterval ?? 5e3,
       loggerLevel: config.loggerLevel ?? 0 /* ERROR */,
       maxIntegrationWaitTime: config.maxIntegrationWaitTime ?? 1e4,
@@ -1155,7 +1377,6 @@ var IntegrationManager = class {
       label: "Saasco Integrations Debug",
       level: this.config.loggerLevel
     });
-    this.initTime = Date.now();
     this.currentEnvironment = typeof window === "undefined" ? "server" : "client";
     this.setupPeriodicFlushing();
     this.setupUnloadHandler();
@@ -1232,6 +1453,8 @@ var IntegrationManager = class {
    */
   send(partial) {
     const envelope = {
+      delivered: /* @__PURE__ */ new Set(),
+      pending: /* @__PURE__ */ new Set(),
       context: { ...this.context },
       id: uuid(),
       name: partial.name,
@@ -1239,65 +1462,55 @@ var IntegrationManager = class {
       timestamp: Date.now(),
       type: partial.type
     };
-    if (!this.isReady()) {
-      if (this.globalQueue.length >= this.config.maxQueueSize) {
-        this.globalQueue.shift();
-        this.logger.warn("Queue full \u2192 dropped oldest");
-      }
-      this.globalQueue.push(envelope);
-      this.logger.debug(`Queued (${this.globalQueue.length})`, envelope);
-      return;
+    if (this.globalQueue.length >= this.config.maxQueueSize) {
+      this.globalQueue.shift();
+      this.logger.warn("Queue full \u2192 dropped oldest");
     }
-    this.deliver(envelope);
+    this.globalQueue.push(envelope);
+    this.flush();
   }
-  async deliver(evt) {
-    for (const { integration, status } of this.integrations.values()) {
-      if (status !== "ready") {
-        continue;
-      }
-      try {
-        if (evt.type === "track" && integration.track && evt.name) {
-          this.logger.debug(`Track (${integration.name}) ${evt.name}`, {
-            context: evt.context,
-            properties: evt.properties
-          });
-          await integration.track(evt.name, evt.properties, evt.context);
-        } else if (evt.type === "identify" && integration.identify) {
-          this.logger.debug(`Identify (${integration.name})`, {
-            context: evt.context,
-            properties: evt.properties,
-            userId: evt.context.distinctId
-          });
-          await integration.identify(
-            evt.context.distinctId,
-            evt.properties,
-            evt.context
-          );
-        }
-      } catch (error) {
-        this.logger.error(
-          `deliver error in ${integration.name} (${evt.type})`,
-          error
+  async deliver(evt, state) {
+    const { integration } = state;
+    evt.pending.add(integration.name);
+    try {
+      if (evt.type === "track" && integration.track && evt.name) {
+        const eventId = evt.properties?.["event_id"];
+        const key = typeof eventId === "string" && eventId.trim() ? `saasco:${this.config.deduplicationNamespace}:${integration.name}:${evt.name}:${eventId}` : void 0;
+        const { track } = integration;
+        const { name } = evt;
+        await deliverOnce(
+          key,
+          () => track.call(integration, name, evt.properties, evt.context)
+        );
+      } else if (evt.type === "identify" && integration.identify) {
+        await integration.identify(
+          evt.context.distinctId,
+          evt.properties,
+          evt.context
         );
       }
+      evt.delivered.add(integration.name);
+    } catch (error) {
+      this.logger.error(
+        `deliver error in ${integration.name} (${evt.type})`,
+        error
+      );
+    } finally {
+      evt.pending.delete(integration.name);
     }
   }
-  /**
-   * Flush queued events FIFO once at least one integration is ready.
-   */
+  /** Each ready destination drains its own copy; a slow/blocked pixel cannot
+   * discard another pixel's queued events or hold up the ready destinations. */
   flush() {
-    if (this.globalQueue.length === 0) {
-      return;
-    }
-    if (!this.isReady()) {
-      return;
-    }
-    this.logger.debug(`flushing ${this.globalQueue.length} queued events`);
-    const toSend = this.globalQueue;
-    this.globalQueue = [];
-    for (const evt of toSend) {
-      this.deliver(evt);
-    }
+    this.globalQueue = this.globalQueue.filter((evt) => {
+      for (const state of this.integrations.values()) {
+        const { name } = state.integration;
+        if (state.status === "ready" && !evt.delivered.has(name) && !evt.pending.has(name)) {
+          void this.deliver(evt, state);
+        }
+      }
+      return evt.delivered.size < this.integrations.size && Date.now() - evt.timestamp < this.config.maxIntegrationWaitTime;
+    });
   }
   readyCount() {
     let n = 0;
@@ -1308,18 +1521,6 @@ var IntegrationManager = class {
     }
     return n;
   }
-  isReady() {
-    const timeElapsed = Date.now() - this.initTime;
-    if (this.readyCount() < this.integrations.size && timeElapsed < this.config.maxIntegrationWaitTime) {
-      return false;
-    }
-    if (this.readyCount() < this.integrations.size) {
-      this.logger.info(
-        `proceeding with ${this.readyCount()}/${this.integrations.size} integrations ready after ${timeElapsed}ms wait`
-      );
-    }
-    return true;
-  }
   /**
    * Setup periodic flushing if enabled
    */
@@ -1403,50 +1604,20 @@ function createPinterestTagIntegration(config, debug) {
         return;
       }
       logger.info("Initializing Pinterest Tag", { tagId: config.tagId });
-      if (window.pintrk || window._pintrk) {
-        logger.warn("Pinterest Tag is already initialized");
-        isTagReady = true;
-        return;
+      if (!window.pintrk) {
+        const pintrk = (...args) => pintrk.queue.push(args);
+        pintrk.queue = [];
+        pintrk.version = "3.0";
+        window.pintrk = pintrk;
       }
-      return new Promise((resolve, reject) => {
-        try {
-          (function init(e) {
-            if (!window.pintrk) {
-              window.pintrk = function pintrk(...args) {
-                window.pintrk.queue.push(args);
-              };
-              const n = window.pintrk;
-              n.queue = [];
-              n.version = "3.0";
-              const t = document.createElement("script");
-              t.async = true;
-              t.src = e;
-              t.addEventListener("load", () => {
-                window.pintrk("load", config.tagId);
-                window.pintrk("page");
-                setTimeout(() => {
-                  logger.debug("Pinterest Tag initialized");
-                  isTagReady = true;
-                  resolve();
-                }, 500);
-              });
-              t.addEventListener("error", () => {
-                logger.error("Failed to load Pinterest Tag script");
-                reject(new Error("Failed to load Pinterest Tag script"));
-              });
-              const r = document.getElementsByTagName("script")[0];
-              r.parentNode.insertBefore(t, r);
-            }
-          })("https://s.pinimg.com/ct/core.js");
-        } catch (error) {
-          logger.error("Failed to initialize Pinterest Tag", error);
-          reject(error);
-        }
-      });
+      await loadPixelScript("https://s.pinimg.com/ct/core.js");
+      window.pintrk("load", config.tagId);
+      window.pintrk("page");
+      isTagReady = true;
     },
     track: (eventName, properties) => {
       if (!isTagReady || !window.pintrk) {
-        return;
+        throw new Error("Pinterest Tag not ready");
       }
       const pinterestEventName = getPinterestEventName(
         eventName,
@@ -1575,8 +1746,8 @@ function createTikTokPixelIntegration(config, debug) {
         return;
       }
       logger.info("Initializing TikTok Pixel", { pixelId: config.pixelId });
-      if (window.ttq) {
-        logger.warn("TikTok Pixel is already initialized");
+      if (window.ttq?.ready) {
+        await new Promise((resolve) => window.ttq.ready(resolve));
         isPixelReady = true;
         return;
       }
@@ -1628,28 +1799,15 @@ function createTikTokPixelIntegration(config, debug) {
               ttq._t[e] = Date.now();
               ttq._o ||= {};
               ttq._o[e] = n || {};
-              const script = document.createElement("script");
-              script.type = "text/javascript";
-              script.async = true;
-              script.src = `${r}?sdkid=${e}&lib=${t}`;
-              script.addEventListener("load", () => {
+              loadPixelScript(`${r}?sdkid=${e}&lib=${t}`).then(() => {
                 isPixelReady = true;
                 resolve();
-              });
-              script.addEventListener("error", () => {
-                reject(new Error("Failed to load TikTok Pixel script"));
-              });
-              const firstScript = document.getElementsByTagName("script")[0];
-              firstScript.parentNode.insertBefore(script, firstScript);
+              }).catch(reject);
             };
             ttq.load(
               config.pixelId,
               config.testMode ? { test_mode: true } : void 0
             );
-            if (window.ttq && typeof window.ttq === "function") {
-              isPixelReady = true;
-              resolve();
-            }
           })(window, document, "ttq");
         } catch (error) {
           reject(error);
@@ -1658,8 +1816,8 @@ function createTikTokPixelIntegration(config, debug) {
     },
     track: (eventName, properties, _context) => {
       const { ttq } = window;
-      if (!isPixelReady || !ttq) {
-        return;
+      if (!isPixelReady || !ttq?.track) {
+        throw new Error("TikTok Pixel not ready");
       }
       const ttEventName = getTikTokEventName(eventName, config.eventMapping);
       if (ttEventName === "PageView") {
@@ -1667,7 +1825,10 @@ function createTikTokPixelIntegration(config, debug) {
         return;
       }
       const ttParams = mapTikTokEventParameters(ttEventName, properties);
-      if (ttParams && Object.keys(ttParams).length > 0) {
+      const eventId = properties?.["event_id"];
+      if (typeof eventId === "string" && eventId.trim().length > 0) {
+        ttq.track?.(ttEventName, ttParams ?? {}, { event_id: eventId });
+      } else if (ttParams && Object.keys(ttParams).length > 0) {
         ttq.track?.(ttEventName, ttParams);
       } else {
         ttq.track?.(ttEventName);
@@ -1875,6 +2036,41 @@ function normalizeSaascoUrl(url) {
   return parsed.toString();
 }
 
+// src/lib/widgetLoader.ts
+function isEnabledPayload(data2) {
+  return typeof data2 === "object" && data2 !== null && "enabled" in data2 && data2.enabled === true;
+}
+function getUrlOrigin(url) {
+  try {
+    return new URL(
+      url,
+      typeof window === "undefined" ? void 0 : window.location.href
+    ).origin;
+  } catch {
+  }
+}
+function isLoaderPresent(fileName, injectedFlag) {
+  return Boolean(
+    injectedFlag || document.querySelector(`script[src*="${fileName}"]`)
+  );
+}
+function appendLoaderScript({
+  attributes,
+  onLoad,
+  src
+}) {
+  const script = document.createElement("script");
+  script.async = true;
+  script.src = src;
+  for (const [name, value] of Object.entries(attributes)) {
+    script.setAttribute(name, value);
+  }
+  if (onLoad) {
+    script.addEventListener("load", onLoad);
+  }
+  (document.body ?? document.head ?? document.documentElement).append(script);
+}
+
 // src/lib/social-proof/storage.ts
 var WIDGET_PAYLOAD_PATH = "/api/social-proof/widget";
 var SOCIAL_PROOF_LOADER_FILE = "saasco-social-proof-loader.js";
@@ -1954,17 +2150,16 @@ async function injectSocialProofLoader({
     return;
   }
   window.__saascoSocialProofInjected = true;
-  const script = document.createElement("script");
-  script.async = true;
-  script.src = normalizeSaascoUrl(scriptUrl);
-  script.setAttribute("data-projectId", projectId);
+  const attributes = {
+    "data-projectId": projectId
+  };
   if (baseUrlOverride !== void 0) {
-    script.setAttribute(
-      "data-base-url",
-      normalizeSaascoBaseUrl(baseUrlOverride)
-    );
+    attributes["data-base-url"] = normalizeSaascoBaseUrl(baseUrlOverride);
   }
-  (document.body ?? document.head ?? document.documentElement).append(script);
+  appendLoaderScript({
+    attributes,
+    src: normalizeSaascoUrl(scriptUrl)
+  });
 }
 async function shouldInjectSocialProof({
   baseUrl,
@@ -1993,23 +2188,12 @@ async function shouldInjectSocialProof({
   writeSession(cacheKey, JSON.stringify({ data: data2, fetchedAt: Date.now() }));
   return isEnabledPayload(data2);
 }
-function isEnabledPayload(data2) {
-  return typeof data2 === "object" && data2 !== null && data2.enabled === true;
-}
 function isSocialProofLoaderPresent() {
-  return Boolean(
-    window.__saascoSocialProofInjected || document.querySelector(`script[src*="${SOCIAL_PROOF_LOADER_FILE}"]`)
+  return isLoaderPresent(
+    SOCIAL_PROOF_LOADER_FILE,
+    window.__saascoSocialProofInjected
   );
 }
-function getUrlOrigin(url) {
-  try {
-    return new URL(
-      url,
-      typeof window === "undefined" ? void 0 : window.location.href
-    ).origin;
-  } catch {
-  }
-}
 function isSocialProofQaMode() {
   if (typeof window === "undefined") {
     return false;
@@ -2024,6 +2208,72 @@ function isSocialProofQaMode() {
   }
 }
 
+// src/lib/support/widgetEnabledCheck.ts
+var SUPPORT_WIDGET_PATH = "/api/support/widget";
+var SUPPORT_LOADER_FILE = "saasco-support-loader.js";
+async function injectSupportLoader({
+  baseUrl: baseUrlOverride,
+  onLoad,
+  placeholder,
+  projectId,
+  scriptUrl
+}) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return "skipped";
+  }
+  if (isSupportLoaderPresent()) {
+    return "present";
+  }
+  const baseUrl = normalizeSaascoBaseUrl(
+    baseUrlOverride ?? getUrlOrigin(scriptUrl) ?? SAASCO_ORIGIN
+  );
+  const enabled = await shouldInjectSupport({
+    baseUrl,
+    projectId
+  });
+  if (!enabled) {
+    return "skipped";
+  }
+  if (isSupportLoaderPresent()) {
+    return "present";
+  }
+  window.__saascoSupportInjected = true;
+  const attributes = {
+    "data-projectId": projectId
+  };
+  if (baseUrlOverride !== void 0) {
+    attributes["data-base-url"] = normalizeSaascoBaseUrl(baseUrlOverride);
+  }
+  if (placeholder !== void 0) {
+    attributes["data-placeholder"] = placeholder;
+  }
+  appendLoaderScript({
+    attributes,
+    onLoad,
+    src: normalizeSaascoUrl(scriptUrl)
+  });
+  return "injected";
+}
+async function shouldInjectSupport({
+  baseUrl,
+  projectId
+}) {
+  try {
+    const response = await fetch(
+      `${baseUrl}${SUPPORT_WIDGET_PATH}?projectId=${encodeURIComponent(projectId)}`
+    );
+    if (!response.ok) {
+      return false;
+    }
+    return isEnabledPayload(await response.json());
+  } catch {
+    return false;
+  }
+}
+function isSupportLoaderPresent() {
+  return isLoaderPresent(SUPPORT_LOADER_FILE, window.__saascoSupportInjected);
+}
+
 // src/lib/analytics.ts
 function getSupportGlobal() {
   return window.SaascoSupport;
@@ -2033,10 +2283,6 @@ var isServer5 = !isBrowser5;
 var PREF = "saasco-sdk";
 var SESSION_DURATION = 1e3 * 60 * 30;
 var USER_DURATION = 1e3 * 60 * 60 * 24 * 365;
-var SUPPORT_ATTR_MAP = {
-  baseUrl: "data-base-url",
-  placeholder: "data-placeholder"
-};
 var data = {};
 function getRootDomain(url) {
   if (isServer5) {
@@ -2102,6 +2348,15 @@ function migrateFromLocalStorage() {
   if (isServer5) {
     return;
   }
+  let storage;
+  try {
+    storage = globalThis.localStorage ?? null;
+  } catch {
+    return;
+  }
+  if (!storage) {
+    return;
+  }
   const keysToMigrate = [
     `${PREF}-session-id`,
     `${PREF}-anonymous-id`,
@@ -2111,20 +2366,23 @@ function migrateFromLocalStorage() {
   ];
   for (const key of keysToMigrate) {
     try {
-      const value = localStorage.getItem(key);
+      const value = storage.getItem(key);
       if (value) {
         const item = JSON.parse(value);
         const now = Date.now();
         if (item.expiry > now) {
           const remainingTtl = item.expiry - now;
           setCookie(key, JSON.stringify(item.value), remainingTtl);
-          localStorage.removeItem(key);
+          storage.removeItem(key);
         } else {
-          localStorage.removeItem(key);
+          storage.removeItem(key);
         }
       }
     } catch {
-      localStorage.removeItem(key);
+      try {
+        storage.removeItem(key);
+      } catch {
+      }
     }
   }
 }
@@ -2325,7 +2583,7 @@ var Saasco = class {
    * @param config Configuration options.
    * @param config.projectId The unique identifier for the project.
    * @param config.proxy The URL of the proxy server to use, if any.
-   * @param config.autoPageTracking Whether to automatically track page views. Default is false.
+   * @param config.autoPageTracking Whether to automatically track page views. Default is true.
    * @param config.enabled Whether analytics is enabled. Default is true. Set to false for development and staging envioronments. Will still allow debug mode to be true, just no events will be sent
    * @param config.debug Whether to log debug information. Default is false.
    * @param config.trackUrlParams Whether to track URL parameters. Default is true.
@@ -2355,7 +2613,8 @@ var Saasco = class {
     };
     this.integrationManager = new IntegrationManager({
       loggerLevel,
-      maxQueueSize: 1e3
+      maxQueueSize: 1e3,
+      deduplicationNamespace: this.config.projectId
     });
     this.integrationManager.setContext({});
     void (async () => {
@@ -2378,6 +2637,7 @@ var Saasco = class {
   // here so an `identify()` that fires before the widget bundle finishes
   // loading is replayed once it does.
   lastSupportIdentity = null;
+  ingestFailureKeys = /* @__PURE__ */ new Set();
   init() {
     if (this.isInitialized) {
       this.logger.info(
@@ -2401,52 +2661,20 @@ var Saasco = class {
       );
     }
     this.initAutoPageTracking();
-    if (this.config.support && this.config.support.enabled !== false) {
-      this.injectSupport();
-    }
-    if (this.config.socialProof?.enabled !== false) {
-      void this.injectSocialProof();
-    }
+    void this.injectSupport();
+    void this.injectSocialProof();
     this.isInitialized = true;
   }
   disableDebug() {
     this.logger.info("Debug mode deactivated.");
     this.config.debug = false;
+    this.logger.setLevel(getLoggerLevel(this.config));
   }
   enableDebug() {
     this.config.debug = true;
+    this.logger.setLevel(getLoggerLevel(this.config));
     this.logger.info("Debug mode activated.");
   }
-  /**
-   * Enables and injects the support widget when it was constructed with
-   * `support: { enabled: false }`. Safe to call multiple times.
-   */
-  enableSupport() {
-    if (!this.config.support) {
-      this.logger.warn(
-        "Support is not configured; enableSupport() was ignored."
-      );
-      return;
-    }
-    this.config.support.enabled = true;
-    this.injectSupport();
-    this.pushSupportIdentity();
-  }
-  /**
-   * Enables and injects the social-proof widget (e.g. after constructing with
-   * `socialProof: { enabled: false }`, or when no `socialProof` block was
-   * passed). Injection still runs the server check, so the loader only
-   * downloads when the project has the app enabled in the dashboard.
-   * Safe to call multiple times — the loader injection is guarded against
-   * double-injection.
-   */
-  enableSocialProof() {
-    this.config.socialProof = {
-      ...this.config.socialProof,
-      enabled: true
-    };
-    void this.injectSocialProof();
-  }
   /**
    * Initialize third-party integrations
    */
@@ -2461,48 +2689,52 @@ var Saasco = class {
       );
       return;
     }
-    for (const integrationConfig of this.config.integrations) {
-      try {
-        if (integrationConfig.type === "facebook-pixel") {
-          this.logger.info(
-            "Registering Facebook Pixel integration with ID:",
-            integrationConfig.config.pixelId
-          );
-          const fbIntegration = createFacebookPixelIntegration(
-            integrationConfig.config,
-            integrationConfig.debug
-          );
-          await this.integrationManager.registerIntegration(fbIntegration);
-        } else if (integrationConfig.type === "pinterest-tag") {
-          this.logger.info(
-            "Registering Pinterest Tag integration with ID:",
-            integrationConfig.config.tagId
-          );
-          const pinterestIntegration = createPinterestTagIntegration(
-            integrationConfig.config,
-            integrationConfig.debug
-          );
-          await this.integrationManager.registerIntegration(
-            pinterestIntegration
-          );
-        } else if (integrationConfig.type === "tiktok-pixel") {
+    await Promise.all(
+      this.config.integrations.map(async (integrationConfig) => {
+        try {
+          if (integrationConfig.type === "facebook-pixel") {
+            this.logger.info(
+              "Registering Facebook Pixel integration with ID:",
+              integrationConfig.config.pixelId
+            );
+            const fbIntegration = createFacebookPixelIntegration(
+              integrationConfig.config,
+              integrationConfig.debug
+            );
+            await this.integrationManager.registerIntegration(fbIntegration);
+          } else if (integrationConfig.type === "pinterest-tag") {
+            this.logger.info(
+              "Registering Pinterest Tag integration with ID:",
+              integrationConfig.config.tagId
+            );
+            const pinterestIntegration = createPinterestTagIntegration(
+              integrationConfig.config,
+              integrationConfig.debug
+            );
+            await this.integrationManager.registerIntegration(
+              pinterestIntegration
+            );
+          } else if (integrationConfig.type === "tiktok-pixel") {
+            this.logger.info(
+              "Registering TikTok Pixel integration with ID:",
+              integrationConfig.config.pixelId
+            );
+            const tiktokIntegration = createTikTokPixelIntegration(
+              integrationConfig.config,
+              integrationConfig.debug
+            );
+            await this.integrationManager.registerIntegration(
+              tiktokIntegration
+            );
+          }
+        } catch (error) {
           this.logger.info(
-            "Registering TikTok Pixel integration with ID:",
-            integrationConfig.config.pixelId
-          );
-          const tiktokIntegration = createTikTokPixelIntegration(
-            integrationConfig.config,
-            integrationConfig.debug
+            `Failed to register ${integrationConfig.type} integration:`,
+            error
           );
-          await this.integrationManager.registerIntegration(tiktokIntegration);
         }
-      } catch (error) {
-        this.logger.info(
-          `Failed to register ${integrationConfig.type} integration:`,
-          error
-        );
-      }
-    }
+      })
+    );
   }
   track(actionOrPayload, propertiesOrNothing, contextOrNothing) {
     if (!this.config.projectId) {
@@ -2559,11 +2791,23 @@ var Saasco = class {
       });
     }
     this.integrationManager.track(action, properties);
-    return this.doRequest("events", requestData);
+    const eventId = properties?.["event_id"];
+    if (!isBrowser5 || typeof eventId !== "string" || !eventId.trim()) {
+      return this.doRequest("events", requestData);
+    }
+    return deliverOnce(
+      `saasco:${this.config.projectId}:ingest:${action}:${eventId}`,
+      async () => {
+        const result = await this.doRequest("events", requestData);
+        if (!result.success) {
+          throw new Error(result.message);
+        }
+      }
+    ).then(() => ({ success: true, message: "Event dispatched" })).catch((error) => ({ success: false, message: String(error) }));
   }
   /**
    * The page method lets you record page views on your website
-   * This records the page title and path and names the event useing the reserved property "Page Viewed"
+   * This records the page title and path and names the event using the reserved name "Page View"
    *
    * Before implementing this make sure you have disabled the autoPageTracking in the config or you will get duplicate page views
    */
@@ -2659,7 +2903,10 @@ var Saasco = class {
       },
       context: context || {}
     };
-    this.logger.info("identify", requestData);
+    this.logger.info("identify", {
+      distinctId,
+      projectId: this.config.projectId
+    });
     if (!this.config.enabled) {
       return Promise.resolve({
         success: true,
@@ -2695,6 +2942,13 @@ var Saasco = class {
         message: "Analytics is disabled"
       };
     }
+    const projectId = requestData.projectId ?? null;
+    const fail = (input) => reportIngestFailure({
+      failure: formatAnalyticsRequestFailure({ path, projectId, ...input }),
+      logger: this.logger,
+      path,
+      seen: this.ingestFailureKeys
+    });
     let response;
     try {
       response = await fetch(url, {
@@ -2704,46 +2958,22 @@ var Saasco = class {
         },
         body: JSON.stringify(requestData)
       });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.warn(
-        `Network request failed`,
-        `
-Error Message: "${message}"`,
-        `
-Url: "${url}"`
-      );
-      return {
-        success: false,
-        message
-      };
+    } catch {
+      return fail({ reason: "unreachable" });
     }
+    let responseBody;
     try {
-      const responseBody = await response.json();
-      if (!response.ok) {
-        throw new Error(
-          `${responseBody.message}: ${responseBody.errors ? `[${responseBody.errors.join(", ")}]` : ""}` || JSON.stringify(responseBody)
-        );
-      }
-      return {
-        success: true,
-        message: responseBody.message ?? ""
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(
-        `
-Error Message: "${message}"`,
-        `
-Path: "/${path}"`,
-        `
-Request Data: ${JSON.stringify(requestData, null, 2)}`
-      );
-      return {
-        success: false,
-        message
-      };
+      responseBody = await response.json();
+    } catch {
+      return fail({ reason: "http" });
+    }
+    if (!response.ok) {
+      return fail({ reason: "http", body: responseBody });
     }
+    return {
+      success: true,
+      message: responseBody && typeof responseBody === "object" && "message" in responseBody && typeof responseBody.message === "string" ? responseBody.message : ""
+    };
   }
   /**
    * If autoPageTracking is enabled, this will automatically track page views
@@ -2787,51 +3017,25 @@ Request Data: ${JSON.stringify(requestData, null, 2)}`
     return this.integrationManager.getStats();
   }
   /**
-   * Lazily injects the support **loader** from the same `/sdk/` origin as
-   * the analytics bundle, forwarding the shared `projectId` and the widget
-   * config as `data-*` attributes. The loader (no React) injects the
-   * cross-origin embed iframe. Deferred (`async`) and guarded against
-   * double-injection so re-running `init()` is a no-op.
+   * Lazily injects the support **loader** (server-gated). See
+   * {@link injectSupportLoader}. Replays identity once the script loads.
    */
-  injectSupport() {
-    if (!isBrowser5 || typeof document === "undefined") {
-      return;
-    }
-    const chat = this.config.support;
-    if (!chat) {
-      return;
-    }
-    if (window.__saascoSupportInjected || document.querySelector('script[src*="saasco-support-loader.js"]')) {
-      return;
-    }
-    const scriptUrl = resolveLoaderScriptUrl(
-      "saasco-support-loader.js",
-      chat.scriptUrl
-    );
-    if (!scriptUrl) {
-      this.logger.warn(
-        "Support is enabled but the loader URL could not be resolved. Pass `support.scriptUrl` pointing at your hosted saasco-support-loader.js (or load the analytics SDK from the CDN)."
-      );
+  async injectSupport() {
+    if (!isBrowser5) {
       return;
     }
-    window.__saascoSupportInjected = true;
-    const script = document.createElement("script");
-    script.async = true;
-    script.src = normalizeSaascoUrl(scriptUrl);
-    script.setAttribute("data-projectId", this.config.projectId);
-    for (const [key, attr] of Object.entries(SUPPORT_ATTR_MAP)) {
-      const value = chat[key];
-      if (value !== void 0) {
-        script.setAttribute(
-          attr,
-          attr === "data-base-url" ? normalizeSaascoBaseUrl(value) : value
-        );
-      }
-    }
-    script.addEventListener("load", () => {
-      this.pushSupportIdentity();
+    const { support } = this.config;
+    const scriptUrl = resolveLoaderScriptUrl("saasco-support-loader.js", support?.scriptUrl) ?? `${SAASCO_ORIGIN}/sdk/saasco-support-loader.js`;
+    const result = await injectSupportLoader({
+      baseUrl: support?.baseUrl,
+      onLoad: () => this.pushSupportIdentity(),
+      placeholder: support?.placeholder,
+      projectId: this.config.projectId,
+      scriptUrl
     });
-    (document.body ?? document.head ?? document.documentElement).append(script);
+    if (result === "present") {
+      this.pushSupportIdentity();
+    }
   }
   /**
    * Lazily injects the social-proof loader (server-gated). See
@@ -2854,27 +3058,23 @@ Request Data: ${JSON.stringify(requestData, null, 2)}`
   }
   /**
    * Records the latest CRM identity and forwards it to the support widget.
-   * No-op when support isn't enabled.
    */
   updateSupportIdentity(identity) {
-    if (!isBrowser5 || !this.config.support) {
+    if (!isBrowser5) {
       return;
     }
     const hasTraits = identity.traits && Object.keys(identity.traits).length > 0;
     this.lastSupportIdentity = identity.distinctId || identity.email || hasTraits ? identity : null;
-    if (this.config.support.enabled === false) {
-      return;
-    }
     this.pushSupportIdentity();
   }
   /**
    * Pushes the current identity onto `window.SaascoSupport.identify`. The
    * widget bundle publishes that global asynchronously, so this short-polls for
-   * it (same approach as tool registration); the load handler also calls this,
-   * so a fresh page load with a stored distinctId still identifies the chat.
+   * it (same approach as tool registration). `injectSupport` calls this on
+   * script load (or immediately when the loader is already present).
    */
   pushSupportIdentity() {
-    if (!isBrowser5 || !this.config.support || this.config.support.enabled === false) {
+    if (!isBrowser5) {
       return;
     }
     const identity = this.lastSupportIdentity ?? {
@@ -3001,31 +3201,31 @@ function getLoggerLevel(config) {
 }
 
 // ../shared/src/lib/types/browserContext.ts
-var import_zod = require("zod");
-var BrowserContextSchema = import_zod.z.object({
-  $href: import_zod.z.string(),
-  $locale: import_zod.z.string(),
-  $location: import_zod.z.string(),
-  $pathname: import_zod.z.string(),
-  $referrer: import_zod.z.string(),
-  $referringDomain: import_zod.z.string(),
-  $screenDPI: import_zod.z.number(),
-  $screenHeight: import_zod.z.number(),
-  $screenWidth: import_zod.z.number(),
-  $title: import_zod.z.string(),
-  $userAgent: import_zod.z.string(),
-  $utmAdId: import_zod.z.string().nullable(),
-  $utmAdSource: import_zod.z.string().nullable(),
-  $utmCampaign: import_zod.z.string().nullable(),
-  $utmCampaignId: import_zod.z.string().nullable(),
-  $utmContent: import_zod.z.string().nullable(),
-  $utmCreativeFormat: import_zod.z.string().nullable(),
-  $utmId: import_zod.z.string().nullable(),
-  $utmMarketingTactic: import_zod.z.string().nullable(),
-  $utmMedium: import_zod.z.string().nullable(),
-  $utmSource: import_zod.z.string().nullable(),
-  $utmSourcePlatform: import_zod.z.string().nullable(),
-  $utmTerm: import_zod.z.string().nullable()
+var import_zod2 = require("zod");
+var BrowserContextSchema = import_zod2.z.object({
+  $href: import_zod2.z.string(),
+  $locale: import_zod2.z.string(),
+  $location: import_zod2.z.string(),
+  $pathname: import_zod2.z.string(),
+  $referrer: import_zod2.z.string(),
+  $referringDomain: import_zod2.z.string(),
+  $screenDPI: import_zod2.z.number(),
+  $screenHeight: import_zod2.z.number(),
+  $screenWidth: import_zod2.z.number(),
+  $title: import_zod2.z.string(),
+  $userAgent: import_zod2.z.string(),
+  $utmAdId: import_zod2.z.string().nullable(),
+  $utmAdSource: import_zod2.z.string().nullable(),
+  $utmCampaign: import_zod2.z.string().nullable(),
+  $utmCampaignId: import_zod2.z.string().nullable(),
+  $utmContent: import_zod2.z.string().nullable(),
+  $utmCreativeFormat: import_zod2.z.string().nullable(),
+  $utmId: import_zod2.z.string().nullable(),
+  $utmMarketingTactic: import_zod2.z.string().nullable(),
+  $utmMedium: import_zod2.z.string().nullable(),
+  $utmSource: import_zod2.z.string().nullable(),
+  $utmSourcePlatform: import_zod2.z.string().nullable(),
+  $utmTerm: import_zod2.z.string().nullable()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {