saasco-sdk 0.2.5 → 0.2.6

package/dist/index.js

@@ -2,7 +2,187 @@
 import { isValid, parse } from "psl";
 
 // package.json
-var version = "0.2.5";
+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
+import { z } from "zod";
+var IDENTIFY_INGEST_ERROR_SOURCE = "saasco-identify";
+var ANALYTICS_INGEST_ERROR_SOURCE = "saasco-analytics";
+var AnalyticsIngestErrorCodeSchema = z.enum([
+  "CREDENTIAL_INVALID",
+  "RESOURCE_FORBIDDEN",
+  "RESOURCE_UNSPECIFIED",
+  "ENVIRONMENT_UNREACHABLE",
+  "INGEST_FAILED"
+]);
+var AnalyticsIngestSurfaceSchema = z.enum(["identify", "events"]);
+var AnalyticsIngestErrorSchema = z.object({
+  affected: z.string(),
+  code: AnalyticsIngestErrorCodeSchema,
+  message: z.string(),
+  projectId: z.string().nullable(),
+  recovery: z.string(),
+  resource: 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 = {
@@ -482,12 +662,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(
@@ -633,6 +811,50 @@ function resolveAdParams(params) {
 
 // src/lib/integrations/facebook-pixel.ts
 import { sha256 } from "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 = [
@@ -674,70 +896,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);
+      if (!window.fbq) {
+        const fbq2 = (...args) => {
+          if (fbq2.callMethod) {
+            fbq2.callMethod(...args);
+          } else {
+            fbq2.queue.push(args);
           }
-          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();
-          }
-        } 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;
@@ -745,9 +929,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
@@ -775,10 +961,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) => {
@@ -1132,12 +1326,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,
@@ -1147,7 +1341,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();
@@ -1224,6 +1417,8 @@ var IntegrationManager = class {
    */
   send(partial) {
     const envelope = {
+      delivered: /* @__PURE__ */ new Set(),
+      pending: /* @__PURE__ */ new Set(),
       context: { ...this.context },
       id: uuid(),
       name: partial.name,
@@ -1231,65 +1426,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;
@@ -1300,18 +1485,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
    */
@@ -1395,50 +1568,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,
@@ -1567,8 +1710,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;
       }
@@ -1620,28 +1763,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);
@@ -1650,8 +1780,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") {
@@ -1659,7 +1789,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);
@@ -2179,6 +2312,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`,
@@ -2188,20 +2330,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 {
+      }
     }
   }
 }
@@ -2432,7 +2577,8 @@ var Saasco = class {
     };
     this.integrationManager = new IntegrationManager({
       loggerLevel,
-      maxQueueSize: 1e3
+      maxQueueSize: 1e3,
+      deduplicationNamespace: this.config.projectId
     });
     this.integrationManager.setContext({});
     void (async () => {
@@ -2455,6 +2601,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(
@@ -2506,48 +2653,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) {
@@ -2604,7 +2755,19 @@ 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
@@ -2704,7 +2867,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,
@@ -2740,6 +2906,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, {
@@ -2749,46 +2922,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
@@ -3016,31 +3165,31 @@ function getLoggerLevel(config) {
 }
 
 // ../shared/src/lib/types/browserContext.ts
-import { z } from "zod";
-var BrowserContextSchema = z.object({
-  $href: z.string(),
-  $locale: z.string(),
-  $location: z.string(),
-  $pathname: z.string(),
-  $referrer: z.string(),
-  $referringDomain: z.string(),
-  $screenDPI: z.number(),
-  $screenHeight: z.number(),
-  $screenWidth: z.number(),
-  $title: z.string(),
-  $userAgent: z.string(),
-  $utmAdId: z.string().nullable(),
-  $utmAdSource: z.string().nullable(),
-  $utmCampaign: z.string().nullable(),
-  $utmCampaignId: z.string().nullable(),
-  $utmContent: z.string().nullable(),
-  $utmCreativeFormat: z.string().nullable(),
-  $utmId: z.string().nullable(),
-  $utmMarketingTactic: z.string().nullable(),
-  $utmMedium: z.string().nullable(),
-  $utmSource: z.string().nullable(),
-  $utmSourcePlatform: z.string().nullable(),
-  $utmTerm: z.string().nullable()
+import { z as z2 } from "zod";
+var BrowserContextSchema = z2.object({
+  $href: z2.string(),
+  $locale: z2.string(),
+  $location: z2.string(),
+  $pathname: z2.string(),
+  $referrer: z2.string(),
+  $referringDomain: z2.string(),
+  $screenDPI: z2.number(),
+  $screenHeight: z2.number(),
+  $screenWidth: z2.number(),
+  $title: z2.string(),
+  $userAgent: z2.string(),
+  $utmAdId: z2.string().nullable(),
+  $utmAdSource: z2.string().nullable(),
+  $utmCampaign: z2.string().nullable(),
+  $utmCampaignId: z2.string().nullable(),
+  $utmContent: z2.string().nullable(),
+  $utmCreativeFormat: z2.string().nullable(),
+  $utmId: z2.string().nullable(),
+  $utmMarketingTactic: z2.string().nullable(),
+  $utmMedium: z2.string().nullable(),
+  $utmSource: z2.string().nullable(),
+  $utmSourcePlatform: z2.string().nullable(),
+  $utmTerm: z2.string().nullable()
 });
 export {
   BrowserContextSchema,