@analyticscli/sdk 0.1.0-preview.4

package/dist/chunk-UILQQPVJ.js

@@ -0,0 +1,1487 @@
+// 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.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_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();
+  }
+  return `${Date.now()}-${Math.random().toString(16).slice(2, 12)}`;
+};
+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 AnalyticsClient = class {
+  apiKey;
+  hasIngestConfig;
+  endpoint;
+  batchSize;
+  flushIntervalMs;
+  maxRetries;
+  debug;
+  platform;
+  appVersion;
+  context;
+  storage;
+  storageReadsAreAsync;
+  sessionTimeoutMs;
+  dedupeOnboardingStepViewsPerSession;
+  runtimeEnv;
+  hasExplicitAnonId;
+  hasExplicitSessionId;
+  hydrationPromise;
+  queue = [];
+  flushTimer = null;
+  isFlushing = false;
+  consentGranted = true;
+  userId = null;
+  anonId;
+  sessionId;
+  sessionEventSeq = 0;
+  inMemoryLastSeenMs = Date.now();
+  hydrationCompleted = false;
+  deferredEventsBeforeHydration = [];
+  onboardingStepViewStateSessionId = null;
+  onboardingStepViewsSeen = /* @__PURE__ */ new Set();
+  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.platform = this.normalizePlatformOption(normalizedOptions.platform) ?? detectDefaultPlatform();
+    this.appVersion = this.readRequiredStringOption(normalizedOptions.appVersion) || detectDefaultAppVersion();
+    this.context = { ...normalizedOptions.context ?? {} };
+    this.runtimeEnv = detectRuntimeEnv();
+    const useCookieStorage = normalizedOptions.useCookieStorage ?? Boolean(normalizedOptions.cookieDomain);
+    const cookieStorage = resolveCookieStorageAdapter(
+      useCookieStorage,
+      normalizedOptions.cookieDomain,
+      normalizedOptions.cookieMaxAgeSeconds ?? DEFAULT_COOKIE_MAX_AGE_SECONDS
+    );
+    const browserStorage = resolveBrowserStorageAdapter();
+    this.storage = normalizedOptions.storage ?? (cookieStorage && browserStorage ? combineStorageAdapters(cookieStorage, browserStorage) : cookieStorage ?? browserStorage);
+    this.storageReadsAreAsync = this.detectAsyncStorageReads();
+    this.sessionTimeoutMs = normalizedOptions.sessionTimeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS;
+    this.dedupeOnboardingStepViewsPerSession = normalizedOptions.dedupeOnboardingStepViewsPerSession ?? false;
+    const providedAnonId = normalizedOptions.anonId?.trim();
+    const providedSessionId = normalizedOptions.sessionId?.trim();
+    this.hasExplicitAnonId = Boolean(providedAnonId);
+    this.hasExplicitSessionId = Boolean(providedSessionId);
+    this.anonId = providedAnonId || this.ensureDeviceId();
+    this.sessionId = providedSessionId || this.ensureSessionId();
+    this.sessionEventSeq = this.readSessionEventSeq(this.sessionId);
+    this.consentGranted = this.hasIngestConfig;
+    this.hydrationPromise = this.hydrateIdentityFromStorage();
+    this.startAutoFlush();
+  }
+  /**
+   * Resolves once any async storage adapter hydration completes.
+   * Useful in React Native when using async persistence (for example AsyncStorage).
+   */
+  async ready() {
+    await this.hydrationPromise;
+  }
+  /**
+   * Enables or disables event collection.
+   * When disabled, queued events are dropped immediately.
+   */
+  setConsent(granted) {
+    if (granted && !this.hasIngestConfig) {
+      this.log("Ignoring consent opt-in because `apiKey` is missing");
+      return;
+    }
+    this.consentGranted = granted;
+    if (!granted) {
+      this.queue = [];
+      this.deferredEventsBeforeHydration = [];
+    }
+  }
+  optIn() {
+    this.setConsent(true);
+  }
+  optOut() {
+    this.setConsent(false);
+  }
+  /**
+   * Sets or updates shared event context fields (useful for mobile device/app metadata).
+   */
+  setContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  /**
+   * Associates following events with a known user id.
+   * Anonymous history remains linked by anonId/sessionId.
+   */
+  identify(userId, traits) {
+    if (!this.consentGranted) {
+      return;
+    }
+    const normalizedUserId = this.readRequiredStringOption(userId);
+    if (!normalizedUserId) {
+      this.log("Dropping identify call without required `userId`");
+      return;
+    }
+    if (this.shouldDeferEventsUntilHydrated()) {
+      const deferredTraits = this.cloneProperties(traits);
+      this.deferEventUntilHydrated(() => {
+        this.identify(normalizedUserId, deferredTraits);
+      });
+      return;
+    }
+    this.userId = normalizedUserId;
+    const sessionId = this.getSessionId();
+    this.enqueue({
+      eventId: randomId(),
+      eventName: "identify",
+      ts: nowIso(),
+      sessionId,
+      anonId: this.anonId,
+      userId: normalizedUserId,
+      properties: this.withRuntimeMetadata(traits, sessionId),
+      platform: this.platform,
+      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 = typeof userId === "string" ? this.readRequiredStringOption(userId) : "";
+    if (!normalizedUserId) {
+      this.clearUser();
+      return;
+    }
+    this.identify(normalizedUserId, traits);
+  }
+  /**
+   * 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.userId,
+      properties: this.withRuntimeMetadata(properties, sessionId),
+      platform: this.platform,
+      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.
+   */
+  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();
+    this.enqueue({
+      eventId: randomId(),
+      eventName: `screen:${name}`,
+      ts: nowIso(),
+      sessionId,
+      anonId: this.anonId,
+      userId: this.userId,
+      properties: this.withRuntimeMetadata(properties, sessionId),
+      platform: this.platform,
+      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.userId,
+      properties: this.withRuntimeMetadata({ message, rating, ...properties }, sessionId),
+      platform: this.platform,
+      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;
+    }
+    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);
+    } catch (error) {
+      this.log("Send failed permanently, requeueing batch", error);
+      this.queue = [...batch, ...this.queue];
+    } 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 attempt = 0;
+    let delay = 250;
+    while (attempt <= this.maxRetries) {
+      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 new Error(`ingest status=${response.status}`);
+        }
+        return;
+      } catch (error) {
+        attempt += 1;
+        if (attempt > this.maxRetries) {
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay *= 2;
+      }
+    }
+  }
+  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] = await Promise.all([
+        readStorageAsync(this.storage, DEVICE_ID_KEY),
+        readStorageAsync(this.storage, SESSION_ID_KEY),
+        readStorageAsync(this.storage, LAST_SEEN_KEY)
+      ]);
+      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();
+        }
+      }
+      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;
+  }
+  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;
+    }
+  }
+  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;
+  }
+  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 long write key."
+    );
+  }
+};
+
+// src/bootstrap.ts
+var DEFAULT_API_KEY_ENV_KEYS = [
+  "ANALYTICSCLI_WRITE_KEY",
+  "NEXT_PUBLIC_ANALYTICSCLI_WRITE_KEY",
+  "EXPO_PUBLIC_ANALYTICSCLI_WRITE_KEY",
+  "VITE_ANALYTICSCLI_WRITE_KEY"
+];
+var readTrimmedString2 = (value) => {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value).trim();
+  }
+  return "";
+};
+var resolveDefaultEnv = () => {
+  const withProcess = globalThis;
+  if (typeof withProcess.process?.env === "object" && withProcess.process.env !== null) {
+    return withProcess.process.env;
+  }
+  return {};
+};
+var resolveValueFromEnv = (env, keys) => {
+  for (const key of keys) {
+    const value = readTrimmedString2(env[key]);
+    if (value.length > 0) {
+      return value;
+    }
+  }
+  return "";
+};
+var toMissingMessage = (details) => {
+  const parts = [];
+  if (details.missingApiKey) {
+    parts.push(`apiKey (searched: ${details.searchedApiKeyEnvKeys.join(", ") || "none"})`);
+  }
+  return `[analyticscli-sdk] Missing required configuration: ${parts.join("; ")}.`;
+};
+var initFromEnv = (options = {}) => {
+  const {
+    env,
+    apiKey,
+    apiKeyEnvKeys,
+    missingConfigMode = "noop",
+    onMissingConfig,
+    ...clientOptions
+  } = options;
+  const resolvedApiKeyEnvKeys = [...apiKeyEnvKeys ?? DEFAULT_API_KEY_ENV_KEYS];
+  const envSource = env ?? resolveDefaultEnv();
+  const resolvedApiKey = readTrimmedString2(apiKey) || resolveValueFromEnv(envSource, resolvedApiKeyEnvKeys);
+  const missingConfig = {
+    missingApiKey: resolvedApiKey.length === 0,
+    searchedApiKeyEnvKeys: resolvedApiKeyEnvKeys
+  };
+  if (missingConfig.missingApiKey) {
+    onMissingConfig?.(missingConfig);
+    if (missingConfigMode === "throw") {
+      throw new Error(toMissingMessage(missingConfig));
+    }
+  }
+  return new AnalyticsClient({
+    ...clientOptions,
+    apiKey: resolvedApiKey
+  });
+};
+
+// src/index.ts
+var normalizeInitInput = (input) => {
+  if (typeof input === "string") {
+    return { apiKey: input };
+  }
+  return input;
+};
+var init = (input = {}) => {
+  return new AnalyticsClient(normalizeInitInput(input));
+};
+var initAsync = async (input = {}) => {
+  const client = new AnalyticsClient(normalizeInitInput(input));
+  await client.ready();
+  return client;
+};
+var BROWSER_API_KEY_ENV_KEYS = [
+  "ANALYTICSCLI_WRITE_KEY",
+  "NEXT_PUBLIC_ANALYTICSCLI_WRITE_KEY",
+  "PUBLIC_ANALYTICSCLI_WRITE_KEY",
+  "VITE_ANALYTICSCLI_WRITE_KEY",
+  "EXPO_PUBLIC_ANALYTICSCLI_WRITE_KEY"
+];
+var REACT_NATIVE_API_KEY_ENV_KEYS = [
+  "ANALYTICSCLI_WRITE_KEY",
+  "EXPO_PUBLIC_ANALYTICSCLI_WRITE_KEY"
+];
+var initBrowserFromEnv = (options = {}) => {
+  const { apiKeyEnvKeys, ...rest } = options;
+  return initFromEnv({
+    ...rest,
+    apiKeyEnvKeys: [...apiKeyEnvKeys ?? BROWSER_API_KEY_ENV_KEYS]
+  });
+};
+var initReactNativeFromEnv = (options = {}) => {
+  const { apiKeyEnvKeys, ...rest } = options;
+  return initFromEnv({
+    ...rest,
+    apiKeyEnvKeys: [...apiKeyEnvKeys ?? REACT_NATIVE_API_KEY_ENV_KEYS]
+  });
+};
+
+export {
+  ONBOARDING_EVENTS,
+  PAYWALL_EVENTS,
+  PURCHASE_EVENTS,
+  ONBOARDING_SURVEY_EVENTS,
+  ONBOARDING_PROGRESS_EVENT_ORDER,
+  PAYWALL_JOURNEY_EVENT_ORDER,
+  ONBOARDING_SCREEN_EVENT_PREFIXES,
+  PAYWALL_ANCHOR_EVENT_CANDIDATES,
+  PAYWALL_SKIP_EVENT_CANDIDATES,
+  PURCHASE_SUCCESS_EVENT_CANDIDATES,
+  AnalyticsClient,
+  DEFAULT_API_KEY_ENV_KEYS,
+  initFromEnv,
+  init,
+  initAsync,
+  BROWSER_API_KEY_ENV_KEYS,
+  REACT_NATIVE_API_KEY_ENV_KEYS,
+  initBrowserFromEnv,
+  initReactNativeFromEnv
+};