@drivemetadata-ai/sdk 0.1.1-beta.1

package/dist/react/index.cjs

@@ -0,0 +1,999 @@
+"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/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  DmdProvider: () => DmdProvider,
+  useAlias: () => useAlias,
+  useDmdConsent: () => useDmdConsent,
+  useDmdFlush: () => useDmdFlush,
+  useDmdHealth: () => useDmdHealth,
+  useDmdSDK: () => useDmdSDK,
+  useGroup: () => useGroup,
+  useIdentify: () => useIdentify,
+  usePage: () => usePage,
+  useReset: () => useReset,
+  useTrackEvent: () => useTrackEvent
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/DmdProvider.tsx
+var import_react = __toESM(require("react"), 1);
+
+// src/core/config.ts
+function requireString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`DMD SDK config ${field} is required`);
+  }
+  return value;
+}
+function normalizeBrowserConfig(config) {
+  const writeKey = config.writeKey || config.token;
+  const legacyConfig = {
+    client_id: requireString(config.clientId, "clientId"),
+    workspace_id: requireString(config.workspaceId, "workspaceId"),
+    app_id: requireString(config.appId, "appId"),
+    token: requireString(writeKey, "writeKey")
+  };
+  if (config.apiHost !== void 0) legacyConfig.api_host = config.apiHost;
+  if (config.uiHost !== void 0) legacyConfig.ui_host = config.uiHost;
+  if (config.deeplink !== void 0) legacyConfig.deeplink = config.deeplink;
+  if (config.debug !== void 0) legacyConfig.debug = config.debug;
+  if (config.consent !== void 0) legacyConfig.consent = config.consent;
+  if (config.gdprConsent !== void 0) legacyConfig.gdprConsent = config.gdprConsent;
+  if (config.autocapture !== void 0) legacyConfig.autocapture = config.autocapture;
+  if (config.capturePageview !== void 0) legacyConfig.capture_pageview = config.capturePageview;
+  if (config.capturePageleave !== void 0) legacyConfig.capture_pageleave = config.capturePageleave;
+  if (config.captureDeadClicks !== void 0) legacyConfig.capture_dead_clicks = config.captureDeadClicks;
+  if (config.crossSubdomainCookie !== void 0) legacyConfig.cross_subdomain_cookie = config.crossSubdomainCookie;
+  if (config.disablePersistence !== void 0) legacyConfig.disable_persistence = config.disablePersistence;
+  if (config.disableSurveys !== void 0) legacyConfig.disable_surveys = config.disableSurveys;
+  if (config.disableSessionRecording !== void 0) legacyConfig.disable_session_recording = config.disableSessionRecording;
+  if (config.enableHeatmaps !== void 0) legacyConfig.enable_heatmaps = config.enableHeatmaps;
+  if (config.maskAllText !== void 0) legacyConfig.mask_all_text = config.maskAllText;
+  if (config.maskAllElementAttributes !== void 0) {
+    legacyConfig.mask_all_element_attributes = config.maskAllElementAttributes;
+  }
+  if (config.persistence !== void 0) legacyConfig.persistence = config.persistence;
+  if (config.propertyDenylist !== void 0) legacyConfig.property_denylist = config.propertyDenylist;
+  if (config.sessionIdleTimeoutSeconds !== void 0) {
+    legacyConfig.session_idle_timeout_seconds = config.sessionIdleTimeoutSeconds;
+  }
+  if (config.beforeSend !== void 0) legacyConfig.before_send = config.beforeSend;
+  return legacyConfig;
+}
+
+// src/core/environment.ts
+function isBrowserRuntime() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function getBrowserWindow() {
+  return typeof window === "undefined" ? void 0 : window;
+}
+
+// src/browser/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/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 event = String(payload.event ?? payload.type ?? "event");
+  const properties = 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;
+  const maxPayloadBytes = config.maxPayloadBytes ?? 64e3;
+  function recordDrop(event) {
+    diagnostics.dropped.push(event);
+    config.onDrop?.(event);
+  }
+  function recordError(error) {
+    diagnostics.lastError = error.message;
+    config.onError?.(error);
+  }
+  function payloadByteLength(payload) {
+    const serialized = JSON.stringify(payload);
+    if (typeof TextEncoder !== "undefined") {
+      return new TextEncoder().encode(serialized).length;
+    }
+    return serialized.length;
+  }
+  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 messageId = String(payload.messageId ?? createId("msg"));
+    return {
+      ...payload,
+      messageId,
+      idempotencyKey: String(payload.idempotencyKey ?? createIdempotencyKey(payload, messageId))
+    };
+  }
+  async function deliver(body) {
+    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);
+      if (payloadByteLength(body) > maxPayloadBytes) {
+        recordDrop({
+          messageId: String(body.messageId),
+          reason: "payload_too_large",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return;
+      }
+      diagnostics.inFlight += 1;
+      try {
+        await deliver(body);
+      } catch (error) {
+        const deliveryError = error instanceof Error ? error : new Error(String(error));
+        recordError(deliveryError);
+        enqueue({
+          messageId: String(body.messageId),
+          savedAt: Date.now(),
+          attempts: 1,
+          lastError: deliveryError.message,
+          payload: body
+        });
+      } 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/privacy.ts
+var sensitiveKeys = /* @__PURE__ */ new Set([
+  "email",
+  "phone",
+  "mobile",
+  "address",
+  "address1",
+  "address2",
+  "first_name",
+  "last_name",
+  "name",
+  "token",
+  "secret",
+  "password",
+  "session",
+  "cookie"
+]);
+function sanitizeValue(value, allow) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeValue(item, allow));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([key]) => !sensitiveKeys.has(key.toLowerCase()) || allow.has(key.toLowerCase())).map(([key, nestedValue]) => [key, sanitizeValue(nestedValue, allow)])
+    );
+  }
+  return value;
+}
+function sanitizeProperties(input, allowRawKeys = []) {
+  const allow = new Set(allowRawKeys.map((key) => key.toLowerCase()));
+  return sanitizeValue(input, allow);
+}
+
+// src/browser/core/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/browser/core/DriveMetaDataSDK.ts
+function createId2(prefix) {
+  return `${prefix}_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function endpointFromConfig(config) {
+  const host = config.apiHost ?? "https://sdk.drivemetadata.com/v2";
+  return `${host.replace(/\/$/, "")}/data-collector`;
+}
+function getBrowserStorage() {
+  const browserWindow = getBrowserWindow();
+  try {
+    return browserWindow?.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+var DriveMetaDataSDK = class {
+  constructor(config) {
+    this.initialized = true;
+    this.queue = [];
+    this.offline = false;
+    this.droppedEvents = 0;
+    this.config = config;
+    this.endpoint = endpointFromConfig(config);
+    const storage = getBrowserStorage();
+    const deliveryConfig = {
+      endpoint: this.endpoint
+    };
+    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?.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(storage ? {
+      ...deliveryConfig,
+      storage
+    } : 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: createId2("anon") };
+    this.consentState = normalizeConsent(config.gdprConsent ?? config.consent);
+    this.gdprConsent = this.consentState.analytics;
+    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: createId2("anon") };
+    this.queue = [];
+    this.offline = false;
+    if (this.retryTimer !== void 0) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+    this.lifecycleCleanup?.();
+    this.lifecycleCleanup = void 0;
+    this.delivery.clearQueue("manual_clear");
+  }
+  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,
+      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;
+      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);
+      }
+    };
+  }
+  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: options.messageId ?? createId2("msg"),
+      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
+    };
+    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(", ")}`;
+    }
+    this.sendEvent(prepared);
+  }
+  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/legacy-loader.ts
+function getLegacySdkInstanceFromWindow() {
+  const browserWindow = getBrowserWindow();
+  return browserWindow?.__DriveMetaDataSDKInstance;
+}
+function ensureLegacySdkLoaded() {
+  if (!isBrowserRuntime()) {
+    throw new Error("DMD legacy SDK is only available in a browser runtime");
+  }
+  const browserWindow = getBrowserWindow();
+  if (!browserWindow?.DriveMetaDataSDK) {
+    throw new Error("DMD legacy SDK constructor is missing from window.DriveMetaDataSDK");
+  }
+  return browserWindow.DriveMetaDataSDK;
+}
+
+// src/browser/client.ts
+var singleton;
+var publicSingleton;
+var droppedEvents = 0;
+var lastError;
+var lastDroppedEvent;
+function createPublicClient(instance) {
+  return {
+    __legacy: instance,
+    track(event, properties, options) {
+      if (instance.trackEvent) {
+        instance.trackEvent(event, properties, options);
+        return;
+      }
+      instance.sendEvent?.({ eventName: event, event, properties, options });
+    },
+    identify(userId, traits, options) {
+      if (instance.identify) {
+        instance.identify(userId, traits, options);
+        return;
+      }
+      instance.identifyUser?.(userId, traits);
+    },
+    page(name, properties, options) {
+      if (instance.page) {
+        instance.page(name, properties, options);
+        return;
+      }
+      instance.trackPageview?.();
+    },
+    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) {
+      if (instance.setConsent) {
+        instance.setConsent(consent);
+        return;
+      }
+      if (typeof consent === "string") {
+        instance.gdprConsent = consent;
+      }
+    },
+    getHealth() {
+      if (instance.getHealth) {
+        return instance.getHealth();
+      }
+      return getDmdHealth();
+    }
+  };
+}
+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;
+  }
+  const legacyConfig = normalizeBrowserConfig(config);
+  const existingInstance = getLegacySdkInstanceFromWindow();
+  if (existingInstance) {
+    return setSingleton(existingInstance);
+  }
+  try {
+    let instance;
+    try {
+      const LegacySdk = ensureLegacySdkLoaded();
+      instance = new LegacySdk(legacyConfig);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("constructor is missing")) {
+        instance = new DriveMetaDataSDK(config);
+      } else {
+        throw error;
+      }
+    }
+    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 group(groupId, traits, options) {
+  const sdk = getDmdSDK();
+  if (!sdk) {
+    recordDroppedEvent("group");
+    return;
+  }
+  sdk.group(groupId, traits, options);
+}
+function alias(previousId, userId, options) {
+  const sdk = getDmdSDK();
+  if (!sdk) {
+    recordDroppedEvent("alias");
+    return;
+  }
+  sdk.alias(previousId, userId, options);
+}
+async function flush() {
+  const sdk = getDmdSDK();
+  if (!sdk) {
+    recordDroppedEvent("flush");
+    return;
+  }
+  await sdk.flush();
+}
+function reset() {
+  singleton?.reset?.();
+  singleton = void 0;
+  publicSingleton = void 0;
+}
+function setConsent(consent) {
+  getDmdSDK()?.setConsent(consent);
+}
+function getDmdHealth() {
+  if (singleton?.getHealth) {
+    return singleton.getHealth();
+  }
+  const health = {
+    initialized: Boolean(singleton?.initialized ?? singleton),
+    consent: singleton?.gdprConsent ?? "pending",
+    queueSize: singleton?.queue?.length ?? 0,
+    offline: Boolean(singleton?.offline),
+    droppedEvents
+  };
+  if (lastError !== void 0) {
+    health.lastError = lastError;
+  }
+  if (lastDroppedEvent !== void 0) {
+    health.lastDroppedEvent = lastDroppedEvent;
+  }
+  return health;
+}
+
+// src/react/DmdProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var DmdContext = import_react.default.createContext(void 0);
+function DmdProvider({
+  config,
+  children,
+  enabled = true,
+  onReady,
+  onError
+}) {
+  const [client, setClient] = import_react.default.useState(() => getDmdSDK());
+  import_react.default.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.apiHost,
+    config.consent,
+    config.gdprConsent,
+    onReady,
+    onError
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DmdContext.Provider, { value: client, children });
+}
+
+// src/react/hooks.ts
+var import_react2 = __toESM(require("react"), 1);
+function useDmdSDK() {
+  return import_react2.default.useContext(DmdContext);
+}
+function useTrackEvent() {
+  return import_react2.default.useCallback((event, properties, options) => {
+    track(event, properties, options);
+  }, []);
+}
+function useIdentify() {
+  return import_react2.default.useCallback((userId, traits) => {
+    identify(userId, traits);
+  }, []);
+}
+function usePage() {
+  return import_react2.default.useCallback((name, properties, options) => {
+    page(name, properties, options);
+  }, []);
+}
+function useGroup() {
+  return import_react2.default.useCallback((groupId, traits, options) => {
+    group(groupId, traits, options);
+  }, []);
+}
+function useAlias() {
+  return import_react2.default.useCallback((previousId, userId, options) => {
+    alias(previousId, userId, options);
+  }, []);
+}
+function useReset() {
+  return import_react2.default.useCallback(() => {
+    reset();
+  }, []);
+}
+function useDmdFlush() {
+  return import_react2.default.useCallback(async () => {
+    await flush();
+  }, []);
+}
+function useDmdConsent() {
+  return import_react2.default.useCallback((consent) => {
+    setConsent(consent);
+  }, []);
+}
+function useDmdHealth() {
+  const client = useDmdSDK();
+  const [health, setHealth] = import_react2.default.useState(() => getDmdHealth());
+  import_react2.default.useEffect(() => {
+    setHealth(getDmdHealth());
+  }, [client]);
+  return health;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DmdProvider,
+  useAlias,
+  useDmdConsent,
+  useDmdFlush,
+  useDmdHealth,
+  useDmdSDK,
+  useGroup,
+  useIdentify,
+  usePage,
+  useReset,
+  useTrackEvent
+});
+//# sourceMappingURL=index.cjs.map