@drivemetadata-ai/sdk 0.1.1-beta.2 → 0.1.1

package/dist/browser/index.js

@@ -1,9 +1,59 @@
+// 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) {
-  if (typeof value !== "string") return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) return value;
-  return date.toISOString().replace("T", " ").slice(0, 19);
+  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)) {
@@ -34,15 +84,19 @@ function createBackendCollectorPayload(input) {
   };
   const metaData = {
     ...normalizedEventData,
-    requestId: input.requestId,
+    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: eventData.anonymousId ?? input.anonymousId,
-    sessionId: eventData.sessionId ?? input.sessionId,
+    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 },
@@ -53,12 +107,45 @@ function createBackendCollectorPayload(input) {
   return cleanObject(payload);
 }
 
-// src/core/environment.ts
-function getBrowserWindow() {
-  return typeof window === "undefined" ? void 0 : window;
+// 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/browser/core/consent.ts
+// src/core/consent.ts
 var purposes = [
   "analytics",
   "advertising",
@@ -98,6 +185,476 @@ function canCollectPurpose(consent2, purpose) {
   return consent2[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/browser/core/attribute-persistence.ts
+var DMD_ATTRIBUTES_STORAGE_KEY = "dmd_attributes";
+var SESSION_STORAGE_KEY = "sessionData";
+var SESSION_ID_KEY = "sessionId";
+var SESSION_TIMESTAMP_KEY = "timestamp";
+function isBlankValue(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+}
+function readAttributes(base) {
+  const raw = base.getItem(DMD_ATTRIBUTES_STORAGE_KEY);
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    base.removeItem(DMD_ATTRIBUTES_STORAGE_KEY);
+    return {};
+  }
+}
+function sanitizeAttributes(attributes) {
+  return Object.fromEntries(Object.entries(attributes).filter(([, value]) => !isBlankValue(value)));
+}
+function writeAttributes(base, attributes) {
+  const sanitized = sanitizeAttributes(attributes);
+  if (Object.keys(sanitized).length === 0) {
+    base.removeItem(DMD_ATTRIBUTES_STORAGE_KEY);
+    return;
+  }
+  base.setItem(DMD_ATTRIBUTES_STORAGE_KEY, JSON.stringify(sanitized));
+}
+function parseSessionData(value) {
+  try {
+    const parsed = JSON.parse(value);
+    const sessionData = {};
+    const sessionId = typeof parsed.sessionId === "string" && parsed.sessionId.trim() !== "" ? parsed.sessionId : void 0;
+    const timestamp = typeof parsed.timestamp === "number" ? parsed.timestamp : void 0;
+    if (sessionId !== void 0) sessionData.sessionId = sessionId;
+    if (timestamp !== void 0) sessionData.timestamp = timestamp;
+    return sessionData;
+  } catch {
+    return {};
+  }
+}
+function getAggregateValue(attributes, key) {
+  if (key === SESSION_STORAGE_KEY) {
+    const sessionId = attributes[SESSION_ID_KEY];
+    const timestamp = attributes[SESSION_TIMESTAMP_KEY];
+    if (typeof sessionId === "string" && !isBlankValue(sessionId) && typeof timestamp === "number") {
+      return JSON.stringify({ sessionId, timestamp });
+    }
+    return null;
+  }
+  const value = attributes[key];
+  if (isBlankValue(value)) return null;
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function setAggregateValue(attributes, key, value) {
+  if (key === SESSION_STORAGE_KEY) {
+    const sessionData = parseSessionData(value);
+    if (sessionData.sessionId === void 0 || sessionData.timestamp === void 0) {
+      delete attributes[SESSION_ID_KEY];
+      delete attributes[SESSION_TIMESTAMP_KEY];
+      return;
+    }
+    attributes[SESSION_ID_KEY] = sessionData.sessionId;
+    attributes[SESSION_TIMESTAMP_KEY] = sessionData.timestamp;
+    return;
+  }
+  attributes[key] = value;
+}
+function removeAggregateValue(attributes, key) {
+  if (key === SESSION_STORAGE_KEY) {
+    delete attributes[SESSION_ID_KEY];
+    delete attributes[SESSION_TIMESTAMP_KEY];
+    return;
+  }
+  delete attributes[key];
+}
+function createDmdAttributesPersistence(base) {
+  return {
+    getItem(key) {
+      if (key === DMD_ATTRIBUTES_STORAGE_KEY) return base.getItem(key);
+      const attributes = readAttributes(base);
+      const aggregateValue = getAggregateValue(attributes, key);
+      if (aggregateValue !== null) return aggregateValue;
+      const legacyValue = base.getItem(key);
+      if (isBlankValue(legacyValue)) return null;
+      setAggregateValue(attributes, key, String(legacyValue));
+      writeAttributes(base, attributes);
+      return legacyValue;
+    },
+    setItem(key, value) {
+      if (key === DMD_ATTRIBUTES_STORAGE_KEY) return base.setItem(key, value);
+      const attributes = readAttributes(base);
+      if (isBlankValue(value)) {
+        removeAggregateValue(attributes, key);
+        writeAttributes(base, attributes);
+        base.removeItem(key);
+        return true;
+      }
+      setAggregateValue(attributes, key, value);
+      writeAttributes(base, attributes);
+      base.setItem(key, value);
+      return true;
+    },
+    removeItem(key) {
+      if (key === DMD_ATTRIBUTES_STORAGE_KEY) {
+        base.removeItem(key);
+        return;
+      }
+      const attributes = readAttributes(base);
+      removeAggregateValue(attributes, key);
+      writeAttributes(base, attributes);
+      base.removeItem(key);
+    },
+    getHealth() {
+      return base.getHealth();
+    }
+  };
+}
+
+// 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
+var DMD_CLICK_ID_QUERY_KEY = "click_id";
+var DMD_CLICK_ID_LEGACY_QUERY_KEY = "dmd_click_id";
+var DMD_CLICK_ID_STORAGE_KEY = "dmd_click_id";
+var DMD_CLICK_ID_ATTRIBUTE_KEY = "click_id";
+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 getClickIdParam(params) {
+  return params.get(DMD_CLICK_ID_LEGACY_QUERY_KEY) || params.get(DMD_CLICK_ID_QUERY_KEY);
+}
+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));
+  }
+  const clickId = getClickIdParam(params);
+  setIfPresent(persistence, DMD_CLICK_ID_ATTRIBUTE_KEY, clickId);
+  setIfPresent(persistence, DMD_CLICK_ID_STORAGE_KEY, clickId);
+  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"),
+    click_id: getStoredString(persistence, DMD_CLICK_ID_STORAGE_KEY) ?? getStoredString(persistence, DMD_CLICK_ID_ATTRIBUTE_KEY)
+  });
+}
+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)}`;
@@ -129,7 +686,6 @@ function createDeliveryManager(config) {
   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);
@@ -138,12 +694,22 @@ function createDeliveryManager(config) {
     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;
+  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;
     }
-    return serialized.length;
+    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({
@@ -233,7 +799,19 @@ function createDeliveryManager(config) {
       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");
@@ -250,26 +828,22 @@ function createDeliveryManager(config) {
   return {
     async send(payload) {
       const body = withEnvelope(payload);
-      if (payloadByteLength(body) > maxPayloadBytes) {
-        recordDrop({
-          messageId: String(body.metaData?.requestId ?? body.messageId),
-          reason: "payload_too_large",
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
+      const preparedBody = preparePayloadForSend(body);
+      if (!preparedBody) {
         return;
       }
       diagnostics.inFlight += 1;
       try {
-        await deliver(body);
+        await deliver(preparedBody);
       } catch (error) {
         const deliveryError = error instanceof Error ? error : new Error(String(error));
         recordError(deliveryError);
         enqueue({
-          messageId: String(body.metaData?.requestId ?? body.messageId),
+          messageId: String(getPayloadMessageId(body)),
           savedAt: Date.now(),
           attempts: 1,
           lastError: deliveryError.message,
-          payload: body
+          payload: preparedBody
         });
       } finally {
         diagnostics.inFlight -= 1;
@@ -382,60 +956,286 @@ function createDeliveryManager(config) {
   };
 }
 
-// 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));
+// 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;
   }
-  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)])
-    );
+}
+function resolveAnonymousId(persistence) {
+  const urlAnonymousId = getUrlParam("aid");
+  if (isUuid(urlAnonymousId)) {
+    persistence.setItem(ANONYMOUS_ID_STORAGE_KEY, urlAnonymousId);
+    return urlAnonymousId;
   }
-  return value;
+  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 sanitizeProperties(input, allowRawKeys = []) {
-  const allow = new Set(allowRawKeys.map((key) => key.toLowerCase()));
-  return sanitizeValue(input, allow);
+function resetAnonymousId(persistence) {
+  const anonymousId = createUuid();
+  persistence.setItem(ANONYMOUS_ID_STORAGE_KEY, anonymousId);
+  return anonymousId;
 }
 
-// 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");
+// 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();
   }
-  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`);
+}
+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;
   }
