@uniformdev/insights 20.7.1-alpha.102

package/dist/index.js

@@ -0,0 +1,828 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BackendInsightsProxyHandler: () => BackendInsightsProxyHandler,
+  createBackendInsightsProxyHandler: () => createBackendInsightsProxyHandler,
+  createInsightsPlugin: () => createInsightsPlugin,
+  createInsightsStorage: () => createInsightsStorage,
+  createMemoryStorage: () => createMemoryStorage,
+  enableUniformInsights: () => createInsightsPlugin
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/batching.ts
+var import_p_limit = __toESM(require("p-limit"));
+var DEFAULT_BATCH_CONFIG = {
+  maxBatchSize: 50,
+  maxBatchDelayMs: 2e3,
+  maxPayloadSizeBytes: 1024 * 1024,
+  // 1MB
+  maxRequestsPerSecond: 1
+};
+var createEventHash = (action, pageViewId, payload) => {
+  const payloadStr = JSON.stringify(payload);
+  return `${action}:${pageViewId}:${payloadStr}`;
+};
+var isDuplicateEvent = (deduplicationMap, hash, deduplicationWindowMs = 5 * 60 * 1e3) => {
+  const now = Date.now();
+  const existing = deduplicationMap.get(hash);
+  if (existing && now - existing.timestamp < deduplicationWindowMs) {
+    return true;
+  }
+  for (const [key, entry] of deduplicationMap.entries()) {
+    if (now - entry.timestamp >= deduplicationWindowMs) {
+      deduplicationMap.delete(key);
+    }
+  }
+  deduplicationMap.set(hash, { timestamp: now, hash });
+  return false;
+};
+var getEventPriority = (action) => {
+  switch (action) {
+    case "session_start":
+      return 3;
+    // Highest priority, as session start has to be the first for correct attribution in Insights
+    case "page_hit":
+      return 2;
+    // Medium priority, has to come right after session start for correct attribution in Insights
+    default:
+      return 1;
+  }
+};
+var sortEventsByPriority = (events) => {
+  return events.sort((a, b) => {
+    if (b.priority !== a.priority) {
+      return b.priority - a.priority;
+    }
+    return a.timestamp - b.timestamp;
+  });
+};
+var adjustTimestampsForOrder = (events) => {
+  const sortedEvents = sortEventsByPriority(events);
+  const baseTime = Date.now();
+  const timeIncrement = 100;
+  return sortedEvents.map((event, index) => ({
+    ...event.message,
+    timestamp: new Date(baseTime + index * timeIncrement).toISOString()
+  }));
+};
+var buildEndpointUrl = (endpoint) => {
+  if (endpoint.type === "api") {
+    const url = new URL(endpoint.host);
+    url.pathname = `/v0/events`;
+    if (endpoint.host.includes("tinybird.co")) {
+      url.pathname = "/v0/events";
+    }
+    url.searchParams.set("name", "events");
+    return url.toString();
+  } else {
+    return endpoint.path;
+  }
+};
+var sendBatchToEndpoint = async (messages, endpoint) => {
+  const endpointUrl = buildEndpointUrl(endpoint);
+  const ndjson = messages.map((msg) => JSON.stringify(msg)).join("\n");
+  const headers = {
+    "Content-Type": "application/x-ndjson"
+  };
+  if (endpoint.type === "api" && endpoint.apiKey) {
+    headers.Authorization = `Bearer ${endpoint.apiKey}`;
+  }
+  const response = await fetch(endpointUrl, {
+    method: "POST",
+    headers,
+    body: ndjson
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to send batch: ${response.statusText}`);
+  }
+  const json = await response.json();
+  return json;
+};
+var createBatchProcessor = (config, endpoint) => {
+  let eventQueue = [];
+  let batchTimeout = null;
+  const limit = (0, import_p_limit.default)(config.maxRequestsPerSecond);
+  const processBatch = async () => {
+    if (eventQueue.length === 0) return;
+    const messages = adjustTimestampsForOrder(eventQueue);
+    const batches = [];
+    let currentBatch = [];
+    let currentBatchSize = 0;
+    for (const message of messages) {
+      const messageSize = JSON.stringify(message).length;
+      if (currentBatch.length >= config.maxBatchSize || currentBatchSize + messageSize > config.maxPayloadSizeBytes) {
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
+        }
+        currentBatch = [message];
+        currentBatchSize = messageSize;
+      } else {
+        currentBatch.push(message);
+        currentBatchSize += messageSize;
+      }
+    }
+    if (currentBatch.length > 0) {
+      batches.push(currentBatch);
+    }
+    const sendPromises = batches.map(
+      (batch) => limit(async () => {
+        try {
+          await sendBatchToEndpoint(batch, endpoint);
+        } catch (error) {
+          console.warn("Failed to send batch:", error);
+        }
+      })
+    );
+    await Promise.all(sendPromises);
+    eventQueue = [];
+    batchTimeout = null;
+  };
+  const scheduleBatch = () => {
+    if (batchTimeout) return;
+    batchTimeout = setTimeout(() => {
+      processBatch();
+    }, config.maxBatchDelayMs);
+  };
+  const addEvent = (message) => {
+    const priority = getEventPriority(message.action);
+    const timestamp = new Date(message.timestamp).getTime();
+    eventQueue.push({ message, priority, timestamp });
+    if (eventQueue.length >= config.maxBatchSize) {
+      if (batchTimeout) {
+        clearTimeout(batchTimeout);
+        batchTimeout = null;
+      }
+      processBatch();
+    } else {
+      scheduleBatch();
+    }
+  };
+  const flush = () => {
+    if (batchTimeout) {
+      clearTimeout(batchTimeout);
+      batchTimeout = null;
+    }
+    processBatch();
+  };
+  const clear = () => {
+    if (batchTimeout) {
+      clearTimeout(batchTimeout);
+      batchTimeout = null;
+    }
+    eventQueue = [];
+  };
+  return { addEvent, flush, clear };
+};
+var createDeduplicationManager = () => {
+  const deduplicationMap = /* @__PURE__ */ new Map();
+  return {
+    isDuplicate: (message) => {
+      const hash = createEventHash(message.action, message.page_view_id, message.payload);
+      return isDuplicateEvent(deduplicationMap, hash);
+    },
+    clear: () => {
+      deduplicationMap.clear();
+    }
+  };
+};
+
+// src/utils.ts
+var getWebMetadata = () => {
+  const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const locale = navigator.languages && navigator.languages.length ? navigator.languages[0] : navigator.userLanguage || navigator.language || navigator.browserLanguage || "en";
+  return {
+    "user-agent": window.navigator.userAgent,
+    locale,
+    location: timeZone,
+    referrer: document.referrer,
+    pathname: window.location.pathname,
+    href: window.location.href
+  };
+};
+var generateVisitorId = async () => {
+  return `visitor_${generalRandomId()}`;
+};
+var generateSessionId = async () => {
+  return `session_${generalRandomId()}`;
+};
+var generatePageId = () => {
+  return `page_${generalRandomId()}`;
+};
+var generalRandomId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    const id = crypto.randomUUID();
+    return id.replaceAll("-", "").toLowerCase();
+  }
+  return Math.random().toString(32).substring(2);
+};
+var convertUniformMetadataToInsightsMetadata = (uniformMetadata) => {
+  return uniformMetadata ? {
+    composition_id: uniformMetadata.compositionId,
+    pm_node_path: uniformMetadata.matchedRoute,
+    dynamic_inputs: uniformMetadata.dynamicInputs
+  } : void 0;
+};
+
+// src/events/enrichment.ts
+var buildEnrichmentUpdatedMessage = ({
+  sessionId,
+  visitorId,
+  pageId,
+  projectId,
+  enrichmentId,
+  key,
+  strength,
+  compositionData
+}) => ({
+  action: "enrichment_updated",
+  version: "2",
+  session_id: sessionId,
+  visitor_id: visitorId,
+  page_view_id: pageId,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  project_id: projectId,
+  payload: {
+    id: enrichmentId,
+    key,
+    strength
+  },
+  web_metadata: getWebMetadata(),
+  uniform: compositionData || {}
+});
+
+// src/events/goal.ts
+var buildGoalConvertMessage = (sessionId, visitorId, pageId, projectId, goalId, compositionData) => ({
+  action: "goal_convert",
+  version: "2",
+  session_id: sessionId,
+  visitor_id: visitorId,
+  page_view_id: pageId,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  project_id: projectId,
+  payload: {
+    goal_id: goalId
+  },
+  web_metadata: getWebMetadata(),
+  uniform: compositionData || {}
+});
+
+// src/events/page.ts
+var buildPageHitMessage = (sessionId, visitorId, pageId, projectId, compositionData) => ({
+  action: "page_hit",
+  version: "2",
+  session_id: sessionId,
+  visitor_id: visitorId,
+  page_view_id: pageId,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  project_id: projectId,
+  payload: {},
+  web_metadata: getWebMetadata(),
+  uniform: compositionData || {}
+});
+
+// src/events/personalization.ts
+var buildPersonalizationResultMessage = (sessionId, visitorId, pageId, projectId, result, variant, compositionData) => ({
+  action: "personalization_result",
+  version: "2",
+  session_id: sessionId,
+  visitor_id: visitorId,
+  page_view_id: pageId,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  project_id: projectId,
+  payload: {
+    name: result.name,
+    variantId: variant.id,
+    control: variant.control || result.control,
+    changed: result.changed
+  },
+  web_metadata: getWebMetadata(),
+  uniform: compositionData || {}
+});
+
+// src/events/segment.ts
+var buildSegmentUpdatedMessage = ({
+  sessionId,
+  visitorId,
+  pageId,
+  projectId,
+  segmentId,
+  value,
+  compositionData
+}) => ({
+  action: "segment_updated",
+  version: "2",
+  session_id: sessionId,
+  visitor_id: visitorId,
+  page_view_id: pageId,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  project_id: projectId,
+  payload: {
+    id: segmentId,
+    value
+  },
+  web_metadata: getWebMetadata(),
+  uniform: compositionData || {}
+});
+
+// src/events/session.ts
+var buildSessionStartMessage = (sessionId, visitorId, pageId, projectId, previousSessionId, compositionData) => ({
+  action: "session_start",
+  version: "2",
+  session_id: sessionId,
+  visitor_id: visitorId,
+  page_view_id: pageId,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  project_id: projectId,
+  payload: {
+    previous_session_id: previousSessionId
+  },
+  web_metadata: getWebMetadata(),
+  uniform: compositionData || {}
+});
+
+// src/events/test.ts
+var buildTestResultMessage = (sessionId, visitorId, pageId, projectId, result, compositionData) => ({
+  action: "test_result",
+  version: "2",
+  session_id: sessionId,
+  visitor_id: visitorId,
+  page_view_id: pageId,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  project_id: projectId,
+  payload: {
+    name: result.name,
+    variantId: result.variantId,
+    control: result.control,
+    variantAssigned: result.variantAssigned
+  },
+  web_metadata: getWebMetadata(),
+  uniform: compositionData || {}
+});
+
+// src/storage.ts
+var createInsightsStorage = (customStorage) => {
+  if (customStorage) {
+    return customStorage;
+  }
+  const STORAGE_KEY = "ufin";
+  return {
+    get: () => {
+      if (typeof localStorage === "undefined") {
+        return void 0;
+      }
+      const data = localStorage.getItem(STORAGE_KEY);
+      if (!data) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(data);
+      } catch (e) {
+        return void 0;
+      }
+    },
+    set: (data) => {
+      if (typeof localStorage === "undefined") {
+        return;
+      }
+      const toSet = {
+        ...data,
+        updated: Date.now()
+      };
+      try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(toSet));
+      } catch (e) {
+      }
+    },
+    clear: () => {
+      if (typeof localStorage === "undefined") {
+        return;
+      }
+      try {
+        localStorage.removeItem(STORAGE_KEY);
+      } catch (e) {
+      }
+    }
+  };
+};
+var createMemoryStorage = () => {
+  let data;
+  return {
+    get: () => data,
+    set: (newData) => {
+      data = {
+        ...newData,
+        updated: Date.now()
+      };
+    },
+    clear: () => {
+      data = void 0;
+    }
+  };
+};
+
+// src/plugin.ts
+var createInsightsCore = (options) => {
+  if (options.endpoint.type === "api" && !options.endpoint.host) {
+    throw new Error("Insights context plugin requires API host");
+  }
+  if (options.endpoint.type === "api" && !options.endpoint.apiKey) {
+    throw new Error("Insights context plugin requires API key");
+  }
+  if (!options.endpoint.projectId) {
+    throw new Error("Insights context plugin requires project ID");
+  }
+  const {
+    endpoint,
+    storage: customStorage,
+    batchConfig,
+    sessionDurationSeconds = 30 * 60,
+    getVisitorId = generateVisitorId,
+    getSessionId = generateSessionId
+  } = options;
+  const storage = createInsightsStorage(customStorage);
+  let storageData;
+  let pageId = generatePageId();
+  let previousUrl = void 0;
+  const batchProcessor = batchConfig ? createBatchProcessor({ ...DEFAULT_BATCH_CONFIG, ...batchConfig }, endpoint) : null;
+  const deduplicationManager = batchConfig ? createDeduplicationManager() : null;
+  const sendEventDirectly = async (message) => {
+    if (typeof window !== "undefined" && window.__UNIFORM_CONTEXTUAL_EDITING__) {
+      return;
+    }
+    try {
+      const endpointUrl = endpoint.type === "api" ? `${endpoint.host}/v0/events?name=events` : endpoint.path;
+      const headers = {
+        "Content-Type": "application/x-ndjson"
+      };
+      if (endpoint.type === "api" && endpoint.apiKey) {
+        headers.Authorization = `Bearer ${endpoint.apiKey}`;
+      }
+      await fetch(endpointUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message)
+      });
+    } catch (error) {
+      console.warn("Failed to send event:", error);
+    }
+  };
+  const addEvent = (message) => {
+    if (typeof window !== "undefined" && window.__UNIFORM_CONTEXTUAL_EDITING__) {
+      return;
+    }
+    if (batchProcessor && deduplicationManager) {
+      if (!deduplicationManager.isDuplicate(message)) {
+        batchProcessor.addEvent(message);
+      }
+    } else {
+      sendEventDirectly(message);
+    }
+  };
+  return {
+    init: async (context) => {
+      storageData = storage.get();
+      if (!storageData || Date.now() - storageData.updated > sessionDurationSeconds * 1e3) {
+        const previousSessionId = storageData == null ? void 0 : storageData.sessionId;
+        let visitorId;
+        if (storageData == null ? void 0 : storageData.visitorId) {
+          visitorId = storageData.visitorId;
+        } else {
+          visitorId = await getVisitorId({
+            context,
+            previousVisitorId: storageData == null ? void 0 : storageData.visitorId,
+            previousSessionId
+          });
+        }
+        const sessionId = await getSessionId({ context, visitorId, previousSessionId });
+        const newStorageData = {
+          visitorId,
+          sessionId,
+          updated: Date.now()
+        };
+        storage.set(newStorageData);
+        storageData = newStorageData;
+        const message = buildSessionStartMessage(
+          storageData.sessionId,
+          storageData.visitorId,
+          pageId,
+          endpoint.projectId,
+          previousSessionId
+        );
+        addEvent(message);
+      } else if (storageData) {
+        storage.set(storageData);
+      }
+    },
+    pageHit: (compositionData) => {
+      if (!storageData) {
+        return;
+      }
+      if (typeof window !== "undefined" && previousUrl === window.location.href) {
+        return;
+      }
+      if (typeof window !== "undefined") {
+        previousUrl = window.location.href;
+      }
+      pageId = generatePageId();
+      const message = buildPageHitMessage(
+        storageData.sessionId,
+        storageData.visitorId,
+        pageId,
+        endpoint.projectId,
+        compositionData
+      );
+      addEvent(message);
+    },
+    testResult: (result, compositionData) => {
+      if (!storageData) {
+        return;
+      }
+      const message = buildTestResultMessage(
+        storageData.sessionId,
+        storageData.visitorId,
+        pageId,
+        endpoint.projectId,
+        result,
+        compositionData
+      );
+      addEvent(message);
+    },
+    personalizationResult: (result, compositionData) => {
+      if (!storageData) {
+        return;
+      }
+      result.variantIds.forEach((variant) => {
+        const message = buildPersonalizationResultMessage(
+          storageData.sessionId,
+          storageData.visitorId,
+          pageId,
+          endpoint.projectId,
+          result,
+          variant,
+          compositionData
+        );
+        addEvent(message);
+      });
+    },
+    goalConvert: (goalId, compositionData) => {
+      if (!storageData) {
+        return;
+      }
+      const message = buildGoalConvertMessage(
+        storageData.sessionId,
+        storageData.visitorId,
+        pageId,
+        endpoint.projectId,
+        goalId,
+        compositionData
+      );
+      addEvent(message);
+    },
+    segmentUpdated: (segmentId, value, compositionData) => {
+      if (!storageData) {
+        return;
+      }
+      const message = buildSegmentUpdatedMessage({
+        sessionId: storageData.sessionId,
+        visitorId: storageData.visitorId,
+        pageId,
+        projectId: endpoint.projectId,
+        segmentId,
+        value,
+        compositionData
+      });
+      addEvent(message);
+    },
+    enrichmentUpdated: (enrichmentId, key, strength, compositionData) => {
+      if (!storageData) {
+        return;
+      }
+      const message = buildEnrichmentUpdatedMessage({
+        sessionId: storageData.sessionId,
+        visitorId: storageData.visitorId,
+        pageId,
+        projectId: endpoint.projectId,
+        enrichmentId,
+        key,
+        strength,
+        compositionData
+      });
+      addEvent(message);
+    },
+    forget: () => {
+      storage.clear();
+      storageData = void 0;
+      deduplicationManager == null ? void 0 : deduplicationManager.clear();
+      batchProcessor == null ? void 0 : batchProcessor.flush();
+    },
+    get sessionId() {
+      return storageData == null ? void 0 : storageData.sessionId;
+    }
+  };
+};
+var createInsightsPlugin = (options) => {
+  const insights = createInsightsCore(options);
+  let previousUrl = void 0;
+  let isInitialized = false;
+  let eventQueue = [];
+  let contextInstance = void 0;
+  const processQueuedEvents = () => {
+    if (isInitialized && eventQueue.length > 0) {
+      eventQueue.forEach((event) => event());
+      eventQueue = [];
+    }
+  };
+  const queueEvent = (eventFn) => {
+    if (isInitialized) {
+      eventFn();
+    } else {
+      eventQueue.push(eventFn);
+    }
+  };
+  const previousScores = {};
+  const handleScoreUpdates = (updatedScores, compositionData) => {
+    if (!contextInstance) {
+      return;
+    }
+    Object.entries(updatedScores).forEach(([scoreKey, value]) => {
+      var _a, _b;
+      if (previousScores[scoreKey] === value) {
+        return;
+      }
+      const aggregateDimension = contextInstance.manifest.getAggregateDimensionByKey(scoreKey);
+      const signalDimension = (_b = (_a = contextInstance.manifest.data.project.pz) == null ? void 0 : _a.sig) == null ? void 0 : _b[scoreKey];
+      if (aggregateDimension || signalDimension) {
+        insights.segmentUpdated(scoreKey, value, compositionData);
+        previousScores[scoreKey] = value;
+      }
+    });
+  };
+  return {
+    init: (context) => {
+      if (typeof window === "undefined") {
+        return () => {
+        };
+      }
+      contextInstance = context;
+      const consentChanged = () => {
+        if (context.storage.data.consent) {
+          insights.init(context).then(() => {
+            isInitialized = true;
+            processQueuedEvents();
+          });
+        } else {
+          insights.forget();
+          isInitialized = false;
+        }
+      };
+      const handlePersonalizationResult = (data) => {
+        queueEvent(() => {
+          insights.personalizationResult(
+            data,
+            convertUniformMetadataToInsightsMetadata(data.compositionMetadata)
+          );
+        });
+      };
+      const handleTestResult = (result) => {
+        queueEvent(() => {
+          insights.testResult(result, convertUniformMetadataToInsightsMetadata(result.compositionMetadata));
+        });
+      };
+      const handleGoalConvert = (result) => {
+        const compositionMetadata = context.getCompositionMetadata();
+        queueEvent(() => {
+          insights.goalConvert(result.goalId, convertUniformMetadataToInsightsMetadata(compositionMetadata));
+        });
+      };
+      const handleCanvasDataUpdated = (data) => {
+        if (data) {
+          queueEvent(() => {
+            insights.pageHit(convertUniformMetadataToInsightsMetadata(data));
+          });
+        }
+      };
+      context.storage.events.on("goalConverted", handleGoalConvert);
+      context.storage.events.on("consentUpdated", consentChanged);
+      context.events.on("personalizationResult", handlePersonalizationResult);
+      context.events.on("testResult", handleTestResult);
+      context.events.on("canvasDataUpdated", handleCanvasDataUpdated);
+      if (context.storage.data.consent) {
+        consentChanged();
+      }
+      return () => {
+        context.storage.events.off("consentUpdated", consentChanged);
+        context.storage.events.off("goalConverted", handleGoalConvert);
+        context.events.off("personalizationResult", handlePersonalizationResult);
+        context.events.off("testResult", handleTestResult);
+        context.events.off("canvasDataUpdated", handleCanvasDataUpdated);
+      };
+    },
+    update: (updatedData, recalculatedScores) => {
+      var _a;
+      const compositionMetadata = convertUniformMetadataToInsightsMetadata(
+        (_a = updatedData.compositionMetadata) != null ? _a : contextInstance == null ? void 0 : contextInstance.getCompositionMetadata()
+      );
+      if (updatedData.url && updatedData.url.toString() !== previousUrl) {
+        previousUrl = updatedData.url.toString();
+        queueEvent(() => {
+          insights.pageHit(compositionMetadata);
+        });
+      }
+      if (updatedData.enrichments && updatedData.enrichments.length > 0) {
+        queueEvent(() => {
+          updatedData.enrichments.forEach((enrichmentData) => {
+            insights.enrichmentUpdated(
+              enrichmentData.cat,
+              enrichmentData.key,
+              enrichmentData.str,
+              compositionMetadata
+            );
+          });
+        });
+      }
+      if (recalculatedScores) {
+        queueEvent(() => {
+          handleScoreUpdates(recalculatedScores, compositionMetadata);
+        });
+      }
+    },
+    forget: () => {
+      insights.forget();
+      isInitialized = false;
+      eventQueue = [];
+    }
+  };
+};
+
+// src/proxy.ts
+var BackendInsightsProxyHandler = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Handle a proxy request with only the body payload
+   * @param body - The request body to forward
+   * @returns Promise resolving to the API response
+   */
+  async handleRequest(originalBody) {
+    try {
+      const targetUrl = new URL("/v0/events", this.config.apiHost);
+      targetUrl.searchParams.set("name", "events");
+      return fetch(targetUrl.toString(), {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/x-ndjson",
+          Accept: "application/json"
+        },
+        body: originalBody
+      });
+    } catch (error) {
+      throw new Error(
+        `Backend proxy request failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+};
+function createBackendInsightsProxyHandler(config) {
+  return new BackendInsightsProxyHandler(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BackendInsightsProxyHandler,
+  createBackendInsightsProxyHandler,
+  createInsightsPlugin,
+  createInsightsStorage,
+  createMemoryStorage,
+  enableUniformInsights
+});