@drivemetadata-ai/sdk 0.1.0

package/dist/next/index.js

@@ -0,0 +1,1650 @@
+"use client";
+
+// src/react/DmdProvider.tsx
+import React from "react";
+
+// src/browser/core/browser-config.ts
+function setIfDefined(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function normalizeBrowserConfig(input) {
+  const normalized = {
+    ...input,
+    clientId: input.clientId ?? "",
+    workspaceId: input.workspaceId ?? "",
+    appId: input.appId ?? ""
+  };
+  setIfDefined(normalized, "apiHost", input.apiHost);
+  setIfDefined(normalized, "capturePageview", input.capturePageview);
+  setIfDefined(normalized, "capturePageleave", input.capturePageleave);
+  setIfDefined(normalized, "captureDeadClicks", input.captureDeadClicks);
+  setIfDefined(normalized, "crossSubdomainCookie", input.crossSubdomainCookie);
+  setIfDefined(normalized, "sessionIdleTimeoutSeconds", input.sessionIdleTimeoutSeconds);
+  setIfDefined(normalized, "schemaValidation", input.schemaValidation);
+  setIfDefined(normalized, "beforeSend", input.beforeSend);
+  setIfDefined(normalized, "persistence", input.disablePersistence === true ? "none" : input.persistence);
+  return normalized;
+}
+
+// src/core/uuid.ts
+function createUuid() {
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.randomUUID === "function") {
+    return cryptoApi.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (typeof cryptoApi?.getRandomValues === "function") {
+    cryptoApi.getRandomValues(bytes);
+  } else {
+    for (let index = 0; index < bytes.length; index += 1) {
+      bytes[index] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function isUuid(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function ensureUuid(value) {
+  return isUuid(value) ? value : createUuid();
+}
+
+// src/core/backend-payload.ts
+function formatUtcTimestamp(value) {
+  const date = typeof value === "string" || typeof value === "number" || value instanceof Date ? new Date(value) : /* @__PURE__ */ new Date();
+  const safeDate = Number.isNaN(date.getTime()) ? /* @__PURE__ */ new Date() : date;
+  return safeDate.toISOString().replace("T", " ").slice(0, 19);
+}
+function cleanObject(value) {
+  if (Array.isArray(value)) {
+    const cleaned = value.map((item) => cleanObject(item)).filter((item) => item !== null && item !== void 0 && item !== "");
+    return cleaned.length > 0 ? cleaned : void 0;
+  }
+  if (value && typeof value === "object") {
+    const cleaned = Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, cleanObject(item)]).filter(([, item]) => {
+        if (item === null || item === void 0 || item === "") return false;
+        if (typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0) return false;
+        return true;
+      })
+    );
+    return Object.keys(cleaned).length > 0 ? cleaned : void 0;
+  }
+  return value;
+}
+function createBackendCollectorPayload(input) {
+  const eventData = input.eventData && typeof input.eventData === "object" ? input.eventData : {};
+  const page2 = eventData.page && typeof eventData.page === "object" ? eventData.page : {};
+  const timestamp = formatUtcTimestamp(eventData.timestamp ?? input.timestamp);
+  const normalizedEventData = {
+    ...eventData,
+    timestamp,
+    requestSentAt: formatUtcTimestamp(eventData.requestSentAt ?? input.requestSentAt ?? timestamp),
+    requestReceivedAt: formatUtcTimestamp(eventData.requestReceivedAt ?? input.requestReceivedAt ?? timestamp)
+  };
+  const metaData = {
+    ...normalizedEventData,
+    requestId: ensureUuid(typeof input.requestId === "string" ? input.requestId : void 0),
+    timestamp,
+    eventType: input.eventType,
+    requestFrom: input.requestFrom ?? "3",
+    clientId: input.clientId,
+    workspaceId: input.workspaceId,
+    token: input.token,
+    anonymousId: ensureUuid(
+      typeof eventData.anonymousId === "string" ? eventData.anonymousId : typeof input.anonymousId === "string" ? input.anonymousId : void 0
+    ),
+    sessionId: ensureUuid(
+      typeof eventData.sessionId === "string" ? eventData.sessionId : typeof input.sessionId === "string" ? input.sessionId : void 0
+    ),
+    ua: input.ua,
+    appDetails: { app_id: input.appId },
+    page: { ...page2, url: page2.url ?? input.pageUrl },
+    requestSentAt: normalizedEventData.requestSentAt,
+    requestReceivedAt: normalizedEventData.requestReceivedAt
+  };
+  const payload = { metaData };
+  return cleanObject(payload);
+}
+
+// src/core/backend-schema.ts
+var requiredMetaDataFields = [
+  "requestId",
+  "timestamp",
+  "eventType",
+  "requestFrom",
+  "clientId",
+  "workspaceId",
+  "anonymousId",
+  "sessionId"
+];
+function isPresent(value) {
+  return value !== null && value !== void 0 && value !== "";
+}
+function validateBackendCollectorPayload(payload) {
+  const errors = [];
+  const metaData = payload.metaData;
+  if (!metaData || typeof metaData !== "object" || Array.isArray(metaData)) {
+    return {
+      ok: false,
+      errors: ["metaData is required"]
+    };
+  }
+  const metadataRecord = metaData;
+  for (const field of requiredMetaDataFields) {
+    if (!isPresent(metadataRecord[field])) {
+      errors.push(`metaData.${field} is required`);
+    }
+  }
+  if (isPresent(metadataRecord.eventType) && typeof metadataRecord.eventType !== "string") {
+    errors.push("metaData.eventType must be a string");
+  }
+  return {
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+// src/core/consent.ts
+var purposes = [
+  "analytics",
+  "advertising",
+  "personalization",
+  "functional",
+  "saleOfData"
+];
+function normalizeConsentValue(value) {
+  if (value === true) return "granted";
+  if (value === false) return "denied";
+  if (value === "granted" || value === "denied" || value === "pending") return value;
+  return "pending";
+}
+function normalizeConsent(input) {
+  const defaultValue = normalizeConsentValue(input ?? "pending");
+  const resolved = Object.fromEntries(
+    purposes.map((purpose) => [purpose, defaultValue])
+  );
+  if (input && typeof input === "object") {
+    for (const purpose of purposes) {
+      const value = input[purpose];
+      if (value !== void 0) {
+        resolved[purpose] = normalizeConsentValue(value);
+      }
+    }
+  }
+  return resolved;
+}
+function mergeConsent(current, update) {
+  const next = { ...current };
+  for (const [purpose, value] of Object.entries(update)) {
+    next[purpose] = normalizeConsentValue(value);
+  }
+  return next;
+}
+function canCollectPurpose(consent, purpose) {
+  return consent[purpose] === "granted";
+}
+
+// src/core/event-schema.ts
+var reservedKeys = /* @__PURE__ */ new Set(["messageId", "timestamp", "type", "event", "anonymousId", "userId", "context"]);
+function validateEventEnvelope(envelope, options = {}) {
+  if (options.mode === "off") return { ok: true, errors: [] };
+  const errors = [];
+  if (typeof envelope.type !== "string") errors.push("type must be a string");
+  if (envelope.type === "track" && typeof envelope.event !== "string") {
+    errors.push("track event must include event name");
+  }
+  if (typeof envelope.messageId !== "string") errors.push("messageId must be a string");
+  if (typeof envelope.timestamp !== "string") errors.push("timestamp must be an ISO string");
+  for (const key of Object.keys(envelope.properties ?? {})) {
+    if (reservedKeys.has(key)) errors.push(`properties.${key} is reserved`);
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+// src/core/environment.ts
+function getBrowserWindow() {
+  return typeof window === "undefined" ? void 0 : window;
+}
+
+// src/core/privacy.ts
+var sensitiveKeys = /* @__PURE__ */ new Set([
+  "email",
+  "phone",
+  "mobile",
+  "address",
+  "address1",
+  "address2",
+  "first_name",
+  "last_name",
+  "name",
+  "token",
+  "secret",
+  "password",
+  "session",
+  "cookie"
+]);
+function redactUrl(url, allowQueryKeys = ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"]) {
+  const parsed = new URL(url, "https://placeholder.local");
+  for (const key of Array.from(parsed.searchParams.keys())) {
+    if (!allowQueryKeys.includes(key)) {
+      parsed.searchParams.set(key, "[REDACTED]");
+    }
+  }
+  return url.startsWith("http") ? parsed.toString() : `${parsed.pathname}${parsed.search}`;
+}
+function sanitizeValue(value, allow, path = []) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeValue(item, allow, path));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([key]) => {
+        const lowerKey = key.toLowerCase();
+        const lowerPath = path.map((item) => item.toLowerCase());
+        const isEcommerceItemName = lowerKey === "name" && lowerPath.includes("ecommerce") && lowerPath.includes("items");
+        return isEcommerceItemName || !sensitiveKeys.has(lowerKey) || allow.has(lowerKey);
+      }).map(([key, nestedValue]) => [key, sanitizeValue(nestedValue, allow, [...path, key])])
+    );
+  }
+  return value;
+}
+function sanitizeProperties(input, allowRawKeys = []) {
+  const allow = new Set(allowRawKeys.map((key) => key.toLowerCase()));
+  return sanitizeValue(input, allow);
+}
+
+// src/core/attribution.ts
+var dmdUtmKeys = [
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content",
+  "utm_id"
+];
+var dmdCampaignKeys = ["campaign_id", "ad_id"];
+var dmdClickIdSources = [
+  ["gclid", 2],
+  ["fbclid", 3],
+  ["ScCid", 1],
+  ["li_fat_id", 4]
+];
+function cleanAttributionRecord(record) {
+  const cleaned = Object.fromEntries(
+    Object.entries(record).filter(([, value]) => value !== null && value !== void 0 && value !== "")
+  );
+  return Object.keys(cleaned).length > 0 ? cleaned : void 0;
+}
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function mergeAttributionRecords(explicitProperties, stored) {
+  const attributionData = objectValue(explicitProperties.attributionData);
+  const utmParameter = objectValue(explicitProperties.utmParameter);
+  return {
+    ...explicitProperties,
+    ...stored.attributionData || attributionData ? { attributionData: { ...stored.attributionData ?? {}, ...attributionData ?? {} } } : {},
+    ...stored.utmParameter || utmParameter ? { utmParameter: { ...stored.utmParameter ?? {}, ...utmParameter ?? {} } } : {}
+  };
+}
+
+// src/browser/core/attribution.ts
+function getCurrentUrl() {
+  return getBrowserWindow()?.location?.href;
+}
+function getCookie(name) {
+  const cookie = getBrowserWindow()?.document?.cookie;
+  if (!cookie) return void 0;
+  const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = new RegExp(`(?:^|; )${escapedName}=([^;]*)`).exec(cookie);
+  return match ? decodeURIComponent(match[1] ?? "") : void 0;
+}
+function getParams(url) {
+  return new URL(url, "https://placeholder.local").searchParams;
+}
+function setIfPresent(persistence, key, value) {
+  if (value !== null && value !== "") {
+    persistence.setItem(key, value);
+  }
+}
+function getStoredString(persistence, key) {
+  const value = persistence.getItem(key);
+  return value === null || value === "" ? void 0 : value;
+}
+function getStoredNumberOrString(persistence, key) {
+  const value = getStoredString(persistence, key);
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? value : parsed;
+}
+function captureAttributionFromUrl(persistence, url = getCurrentUrl()) {
+  if (!url) return;
+  const params = getParams(url);
+  for (const key of dmdUtmKeys) {
+    setIfPresent(persistence, key, params.get(key));
+  }
+  for (const key of dmdCampaignKeys) {
+    setIfPresent(persistence, key, params.get(key));
+  }
+  for (const [param, sdkPubId] of dmdClickIdSources) {
+    const value = params.get(param);
+    if (value) {
+      persistence.setItem("unique_id", value);
+      persistence.setItem("sdk_pub_id", String(sdkPubId));
+    }
+  }
+}
+function getStoredAttributionData(persistence) {
+  return cleanAttributionRecord({
+    unique_id: getStoredString(persistence, "unique_id"),
+    sdk_pub_id: getStoredNumberOrString(persistence, "sdk_pub_id"),
+    fbc: getStoredString(persistence, "fbc") ?? getCookie("_fbc"),
+    fbp: getStoredString(persistence, "fbp") ?? getCookie("_fbp"),
+    campaign_id: getStoredString(persistence, "campaign_id"),
+    ad_id: getStoredString(persistence, "ad_id")
+  });
+}
+function getStoredUtmParameter(persistence) {
+  return cleanAttributionRecord(Object.fromEntries(dmdUtmKeys.map((key) => [key, getStoredString(persistence, key)])));
+}
+function mergeStoredAttribution(properties, persistence) {
+  const stored = {};
+  const attributionData = getStoredAttributionData(persistence);
+  const utmParameter = getStoredUtmParameter(persistence);
+  if (attributionData !== void 0) stored.attributionData = attributionData;
+  if (utmParameter !== void 0) stored.utmParameter = utmParameter;
+  return mergeAttributionRecords(properties, stored);
+}
+
+// src/browser/core/autocapture.ts
+function installAutocapture(config) {
+  const trackedPageUrls = /* @__PURE__ */ new Set();
+  const timers = /* @__PURE__ */ new Set();
+  const pageviewDelayMs = config.pageviewDelayMs ?? 500;
+  const history = config.browserWindow.history;
+  const originalPushState = history?.pushState;
+  const originalReplaceState = history?.replaceState;
+  function clearTimer(timer) {
+    timers.delete(timer);
+    clearTimeout(timer);
+  }
+  function canonicalUrl() {
+    return config.browserWindow.location.href;
+  }
+  function trackCurrentPageview() {
+    if (!config.capturePageview) return;
+    const url = canonicalUrl();
+    if (trackedPageUrls.has(url)) return;
+    trackedPageUrls.add(url);
+    config.onPageView();
+  }
+  function schedulePageview(delayMs) {
+    if (!config.capturePageview) return;
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      trackCurrentPageview();
+    }, delayMs);
+    timers.add(timer);
+  }
+  function handleRouteChange() {
+    config.onRouteChange?.();
+    trackCurrentPageview();
+  }
+  function wrapHistoryMethod(method) {
+    if (!history) return;
+    const original = history[method];
+    if (typeof original !== "function") return;
+    history[method] = function wrappedHistoryMethod(...args) {
+      const result = original.apply(this, args);
+      const timer = setTimeout(() => {
+        timers.delete(timer);
+        handleRouteChange();
+      }, 0);
+      timers.add(timer);
+      return result;
+    };
+  }
+  function handlePopOrHashChange() {
+    handleRouteChange();
+  }
+  function handlePageLeave() {
+    if (config.capturePageleave) {
+      config.onPageLeave();
+    }
+  }
+  schedulePageview(pageviewDelayMs);
+  wrapHistoryMethod("pushState");
+  wrapHistoryMethod("replaceState");
+  const canListen = typeof config.browserWindow.addEventListener === "function" && typeof config.browserWindow.removeEventListener === "function";
+  if (canListen) {
+    config.browserWindow.addEventListener("popstate", handlePopOrHashChange);
+    config.browserWindow.addEventListener("hashchange", handlePopOrHashChange);
+    config.browserWindow.addEventListener("beforeunload", handlePageLeave);
+  }
+  return {
+    cleanup() {
+      for (const timer of Array.from(timers)) {
+        clearTimer(timer);
+      }
+      if (history && originalPushState) history.pushState = originalPushState;
+      if (history && originalReplaceState) history.replaceState = originalReplaceState;
+      if (canListen) {
+        config.browserWindow.removeEventListener("popstate", handlePopOrHashChange);
+        config.browserWindow.removeEventListener("hashchange", handlePopOrHashChange);
+        config.browserWindow.removeEventListener("beforeunload", handlePageLeave);
+      }
+    }
+  };
+}
+
+// src/core/payload-size.ts
+var preserveStringKeys = /* @__PURE__ */ new Set([
+  "requestId",
+  "eventType",
+  "requestFrom",
+  "clientId",
+  "workspaceId",
+  "anonymousId",
+  "sessionId",
+  "token"
+]);
+function payloadByteLength(payload) {
+  const serialized = JSON.stringify(payload);
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(serialized).length;
+  }
+  return serialized.length;
+}
+function clonePayload(payload) {
+  try {
+    return JSON.parse(JSON.stringify(payload));
+  } catch {
+    return void 0;
+  }
+}
+function truncateValue(value, truncateStringLength, key) {
+  if (typeof value === "string") {
+    if (key && preserveStringKeys.has(key)) return value;
+    if (value.length <= truncateStringLength) return value;
+    return `${value.slice(0, truncateStringLength)}...[TRUNCATED]`;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => truncateValue(item, truncateStringLength));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([childKey, childValue]) => [
+        childKey,
+        truncateValue(childValue, truncateStringLength, childKey)
+      ])
+    );
+  }
+  return value;
+}
+function markPayloadTruncated(payload) {
+  if (payload.metaData && typeof payload.metaData === "object" && !Array.isArray(payload.metaData)) {
+    return {
+      ...payload,
+      metaData: {
+        ...payload.metaData,
+        payloadTruncated: true
+      }
+    };
+  }
+  return {
+    ...payload,
+    payloadTruncated: true
+  };
+}
+function truncatePayload(payload, truncateStringLength) {
+  const cloned = clonePayload(payload);
+  if (!cloned) return void 0;
+  return markPayloadTruncated(truncateValue(cloned, truncateStringLength));
+}
+function getPayloadMessageId(payload) {
+  const value = payload.metaData?.requestId ?? payload.messageId;
+  return value === void 0 ? void 0 : String(value);
+}
+function preparePayloadForSizePolicy(payload, options = {}) {
+  const maxPayloadBytes = options.maxPayloadBytes ?? 64e3;
+  const payloadSizePolicy = options.payloadSizePolicy ?? "drop";
+  const payloadTruncateStringLength = options.payloadTruncateStringLength ?? 1024;
+  if (payloadByteLength(payload) <= maxPayloadBytes) {
+    return { ok: true, payload, truncated: false };
+  }
+  if (payloadSizePolicy === "truncate") {
+    const truncatedPayload = truncatePayload(payload, payloadTruncateStringLength);
+    if (truncatedPayload && payloadByteLength(truncatedPayload) <= maxPayloadBytes) {
+      return { ok: true, payload: truncatedPayload, truncated: true };
+    }
+  }
+  const messageId = getPayloadMessageId(payload);
+  return messageId === void 0 ? { ok: false, reason: "payload_too_large" } : { ok: false, reason: "payload_too_large", messageId };
+}
+
+// src/browser/core/delivery.ts
+function createId(prefix) {
+  return `${prefix}_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function stableStringify(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  return JSON.stringify(
+    Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
+    )
+  );
+}
+function createIdempotencyKey(payload, messageId) {
+  const metaData = payload.metaData;
+  const event = String(metaData?.eventType ?? payload.event ?? payload.type ?? "event");
+  const properties = metaData ?? payload.properties;
+  const orderId = properties?.orderId ?? properties?.order_id ?? properties?.transaction_id;
+  if (orderId !== void 0) return `${event}:${String(orderId)}`;
+  return `${event}:${stableStringify(properties ?? {}) || messageId}`;
+}
+function createDeliveryManager(config) {
+  const queue = [];
+  const diagnostics = { queued: 0, inFlight: 0, dropped: [] };
+  const maxQueueSize = config.maxQueueSize ?? 100;
+  const queueKey = config.queueKey ?? "dmd_delivery_queue";
+  const lockKey = config.lockKey ?? "dmd_delivery_flush_lock";
+  const lockTtlMs = config.lockTtlMs ?? 5e3;
+  const tabId = config.tabId ?? createId("tab");
+  const batchSize = config.batchSize ?? 25;
+  function recordDrop(event) {
+    diagnostics.dropped.push(event);
+    config.onDrop?.(event);
+  }
+  function recordError(error) {
+    diagnostics.lastError = error.message;
+    config.onError?.(error);
+  }
+  function preparePayloadForSend(payload) {
+    const sizePolicyOptions = {};
+    if (config.maxPayloadBytes !== void 0) sizePolicyOptions.maxPayloadBytes = config.maxPayloadBytes;
+    if (config.payloadSizePolicy !== void 0) sizePolicyOptions.payloadSizePolicy = config.payloadSizePolicy;
+    if (config.payloadTruncateStringLength !== void 0) {
+      sizePolicyOptions.payloadTruncateStringLength = config.payloadTruncateStringLength;
+    }
+    const prepared = preparePayloadForSizePolicy(payload, sizePolicyOptions);
+    if (prepared.ok) return prepared.payload;
+    const diagnostic = {
+      reason: prepared.reason,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (prepared.messageId !== void 0) diagnostic.messageId = prepared.messageId;
+    recordDrop(diagnostic);
+    return void 0;
+  }
+  function recordStorageUnavailable() {
+    recordDrop({
+      reason: "storage_unavailable",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  function safeGetItem(key) {
+    try {
+      return config.storage?.getItem(key) ?? null;
+    } catch {
+      recordStorageUnavailable();
+      return null;
+    }
+  }
+  function safeSetItem(key, value) {
+    try {
+      config.storage?.setItem(key, value);
+      return true;
+    } catch {
+      recordStorageUnavailable();
+      return false;
+    }
+  }
+  function safeRemoveItem(key) {
+    try {
+      config.storage?.removeItem(key);
+      return true;
+    } catch {
+      recordStorageUnavailable();
+      return false;
+    }
+  }
+  function persistQueue() {
+    if (!config.storage) return;
+    if (queue.length === 0) {
+      safeRemoveItem(queueKey);
+      return;
+    }
+    safeSetItem(queueKey, JSON.stringify(queue));
+  }
+  function loadQueue() {
+    if (!config.storage) return;
+    const rawQueue = safeGetItem(queueKey);
+    if (!rawQueue) return;
+    try {
+      const records = JSON.parse(rawQueue);
+      queue.splice(0, queue.length, ...records.filter((record) => record && typeof record.messageId === "string"));
+      diagnostics.queued = queue.length;
+    } catch {
+      safeRemoveItem(queueKey);
+      recordDrop({
+        reason: "queue_corrupt",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  function enqueue(record) {
+    queue.push(record);
+    while (queue.length > maxQueueSize) {
+      const dropped = queue.shift();
+      const diagnostic = {
+        reason: "queue_limit_exceeded",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (dropped?.messageId !== void 0) diagnostic.messageId = dropped.messageId;
+      recordDrop(diagnostic);
+    }
+    diagnostics.queued = queue.length;
+    persistQueue();
+  }
+  function withEnvelope(payload) {
+    const metaData = payload.metaData;
+    const messageId = String(metaData?.requestId ?? payload.messageId ?? createId("msg"));
+    if (metaData) {
+      return {
+        ...payload,
+        metaData: {
+          ...metaData,
+          requestId: messageId
+        }
+      };
+    }
+    return {
+      ...payload,
+      messageId,
+      idempotencyKey: String(payload.idempotencyKey ?? createIdempotencyKey(payload, messageId))
+    };
+  }
+  function tryBeacon(body) {
+    if (!config.useBeacon) return false;
+    const sendBeacon = globalThis.navigator?.sendBeacon;
+    if (typeof sendBeacon !== "function") return false;
+    try {
+      const blob = new Blob([JSON.stringify(body)], { type: "application/json" });
+      return sendBeacon.call(globalThis.navigator, config.endpoint, blob);
+    } catch {
+      return false;
+    }
+  }
+  async function deliver(body) {
+    if (tryBeacon(body)) return;
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new Error("fetch_unavailable");
+    }
+    const response = await fetchImpl(config.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      keepalive: true
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  }
+  loadQueue();
+  return {
+    async send(payload) {
+      const body = withEnvelope(payload);
+      const preparedBody = preparePayloadForSend(body);
+      if (!preparedBody) {
+        return;
+      }
+      diagnostics.inFlight += 1;
+      try {
+        await deliver(preparedBody);
+      } catch (error) {
+        const deliveryError = error instanceof Error ? error : new Error(String(error));
+        recordError(deliveryError);
+        enqueue({
+          messageId: String(getPayloadMessageId(body)),
+          savedAt: Date.now(),
+          attempts: 1,
+          lastError: deliveryError.message,
+          payload: preparedBody
+        });
+      } finally {
+        diagnostics.inFlight -= 1;
+        diagnostics.queued = queue.length;
+      }
+    },
+    async flushQueue() {
+      this.flushExpired();
+      if (queue.length === 0 || !this.acquireFlushLease()) return;
+      diagnostics.inFlight += 1;
+      try {
+        let sentInBatch = 0;
+        for (let index = 0; index < queue.length && sentInBatch < batchSize; ) {
+          const record = queue[index];
+          if (!record) {
+            index += 1;
+            continue;
+          }
+          try {
+            await deliver(record.payload);
+            queue.splice(index, 1);
+            sentInBatch += 1;
+            persistQueue();
+          } catch (error) {
+            const deliveryError = error instanceof Error ? error : new Error(String(error));
+            record.attempts += 1;
+            record.lastError = deliveryError.message;
+            recordError(deliveryError);
+            index += 1;
+            persistQueue();
+            break;
+          }
+        }
+      } finally {
+        diagnostics.inFlight -= 1;
+        diagnostics.queued = queue.length;
+        this.releaseFlushLease();
+      }
+    },
+    clearQueue(reason) {
+      for (const record of queue) {
+        recordDrop({
+          messageId: record.messageId,
+          reason,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      queue.splice(0, queue.length);
+      diagnostics.queued = 0;
+      persistQueue();
+    },
+    enqueueForTests(record) {
+      enqueue(record);
+    },
+    flushExpired() {
+      const ttl = config.queueTtlMs ?? 864e5;
+      const now = Date.now();
+      for (let index = queue.length - 1; index >= 0; index -= 1) {
+        const record = queue[index];
+        if (record && now - record.savedAt > ttl) {
+          recordDrop({
+            messageId: record.messageId,
+            reason: "queue_ttl_expired",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          queue.splice(index, 1);
+        }
+      }
+      diagnostics.queued = queue.length;
+      persistQueue();
+    },
+    acquireFlushLease() {
+      if (!config.storage) return true;
+      const now = Date.now();
+      const rawLock = safeGetItem(lockKey);
+      let existingLock;
+      if (rawLock) {
+        try {
+          existingLock = JSON.parse(rawLock);
+        } catch {
+          existingLock = void 0;
+        }
+      }
+      const lockExpired = !existingLock?.expiresAt || existingLock.expiresAt <= now;
+      const lockOwnedByThisTab = existingLock?.owner === tabId;
+      if (!existingLock || lockExpired || lockOwnedByThisTab) {
+        if (!safeSetItem(lockKey, JSON.stringify({ owner: tabId, expiresAt: now + lockTtlMs }))) {
+          return true;
+        }
+        return true;
+      }
+      return false;
+    },
+    releaseFlushLease() {
+      if (!config.storage) return;
+      const rawLock = safeGetItem(lockKey);
+      if (!rawLock) return;
+      try {
+        const existingLock = JSON.parse(rawLock);
+        if (existingLock.owner === tabId) {
+          safeRemoveItem(lockKey);
+        }
+      } catch {
+        safeRemoveItem(lockKey);
+      }
+    },
+    getDiagnostics() {
+      return diagnostics;
+    }
+  };
+}
+
+// src/browser/core/identity.ts
+var ANONYMOUS_ID_STORAGE_KEY = "dmd_anonymous_id";
+var LEGACY_ANONYMOUS_ID_STORAGE_KEY = "anonymousId";
+function getUrlParam(name) {
+  const href = getBrowserWindow()?.location?.href;
+  if (!href) return null;
+  try {
+    return new URL(href).searchParams.get(name);
+  } catch {
+    return null;
+  }
+}
+function resolveAnonymousId(persistence) {
+  const urlAnonymousId = getUrlParam("aid");
+  if (isUuid(urlAnonymousId)) {
+    persistence.setItem(ANONYMOUS_ID_STORAGE_KEY, urlAnonymousId);
+    return urlAnonymousId;
+  }
+  const storedAnonymousId = persistence.getItem(ANONYMOUS_ID_STORAGE_KEY);
+  if (isUuid(storedAnonymousId)) {
+    return storedAnonymousId;
+  }
+  const legacyAnonymousId = persistence.getItem(LEGACY_ANONYMOUS_ID_STORAGE_KEY);
+  if (isUuid(legacyAnonymousId)) {
+    persistence.setItem(ANONYMOUS_ID_STORAGE_KEY, legacyAnonymousId);
+    return legacyAnonymousId;
+  }
+  const anonymousId = createUuid();
+  persistence.setItem(ANONYMOUS_ID_STORAGE_KEY, anonymousId);
+  return anonymousId;
+}
+function resetAnonymousId(persistence) {
+  const anonymousId = createUuid();
+  persistence.setItem(ANONYMOUS_ID_STORAGE_KEY, anonymousId);
+  return anonymousId;
+}
+
+// src/browser/core/page-context.ts
+function redactSearch(search) {
+  const redacted = redactUrl(search);
+  return redacted.startsWith("/?") ? redacted.slice(1) : redacted;
+}
+function getBrowserPageContext() {
+  const browserWindow = getBrowserWindow();
+  const documentRef = browserWindow?.document ?? globalThis.document;
+  const location = browserWindow?.location;
+  const page2 = {};
+  if (location?.href) page2.url = location.href;
+  if (location?.pathname) page2.path = location.pathname;
+  if (location?.search) page2.search = redactSearch(location.search);
+  if (documentRef?.title) page2.title = documentRef.title;
+  if (documentRef?.referrer) page2.referrer = redactUrl(documentRef.referrer);
+  return page2;
+}
+
+// src/browser/core/persistence.ts
+function createPersistenceHealth(requested) {
+  return {
+    requested,
+    cookieFallbackUsed: false,
+    memoryFallbackUsed: requested === "memory",
+    failures: []
+  };
+}
+function recordFailure(health, backend, operation, error) {
+  health.failures.push({
+    backend,
+    operation,
+    message: error instanceof Error ? error.message : String(error)
+  });
+  if (health.failures.length > 25) {
+    health.failures.shift();
+  }
+}
+function createMemoryPersistence(health = createPersistenceHealth("memory")) {
+  const memory = {};
+  return {
+    getItem(key) {
+      return Object.prototype.hasOwnProperty.call(memory, key) ? memory[key] ?? null : null;
+    },
+    setItem(key, value) {
+      memory[key] = value;
+      return true;
+    },
+    removeItem(key) {
+      delete memory[key];
+    },
+    getHealth() {
+      return {
+        ...health,
+        failures: health.failures.map((failure) => ({ ...failure }))
+      };
+    }
+  };
+}
+function getCookie2(name) {
+  const browserWindow = getBrowserWindow();
+  const cookie = browserWindow?.document?.cookie;
+  if (!cookie) return null;
+  const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = new RegExp(`(?:^|; )${escapedName}=([^;]*)`).exec(cookie);
+  return match ? decodeURIComponent(match[1] ?? "") : null;
+}
+function setCookie(name, value) {
+  const browserWindow = getBrowserWindow();
+  if (!browserWindow?.document) return false;
+  try {
+    const expires = new Date(Date.now() + 365 * 24 * 60 * 60 * 1e3).toUTCString();
+    const secure = browserWindow.location?.protocol === "https:" ? "; Secure" : "";
+    browserWindow.document.cookie = `${name}=${encodeURIComponent(value)}; expires=${expires}; path=/${secure}; SameSite=Lax`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeCookie(name) {
+  const browserWindow = getBrowserWindow();
+  if (!browserWindow?.document) return;
+  browserWindow.document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+}
+function getLocalStorage() {
+  const browserWindow = getBrowserWindow();
+  try {
+    return browserWindow?.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+function getSessionStorage() {
+  const browserWindow = getBrowserWindow();
+  try {
+    return browserWindow?.sessionStorage;
+  } catch {
+    return void 0;
+  }
+}
+function createBrowserPersistence(mode = "localStorage+cookie") {
+  const health = createPersistenceHealth(mode);
+  const memory = createMemoryPersistence(health);
+  if (mode === "none") {
+    return {
+      getItem() {
+        return null;
+      },
+      setItem() {
+        return false;
+      },
+      removeItem() {
+      },
+      getHealth() {
+        return {
+          ...health,
+          failures: health.failures.map((failure) => ({ ...failure }))
+        };
+      }
+    };
+  }
+  if (mode === "memory") return memory;
+  const primary = mode === "sessionStorage" ? getSessionStorage() : getLocalStorage();
+  const useCookie = mode === "cookie" || mode === "localStorage+cookie" || !primary;
+  return {
+    getItem(key) {
+      try {
+        const stored = primary?.getItem(key);
+        if (stored) return stored;
+      } catch (error) {
+        recordFailure(health, mode === "sessionStorage" ? "sessionStorage" : "localStorage", "get", error);
+      }
+      if (useCookie) {
+        const cookie = getCookie2(key);
+        if (cookie) {
+          health.cookieFallbackUsed = true;
+          return cookie;
+        }
+      }
+      const value = memory.getItem(key);
+      if (value !== null) health.memoryFallbackUsed = true;
+      return value;
+    },
+    setItem(key, value) {
+      let wrote = false;
+      try {
+        primary?.setItem(key, value);
+        wrote = primary !== void 0;
+      } catch (error) {
+        recordFailure(health, mode === "sessionStorage" ? "sessionStorage" : "localStorage", "set", error);
+        wrote = false;
+      }
+      if (useCookie) {
+        const cookieWrote = setCookie(key, value);
+        if (cookieWrote) health.cookieFallbackUsed = true;
+        wrote = cookieWrote || wrote;
+      }
+      if (!wrote) {
+        health.memoryFallbackUsed = true;
+        return memory.setItem(key, value);
+      }
+      if (mode === "localStorage+cookie") {
+        memory.setItem(key, value);
+      }
+      return true;
+    },
+    removeItem(key) {
+      try {
+        primary?.removeItem(key);
+      } catch (error) {
+        recordFailure(health, mode === "sessionStorage" ? "sessionStorage" : "localStorage", "remove", error);
+      }
+      if (useCookie) removeCookie(key);
+      memory.removeItem(key);
+    },
+    getHealth() {
+      return {
+        ...health,
+        failures: health.failures.map((failure) => ({ ...failure }))
+      };
+    }
+  };
+}
+
+// src/browser/core/session.ts
+var SESSION_STORAGE_KEY = "sessionData";
+function getUrlParam2(name) {
+  const href = getBrowserWindow()?.location?.href;
+  if (!href) return null;
+  try {
+    return new URL(href).searchParams.get(name);
+  } catch {
+    return null;
+  }
+}
+function readStoredSession(persistence) {
+  const rawSession = persistence.getItem(SESSION_STORAGE_KEY);
+  if (!rawSession) return void 0;
+  try {
+    const parsed = JSON.parse(rawSession);
+    if (isUuid(parsed.sessionId) && typeof parsed.timestamp === "number") {
+      return {
+        sessionId: parsed.sessionId,
+        timestamp: parsed.timestamp
+      };
+    }
+  } catch {
+    persistence.removeItem(SESSION_STORAGE_KEY);
+  }
+  return void 0;
+}
+function writeStoredSession(persistence, sessionId, timestamp) {
+  persistence.setItem(SESSION_STORAGE_KEY, JSON.stringify({ sessionId, timestamp }));
+}
+function createSessionManager(persistence, idleTimeoutSeconds = 30 * 60) {
+  function resolveSessionId() {
+    const now = Date.now();
+    const urlSessionId = getUrlParam2("sid") ?? getUrlParam2("session_id");
+    if (isUuid(urlSessionId)) {
+      writeStoredSession(persistence, urlSessionId, now);
+      return urlSessionId;
+    }
+    const storedSession = readStoredSession(persistence);
+    if (storedSession && now - storedSession.timestamp <= idleTimeoutSeconds * 1e3) {
+      writeStoredSession(persistence, storedSession.sessionId, now);
+      return storedSession.sessionId;
+    }
+    const sessionId = createUuid();
+    writeStoredSession(persistence, sessionId, now);
+    return sessionId;
+  }
+  return {
+    getSessionId() {
+      return resolveSessionId();
+    },
+    reset() {
+      const sessionId = createUuid();
+      writeStoredSession(persistence, sessionId, Date.now());
+      return sessionId;
+    }
+  };
+}
+
+// src/browser/core/DriveMetaDataSDK.ts
+function endpointFromConfig(config) {
+  const host = config.apiHost ?? "https://sdk.drivemetadata.com/v2";
+  return `${host.replace(/\/$/, "")}/data-collector`;
+}
+function requireConfigString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`DMD SDK config ${field} is required`);
+  }
+  return value;
+}
+var DriveMetaDataSDK = class {
+  constructor(config) {
+    this.initialized = true;
+    this.queue = [];
+    this.offline = false;
+    this.droppedEvents = 0;
+    requireConfigString(config.clientId, "clientId");
+    requireConfigString(config.workspaceId, "workspaceId");
+    requireConfigString(config.appId, "appId");
+    requireConfigString(config.writeKey || config.token, "writeKey or token");
+    this.config = config;
+    this.endpoint = endpointFromConfig(config);
+    this.persistence = createBrowserPersistence(config.persistence);
+    this.session = createSessionManager(this.persistence, config.sessionIdleTimeoutSeconds);
+    const deliveryConfig = {
+      endpoint: this.endpoint,
+      storage: this.persistence
+    };
+    if (config.delivery?.maxQueueSize !== void 0) deliveryConfig.maxQueueSize = config.delivery.maxQueueSize;
+    if (config.delivery?.queueTtlMs !== void 0) deliveryConfig.queueTtlMs = config.delivery.queueTtlMs;
+    if (config.delivery?.retryDelayMs !== void 0) deliveryConfig.retryDelayMs = config.delivery.retryDelayMs;
+    if (config.delivery?.maxRetryDelayMs !== void 0) deliveryConfig.maxRetryDelayMs = config.delivery.maxRetryDelayMs;
+    if (config.delivery?.maxPayloadBytes !== void 0) deliveryConfig.maxPayloadBytes = config.delivery.maxPayloadBytes;
+    if (config.delivery?.payloadSizePolicy !== void 0) deliveryConfig.payloadSizePolicy = config.delivery.payloadSizePolicy;
+    if (config.delivery?.payloadTruncateStringLength !== void 0) {
+      deliveryConfig.payloadTruncateStringLength = config.delivery.payloadTruncateStringLength;
+    }
+    if (config.delivery?.useBeacon !== void 0) deliveryConfig.useBeacon = config.delivery.useBeacon;
+    if (config.delivery?.batchSize !== void 0) deliveryConfig.batchSize = config.delivery.batchSize;
+    if (config.onDrop !== void 0) deliveryConfig.onDrop = config.onDrop;
+    if (config.onError !== void 0) deliveryConfig.onError = config.onError;
+    this.delivery = createDeliveryManager(deliveryConfig);
+    this.initialRetryDelayMs = config.delivery?.retryDelayMs ?? 1e3;
+    this.retryDelayMs = this.initialRetryDelayMs;
+    this.maxRetryDelayMs = config.delivery?.maxRetryDelayMs ?? 3e4;
+    this.writeKey = config.writeKey || config.token || "";
+    this.identity = { anonymousId: resolveAnonymousId(this.persistence) };
+    captureAttributionFromUrl(this.persistence);
+    this.consentState = normalizeConsent(config.gdprConsent ?? config.consent);
+    this.gdprConsent = this.consentState.analytics;
+    this.installAutocapture();
+    if (!config.delivery?.disableLifecycleFlush) {
+      this.installLifecycleFlush();
+    }
+  }
+  trackEvent(event, properties = {}, options = {}) {
+    this.sendPreparedEvent("track", event, properties, options);
+  }
+  page(name, properties = {}, options = {}) {
+    this.sendPreparedEvent("page", "page_view", { name, ...properties }, options);
+  }
+  trackPageview() {
+    this.page();
+  }
+  identify(userId, traits = {}, options = {}) {
+    this.identity = { ...this.identity, userId, traits };
+    this.sendPreparedEvent("identify", "identify", { userId, traits }, options);
+  }
+  identifyUser(userId, traits = {}) {
+    this.identify(userId, traits);
+  }
+  group(groupId, traits = {}, options = {}) {
+    this.identity = { ...this.identity, groupId };
+    this.sendPreparedEvent("group", "group", { groupId, traits }, options);
+  }
+  alias(previousId, userId, options = {}) {
+    this.sendPreparedEvent("alias", "alias", { previousId, userId }, options);
+  }
+  async flush() {
+    await this.delivery.flushQueue();
+    const diagnostics = this.delivery.getDiagnostics();
+    this.offline = diagnostics.queued > 0;
+    this.lastError = diagnostics.lastError;
+    if (diagnostics.queued > 0) {
+      this.scheduleRetryFlush();
+    } else {
+      this.retryDelayMs = this.initialRetryDelayMs;
+    }
+  }
+  reset() {
+    this.identity = { anonymousId: resetAnonymousId(this.persistence) };
+    this.session.reset();
+    this.queue = [];
+    this.offline = false;
+    if (this.retryTimer !== void 0) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+    this.lifecycleCleanup?.();
+    this.lifecycleCleanup = void 0;
+    this.autocaptureCleanup?.();
+    this.autocaptureCleanup = void 0;
+    this.delivery.clearQueue("manual_clear");
+  }
+  disposeForTests() {
+    if (this.retryTimer !== void 0) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+    this.lifecycleCleanup?.();
+    this.lifecycleCleanup = void 0;
+    this.autocaptureCleanup?.();
+    this.autocaptureCleanup = void 0;
+  }
+  setConsent(consent) {
+    this.consentState = typeof consent === "object" ? mergeConsent(this.consentState, consent) : normalizeConsent(consent);
+    this.gdprConsent = this.consentState.analytics;
+    if (!canCollectPurpose(this.consentState, "analytics")) {
+      this.queue = [];
+      this.delivery.clearQueue("consent_revoked");
+    }
+  }
+  getHealth() {
+    const deliveryDiagnostics = this.delivery.getDiagnostics();
+    const health = {
+      initialized: this.initialized,
+      consent: this.gdprConsent,
+      consentPurposes: this.consentState,
+      persistence: this.persistence.getHealth(),
+      queueSize: deliveryDiagnostics.queued,
+      offline: this.offline || deliveryDiagnostics.queued > 0,
+      droppedEvents: this.droppedEvents + deliveryDiagnostics.dropped.length,
+      delivery: deliveryDiagnostics
+    };
+    const lastError2 = this.lastError ?? deliveryDiagnostics.lastError;
+    if (lastError2 !== void 0) health.lastError = lastError2;
+    if (this.lastDroppedEvent !== void 0) health.lastDroppedEvent = this.lastDroppedEvent;
+    return health;
+  }
+  sendEvent(payload) {
+    void this.delivery.send(payload).then(() => {
+      const diagnostics = this.delivery.getDiagnostics();
+      this.offline = diagnostics.queued > 0;
+      if (diagnostics.lastError !== void 0) {
+        this.lastError = diagnostics.lastError;
+      }
+      if (diagnostics.queued > 0) {
+        this.scheduleRetryFlush();
+      }
+    });
+  }
+  installLifecycleFlush() {
+    const browserWindow = getBrowserWindow();
+    if (!browserWindow) return;
+    if (typeof browserWindow.addEventListener !== "function") return;
+    if (typeof browserWindow.removeEventListener !== "function") return;
+    const flushOnLifecycle = () => {
+      void this.flush();
+    };
+    const flushOnVisibility = () => {
+      if (browserWindow.document?.visibilityState === "hidden") {
+        void this.flush();
+      }
+    };
+    browserWindow.addEventListener("online", flushOnLifecycle);
+    browserWindow.addEventListener("pagehide", flushOnLifecycle);
+    if (typeof browserWindow.document?.addEventListener === "function") {
+      browserWindow.document.addEventListener("visibilitychange", flushOnVisibility);
+    }
+    this.lifecycleCleanup = () => {
+      browserWindow.removeEventListener("online", flushOnLifecycle);
+      browserWindow.removeEventListener("pagehide", flushOnLifecycle);
+      if (typeof browserWindow.document?.removeEventListener === "function") {
+        browserWindow.document.removeEventListener("visibilitychange", flushOnVisibility);
+      }
+    };
+  }
+  installAutocapture() {
+    const browserWindow = getBrowserWindow();
+    if (!browserWindow) return;
+    if (this.config.autocapture === false) return;
+    const capturePageview = this.config.capturePageview !== false;
+    const capturePageleave = this.config.capturePageleave !== false;
+    const controller = installAutocapture({
+      browserWindow,
+      capturePageview,
+      capturePageleave,
+      onPageView: () => {
+        this.page();
+      },
+      onPageLeave: () => {
+        this.trackEvent("page_leave", { url: browserWindow.location.href });
+      },
+      onRouteChange: () => {
+        captureAttributionFromUrl(this.persistence);
+      }
+    });
+    this.autocaptureCleanup = controller.cleanup;
+  }
+  scheduleRetryFlush() {
+    if (this.retryTimer !== void 0) return;
+    const delay = Math.min(this.retryDelayMs, this.maxRetryDelayMs);
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      void this.flush().then(() => {
+        if (this.delivery.getDiagnostics().queued > 0) {
+          this.retryDelayMs = Math.min(this.retryDelayMs * 2, this.maxRetryDelayMs);
+          this.scheduleRetryFlush();
+        }
+      });
+    }, delay);
+  }
+  sendPreparedEvent(type, event, properties, options) {
+    void this.prepareAndSendEvent(type, event, properties, options);
+  }
+  async prepareAndSendEvent(type, event, properties, options) {
+    if (!canCollectPurpose(this.consentState, "analytics")) {
+      this.recordDrop(type, "consent_denied", event);
+      return;
+    }
+    let prepared = {
+      type,
+      event,
+      properties: sanitizeProperties(properties),
+      messageId: ensureUuid(options.messageId),
+      timestamp: options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      context: options.context ?? {},
+      anonymousId: this.identity.anonymousId,
+      clientId: this.config.clientId,
+      workspaceId: this.config.workspaceId,
+      appId: this.config.appId,
+      writeKey: this.writeKey,
+      consent: this.consentState,
+      sessionId: this.session.getSessionId()
+    };
+    if (this.identity.userId !== void 0) prepared.userId = this.identity.userId;
+    if (this.identity.groupId !== void 0) prepared.groupId = this.identity.groupId;
+    if (this.config.beforeSend !== void 0) {
+      const beforeSendResult = await this.config.beforeSend(prepared);
+      if (beforeSendResult === null) {
+        this.recordDrop(type, "before_send_dropped", event);
+        return;
+      }
+      prepared = {
+        ...prepared,
+        ...beforeSendResult,
+        properties: sanitizeProperties(beforeSendResult.properties ?? prepared.properties)
+      };
+    }
+    const validation = validateEventEnvelope(prepared, { mode: this.config.schemaValidation ?? "warn" });
+    if (!validation.ok && this.config.schemaValidation === "strict") {
+      this.recordDrop(type, "invalid_payload", event);
+      return;
+    }
+    if (!validation.ok) {
+      this.lastError = `DMD SDK schema warning: ${validation.errors.join(", ")}`;
+    }
+    const collectorPayload = this.toCollectorPayload(prepared);
+    const backendValidation = validateBackendCollectorPayload(collectorPayload);
+    if (!backendValidation.ok && this.config.schemaValidation === "strict") {
+      this.lastError = `DMD SDK backend schema warning: ${backendValidation.errors.join(", ")}`;
+      this.recordDrop(type, "invalid_payload", event);
+      return;
+    }
+    if (!backendValidation.ok) {
+      this.lastError = `DMD SDK backend schema warning: ${backendValidation.errors.join(", ")}`;
+    }
+    this.sendEvent(collectorPayload);
+  }
+  toCollectorPayload(prepared) {
+    const browserWindow = getBrowserWindow();
+    const pageContext = getBrowserPageContext();
+    return createBackendCollectorPayload({
+      requestId: prepared.messageId,
+      timestamp: prepared.timestamp,
+      eventType: prepared.event,
+      clientId: prepared.clientId,
+      workspaceId: prepared.workspaceId,
+      token: prepared.writeKey,
+      anonymousId: prepared.anonymousId,
+      sessionId: prepared.sessionId,
+      ua: browserWindow?.navigator?.userAgent,
+      appId: prepared.appId,
+      pageUrl: pageContext.url ?? browserWindow?.location?.href,
+      eventData: mergeStoredAttribution({
+        ...prepared.properties,
+        page: {
+          ...pageContext,
+          ...prepared.properties.page && typeof prepared.properties.page === "object" ? prepared.properties.page : {}
+        },
+        anonymousId: prepared.anonymousId,
+        sessionId: prepared.sessionId,
+        timestamp: prepared.timestamp,
+        requestSentAt: prepared.timestamp,
+        requestReceivedAt: prepared.timestamp
+      }, this.persistence)
+    });
+  }
+  recordDrop(type, reason, event) {
+    this.droppedEvents += 1;
+    this.lastDroppedEvent = {
+      type,
+      reason,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (event !== void 0) this.lastDroppedEvent.event = event;
+    this.lastError = `DMD SDK ${type} dropped because ${reason}`;
+  }
+};
+
+// src/browser/client.ts
+var singleton;
+var publicSingleton;
+var droppedEvents = 0;
+var lastError;
+var lastDroppedEvent;
+function createPublicClient(instance) {
+  return {
+    track(event, properties, options) {
+      instance.trackEvent(event, properties, options);
+    },
+    identify(userId, traits, options) {
+      instance.identify(userId, traits, options);
+    },
+    page(name, properties, options) {
+      instance.page(name, properties, options);
+    },
+    group(groupId, traits, options) {
+      instance.group(groupId, traits, options);
+    },
+    alias(previousId, userId, options) {
+      instance.alias(previousId, userId, options);
+    },
+    async flush() {
+      await instance.flush();
+    },
+    reset() {
+      instance.reset();
+      singleton = void 0;
+      publicSingleton = void 0;
+    },
+    setConsent(consent) {
+      instance.setConsent(consent);
+    },
+    getHealth() {
+      return instance.getHealth();
+    }
+  };
+}
+function setSingleton(instance) {
+  singleton = instance;
+  publicSingleton = createPublicClient(instance);
+  return publicSingleton;
+}
+function recordDroppedEvent(type, event) {
+  droppedEvents += 1;
+  lastDroppedEvent = {
+    type,
+    reason: "not_initialized",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (event !== void 0) {
+    lastDroppedEvent.event = event;
+  }
+  lastError = `DMD SDK ${type} called before initialization`;
+}
+function initDmdSDK(config) {
+  if (publicSingleton) {
+    return publicSingleton;
+  }
+  try {
+    const instance = new DriveMetaDataSDK(normalizeBrowserConfig(config));
+    return setSingleton(instance);
+  } catch (error) {
+    lastError = error instanceof Error ? error.message : String(error);
+    throw error;
+  }
+}
+function getDmdSDK() {
+  return publicSingleton;
+}
+function track(event, properties, options) {
+  const sdk = getDmdSDK();
+  if (!sdk) {
+    recordDroppedEvent("track", event);
+    return;
+  }
+  sdk.track(event, properties, options);
+}
+function identify(userId, traits, options) {
+  const sdk = getDmdSDK();
+  if (!sdk) {
+    recordDroppedEvent("identify");
+    return;
+  }
+  sdk.identify(userId, traits, options);
+}
+function page(name, properties, options) {
+  const sdk = getDmdSDK();
+  if (!sdk) {
+    recordDroppedEvent("page");
+    return;
+  }
+  sdk.page(name, properties, options);
+}
+function setConsent(consent) {
+  getDmdSDK()?.setConsent(consent);
+}
+function getDmdHealth() {
+  if (singleton) {
+    return singleton.getHealth();
+  }
+  const health = {
+    initialized: false,
+    consent: "pending",
+    queueSize: 0,
+    offline: false,
+    droppedEvents
+  };
+  if (lastError !== void 0) {
+    health.lastError = lastError;
+  }
+  if (lastDroppedEvent !== void 0) {
+    health.lastDroppedEvent = lastDroppedEvent;
+  }
+  return health;
+}
+
+// src/react/DmdProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var DmdContext = React.createContext(void 0);
+function DmdProvider({
+  config,
+  children,
+  enabled = true,
+  onReady,
+  onError
+}) {
+  const [client, setClient] = React.useState(() => getDmdSDK());
+  React.useEffect(() => {
+    if (!enabled) return;
+    try {
+      const initializedClient = initDmdSDK(config);
+      const configuredConsent = config.gdprConsent ?? config.consent;
+      if (configuredConsent !== void 0) {
+        initializedClient.setConsent(configuredConsent);
+      }
+      setClient(initializedClient);
+      onReady?.(initializedClient);
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      onError?.(normalizedError);
+    }
+  }, [
+    enabled,
+    config.clientId,
+    config.workspaceId,
+    config.appId,
+    config.writeKey,
+    config.token,
+    config.apiHost,
+    config.consent,
+    config.gdprConsent,
+    onReady,
+    onError
+  ]);
+  return /* @__PURE__ */ jsx(DmdContext.Provider, { value: client, children });
+}
+
+// src/next/useDmdAppRouterPageTracking.ts
+import React2 from "react";
+function useDmdAppRouterPageTracking(pathname, search, options = {}) {
+  const lastRouteKey = React2.useRef(void 0);
+  const routeKey = pathname ? `${pathname}?${search ?? ""}` : "";
+  React2.useEffect(() => {
+    if (!pathname || !routeKey || lastRouteKey.current === routeKey) return;
+    lastRouteKey.current = routeKey;
+    page(options.name, {
+      ...options.properties,
+      pathname,
+      search: search ?? ""
+    });
+  }, [options.name, options.properties, pathname, routeKey, search]);
+}
+
+// src/next/useDmdPagesRouterPageTracking.ts
+import React3 from "react";
+function useDmdPagesRouterPageTracking(router, options = {}) {
+  const lastRouteKey = React3.useRef(void 0);
+  const routeKey = router?.asPath ?? router?.pathname ?? "";
+  React3.useEffect(() => {
+    if (!routeKey || lastRouteKey.current === routeKey) return;
+    lastRouteKey.current = routeKey;
+    page(options.name, {
+      ...options.properties,
+      route: routeKey
+    });
+  }, [options.name, options.properties, routeKey]);
+}
+
+// src/react/hooks.ts
+import React4 from "react";
+function useDmdSDK() {
+  return React4.useContext(DmdContext);
+}
+function useTrackEvent() {
+  return React4.useCallback((event, properties, options) => {
+    track(event, properties, options);
+  }, []);
+}
+function useIdentify() {
+  return React4.useCallback((userId, traits) => {
+    identify(userId, traits);
+  }, []);
+}
+function useDmdConsent() {
+  return React4.useCallback((consent) => {
+    setConsent(consent);
+  }, []);
+}
+function useDmdHealth() {
+  const client = useDmdSDK();
+  const [health, setHealth] = React4.useState(() => getDmdHealth());
+  React4.useEffect(() => {
+    setHealth(getDmdHealth());
+  }, [client]);
+  return health;
+}
+export {
+  DmdProvider,
+  useDmdAppRouterPageTracking,
+  useDmdConsent,
+  useDmdHealth,
+  useDmdPagesRouterPageTracking,
+  useDmdSDK,
+  useIdentify,
+  useTrackEvent
+};
+//# sourceMappingURL=index.js.map