-  return { ok: errors.length === 0, errors };
+}
+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/DriveMetaDataSDK.ts
-function createId2(prefix) {
-  return `${prefix}_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+// src/browser/core/session.ts
+var SESSION_STORAGE_KEY2 = "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_KEY2);
+  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_KEY2);
+  }
+  return void 0;
+}
+function writeStoredSession(persistence, sessionId, timestamp) {
+  persistence.setItem(SESSION_STORAGE_KEY2, 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`;
@@ -446,14 +1246,6 @@ function requireConfigString(value, field) {
   }
   return value;
 }
-function getBrowserStorage() {
-  const browserWindow = getBrowserWindow();
-  try {
-    return browserWindow?.localStorage;
-  } catch {
-    return void 0;
-  }
-}
 var DriveMetaDataSDK = class {
   constructor(config) {
     this.initialized = true;
@@ -466,30 +1258,36 @@ var DriveMetaDataSDK = class {
     requireConfigString(config.writeKey || config.token, "writeKey or token");
     this.config = config;
     this.endpoint = endpointFromConfig(config);
-    const storage = getBrowserStorage();
+    const storagePersistence = createBrowserPersistence(config.persistence);
+    this.persistence = createDmdAttributesPersistence(storagePersistence);
+    this.session = createSessionManager(this.persistence, config.sessionIdleTimeoutSeconds);
     const deliveryConfig = {
-      endpoint: this.endpoint
+      endpoint: this.endpoint,
+      storage: storagePersistence
     };
     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(storage ? {
-      ...deliveryConfig,
-      storage
-    } : deliveryConfig);
+    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: createId2("anon") };
-    this.sessionId = createId2("session");
+    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();
     }
@@ -529,7 +1327,8 @@ var DriveMetaDataSDK = class {
     }
   }
   reset() {
-    this.identity = { anonymousId: createId2("anon") };
+    this.identity = { anonymousId: resetAnonymousId(this.persistence) };
+    this.session.reset();
     this.queue = [];
     this.offline = false;
     if (this.retryTimer !== void 0) {
@@ -538,8 +1337,20 @@ var DriveMetaDataSDK = class {
     }
     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(consent2) {
     this.consentState = typeof consent2 === "object" ? mergeConsent(this.consentState, consent2) : normalizeConsent(consent2);
     this.gdprConsent = this.consentState.analytics;
@@ -554,6 +1365,7 @@ var DriveMetaDataSDK = class {
       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,
@@ -568,7 +1380,9 @@ var DriveMetaDataSDK = class {
     void this.delivery.send(payload).then(() => {
       const diagnostics = this.delivery.getDiagnostics();
       this.offline = diagnostics.queued > 0;
-      this.lastError = diagnostics.lastError;
+      if (diagnostics.lastError !== void 0) {
+        this.lastError = diagnostics.lastError;
+      }
       if (diagnostics.queued > 0) {
         this.scheduleRetryFlush();
       }
@@ -600,6 +1414,28 @@ var DriveMetaDataSDK = class {
       }
     };
   }
+  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);
@@ -625,7 +1461,7 @@ var DriveMetaDataSDK = class {
       type,
       event,
       properties: sanitizeProperties(properties),
-      messageId: options.messageId ?? createId2("msg"),
+      messageId: ensureUuid(options.messageId),
       timestamp: options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
       context: options.context ?? {},
       anonymousId: this.identity.anonymousId,
@@ -634,7 +1470,7 @@ var DriveMetaDataSDK = class {
       appId: this.config.appId,
       writeKey: this.writeKey,
       consent: this.consentState,
-      sessionId: this.sessionId
+      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;
@@ -658,10 +1494,21 @@ var DriveMetaDataSDK = class {
     if (!validation.ok) {
       this.lastError = `DMD SDK schema warning: ${validation.errors.join(", ")}`;
     }
-    this.sendEvent(this.toCollectorPayload(prepared));
+    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,
@@ -673,15 +1520,19 @@ var DriveMetaDataSDK = class {
       sessionId: prepared.sessionId,
       ua: browserWindow?.navigator?.userAgent,
       appId: prepared.appId,
-      pageUrl: browserWindow?.location?.href,
-      eventData: {
+      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) {
@@ -757,7 +1608,7 @@ function initDmdSDK(config) {
     return publicSingleton;
   }
   try {
-    const instance = new DriveMetaDataSDK(config);
+    const instance = new DriveMetaDataSDK(normalizeBrowserConfig(config));
     return setSingleton(instance);
   } catch (error) {
     lastError = error instanceof Error ? error.message : String(error);
@@ -851,7 +1702,7 @@ function getDmdHealth() {
   return health;
 }
 function resetDmdSDKForTests() {
-  singleton?.reset();
+  singleton?.disposeForTests();
   singleton = void 0;
   publicSingleton = void 0;
   droppedEvents = 0;