@analyticscli/sdk 0.1.0-preview.10

package/dist/browser.cjs

@@ -0,0 +1,1978 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  AnalyticsClient: () => AnalyticsClient,
+  ONBOARDING_EVENTS: () => ONBOARDING_EVENTS,
+  ONBOARDING_PROGRESS_EVENT_ORDER: () => ONBOARDING_PROGRESS_EVENT_ORDER,
+  ONBOARDING_SCREEN_EVENT_PREFIXES: () => ONBOARDING_SCREEN_EVENT_PREFIXES,
+  ONBOARDING_SURVEY_EVENTS: () => ONBOARDING_SURVEY_EVENTS,
+  PAYWALL_ANCHOR_EVENT_CANDIDATES: () => PAYWALL_ANCHOR_EVENT_CANDIDATES,
+  PAYWALL_EVENTS: () => PAYWALL_EVENTS,
+  PAYWALL_JOURNEY_EVENT_ORDER: () => PAYWALL_JOURNEY_EVENT_ORDER,
+  PAYWALL_SKIP_EVENT_CANDIDATES: () => PAYWALL_SKIP_EVENT_CANDIDATES,
+  PURCHASE_EVENTS: () => PURCHASE_EVENTS,
+  PURCHASE_SUCCESS_EVENT_CANDIDATES: () => PURCHASE_SUCCESS_EVENT_CANDIDATES,
+  createAnalyticsContext: () => createAnalyticsContext,
+  init: () => init,
+  initAsync: () => initAsync,
+  initConsentFirst: () => initConsentFirst,
+  initConsentFirstAsync: () => initConsentFirstAsync
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/sdk-contract.ts
+var DEFAULT_INGEST_LIMITS = {
+  maxBatchSize: 50,
+  maxPayloadBytes: 128 * 1024
+};
+var ONBOARDING_EVENTS = {
+  START: "onboarding:start",
+  STEP_VIEW: "onboarding:step_view",
+  STEP_COMPLETE: "onboarding:step_complete",
+  COMPLETE: "onboarding:complete",
+  SKIP: "onboarding:skip"
+};
+var PAYWALL_EVENTS = {
+  SHOWN: "paywall:shown",
+  SKIP: "paywall:skip"
+};
+var PURCHASE_EVENTS = {
+  STARTED: "purchase:started",
+  SUCCESS: "purchase:success",
+  FAILED: "purchase:failed",
+  CANCEL: "purchase:cancel"
+};
+var ONBOARDING_SURVEY_EVENTS = {
+  RESPONSE: "onboarding:survey_response"
+};
+var ONBOARDING_PROGRESS_EVENT_ORDER = [
+  ONBOARDING_EVENTS.COMPLETE,
+  ONBOARDING_EVENTS.SKIP
+];
+var PAYWALL_JOURNEY_EVENT_ORDER = [
+  PAYWALL_EVENTS.SHOWN,
+  PAYWALL_EVENTS.SKIP,
+  PURCHASE_EVENTS.SUCCESS,
+  PURCHASE_EVENTS.FAILED
+];
+var ONBOARDING_SCREEN_EVENT_PREFIXES = ["screen:onboarding", "screen:onboarding_"];
+var PAYWALL_ANCHOR_EVENT_CANDIDATES = [PAYWALL_EVENTS.SHOWN];
+var PAYWALL_SKIP_EVENT_CANDIDATES = [PAYWALL_EVENTS.SKIP];
+var PURCHASE_SUCCESS_EVENT_CANDIDATES = [PURCHASE_EVENTS.SUCCESS];
+var RESERVED_PII_KEYS = /* @__PURE__ */ new Set([
+  "email",
+  "phone",
+  "firstName",
+  "lastName",
+  "fullName",
+  "address",
+  "ssn",
+  "creditCard"
+]);
+var EVENT_NAME_REGEX = /^[a-zA-Z0-9_:\-.]{1,100}$/;
+
+// src/ingest-validation.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var ISO_DATETIME_WITH_OFFSET_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+var TYPE_VALUES = /* @__PURE__ */ new Set(["track", "screen", "identify", "feedback"]);
+var isRecord = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var isStringBetween = (value, min, max) => {
+  return typeof value === "string" && value.length >= min && value.length <= max;
+};
+var isOptionalStringMax = (value, max) => {
+  return value === void 0 || typeof value === "string" && value.length <= max;
+};
+var isNullableOptionalStringBetween = (value, min, max) => {
+  return value === void 0 || value === null || isStringBetween(value, min, max);
+};
+var isIsoDatetimeWithOffset = (value) => {
+  if (typeof value !== "string" || !ISO_DATETIME_WITH_OFFSET_REGEX.test(value)) {
+    return false;
+  }
+  return Number.isFinite(Date.parse(value));
+};
+var validateEvent = (event, index) => {
+  if (!isRecord(event)) {
+    return { success: false, reason: `events[${index}] is not an object` };
+  }
+  if (!isStringBetween(event.eventName, 1, 100) || !EVENT_NAME_REGEX.test(event.eventName)) {
+    return { success: false, reason: `events[${index}].eventName is invalid` };
+  }
+  if (!isStringBetween(event.sessionId, 1, 128)) {
+    return { success: false, reason: `events[${index}].sessionId is invalid` };
+  }
+  if (!isStringBetween(event.anonId, 1, 128)) {
+    return { success: false, reason: `events[${index}].anonId is invalid` };
+  }
+  if (!isNullableOptionalStringBetween(event.userId, 1, 128)) {
+    return { success: false, reason: `events[${index}].userId is invalid` };
+  }
+  if (!isRecord(event.properties)) {
+    return { success: false, reason: `events[${index}].properties is invalid` };
+  }
+  if (!isOptionalStringMax(event.platform, 64)) {
+    return { success: false, reason: `events[${index}].platform is invalid` };
+  }
+  if (!isOptionalStringMax(event.projectSurface, 64)) {
+    return { success: false, reason: `events[${index}].projectSurface is invalid` };
+  }
+  if (!isOptionalStringMax(event.appVersion, 64)) {
+    return { success: false, reason: `events[${index}].appVersion is invalid` };
+  }
+  if (!isOptionalStringMax(event.appBuild, 64)) {
+    return { success: false, reason: `events[${index}].appBuild is invalid` };
+  }
+  if (!isOptionalStringMax(event.osName, 64)) {
+    return { success: false, reason: `events[${index}].osName is invalid` };
+  }
+  if (!isOptionalStringMax(event.osVersion, 64)) {
+    return { success: false, reason: `events[${index}].osVersion is invalid` };
+  }
+  if (!isOptionalStringMax(event.deviceModel, 128)) {
+    return { success: false, reason: `events[${index}].deviceModel is invalid` };
+  }
+  if (!isOptionalStringMax(event.deviceManufacturer, 128)) {
+    return { success: false, reason: `events[${index}].deviceManufacturer is invalid` };
+  }
+  if (!isOptionalStringMax(event.deviceType, 32)) {
+    return { success: false, reason: `events[${index}].deviceType is invalid` };
+  }
+  if (!isOptionalStringMax(event.locale, 32)) {
+    return { success: false, reason: `events[${index}].locale is invalid` };
+  }
+  if (!isOptionalStringMax(event.country, 8)) {
+    return { success: false, reason: `events[${index}].country is invalid` };
+  }
+  if (!isOptionalStringMax(event.region, 96)) {
+    return { success: false, reason: `events[${index}].region is invalid` };
+  }
+  if (!isOptionalStringMax(event.city, 96)) {
+    return { success: false, reason: `events[${index}].city is invalid` };
+  }
+  if (!isOptionalStringMax(event.timezone, 64)) {
+    return { success: false, reason: `events[${index}].timezone is invalid` };
+  }
+  if (!isOptionalStringMax(event.networkType, 32)) {
+    return { success: false, reason: `events[${index}].networkType is invalid` };
+  }
+  if (!isOptionalStringMax(event.carrier, 64)) {
+    return { success: false, reason: `events[${index}].carrier is invalid` };
+  }
+  if (!isOptionalStringMax(event.installSource, 64)) {
+    return { success: false, reason: `events[${index}].installSource is invalid` };
+  }
+  if (event.eventId !== void 0 && (typeof event.eventId !== "string" || !UUID_REGEX.test(event.eventId))) {
+    return { success: false, reason: `events[${index}].eventId is invalid` };
+  }
+  if (event.ts !== void 0 && !isIsoDatetimeWithOffset(event.ts)) {
+    return { success: false, reason: `events[${index}].ts is invalid` };
+  }
+  if (event.type !== void 0 && (typeof event.type !== "string" || !TYPE_VALUES.has(event.type))) {
+    return { success: false, reason: `events[${index}].type is invalid` };
+  }
+  return { success: true };
+};
+var validateIngestBatch = (batch) => {
+  if (batch.sentAt !== void 0 && !isIsoDatetimeWithOffset(batch.sentAt)) {
+    return { success: false, reason: "sentAt is invalid" };
+  }
+  if (!Array.isArray(batch.events)) {
+    return { success: false, reason: "events is invalid" };
+  }
+  if (batch.events.length === 0 || batch.events.length > DEFAULT_INGEST_LIMITS.maxBatchSize) {
+    return { success: false, reason: "events length is out of bounds" };
+  }
+  for (let index = 0; index < batch.events.length; index += 1) {
+    const result = validateEvent(batch.events[index], index);
+    if (!result.success) {
+      return result;
+    }
+  }
+  return { success: true };
+};
+
+// src/constants.ts
+var DEVICE_ID_KEY = "pi_device_id";
+var SESSION_ID_KEY = "pi_session_id";
+var LAST_SEEN_KEY = "pi_last_seen";
+var SESSION_EVENT_SEQ_PREFIX = "pi_session_event_seq:";
+var ONBOARDING_STEP_VIEW_STATE_KEY = "pi_onboarding_step_views";
+var DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_SCREEN_VIEW_DEDUPE_WINDOW_MS = 1200;
+var DEFAULT_COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 400;
+var DEFAULT_COLLECTOR_ENDPOINT = "https://collector.analyticscli.com";
+
+// src/helpers.ts
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var isPromiseLike = (value) => {
+  return typeof value === "object" && value !== null && "then" in value;
+};
+var normalizeStoredValue = (value) => {
+  if (typeof value === "string" || value === null) {
+    return value;
+  }
+  return null;
+};
+var randomId = () => {
+  if (globalThis.crypto?.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let index = 0; index < bytes.length; index += 1) {
+      bytes[index] = Math.floor(Math.random() * 256);
+    }
+  }
+  const byte6 = bytes[6] ?? 0;
+  const byte8 = bytes[8] ?? 0;
+  bytes[6] = byte6 & 15 | 64;
+  bytes[8] = byte8 & 63 | 128;
+  let output = "";
+  for (let index = 0; index < bytes.length; index += 1) {
+    const byte = bytes[index] ?? 0;
+    const hex = byte.toString(16).padStart(2, "0");
+    output += hex;
+    if (index === 3 || index === 5 || index === 7 || index === 9) {
+      output += "-";
+    }
+  }
+  return output;
+};
+var readStorageSync = (storage, key) => {
+  if (!storage) {
+    return null;
+  }
+  try {
+    const value = storage.getItem(key);
+    if (isPromiseLike(value)) {
+      void value.catch(() => {
+      });
+      return null;
+    }
+    return normalizeStoredValue(value);
+  } catch {
+    return null;
+  }
+};
+var readStorageAsync = async (storage, key) => {
+  if (!storage) {
+    return null;
+  }
+  try {
+    const value = storage.getItem(key);
+    if (isPromiseLike(value)) {
+      return normalizeStoredValue(await value.catch(() => null));
+    }
+    return normalizeStoredValue(value);
+  } catch {
+    return null;
+  }
+};
+var writeStorageSync = (storage, key, value) => {
+  if (!storage) {
+    return;
+  }
+  try {
+    const result = storage.setItem(key, value);
+    if (isPromiseLike(result)) {
+      void result.catch(() => {
+      });
+    }
+  } catch {
+  }
+};
+var readTrimmedString = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+};
+var normalizePlatformValue = (value) => {
+  const normalized = readTrimmedString(value)?.toLowerCase();
+  if (normalized === "web" || normalized === "ios" || normalized === "android" || normalized === "mac" || normalized === "windows") {
+    return normalized;
+  }
+  if (normalized === "macos" || normalized === "osx" || normalized === "darwin") {
+    return "mac";
+  }
+  if (normalized === "win32") {
+    return "windows";
+  }
+  return void 0;
+};
+var readGlobalPlatformOs = () => {
+  const withPlatform = globalThis;
+  const fromPlatform = normalizePlatformValue(withPlatform.Platform?.OS);
+  if (fromPlatform) {
+    return fromPlatform;
+  }
+  const withExpoPlatform = globalThis;
+  return normalizePlatformValue(withExpoPlatform.expo?.modules?.ExpoPlatform?.osName);
+};
+var detectDefaultPlatform = () => {
+  const detectedNativePlatform = readGlobalPlatformOs();
+  if (detectedNativePlatform) {
+    return detectedNativePlatform;
+  }
+  if (typeof navigator === "undefined") {
+    return void 0;
+  }
+  if (navigator.product === "ReactNative") {
+    return void 0;
+  }
+  return "web";
+};
+var detectDefaultAppVersion = () => {
+  const withExpoModules = globalThis;
+  const expoApp = withExpoModules.expo?.modules?.ExpoApplication;
+  const candidates = [
+    expoApp?.nativeApplicationVersion,
+    expoApp?.applicationVersion,
+    expoApp?.version
+  ];
+  for (const candidate of candidates) {
+    const value = readTrimmedString(candidate);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+};
+var detectRuntimeEnv = () => {
+  const globalWithDevFlag = globalThis;
+  if (typeof globalWithDevFlag.__DEV__ === "boolean") {
+    return globalWithDevFlag.__DEV__ ? "development" : "production";
+  }
+  const globalWithProcess = globalThis;
+  const nodeEnv = globalWithProcess.process?.env?.NODE_ENV;
+  if (nodeEnv) {
+    return nodeEnv === "production" ? "production" : "development";
+  }
+  if (typeof window !== "undefined" && typeof window.location?.hostname === "string") {
+    const hostname = window.location.hostname.toLowerCase();
+    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".local") || hostname.endsWith(".test") || hostname.includes("dev") || hostname.includes("staging") || hostname.includes("preview")) {
+      return "development";
+    }
+  }
+  return "production";
+};
+var decodeComponentSafe = (value) => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+var resolveCookieStorageAdapter = (enabled, cookieDomain, cookieMaxAgeSeconds) => {
+  if (!enabled || typeof document === "undefined") {
+    return null;
+  }
+  const normalizedDomain = cookieDomain?.trim();
+  const getCookie = (key) => {
+    const encodedKey = encodeURIComponent(key);
+    const cookies = document.cookie ? document.cookie.split(";") : [];
+    for (const rawCookie of cookies) {
+      const cookie = rawCookie.trim();
+      if (!cookie.startsWith(`${encodedKey}=`)) {
+        continue;
+      }
+      const rawValue = cookie.slice(encodedKey.length + 1);
+      return decodeComponentSafe(rawValue);
+    }
+    return null;
+  };
+  const setCookie = (key, value) => {
+    const attributes = [
+      "Path=/",
+      "SameSite=Lax",
+      `Max-Age=${cookieMaxAgeSeconds}`,
+      ...normalizedDomain ? [`Domain=${normalizedDomain}`] : [],
+      ...typeof location !== "undefined" && location.protocol === "https:" ? ["Secure"] : []
+    ];
+    document.cookie = `${encodeURIComponent(key)}=${encodeURIComponent(value)}; ${attributes.join("; ")}`;
+  };
+  const removeCookie = (key) => {
+    const attributes = [
+      "Path=/",
+      "SameSite=Lax",
+      "Max-Age=0",
+      ...normalizedDomain ? [`Domain=${normalizedDomain}`] : [],
+      ...typeof location !== "undefined" && location.protocol === "https:" ? ["Secure"] : []
+    ];
+    document.cookie = `${encodeURIComponent(key)}=; ${attributes.join("; ")}`;
+  };
+  return {
+    getItem: (key) => getCookie(key),
+    setItem: (key, value) => setCookie(key, value),
+    removeItem: (key) => removeCookie(key)
+  };
+};
+var resolveBrowserStorageAdapter = () => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  let storage;
+  try {
+    storage = window.localStorage;
+  } catch {
+    return null;
+  }
+  if (!storage) {
+    return null;
+  }
+  return {
+    getItem: (key) => storage.getItem(key),
+    setItem: (key, value) => storage.setItem(key, value),
+    removeItem: (key) => storage.removeItem(key)
+  };
+};
+var combineStorageAdapters = (primary, secondary) => {
+  return {
+    getItem: (key) => {
+      const primaryValue = primary.getItem(key);
+      if (typeof primaryValue === "string") {
+        return primaryValue;
+      }
+      if (primaryValue === null) {
+        const secondaryValue = secondary.getItem(key);
+        if (typeof secondaryValue === "string") {
+          return secondaryValue;
+        }
+        return secondaryValue === null ? null : null;
+      }
+      return null;
+    },
+    setItem: (key, value) => {
+      primary.setItem(key, value);
+      secondary.setItem(key, value);
+    },
+    removeItem: (key) => {
+      primary.removeItem?.(key);
+      secondary.removeItem?.(key);
+    }
+  };
+};
+var sanitizeProperties = (properties) => {
+  if (!properties) {
+    return {};
+  }
+  const entries = Object.entries(properties).filter(([key]) => !RESERVED_PII_KEYS.has(key));
+  return Object.fromEntries(entries);
+};
+var toStableKey = (value) => {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_\-:.]/g, "_");
+  if (!normalized) return void 0;
+  return normalized.slice(0, 80);
+};
+var toNumericBucket = (value) => {
+  if (!Number.isFinite(value)) return "nan";
+  if (value < 0) return "lt_0";
+  if (value <= 10) return "0_10";
+  if (value <= 20) return "11_20";
+  if (value <= 30) return "21_30";
+  if (value <= 40) return "31_40";
+  if (value <= 50) return "41_50";
+  if (value <= 100) return "51_100";
+  return "gt_100";
+};
+var toTextLengthBucket = (value) => {
+  const length = value.trim().length;
+  if (length === 0) return "empty";
+  if (length <= 10) return "1_10";
+  if (length <= 30) return "11_30";
+  if (length <= 80) return "31_80";
+  return "gt_80";
+};
+
+// src/survey.ts
+var sanitizeSurveyResponseInput = (input) => {
+  const surveyKey = toStableKey(input.surveyKey);
+  const questionKey = toStableKey(input.questionKey);
+  if (!surveyKey || !questionKey) {
+    return [];
+  }
+  const baseProperties = {
+    surveyKey,
+    questionKey,
+    answerType: input.answerType,
+    responseProvided: true,
+    ...input.appVersion ? { appVersion: input.appVersion } : {},
+    ...input.isNewUser !== void 0 ? { isNewUser: input.isNewUser } : {},
+    ...input.onboardingFlowId ? { onboardingFlowId: input.onboardingFlowId } : {},
+    ...input.onboardingFlowVersion !== void 0 ? { onboardingFlowVersion: input.onboardingFlowVersion } : {},
+    ...input.stepKey ? { stepKey: input.stepKey } : {},
+    ...input.stepIndex !== void 0 ? { stepIndex: input.stepIndex } : {},
+    ...input.stepCount !== void 0 ? { stepCount: input.stepCount } : {},
+    ...input.experimentVariant ? { experimentVariant: input.experimentVariant } : {},
+    ...input.paywallId ? { paywallId: input.paywallId } : {},
+    ...sanitizeProperties(input.properties)
+  };
+  if (input.answerType === "multiple_choice") {
+    const keys = (input.responseKeys ?? []).map((value) => toStableKey(value)).filter((value) => Boolean(value)).slice(0, 20);
+    return keys.map((responseKey2) => ({
+      ...baseProperties,
+      responseKey: responseKey2
+    }));
+  }
+  if (input.answerType === "single_choice") {
+    const responseKey2 = toStableKey(input.responseKey);
+    if (!responseKey2) return [];
+    return [
+      {
+        ...baseProperties,
+        responseKey: responseKey2
+      }
+    ];
+  }
+  if (input.answerType === "boolean") {
+    if (typeof input.responseBoolean !== "boolean") return [];
+    return [
+      {
+        ...baseProperties,
+        responseKey: input.responseBoolean ? "true" : "false"
+      }
+    ];
+  }
+  if (input.answerType === "numeric") {
+    if (typeof input.responseNumber !== "number") return [];
+    return [
+      {
+        ...baseProperties,
+        responseKey: toNumericBucket(input.responseNumber)
+      }
+    ];
+  }
+  if (input.answerType === "text") {
+    if (typeof input.responseText !== "string") return [];
+    return [
+      {
+        ...baseProperties,
+        responseKey: `text_len:${toTextLengthBucket(input.responseText)}`
+      }
+    ];
+  }
+  const responseKey = toStableKey(input.responseKey);
+  if (!responseKey) return [];
+  return [
+    {
+      ...baseProperties,
+      responseKey
+    }
+  ];
+};
+
+// src/analytics-client.ts
+var DEFAULT_CONSENT_STORAGE_KEY = "analyticscli:consent:v1";
+var AUTH_FAILURE_FLUSH_PAUSE_MS = 6e4;
+var resolveDefaultOsNameFromPlatform = (platform) => {
+  if (!platform) {
+    return void 0;
+  }
+  if (platform === "ios") {
+    return "iOS";
+  }
+  if (platform === "android") {
+    return "Android";
+  }
+  if (platform === "web") {
+    return "Web";
+  }
+  if (platform === "mac") {
+    return "macOS";
+  }
+  if (platform === "windows") {
+    return "Windows";
+  }
+  return void 0;
+};
+var IngestSendError = class extends Error {
+  retryable;
+  attempts;
+  status;
+  errorCode;
+  serverMessage;
+  requestId;
+  constructor(input) {
+    super(input.message);
+    this.name = "IngestSendError";
+    this.retryable = input.retryable;
+    this.attempts = input.attempts;
+    this.status = input.status;
+    this.errorCode = input.errorCode;
+    this.serverMessage = input.serverMessage;
+    this.requestId = input.requestId;
+    if (input.cause !== void 0) {
+      this.cause = input.cause;
+    }
+  }
+};
+var AnalyticsClient = class {
+  apiKey;
+  hasIngestConfig;
+  endpoint;
+  batchSize;
+  flushIntervalMs;
+  maxRetries;
+  debug;
+  onIngestError;
+  platform;
+  projectSurface;
+  appVersion;
+  identityTrackingMode;
+  context;
+  configuredStorage;
+  storage;
+  storageReadsAreAsync;
+  persistConsentState;
+  consentStorageKey;
+  hasExplicitInitialConsent;
+  hasExplicitInitialFullTrackingConsent;
+  sessionTimeoutMs;
+  dedupeOnboardingStepViewsPerSession;
+  dedupeScreenViewsPerSession;
+  screenViewDedupeWindowMs;
+  runtimeEnv;
+  hasExplicitAnonId;
+  hasExplicitSessionId;
+  hydrationPromise;
+  queue = [];
+  flushTimer = null;
+  isFlushing = false;
+  consentGranted = true;
+  fullTrackingConsentGranted = false;
+  userId = null;
+  anonId;
+  sessionId;
+  sessionEventSeq = 0;
+  inMemoryLastSeenMs = Date.now();
+  hydrationCompleted = false;
+  deferredEventsBeforeHydration = [];
+  onboardingStepViewStateSessionId = null;
+  onboardingStepViewsSeen = /* @__PURE__ */ new Set();
+  lastScreenViewDedupeSessionId = null;
+  lastScreenViewDedupeKey = null;
+  lastScreenViewDedupeTsMs = 0;
+  flushPausedUntilMs = 0;
+  constructor(options) {
+    const normalizedOptions = this.normalizeOptions(options);
+    this.apiKey = this.readRequiredStringOption(normalizedOptions.apiKey);
+    this.hasIngestConfig = Boolean(this.apiKey);
+    if (!this.hasIngestConfig) {
+      this.reportMissingApiKey();
+    }
+    this.endpoint = (this.readRequiredStringOption(normalizedOptions.endpoint) || DEFAULT_COLLECTOR_ENDPOINT).replace(/\/$/, "");
+    this.batchSize = Math.min(normalizedOptions.batchSize ?? 20, DEFAULT_INGEST_LIMITS.maxBatchSize);
+    this.flushIntervalMs = normalizedOptions.flushIntervalMs ?? 5e3;
+    this.maxRetries = normalizedOptions.maxRetries ?? 4;
+    this.debug = normalizedOptions.debug ?? false;
+    this.onIngestError = typeof normalizedOptions.onIngestError === "function" ? normalizedOptions.onIngestError : null;
+    this.platform = this.normalizePlatformOption(normalizedOptions.platform) ?? detectDefaultPlatform();
+    this.projectSurface = this.normalizeProjectSurfaceOption(normalizedOptions.projectSurface);
+    this.appVersion = this.readRequiredStringOption(normalizedOptions.appVersion) || detectDefaultAppVersion();
+    this.identityTrackingMode = this.resolveIdentityTrackingModeOption(normalizedOptions);
+    const initialContext = { ...normalizedOptions.context ?? {} };
+    const hasExplicitOsName = this.readRequiredStringOption(initialContext.osName).length > 0;
+    this.context = {
+      ...initialContext,
+      osName: hasExplicitOsName ? initialContext.osName : resolveDefaultOsNameFromPlatform(this.platform) ?? initialContext.osName
+    };
+    this.runtimeEnv = detectRuntimeEnv();
+    this.persistConsentState = normalizedOptions.persistConsentState ?? false;
+    this.consentStorageKey = this.readRequiredStringOption(normalizedOptions.consentStorageKey) || DEFAULT_CONSENT_STORAGE_KEY;
+    this.hasExplicitInitialConsent = typeof normalizedOptions.initialConsentGranted === "boolean";
+    this.hasExplicitInitialFullTrackingConsent = typeof normalizedOptions.initialFullTrackingConsentGranted === "boolean";
+    this.sessionTimeoutMs = normalizedOptions.sessionTimeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS;
+    this.dedupeOnboardingStepViewsPerSession = normalizedOptions.dedupeOnboardingStepViewsPerSession ?? true;
+    this.dedupeScreenViewsPerSession = normalizedOptions.dedupeScreenViewsPerSession ?? true;
+    this.screenViewDedupeWindowMs = this.normalizeScreenViewDedupeWindowMs(
+      normalizedOptions.screenViewDedupeWindowMs
+    );
+    this.configuredStorage = this.resolveConfiguredStorage(normalizedOptions);
+    const persistedFullTrackingConsent = this.readPersistedConsentSync(this.configuredStorage);
+    const configuredFullTrackingConsent = normalizedOptions.initialFullTrackingConsentGranted;
+    const initialFullTrackingConsentGranted = typeof configuredFullTrackingConsent === "boolean" ? configuredFullTrackingConsent : persistedFullTrackingConsent ?? false;
+    this.fullTrackingConsentGranted = this.identityTrackingMode === "always_on" || initialFullTrackingConsentGranted;
+    this.storage = this.isFullTrackingActive() ? this.configuredStorage : null;
+    this.storageReadsAreAsync = this.detectAsyncStorageReads();
+    const providedAnonId = this.isFullTrackingActive() ? this.readRequiredStringOption(normalizedOptions.anonId) : "";
+    const providedSessionId = this.isFullTrackingActive() ? this.readRequiredStringOption(normalizedOptions.sessionId) : "";
+    this.hasExplicitAnonId = Boolean(providedAnonId);
+    this.hasExplicitSessionId = Boolean(providedSessionId);
+    this.anonId = providedAnonId || this.ensureDeviceId();
+    this.sessionId = providedSessionId || this.ensureSessionId();
+    this.sessionEventSeq = this.readSessionEventSeq(this.sessionId);
+    const persistedConsent = this.readPersistedConsentSync(this.storage);
+    const configuredConsent = normalizedOptions.initialConsentGranted;
+    const initialConsentGranted = typeof configuredConsent === "boolean" ? configuredConsent : persistedConsent ?? this.hasIngestConfig;
+    this.consentGranted = this.hasIngestConfig && initialConsentGranted;
+    if (this.hasExplicitInitialConsent && this.persistConsentState) {
+      this.writePersistedConsent(this.storage, this.consentGranted);
+    }
+    if (this.hasExplicitInitialFullTrackingConsent && this.persistConsentState) {
+      this.writePersistedConsent(this.configuredStorage, this.fullTrackingConsentGranted);
+    }
+    this.hydrationPromise = this.hydrateIdentityFromStorage();
+    this.enqueueInitialSessionStart();
+    this.startAutoFlush();
+  }
+  /**
+   * Resolves once client initialization work completes.
+   */
+  async ready() {
+    await this.hydrationPromise;
+  }
+  /**
+   * Enables or disables event collection.
+   * When disabled, queued events are dropped immediately.
+   */
+  setConsent(granted, options = {}) {
+    if (granted && !this.hasIngestConfig) {
+      this.log("Ignoring consent opt-in because `apiKey` is missing");
+      return;
+    }
+    this.consentGranted = granted;
+    if ((options.persist ?? true) && this.persistConsentState) {
+      this.writePersistedConsent(this.storage, granted);
+    }
+    if (this.identityTrackingMode === "consent_gated") {
+      this.setFullTrackingConsent(granted, options);
+    }
+    if (!granted) {
+      this.queue = [];
+      this.deferredEventsBeforeHydration = [];
+    }
+  }
+  optIn(options) {
+    this.setConsent(true, options);
+  }
+  optOut(options) {
+    this.setConsent(false, options);
+  }
+  getConsent() {
+    return this.consentGranted;
+  }
+  getConsentState() {
+    const persisted = this.readPersistedConsentSync(this.storage);
+    if (persisted === true) {
+      return "granted";
+    }
+    if (persisted === false) {
+      return "denied";
+    }
+    return this.consentGranted ? "granted" : "unknown";
+  }
+  /**
+   * Sets or updates shared event context fields (useful for mobile device/app metadata).
+   */
+  setContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  enqueueInitialSessionStart() {
+    if (!this.consentGranted) {
+      return;
+    }
+    if (this.shouldDeferEventsUntilHydrated()) {
+      this.deferEventUntilHydrated(() => {
+        this.enqueueInitialSessionStart();
+      });
+      return;
+    }
+    const sessionId = this.getSessionId();
+    this.enqueue({
+      eventId: randomId(),
+      eventName: "session_start",
+      ts: nowIso(),
+      sessionId,
+      anonId: this.anonId,
+      userId: this.getEventUserId(),
+      properties: this.withRuntimeMetadata({ source: "sdk_mount" }, sessionId),
+      platform: this.platform,
+      projectSurface: this.projectSurface,
+      appVersion: this.appVersion,
+      ...this.withEventContext(),
+      type: "track"
+    });
+  }
+  /**
+   * Associates following events with a known user id.
+   * Anonymous history remains linked by anonId/sessionId.
+   */
+  identify(userId, traits) {
+    const normalizedUserId = this.readRequiredStringOption(userId);
+    if (!normalizedUserId) {
+      return;
+    }
+    if (!this.isFullTrackingActive()) {
+      this.log("Ignoring identify() because identity persistence is not enabled");
+      return;
+    }
+    this.userId = normalizedUserId;
+    if (!this.consentGranted) {
+      return;
+    }
+    const normalizedTraits = this.cloneProperties(traits);
+    if (this.shouldDeferEventsUntilHydrated()) {
+      this.deferEventUntilHydrated(() => {
+        this.identify(normalizedUserId, normalizedTraits);
+      });
+      return;
+    }
+    const sessionId = this.getSessionId();
+    this.enqueue({
+      eventId: randomId(),
+      eventName: "identify",
+      ts: nowIso(),
+      sessionId,
+      anonId: this.anonId,
+      userId: normalizedUserId,
+      properties: this.withRuntimeMetadata(normalizedTraits, sessionId),
+      platform: this.platform,
+      projectSurface: this.projectSurface,
+      appVersion: this.appVersion,
+      ...this.withEventContext(),
+      type: "identify"
+    });
+  }
+  /**
+   * Convenience helper for login/logout boundaries.
+   * - pass a non-empty user id to emit an identify event
+   * - pass null/undefined/empty string to clear user linkage
+   */
+  setUser(userId, traits) {
+    const normalizedUserId = this.readRequiredStringOption(userId);
+    if (!normalizedUserId) {
+      this.clearUser();
+      return;
+    }
+    this.identify(normalizedUserId, traits);
+  }
+  /**
+   * Sets consent specifically for persistent identity tracking.
+   * In `consent_gated` mode this toggles strict-vs-full identity behavior while generic event tracking can stay enabled.
+   */
+  setFullTrackingConsent(granted, options = {}) {
+    if (this.identityTrackingMode === "strict") {
+      return;
+    }
+    if (this.identityTrackingMode === "always_on") {
+      return;
+    }
+    this.fullTrackingConsentGranted = granted;
+    if ((options.persist ?? true) && this.persistConsentState) {
+      this.writePersistedConsent(this.configuredStorage, granted);
+    }
+    this.applyIdentityTrackingState();
+  }
+  optInFullTracking(options) {
+    this.setFullTrackingConsent(true, options);
+  }
+  optOutFullTracking(options) {
+    this.setFullTrackingConsent(false, options);
+  }
+  isFullTrackingEnabled() {
+    return this.isFullTrackingActive();
+  }
+  /**
+   * Clears the current identified user from in-memory SDK state.
+   */
+  clearUser() {
+    this.userId = null;
+  }
+  /**
+   * Sends a generic product event.
+   */
+  track(eventName, properties) {
+    if (!this.consentGranted) {
+      return;
+    }
+    if (this.shouldDeferEventsUntilHydrated()) {
+      const deferredProperties = this.cloneProperties(properties);
+      this.deferEventUntilHydrated(() => {
+        this.track(eventName, deferredProperties);
+      });
+      return;
+    }
+    const sessionId = this.getSessionId();
+    if (this.shouldDropOnboardingStepView(eventName, properties, sessionId)) {
+      return;
+    }
+    this.enqueue({
+      eventId: randomId(),
+      eventName,
+      ts: nowIso(),
+      sessionId,
+      anonId: this.anonId,
+      userId: this.getEventUserId(),
+      properties: this.withRuntimeMetadata(properties, sessionId),
+      platform: this.platform,
+      projectSurface: this.projectSurface,
+      appVersion: this.appVersion,
+      ...this.withEventContext(),
+      type: "track"
+    });
+  }
+  /**
+   * Sends a typed onboarding event with conventional onboarding metadata.
+   */
+  trackOnboardingEvent(eventName, properties) {
+    this.track(eventName, properties);
+  }
+  /**
+   * Creates a scoped onboarding tracker that applies shared flow properties to every onboarding event.
+   * This reduces app-side boilerplate while keeping each emitted event fully self-describing.
+   */
+  createOnboardingTracker(defaults) {
+    const {
+      surveyKey: rawDefaultSurveyKey,
+      appVersion: rawDefaultAppVersion,
+      isNewUser: rawDefaultIsNewUser,
+      onboardingFlowId: rawDefaultFlowId,
+      onboardingFlowVersion: rawDefaultFlowVersion,
+      stepKey: rawDefaultStepKey,
+      stepIndex: rawDefaultStepIndex,
+      stepCount: rawDefaultStepCount,
+      ...defaultExtraProperties
+    } = defaults;
+    const defaultSurveyKey = this.readPropertyAsString(rawDefaultSurveyKey);
+    const defaultAppVersion = this.readPropertyAsString(rawDefaultAppVersion);
+    const defaultIsNewUser = typeof rawDefaultIsNewUser === "boolean" ? rawDefaultIsNewUser : void 0;
+    const defaultFlowId = this.readPropertyAsString(rawDefaultFlowId);
+    const defaultFlowVersion = typeof rawDefaultFlowVersion === "string" || typeof rawDefaultFlowVersion === "number" ? rawDefaultFlowVersion : void 0;
+    const defaultStepKey = this.readPropertyAsString(rawDefaultStepKey);
+    const defaultStepIndex = this.readPropertyAsStepIndex(rawDefaultStepIndex);
+    const defaultStepCount = this.readPropertyAsStepIndex(rawDefaultStepCount);
+    const mergeEventProperties = (properties) => ({
+      ...defaultExtraProperties,
+      appVersion: defaultAppVersion,
+      isNewUser: defaultIsNewUser,
+      onboardingFlowId: defaultFlowId,
+      onboardingFlowVersion: defaultFlowVersion,
+      stepKey: defaultStepKey,
+      stepIndex: defaultStepIndex,
+      stepCount: defaultStepCount,
+      ...properties ?? {}
+    });
+    const track = (eventName, properties) => {
+      this.trackOnboardingEvent(eventName, mergeEventProperties(properties));
+    };
+    const surveyResponse = (input) => {
+      this.trackOnboardingSurveyResponse({
+        ...input,
+        surveyKey: input.surveyKey ?? defaultSurveyKey ?? defaultFlowId ?? "onboarding",
+        appVersion: input.appVersion ?? defaultAppVersion,
+        isNewUser: input.isNewUser ?? defaultIsNewUser,
+        onboardingFlowId: input.onboardingFlowId ?? defaultFlowId,
+        onboardingFlowVersion: input.onboardingFlowVersion ?? defaultFlowVersion,
+        stepKey: input.stepKey ?? defaultStepKey,
+        stepIndex: input.stepIndex ?? defaultStepIndex,
+        stepCount: input.stepCount ?? defaultStepCount,
+        properties: {
+          ...defaultExtraProperties,
+          ...input.properties ?? {}
+        }
+      });
+    };
+    const step = (stepKey, stepIndex, properties) => {
+      const stepProps = {
+        ...properties ?? {},
+        stepKey,
+        stepIndex
+      };
+      return {
+        view: (overrides) => track(ONBOARDING_EVENTS.STEP_VIEW, { ...stepProps, ...overrides ?? {} }),
+        complete: (overrides) => track(ONBOARDING_EVENTS.STEP_COMPLETE, { ...stepProps, ...overrides ?? {} }),
+        surveyResponse: (input) => surveyResponse({
+          ...input,
+          stepKey,
+          stepIndex
+        })
+      };
+    };
+    return {
+      track,
+      start: (properties) => track(ONBOARDING_EVENTS.START, properties),
+      stepView: (properties) => track(ONBOARDING_EVENTS.STEP_VIEW, properties),
+      stepComplete: (properties) => track(ONBOARDING_EVENTS.STEP_COMPLETE, properties),
+      complete: (properties) => track(ONBOARDING_EVENTS.COMPLETE, properties),
+      skip: (properties) => track(ONBOARDING_EVENTS.SKIP, properties),
+      surveyResponse,
+      step
+    };
+  }
+  /**
+   * Creates a scoped paywall tracker that applies shared paywall defaults to every journey event.
+   * Useful when a flow has a stable `source`, `paywallId`, `offering`, or experiment metadata.
+   * Reuse the returned tracker for that flow context; creating a new tracker per event resets
+   * paywall entry correlation.
+   */
+  createPaywallTracker(defaults) {
+    const { source: rawDefaultSource, ...defaultProperties } = defaults;
+    const defaultSource = this.readRequiredStringOption(rawDefaultSource);
+    let currentPaywallEntryId;
+    if (!defaultSource) {
+      this.log("createPaywallTracker() called without a valid default `source`");
+    }
+    const mergeProperties = (properties) => {
+      const mergedSource = this.readRequiredStringOption(
+        this.readPropertyAsString(properties?.source) ?? defaultSource
+      );
+      return {
+        ...defaultProperties,
+        ...properties ?? {},
+        source: mergedSource
+      };
+    };
+    const track = (eventName, properties) => {
+      const mergedProperties = mergeProperties(properties);
+      delete mergedProperties.paywallEntryId;
+      if (eventName === PAYWALL_EVENTS.SHOWN) {
+        currentPaywallEntryId = randomId();
+        mergedProperties.paywallEntryId = currentPaywallEntryId;
+      } else {
+        if (currentPaywallEntryId) {
+          mergedProperties.paywallEntryId = currentPaywallEntryId;
+        }
+        if (properties?.offering === void 0) {
+          delete mergedProperties.offering;
+        }
+      }
+      this.sendPaywallEvent(eventName, mergedProperties, {
+        allowPaywallEntryId: true
+      });
+    };
+    return {
+      track,
+      shown: (properties) => track(PAYWALL_EVENTS.SHOWN, properties),
+      skip: (properties) => track(PAYWALL_EVENTS.SKIP, properties),
+      purchaseStarted: (properties) => track(PURCHASE_EVENTS.STARTED, properties),
+      purchaseSuccess: (properties) => track(PURCHASE_EVENTS.SUCCESS, properties),
+      purchaseFailed: (properties) => track(PURCHASE_EVENTS.FAILED, properties),
+      purchaseCancel: (properties) => track(PURCHASE_EVENTS.CANCEL, properties)
+    };
+  }
+  /**
+   * Sends a typed paywall/purchase journey event.
+   * Direct calls ignore `paywallEntryId`; use `createPaywallTracker(...)` for entry correlation.
+   */
+  trackPaywallEvent(eventName, properties) {
+    this.sendPaywallEvent(eventName, properties, {
+      allowPaywallEntryId: false
+    });
+  }
+  sendPaywallEvent(eventName, properties, options) {
+    if (typeof properties?.source !== "string" || properties.source.trim().length === 0) {
+      this.log("Dropping paywall event without required `source` property", { eventName });
+      return;
+    }
+    const normalizedProperties = {
+      ...properties
+    };
+    if (!options.allowPaywallEntryId && normalizedProperties.paywallEntryId !== void 0) {
+      this.log(
+        "Ignoring `paywallEntryId` in direct trackPaywallEvent(); use createPaywallTracker()",
+        { eventName }
+      );
+      delete normalizedProperties.paywallEntryId;
+    }
+    this.track(eventName, normalizedProperties);
+  }
+  /**
+   * Sends anonymized onboarding survey responses using canonical event naming.
+   * Free text and raw numeric values are reduced to coarse buckets.
+   */
+  trackOnboardingSurveyResponse(input, eventName = ONBOARDING_SURVEY_EVENTS.RESPONSE) {
+    const rows = sanitizeSurveyResponseInput(input);
+    for (const properties of rows) {
+      this.track(eventName, properties);
+    }
+  }
+  /**
+   * Sends a screen-view style event using the `screen:<name>` convention.
+   */
+  screen(name, properties) {
+    if (!this.consentGranted) {
+      return;
+    }
+    if (this.shouldDeferEventsUntilHydrated()) {
+      const deferredProperties = this.cloneProperties(properties);
+      this.deferEventUntilHydrated(() => {
+        this.screen(name, deferredProperties);
+      });
+      return;
+    }
+    const sessionId = this.getSessionId();
+    if (this.shouldDropScreenView(name, properties, sessionId)) {
+      return;
+    }
+    this.enqueue({
+      eventId: randomId(),
+      eventName: `screen:${name}`,
+      ts: nowIso(),
+      sessionId,
+      anonId: this.anonId,
+      userId: this.getEventUserId(),
+      properties: this.withRuntimeMetadata(properties, sessionId),
+      platform: this.platform,
+      projectSurface: this.projectSurface,
+      appVersion: this.appVersion,
+      ...this.withEventContext(),
+      type: "screen"
+    });
+  }
+  /**
+   * Alias of `screen(...)` for web-style naming.
+   */
+  page(name, properties) {
+    this.screen(name, properties);
+  }
+  /**
+   * Sends a feedback event.
+   */
+  feedback(message, rating, properties) {
+    if (!this.consentGranted) {
+      return;
+    }
+    if (this.shouldDeferEventsUntilHydrated()) {
+      const deferredProperties = this.cloneProperties(properties);
+      this.deferEventUntilHydrated(() => {
+        this.feedback(message, rating, deferredProperties);
+      });
+      return;
+    }
+    const sessionId = this.getSessionId();
+    this.enqueue({
+      eventId: randomId(),
+      eventName: "feedback_submitted",
+      ts: nowIso(),
+      sessionId,
+      anonId: this.anonId,
+      userId: this.getEventUserId(),
+      properties: this.withRuntimeMetadata({ message, rating, ...properties }, sessionId),
+      platform: this.platform,
+      projectSurface: this.projectSurface,
+      appVersion: this.appVersion,
+      ...this.withEventContext(),
+      type: "feedback"
+    });
+  }
+  /**
+   * Flushes current event queue to the ingest endpoint.
+   */
+  async flush() {
+    if (!this.hydrationCompleted && this.deferredEventsBeforeHydration.length > 0) {
+      await this.hydrationPromise;
+    }
+    if (this.queue.length === 0 || this.isFlushing || !this.consentGranted) {
+      return;
+    }
+    if (Date.now() < this.flushPausedUntilMs) {
+      return;
+    }
+    this.isFlushing = true;
+    const batch = this.queue.splice(0, this.batchSize);
+    const payload = {
+      sentAt: nowIso(),
+      events: batch
+    };
+    const validation = validateIngestBatch(payload);
+    if (!validation.success) {
+      this.log("Validation failed, dropping batch", validation.reason);
+      this.isFlushing = false;
+      return;
+    }
+    try {
+      await this.sendWithRetry(payload);
+      this.flushPausedUntilMs = 0;
+    } catch (error) {
+      this.queue = [...batch, ...this.queue];
+      const ingestError = this.toIngestSendError(error);
+      const diagnostics = this.createIngestDiagnostics(ingestError, batch.length, this.queue.length);
+      if (ingestError.status === 401 || ingestError.status === 403) {
+        this.flushPausedUntilMs = Date.now() + AUTH_FAILURE_FLUSH_PAUSE_MS;
+        this.log("Pausing ingest flush after auth failure", {
+          status: ingestError.status,
+          retryAfterMs: AUTH_FAILURE_FLUSH_PAUSE_MS
+        });
+      }
+      this.log("Send failed permanently, requeueing batch", diagnostics);
+      this.reportIngestError(diagnostics);
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Stops internal timers and unload handlers.
+   */
+  shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  enqueue(event) {
+    if (!this.consentGranted) {
+      return;
+    }
+    this.queue.push(event);
+    if (this.queue.length >= this.batchSize) {
+      this.scheduleFlush();
+    }
+  }
+  scheduleFlush() {
+    void this.flush().catch((error) => {
+      this.log("Unexpected flush failure", error);
+    });
+  }
+  async sendWithRetry(payload) {
+    let delay = 250;
+    for (let attempt = 1; attempt <= this.maxRetries + 1; attempt += 1) {
+      try {
+        const response = await fetch(`${this.endpoint}/v1/collect`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": this.apiKey
+          },
+          body: JSON.stringify(payload),
+          keepalive: true
+        });
+        if (!response.ok) {
+          throw await this.createHttpIngestSendError(response, attempt);
+        }
+        return;
+      } catch (error) {
+        const normalized = this.toIngestSendError(error, attempt);
+        const finalAttempt = attempt >= this.maxRetries + 1;
+        this.log("Ingest attempt failed", {
+          attempt: normalized.attempts,
+          maxRetries: this.maxRetries,
+          retryable: normalized.retryable,
+          status: normalized.status,
+          errorCode: normalized.errorCode,
+          requestId: normalized.requestId,
+          nextRetryInMs: !finalAttempt && normalized.retryable ? delay : null
+        });
+        if (finalAttempt || !normalized.retryable) {
+          throw normalized;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay *= 2;
+      }
+    }
+  }
+  async createHttpIngestSendError(response, attempts) {
+    const requestId = response.headers.get("x-request-id") ?? response.headers.get("cf-ray") ?? void 0;
+    let errorCode;
+    let serverMessage;
+    try {
+      const parsed = await response.json();
+      const errorBody = parsed && typeof parsed === "object" && parsed.error && typeof parsed.error === "object" ? parsed.error : void 0;
+      if (typeof errorBody?.code === "string") {
+        errorCode = errorBody.code;
+      }
+      if (typeof errorBody?.message === "string") {
+        serverMessage = errorBody.message;
+      }
+    } catch {
+    }
+    const retryable = this.shouldRetryHttpStatus(response.status);
+    const statusSuffix = errorCode ? ` ${errorCode}` : "";
+    const message = `ingest status=${response.status}${statusSuffix}`;
+    return new IngestSendError({
+      message,
+      retryable,
+      attempts,
+      status: response.status,
+      errorCode,
+      serverMessage,
+      requestId
+    });
+  }
+  shouldRetryHttpStatus(status) {
+    return status === 408 || status === 425 || status === 429 || status >= 500;
+  }
+  toIngestSendError(error, attempts) {
+    if (error instanceof IngestSendError) {
+      const resolvedAttempts = attempts ?? error.attempts;
+      return new IngestSendError({
+        message: error.message,
+        retryable: error.retryable,
+        attempts: resolvedAttempts,
+        status: error.status,
+        errorCode: error.errorCode,
+        serverMessage: error.serverMessage,
+        requestId: error.requestId,
+        cause: error.cause
+      });
+    }
+    const fallbackMessage = error instanceof Error ? error.message : "ingest request failed";
+    return new IngestSendError({
+      message: fallbackMessage,
+      retryable: true,
+      attempts: attempts ?? 1,
+      cause: error
+    });
+  }
+  createIngestDiagnostics(error, batchSize, queueSize) {
+    return {
+      name: "AnalyticsIngestError",
+      message: error.message,
+      endpoint: this.endpoint,
+      path: "/v1/collect",
+      status: error.status,
+      errorCode: error.errorCode,
+      serverMessage: error.serverMessage,
+      requestId: error.requestId,
+      retryable: error.retryable,
+      attempts: error.attempts,
+      maxRetries: this.maxRetries,
+      batchSize,
+      queueSize,
+      timestamp: nowIso()
+    };
+  }
+  reportIngestError(error) {
+    if (!this.onIngestError) {
+      return;
+    }
+    try {
+      this.onIngestError(error);
+    } catch (callbackError) {
+      this.log("onIngestError callback threw", callbackError);
+    }
+  }
+  parsePersistedConsent(raw) {
+    if (raw === "granted") {
+      return true;
+    }
+    if (raw === "denied") {
+      return false;
+    }
+    return null;
+  }
+  readPersistedConsentSync(storage) {
+    if (!this.persistConsentState) {
+      return null;
+    }
+    if (storage === this.storage && this.storageReadsAreAsync) {
+      return null;
+    }
+    return this.parsePersistedConsent(readStorageSync(storage, this.consentStorageKey));
+  }
+  async readPersistedConsentAsync(storage) {
+    if (!this.persistConsentState) {
+      return null;
+    }
+    return this.parsePersistedConsent(await readStorageAsync(storage, this.consentStorageKey));
+  }
+  writePersistedConsent(storage, granted) {
+    if (!this.persistConsentState) {
+      return;
+    }
+    writeStorageSync(storage, this.consentStorageKey, granted ? "granted" : "denied");
+  }
+  startAutoFlush() {
+    if (!this.hasIngestConfig) {
+      return;
+    }
+    this.flushTimer = setInterval(() => {
+      this.scheduleFlush();
+    }, this.flushIntervalMs);
+    if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+      window.addEventListener("beforeunload", () => {
+        this.scheduleFlush();
+      });
+    }
+  }
+  ensureDeviceId() {
+    if (this.storageReadsAreAsync) {
+      return randomId();
+    }
+    const existing = readStorageSync(this.storage, DEVICE_ID_KEY);
+    if (existing) {
+      return existing;
+    }
+    const value = randomId();
+    writeStorageSync(this.storage, DEVICE_ID_KEY, value);
+    return value;
+  }
+  ensureSessionId() {
+    const now = Date.now();
+    if (this.sessionId && now - this.inMemoryLastSeenMs < this.sessionTimeoutMs) {
+      this.inMemoryLastSeenMs = now;
+      if (!this.storageReadsAreAsync || this.hydrationCompleted) {
+        writeStorageSync(this.storage, SESSION_ID_KEY, this.sessionId);
+        writeStorageSync(this.storage, LAST_SEEN_KEY, String(now));
+      }
+      return this.sessionId;
+    }
+    if (this.storageReadsAreAsync) {
+      this.inMemoryLastSeenMs = now;
+      const next2 = randomId();
+      if (this.hydrationCompleted) {
+        writeStorageSync(this.storage, SESSION_ID_KEY, next2);
+        writeStorageSync(this.storage, LAST_SEEN_KEY, String(now));
+      }
+      return next2;
+    }
+    const existing = readStorageSync(this.storage, SESSION_ID_KEY);
+    const lastSeenRaw = readStorageSync(this.storage, LAST_SEEN_KEY);
+    const lastSeen = lastSeenRaw ? Number(lastSeenRaw) : NaN;
+    if (existing && Number.isFinite(lastSeen) && now - lastSeen < this.sessionTimeoutMs) {
+      this.inMemoryLastSeenMs = now;
+      writeStorageSync(this.storage, LAST_SEEN_KEY, String(now));
+      return existing;
+    }
+    this.inMemoryLastSeenMs = now;
+    const next = randomId();
+    writeStorageSync(this.storage, SESSION_ID_KEY, next);
+    writeStorageSync(this.storage, LAST_SEEN_KEY, String(now));
+    return next;
+  }
+  getSessionId() {
+    const resolvedSessionId = this.ensureSessionId();
+    if (resolvedSessionId !== this.sessionId) {
+      this.sessionId = resolvedSessionId;
+      this.sessionEventSeq = this.readSessionEventSeq(resolvedSessionId);
+    }
+    return this.sessionId;
+  }
+  readSessionEventSeq(sessionId) {
+    const raw = readStorageSync(this.storage, `${SESSION_EVENT_SEQ_PREFIX}${sessionId}`);
+    return this.parseSessionEventSeq(raw);
+  }
+  async readSessionEventSeqAsync(sessionId) {
+    const raw = await readStorageAsync(this.storage, `${SESSION_EVENT_SEQ_PREFIX}${sessionId}`);
+    return this.parseSessionEventSeq(raw);
+  }
+  parseSessionEventSeq(raw) {
+    const parsed = raw ? Number(raw) : Number.NaN;
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      return 0;
+    }
+    return Math.floor(parsed);
+  }
+  writeSessionEventSeq(sessionId, value) {
+    writeStorageSync(this.storage, `${SESSION_EVENT_SEQ_PREFIX}${sessionId}`, String(value));
+  }
+  async hydrateIdentityFromStorage() {
+    if (!this.storage) {
+      this.onboardingStepViewStateSessionId = this.sessionId;
+      this.hydrationCompleted = true;
+      return;
+    }
+    try {
+      const [storedAnonId, storedSessionId, storedLastSeen, storedConsent] = await Promise.all([
+        readStorageAsync(this.storage, DEVICE_ID_KEY),
+        readStorageAsync(this.storage, SESSION_ID_KEY),
+        readStorageAsync(this.storage, LAST_SEEN_KEY),
+        this.readPersistedConsentAsync(this.storage)
+      ]);
+      if (!this.hasExplicitAnonId && storedAnonId) {
+        this.anonId = storedAnonId;
+      }
+      if (!this.hasExplicitSessionId && storedSessionId) {
+        const lastSeenMs = storedLastSeen ? Number(storedLastSeen) : Number.NaN;
+        if (Number.isFinite(lastSeenMs) && Date.now() - lastSeenMs < this.sessionTimeoutMs) {
+          this.sessionId = storedSessionId;
+          this.inMemoryLastSeenMs = Date.now();
+        }
+      }
+      if (!this.hasExplicitInitialConsent && typeof storedConsent === "boolean") {
+        this.consentGranted = this.hasIngestConfig && storedConsent;
+        if (!this.consentGranted) {
+          this.queue = [];
+          this.deferredEventsBeforeHydration = [];
+        }
+      }
+      this.sessionEventSeq = await this.readSessionEventSeqAsync(this.sessionId);
+      await this.hydrateOnboardingStepViewState(this.sessionId);
+      writeStorageSync(this.storage, DEVICE_ID_KEY, this.anonId);
+      writeStorageSync(this.storage, SESSION_ID_KEY, this.sessionId);
+      writeStorageSync(this.storage, LAST_SEEN_KEY, String(this.inMemoryLastSeenMs));
+    } catch (error) {
+      this.log("Storage hydration failed; continuing with in-memory identity", error);
+    } finally {
+      this.hydrationCompleted = true;
+      this.drainDeferredEventsAfterHydration();
+    }
+  }
+  shouldDeferEventsUntilHydrated() {
+    return this.storageReadsAreAsync && !this.hydrationCompleted && (!this.hasExplicitAnonId || !this.hasExplicitSessionId);
+  }
+  deferEventUntilHydrated(action) {
+    const maxDeferredEvents = 1e3;
+    if (this.deferredEventsBeforeHydration.length >= maxDeferredEvents) {
+      this.deferredEventsBeforeHydration.shift();
+      this.log("Dropping oldest deferred pre-hydration event to cap memory usage");
+    }
+    this.deferredEventsBeforeHydration.push(action);
+  }
+  drainDeferredEventsAfterHydration() {
+    if (this.deferredEventsBeforeHydration.length === 0) {
+      return;
+    }
+    const deferred = this.deferredEventsBeforeHydration;
+    this.deferredEventsBeforeHydration = [];
+    for (const action of deferred) {
+      try {
+        action();
+      } catch (error) {
+        this.log("Failed to emit deferred pre-hydration event", error);
+      }
+    }
+  }
+  cloneProperties(properties) {
+    if (!properties) {
+      return void 0;
+    }
+    return { ...properties };
+  }
+  detectAsyncStorageReads() {
+    if (!this.storage) {
+      return false;
+    }
+    try {
+      const value = this.storage.getItem(DEVICE_ID_KEY);
+      if (typeof value === "object" && value !== null && "then" in value) {
+        void value.catch(() => {
+        });
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  withRuntimeMetadata(properties, sessionId) {
+    const sanitized = sanitizeProperties(properties);
+    const nextEventIndex = this.sessionEventSeq + 1;
+    this.sessionEventSeq = nextEventIndex;
+    this.writeSessionEventSeq(sessionId, nextEventIndex);
+    if (typeof sanitized.runtimeEnv !== "string") {
+      sanitized.runtimeEnv = this.runtimeEnv;
+    }
+    if (typeof sanitized.sessionEventIndex !== "number") {
+      sanitized.sessionEventIndex = nextEventIndex;
+    }
+    return sanitized;
+  }
+  shouldDropOnboardingStepView(eventName, properties, sessionId) {
+    if (!this.dedupeOnboardingStepViewsPerSession || eventName !== ONBOARDING_EVENTS.STEP_VIEW) {
+      return false;
+    }
+    const dedupeKey = this.getOnboardingStepViewDedupeKey(properties);
+    if (!dedupeKey) {
+      return false;
+    }
+    this.syncOnboardingStepViewState(sessionId);
+    if (this.onboardingStepViewsSeen.has(dedupeKey)) {
+      this.log("Dropping duplicate onboarding step view for session", { sessionId, dedupeKey });
+      return true;
+    }
+    this.onboardingStepViewsSeen.add(dedupeKey);
+    this.persistOnboardingStepViewState(sessionId);
+    return false;
+  }
+  shouldDropScreenView(name, properties, sessionId) {
+    if (!this.dedupeScreenViewsPerSession) {
+      return false;
+    }
+    const dedupeKey = this.getScreenViewDedupeKey(name, properties);
+    if (!dedupeKey) {
+      return false;
+    }
+    const nowMs = Date.now();
+    if (this.lastScreenViewDedupeSessionId !== sessionId) {
+      this.lastScreenViewDedupeSessionId = sessionId;
+      this.lastScreenViewDedupeKey = null;
+      this.lastScreenViewDedupeTsMs = 0;
+    }
+    const withinWindow = this.lastScreenViewDedupeKey === dedupeKey && nowMs - this.lastScreenViewDedupeTsMs <= this.screenViewDedupeWindowMs;
+    if (withinWindow) {
+      this.log("Dropping duplicate screen view for session", {
+        sessionId,
+        dedupeKey,
+        windowMs: this.screenViewDedupeWindowMs
+      });
+      return true;
+    }
+    this.lastScreenViewDedupeSessionId = sessionId;
+    this.lastScreenViewDedupeKey = dedupeKey;
+    this.lastScreenViewDedupeTsMs = nowMs;
+    return false;
+  }
+  getScreenViewDedupeKey(name, properties) {
+    const normalizedName = toStableKey(name);
+    if (!normalizedName) {
+      return null;
+    }
+    const screenClass = properties && typeof properties === "object" ? toStableKey(this.readPropertyAsString(properties.screen_class)) : null;
+    const resolvedScreenClass = screenClass ?? normalizedName;
+    return `${normalizedName}|${resolvedScreenClass}`;
+  }
+  getOnboardingStepViewDedupeKey(properties) {
+    if (!properties) {
+      return null;
+    }
+    const flowId = toStableKey(this.readPropertyAsString(properties.onboardingFlowId)) ?? "unknown_flow";
+    const flowVersion = toStableKey(this.readPropertyAsString(properties.onboardingFlowVersion)) ?? "unknown_version";
+    const stepKey = toStableKey(this.readPropertyAsString(properties.stepKey));
+    const stepIndex = this.readPropertyAsStepIndex(properties.stepIndex);
+    if (!stepKey && stepIndex === void 0) {
+      return null;
+    }
+    return `${flowId}|${flowVersion}|${stepKey ?? "unknown_step"}|${stepIndex ?? "unknown_index"}`;
+  }
+  readPropertyAsString(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return String(value);
+    }
+    return void 0;
+  }
+  readPropertyAsStepIndex(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return void 0;
+    }
+    return Math.max(0, Math.floor(value));
+  }
+  syncOnboardingStepViewState(sessionId) {
+    if (this.onboardingStepViewStateSessionId === sessionId) {
+      return;
+    }
+    const persisted = this.parseOnboardingStepViewState(
+      readStorageSync(this.storage, ONBOARDING_STEP_VIEW_STATE_KEY)
+    );
+    this.onboardingStepViewStateSessionId = sessionId;
+    this.onboardingStepViewsSeen = persisted?.sessionId === sessionId ? new Set(persisted.keys) : /* @__PURE__ */ new Set();
+  }
+  async hydrateOnboardingStepViewState(sessionId) {
+    if (!this.dedupeOnboardingStepViewsPerSession) {
+      this.onboardingStepViewStateSessionId = sessionId;
+      this.onboardingStepViewsSeen = /* @__PURE__ */ new Set();
+      return;
+    }
+    const persisted = this.parseOnboardingStepViewState(
+      await readStorageAsync(this.storage, ONBOARDING_STEP_VIEW_STATE_KEY)
+    );
+    this.onboardingStepViewStateSessionId = sessionId;
+    this.onboardingStepViewsSeen = persisted?.sessionId === sessionId ? /* @__PURE__ */ new Set([...persisted.keys, ...this.onboardingStepViewsSeen]) : new Set(this.onboardingStepViewsSeen);
+  }
+  persistOnboardingStepViewState(sessionId) {
+    this.onboardingStepViewStateSessionId = sessionId;
+    writeStorageSync(
+      this.storage,
+      ONBOARDING_STEP_VIEW_STATE_KEY,
+      JSON.stringify({
+        sessionId,
+        keys: Array.from(this.onboardingStepViewsSeen)
+      })
+    );
+  }
+  parseOnboardingStepViewState(raw) {
+    if (!raw) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.sessionId !== "string" || !Array.isArray(parsed.keys)) {
+        return null;
+      }
+      const keys = parsed.keys.filter((value) => typeof value === "string");
+      return {
+        sessionId: parsed.sessionId,
+        keys
+      };
+    } catch {
+      return null;
+    }
+  }
+  resolveIdentityTrackingModeOption(options) {
+    const explicitMode = this.readRequiredStringOption(options.identityTrackingMode).toLowerCase();
+    if (explicitMode === "strict") {
+      return "strict";
+    }
+    if (explicitMode === "consent_gated") {
+      return "consent_gated";
+    }
+    if (explicitMode === "always_on") {
+      return "always_on";
+    }
+    if (options.enableFullTrackingWithoutConsent === true) {
+      return "always_on";
+    }
+    return "consent_gated";
+  }
+  resolveConfiguredStorage(options) {
+    if (this.identityTrackingMode === "strict") {
+      if (options.storage || options.useCookieStorage || options.cookieDomain) {
+        this.log("Ignoring storage/cookie configuration because identityTrackingMode=strict");
+      }
+      return null;
+    }
+    const customStorage = options.storage ?? null;
+    const browserStorage = resolveBrowserStorageAdapter();
+    const primaryStorage = customStorage ?? browserStorage;
+    const cookieStorage = resolveCookieStorageAdapter(
+      options.useCookieStorage === true,
+      this.readRequiredStringOption(options.cookieDomain) || void 0,
+      this.normalizeCookieMaxAgeSeconds(options.cookieMaxAgeSeconds)
+    );
+    if (primaryStorage && cookieStorage) {
+      return combineStorageAdapters(primaryStorage, cookieStorage);
+    }
+    return primaryStorage ?? cookieStorage;
+  }
+  normalizeCookieMaxAgeSeconds(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+      return DEFAULT_COOKIE_MAX_AGE_SECONDS;
+    }
+    return Math.floor(value);
+  }
+  normalizeScreenViewDedupeWindowMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      return DEFAULT_SCREEN_VIEW_DEDUPE_WINDOW_MS;
+    }
+    return Math.floor(value);
+  }
+  isFullTrackingActive() {
+    if (!this.hasIngestConfig) {
+      return false;
+    }
+    if (this.identityTrackingMode === "always_on") {
+      return true;
+    }
+    if (this.identityTrackingMode === "strict") {
+      return false;
+    }
+    return this.fullTrackingConsentGranted;
+  }
+  applyIdentityTrackingState() {
+    if (!this.isFullTrackingActive()) {
+      this.storage = null;
+      this.storageReadsAreAsync = false;
+      this.userId = null;
+      return;
+    }
+    this.storage = this.configuredStorage;
+    this.storageReadsAreAsync = this.detectAsyncStorageReads();
+    this.sessionId = this.ensureSessionId();
+    this.sessionEventSeq = this.readSessionEventSeq(this.sessionId);
+    writeStorageSync(this.storage, DEVICE_ID_KEY, this.anonId);
+    writeStorageSync(this.storage, SESSION_ID_KEY, this.sessionId);
+    writeStorageSync(this.storage, LAST_SEEN_KEY, String(this.inMemoryLastSeenMs));
+  }
+  getEventUserId() {
+    if (!this.isFullTrackingActive()) {
+      return null;
+    }
+    return this.userId;
+  }
+  withEventContext() {
+    return {
+      appBuild: this.context.appBuild,
+      osName: this.context.osName,
+      osVersion: this.context.osVersion,
+      country: this.context.country,
+      region: this.context.region,
+      city: this.context.city
+    };
+  }
+  normalizeOptions(options) {
+    if (typeof options !== "object" || options === null) {
+      return {};
+    }
+    return options;
+  }
+  readRequiredStringOption(value) {
+    if (typeof value !== "string") {
+      return "";
+    }
+    return value.trim();
+  }
+  normalizePlatformOption(value) {
+    const normalized = this.readRequiredStringOption(value).toLowerCase();
+    if (normalized === "web" || normalized === "ios" || normalized === "android" || normalized === "mac" || normalized === "windows") {
+      return normalized;
+    }
+    if (normalized === "macos" || normalized === "osx" || normalized === "darwin") {
+      return "mac";
+    }
+    if (normalized === "win32") {
+      return "windows";
+    }
+    return void 0;
+  }
+  normalizeProjectSurfaceOption(value) {
+    const normalized = this.readRequiredStringOption(value).toLowerCase();
+    if (!normalized) {
+      return void 0;
+    }
+    if (normalized.length > 64) {
+      return normalized.slice(0, 64);
+    }
+    return normalized;
+  }
+  log(message, data) {
+    if (!this.debug) {
+      return;
+    }
+    console.debug("[analyticscli-sdk]", message, data);
+  }
+  reportMissingApiKey() {
+    console.error(
+      "[analyticscli-sdk] Missing required `apiKey`. Tracking is disabled (safe no-op). Pass your publishable API key."
+    );
+  }
+};
+
+// src/context.ts
+var normalizeInitInput = (input) => {
+  if (typeof input === "string") {
+    return { apiKey: input };
+  }
+  if (input === null || input === void 0) {
+    return {};
+  }
+  return input;
+};
+var resolveClient = (input) => {
+  if (input instanceof AnalyticsClient) {
+    return input;
+  }
+  return new AnalyticsClient(normalizeInitInput(input ?? {}));
+};
+var createAnalyticsContext = (options = {}) => {
+  const client = resolveClient(options.client);
+  let onboardingTracker = client.createOnboardingTracker(options.onboarding ?? {});
+  let paywallTracker = options.paywall ? client.createPaywallTracker(options.paywall) : null;
+  const consent = {
+    get: () => client.getConsent(),
+    getState: () => client.getConsentState(),
+    set: (granted, setOptions) => client.setConsent(granted, setOptions),
+    optIn: (setOptions) => client.optIn(setOptions),
+    optOut: (setOptions) => client.optOut(setOptions),
+    setFullTracking: (granted, setOptions) => client.setFullTrackingConsent(granted, setOptions),
+    optInFullTracking: (setOptions) => client.optInFullTracking(setOptions),
+    optOutFullTracking: (setOptions) => client.optOutFullTracking(setOptions),
+    isFullTrackingEnabled: () => client.isFullTrackingEnabled()
+  };
+  const user = {
+    identify: (userId, traits) => client.identify(userId, traits),
+    set: (userId, traits) => client.setUser(userId, traits),
+    clear: () => client.clearUser()
+  };
+  return {
+    client,
+    get onboarding() {
+      return onboardingTracker;
+    },
+    get paywall() {
+      return paywallTracker;
+    },
+    consent,
+    user,
+    track: (eventName, properties) => client.track(eventName, properties),
+    trackOnboardingEvent: (eventName, properties) => client.trackOnboardingEvent(eventName, properties),
+    trackOnboardingSurveyResponse: (input, eventName) => client.trackOnboardingSurveyResponse(input, eventName),
+    trackPaywallEvent: (eventName, properties) => client.trackPaywallEvent(eventName, properties),
+    screen: (name, properties) => client.screen(name, properties),
+    page: (name, properties) => client.page(name, properties),
+    feedback: (message, rating, properties) => client.feedback(message, rating, properties),
+    setContext: (context) => client.setContext(context),
+    createOnboarding: (defaults) => client.createOnboardingTracker(defaults),
+    createPaywall: (defaults) => client.createPaywallTracker(defaults),
+    configureOnboarding: (defaults) => {
+      onboardingTracker = client.createOnboardingTracker(defaults);
+      return onboardingTracker;
+    },
+    configurePaywall: (defaults) => {
+      paywallTracker = client.createPaywallTracker(defaults);
+      return paywallTracker;
+    },
+    ready: () => client.ready(),
+    flush: () => client.flush(),
+    shutdown: () => client.shutdown()
+  };
+};
+
+// src/index.ts
+var normalizeInitInput2 = (input) => {
+  if (typeof input === "string") {
+    return { apiKey: input };
+  }
+  if (input === null || input === void 0) {
+    return {};
+  }
+  return input;
+};
+var init = (input = {}) => {
+  return new AnalyticsClient(normalizeInitInput2(input));
+};
+var initConsentFirst = (input = {}) => {
+  const normalized = normalizeInitInput2(input);
+  return new AnalyticsClient({
+    ...normalized,
+    initialConsentGranted: false
+  });
+};
+var initAsync = async (input = {}) => {
+  const client = new AnalyticsClient(normalizeInitInput2(input));
+  await client.ready();
+  return client;
+};
+var initConsentFirstAsync = async (input = {}) => {
+  const client = initConsentFirst(input);
+  await client.ready();
+  return client;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnalyticsClient,
+  ONBOARDING_EVENTS,
+  ONBOARDING_PROGRESS_EVENT_ORDER,
+  ONBOARDING_SCREEN_EVENT_PREFIXES,
+  ONBOARDING_SURVEY_EVENTS,
+  PAYWALL_ANCHOR_EVENT_CANDIDATES,
+  PAYWALL_EVENTS,
+  PAYWALL_JOURNEY_EVENT_ORDER,
+  PAYWALL_SKIP_EVENT_CANDIDATES,
+  PURCHASE_EVENTS,
+  PURCHASE_SUCCESS_EVENT_CANDIDATES,
+  createAnalyticsContext,
+  init,
+  initAsync,
+  initConsentFirst,
+  initConsentFirstAsync
+});