@drip-apex/app-sdk 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1217 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Apex: () => Apex,
+  ApexClient: () => ApexClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// package.json
+var version = "0.1.0";
+
+// src/index.ts
+var localStorageAdapter = {
+  async get(key) {
+    if (typeof globalThis.localStorage === "undefined") throw new Error("Storage unavailable");
+    return globalThis.localStorage.getItem(key);
+  },
+  async set(key, value) {
+    if (typeof globalThis.localStorage === "undefined") throw new Error("Storage unavailable");
+    globalThis.localStorage.setItem(key, value);
+  }
+};
+function detectPlatform() {
+  var _a, _b, _c;
+  const shell = globalThis;
+  try {
+    const platform = (_b = (_a = shell.Capacitor) == null ? void 0 : _a.getPlatform) == null ? void 0 : _b.call(_a);
+    if (platform === "ios" || platform === "android" || platform === "web") return platform;
+  } catch {
+  }
+  const cordova = typeof ((_c = shell.device) == null ? void 0 : _c.platform) === "string" ? shell.device.platform.toLowerCase() : void 0;
+  if (cordova === "ios" || cordova === "android") return cordova;
+  const agent = typeof navigator === "undefined" ? "" : navigator.userAgent;
+  return /iPhone|iPad|iPod/i.test(agent) ? "ios" : /Android/i.test(agent) ? "android" : "web";
+}
+var isRow = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var string = (v) => typeof v === "string" ? v : void 0;
+var safeNumber = (v) => typeof v === "number" && Number.isFinite(v) && (!Number.isInteger(v) || Number.isSafeInteger(v));
+var clamp = (v, fallback, min, max) => typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, v)) : fallback;
+var SERVER_MAX_EVENTS = 200;
+var clone = (v) => JSON.parse(JSON.stringify(v));
+var uuid = () => {
+  const crypto = typeof globalThis.crypto === "undefined" ? void 0 : globalThis.crypto;
+  if (typeof (crypto == null ? void 0 : crypto.randomUUID) === "function") return crypto.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (typeof (crypto == null ? void 0 : crypto.getRandomValues) === "function") crypto.getRandomValues(bytes);
+  else for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const s = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20)}`;
+};
+var isUuid = (s) => s !== null && /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i.test(s);
+var unsafeKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var textInput = (v, max = 1024) => typeof v === "string" && v.length > 0 && v.length <= max && v.trim().length > 0;
+function jsonValue(value) {
+  let nodes = 0, bytes = 0;
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (v, depth) => {
+    if (++nodes > 1e4 || depth > 32) return false;
+    if (v === null || typeof v === "boolean") return true;
+    if (typeof v === "string") {
+      bytes += v.length;
+      return bytes <= 1048576;
+    }
+    if (typeof v === "number") return safeNumber(v);
+    if (typeof v !== "object" || seen.has(v)) return false;
+    if (Array.isArray(v) && v.length > 1e4) return false;
+    if (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype && Object.getPrototypeOf(v) !== null) return false;
+    seen.add(v);
+    const descriptors = Object.getOwnPropertyDescriptors(v);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      bytes += key.length;
+      if (unsafeKeys.has(key) || bytes > 1048576 || !("value" in descriptor) || !visit(descriptor.value, depth + 1)) return false;
+    }
+    seen.delete(v);
+    return true;
+  };
+  try {
+    return visit(value, 0);
+  } catch {
+    return false;
+  }
+}
+function recordInput(v) {
+  try {
+    return isRow(v) && jsonValue(v);
+  } catch {
+    return false;
+  }
+}
+function optionRecord(v) {
+  try {
+    if (!isRow(v) || Object.getPrototypeOf(v) !== Object.prototype && Object.getPrototypeOf(v) !== null) return null;
+    const result = {};
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(v))) {
+      if (unsafeKeys.has(key) || !("value" in descriptor)) return null;
+      result[key] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function loggerInput(v) {
+  try {
+    if (v === null || typeof v !== "object") return void 0;
+    const descriptor = Object.getOwnPropertyDescriptor(v, "logger");
+    return descriptor && "value" in descriptor && typeof descriptor.value === "function" ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function flagOptions(v) {
+  if (v === void 0) return true;
+  const row = optionRecord(v);
+  return row !== null && Object.keys(row).every((key) => key === "exposure" || key === "validate") && (row.exposure === void 0 || row.exposure === "manual" || row.exposure === "auto") && (row.validate === void 0 || typeof row.validate === "function");
+}
+function configuration(v) {
+  const row = optionRecord(v);
+  if (!row || !textInput(row.publishableKey) || !row.publishableKey.startsWith("apx_pk_") || !textInput(row.shopId)) return null;
+  const texts = ["environment", "appVersion", "applicationId", "baseUrl"];
+  const numbers = ["flushIntervalSeconds", "batchSize", "queueCapacity", "queueRetentionHours", "initTimeoutMs"];
+  const callbacks = ["screen", "fetch", "logger"];
+  const keys = ["publishableKey", "shopId", "qaMode", "platform", "storage", "refreshJitterSeconds", ...texts, ...numbers, ...callbacks];
+  if (Object.keys(row).some((key) => !keys.includes(key))) return null;
+  for (const key of texts) if (row[key] !== void 0 && !textInput(row[key])) return null;
+  for (const key of numbers) if (row[key] !== void 0 && !safeNumber(row[key])) return null;
+  for (const key of callbacks) if (row[key] !== void 0 && typeof row[key] !== "function") return null;
+  if (row.baseUrl !== void 0) {
+    try {
+      const url = new URL(row.baseUrl);
+      if (!["http:", "https:"].includes(url.protocol) || !url.hostname || url.username || url.password) return null;
+    } catch {
+      return null;
+    }
+  }
+  if (row.qaMode !== void 0 && typeof row.qaMode !== "boolean") return null;
+  if (row.platform !== void 0 && !["ios", "android", "web"].includes(row.platform)) return null;
+  if (row.refreshJitterSeconds !== void 0) {
+    const jitter = row.refreshJitterSeconds;
+    if (!Array.isArray(jitter) || jitter.length !== 2 || !jsonValue(jitter) || !jitter.every(safeNumber) || jitter[0] < 0 || jitter[1] < jitter[0]) return null;
+    row.refreshJitterSeconds = [...jitter];
+  }
+  if (row.storage !== void 0) {
+    try {
+      if (!isRow(row.storage) || typeof row.storage.get !== "function" || typeof row.storage.set !== "function") return null;
+    } catch {
+      return null;
+    }
+  }
+  return row;
+}
+function screenURL(applicationId, screen) {
+  const host = applicationId.toLowerCase();
+  if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(host)) return "app://unknown/home";
+  try {
+    if (!textInput(screen, 4096)) return `app://${host}/home`;
+    return `app://${host}/${screen.replace(/^\/+|\/+$/g, "").split("/").map(encodeURIComponent).join("/")}`;
+  } catch {
+    return `app://${host}/home`;
+  }
+}
+var ApexClient = class {
+  constructor(options) {
+    this.sdkVersion = version;
+    this.device = "";
+    this.identity = "";
+    this.assignmentIdentity = "";
+    this.assignments = [];
+    this.assignmentsLoaded = false;
+    this.cache = /* @__PURE__ */ new Map();
+    this.fetchedAt = null;
+    this.fromCache = false;
+    this.events = [];
+    this.durableEvents = [];
+    this.queueRevision = 0;
+    this.durableQueueRevision = 0;
+    this.queueWaiters = [];
+    this.queueDropLogs = /* @__PURE__ */ new Set();
+    this.session = "";
+    this.backgroundAt = null;
+    this.appState = "foreground";
+    this.lastBackground = -Infinity;
+    this.lastForeground = -Infinity;
+    this.foregroundPending = false;
+    this.settleFirstAssignment = () => {
+    };
+    this.warnings = /* @__PURE__ */ new Set();
+    this.failureLogs = /* @__PURE__ */ new Map();
+    this.exposures = /* @__PURE__ */ new Set();
+    this.pendingExposures = /* @__PURE__ */ new Set();
+    this.handlers = /* @__PURE__ */ new Set();
+    this.stopped = false;
+    this.generation = 0;
+    this.identityRevision = 0;
+    this.identityPending = false;
+    this.networkingSuspended = false;
+    this.networkRevision = 0;
+    this.identityWriteWarned = false;
+    this.identifyWaiters = /* @__PURE__ */ new Map();
+    this.assignFailures = 0;
+    this.eventFailures = 0;
+    this.assignNotBefore = -Infinity;
+    this.eventsNotBefore = -Infinity;
+    this.flushing = false;
+    this.serial = Promise.resolve();
+    this.timers = /* @__PURE__ */ new Map();
+    this.requests = /* @__PURE__ */ new Set();
+    this.assignmentRequests = /* @__PURE__ */ new Set();
+    this.visibility = () => {
+      if (typeof document === "undefined") return;
+      if (document.visibilityState === "hidden") this.setAppState("background");
+      else if (document.visibilityState === "visible") this.setAppState("foreground");
+    };
+    this.pause = () => this.setAppState("background");
+    this.resume = () => this.setAppState("foreground");
+    var _a, _b, _c, _d;
+    const valid = configuration(options);
+    const invalidLogger = (_a = valid == null ? void 0 : valid.logger) != null ? _a : loggerInput(options);
+    options = valid != null ? valid : { publishableKey: "", shopId: "", logger: typeof invalidLogger === "function" ? invalidLogger : void 0 };
+    this.options = { ...options, environment: (_b = options.environment) != null ? _b : "production" };
+    this.storage = (_c = options.storage) != null ? _c : localStorageAdapter;
+    this.namespace = `apex_app_${encodeURIComponent(JSON.stringify([options.shopId, this.options.environment]))}`;
+    this.batchSize = Math.trunc(clamp(options.batchSize, 20, 1, 20));
+    this.capacity = Math.trunc(clamp(options.queueCapacity, 2e3, 1, 2e3));
+    this.retention = clamp(options.queueRetentionHours, 47, 0, 47) * 36e5;
+    this.flushInterval = clamp(options.flushIntervalSeconds, 5, 0.1, 86400);
+    this.platform = (_d = options.platform) != null ? _d : detectPlatform();
+    const firstAssignment = new Promise((resolve) => {
+      this.settleFirstAssignment = resolve;
+    });
+    if (!valid) {
+      this.stopped = true;
+      this.log("Apex configure: invalid options; SDK stopped");
+      this.ready = Promise.resolve();
+      return;
+    }
+    this.serial = this.initialize().catch(() => {
+      this.stopped = true;
+      this.log("Apex initialization failed");
+    });
+    this.ready = this.serial.then(() => {
+      if (this.stopped) return;
+      const timeoutMs = clamp(options.initTimeoutMs, 3e3, 0, 2147483647);
+      if (timeoutMs === 0) return;
+      return new Promise((resolve) => {
+        const timer = setTimeout(resolve, timeoutMs);
+        void firstAssignment.then(() => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    });
+  }
+  /** Drive lifecycle explicitly when the shell cannot expose its events. */
+  setAppState(state) {
+    var _a;
+    if (state !== "foreground" && state !== "background") {
+      this.log("Apex ignored invalid app state");
+      return;
+    }
+    if (this.stopped || state === this.appState) return;
+    this.appState = state;
+    const now = Date.now();
+    if (state === "background") {
+      (_a = this.backgroundAt) != null ? _a : this.backgroundAt = now;
+      if (now - this.lastBackground < 1e3) return;
+      this.lastBackground = now;
+      this.cancelTimer("foreground");
+      void this.task(async () => {
+        await this.persistQueue();
+        await this.flushLocked(true);
+      });
+    } else {
+      if (this.backgroundAt !== null && Date.now() - this.backgroundAt >= 18e5) {
+        this.session = uuid();
+        this.exposures.clear();
+        this.warnings.clear();
+      }
+      this.backgroundAt = null;
+      const deliver = now - this.lastForeground >= 1e3;
+      if (now - this.lastForeground < 1e3 && !this.foregroundPending) return;
+      if (now - this.lastForeground >= 1e3) this.lastForeground = now;
+      this.foregroundPending = true;
+      this.schedule("foreground", this.jitter(), () => {
+        if (this.appState === "foreground") {
+          this.foregroundPending = false;
+          void this.refresh();
+        }
+      });
+      if (deliver) void this.flush();
+    }
+  }
+  /** Durable anonymous identity for registering/looking up a QA device. */
+  get deviceId() {
+    return this.device;
+  }
+  get userId() {
+    return this.identity;
+  }
+  log(line) {
+    var _a, _b;
+    try {
+      (_b = (_a = this.options).logger) == null ? void 0 : _b.call(_a, line);
+    } catch {
+    }
+  }
+  logFailure(failureClass, line) {
+    if (!this.options.logger) return;
+    const now = Date.now();
+    const previous = this.failureLogs.get(failureClass);
+    if (previous !== void 0 && now >= previous && now - previous < 6e4) return;
+    if (!this.failureLogs.has(failureClass) && this.failureLogs.size >= 128) return;
+    this.failureLogs.set(failureClass, now);
+    this.log(line);
+  }
+  logDeliveryFailure(lane, reply, outcome) {
+    const failure = reply ? `HTTP ${reply.status}` : "network error";
+    this.logFailure(`${lane}:${failure}`, `Apex ${lane} failed: ${failure}; ${outcome}`);
+  }
+  async initialize() {
+    var _a, _b;
+    if (typeof document === "undefined") {
+      this.stopped = true;
+      this.log("Apex requires a browser or WebView; initialization skipped");
+      return;
+    }
+    try {
+      const saved = await this.storage.get("apex_device_id");
+      this.device = isUuid(saved) ? saved : uuid();
+      if (!isUuid(saved)) await this.storage.set("apex_device_id", this.device);
+      this.identity = this.device;
+      this.assignmentIdentity = this.device;
+      this.session = uuid();
+    } catch {
+      this.stopped = true;
+      this.log("Apex identity storage unavailable; networking stopped");
+      return;
+    }
+    const savedIdentity = await this.read("identity");
+    if (typeof savedIdentity === "string") this.identity = savedIdentity;
+    this.assignmentIdentity = this.identity;
+    const raw = await this.read("cache");
+    if (isRow(raw)) {
+      const entries = isRow(raw.entries) ? raw.entries : typeof raw.identity === "string" ? { [raw.identity]: raw } : {};
+      for (const [id, entry] of Object.entries(entries)) {
+        if (isRow(entry) && typeof entry.fetched_at === "number" && Number.isFinite(entry.fetched_at) && Array.isArray(entry.assignments) && entry.assignments.every(isRow)) {
+          this.cache.set(id, { fetched_at: entry.fetched_at, assignments: entry.assignments });
+        }
+      }
+    }
+    this.trimCache();
+    const cached = this.cache.get(this.identity);
+    if (cached) {
+      this.assignments = cached.assignments;
+      this.assignmentsLoaded = true;
+      this.fetchedAt = cached.fetched_at;
+      this.fromCache = true;
+    }
+    const events = await this.read("events");
+    const restored = Array.isArray(events) ? events.filter(isRow) : [];
+    if (restored.length <= this.capacity) this.events = this.durableEvents = restored;
+    if (!await this.prune(restored, true) && restored.length > this.capacity) {
+      this.stopped = true;
+      this.log("Apex queue restore exceeded capacity and could not be saved; networking stopped");
+      return;
+    }
+    if (this.stopped) return;
+    if (typeof document !== "undefined") {
+      if (document.visibilityState === "hidden") {
+        this.backgroundAt = Date.now();
+        this.appState = "background";
+      }
+      document.addEventListener("visibilitychange", this.visibility);
+      document.addEventListener("pause", this.pause);
+      document.addEventListener("resume", this.resume);
+    }
+    const app = (_b = (_a = globalThis.Capacitor) == null ? void 0 : _a.Plugins) == null ? void 0 : _b.App;
+    try {
+      if (typeof (app == null ? void 0 : app.addListener) === "function") {
+        void Promise.resolve(app.addListener("appStateChange", (state) => this.setAppState(state.isActive ? "foreground" : "background"))).then((listener) => {
+          if (this.stopped) this.removeShellListener(listener);
+          else this.shellListener = listener;
+        }).catch(() => this.log("Apex shell lifecycle listener unavailable"));
+      }
+    } catch {
+      this.log("Apex shell lifecycle listener unavailable");
+    }
+    this.requestAssignments();
+    this.scheduleFlush(this.events.length ? 0 : this.flushInterval);
+  }
+  task(action) {
+    this.queueActions = void 0;
+    const next = this.serial.then(action).catch(() => this.log("Apex operation failed"));
+    this.serial = next;
+    return next;
+  }
+  // Keep mutation order with identity/assignment operations, but let subsequent
+  // enqueues stage their rows while the adapter is writing. Only the caller waits
+  // for its durability barrier, not the shared mutation chain.
+  queueTask(action) {
+    if (!this.queueActions) {
+      const actions = [];
+      void this.task(() => {
+        if (this.queueActions === actions) this.queueActions = void 0;
+        for (const pending of actions) {
+          if (this.stopped) {
+            pending.resolve(false);
+            continue;
+          }
+          try {
+            void pending.action().then(pending.resolve, () => {
+              this.log("Apex operation failed");
+              pending.resolve(false);
+            });
+          } catch {
+            this.log("Apex operation failed");
+            pending.resolve(false);
+          }
+        }
+      });
+      this.queueActions = actions;
+    }
+    return new Promise((resolve) => this.queueActions.push({ action, resolve }));
+  }
+  persistQueue(failureLog) {
+    if (this.queueRevision === this.durableQueueRevision) return Promise.resolve(true);
+    const saved = new Promise((resolve) => this.queueWaiters.push({ revision: this.queueRevision, resolve, failureLog }));
+    if (!this.queueWriter) {
+      this.queueWriter = Promise.resolve().then(async () => {
+        while (this.queueWaiters.length) {
+          const revision = this.queueRevision, snapshot = this.events;
+          for (const line of this.queueDropLogs) this.log(line);
+          this.queueDropLogs.clear();
+          if (!await this.write("events", snapshot, "")) {
+            this.events = this.durableEvents;
+            this.durableQueueRevision = this.queueRevision;
+            const failed = this.queueWaiters.splice(0);
+            this.queueDropLogs.clear();
+            this.log("Apex could not persist events");
+            for (const waiter of failed) {
+              if (waiter.failureLog) this.log(waiter.failureLog);
+              waiter.resolve(false);
+            }
+            break;
+          }
+          this.durableEvents = snapshot;
+          this.durableQueueRevision = revision;
+          const completed = this.queueWaiters.filter((waiter) => waiter.revision <= revision);
+          this.queueWaiters = this.queueWaiters.filter((waiter) => waiter.revision > revision);
+          for (const waiter of completed) waiter.resolve(true);
+        }
+        this.queueWriter = void 0;
+      });
+    }
+    return saved;
+  }
+  replaceQueue(next, failureLog) {
+    this.events = next;
+    this.queueRevision++;
+    return this.persistQueue(failureLog);
+  }
+  async read(name) {
+    try {
+      const raw = await this.storage.get(`${this.namespace}-${name}.json`);
+      return raw === null ? null : JSON.parse(raw);
+    } catch {
+      this.log(`Apex could not load ${name}`);
+      return null;
+    }
+  }
+  async write(name, value, failureLog) {
+    try {
+      await this.storage.set(`${this.namespace}-${name}.json`, JSON.stringify(value));
+      return true;
+    } catch {
+      const line = failureLog != null ? failureLog : `Apex could not persist ${name}`;
+      if (line) this.log(line);
+      return false;
+    }
+  }
+  schedule(name, seconds, action) {
+    this.cancelTimer(name);
+    if (this.stopped || this.networkingSuspended) return;
+    this.timers.set(name, setTimeout(() => {
+      this.timers.delete(name);
+      if (!this.stopped) action();
+    }, seconds * 1e3));
+  }
+  cancelTimer(name) {
+    const timer = this.timers.get(name);
+    if (timer !== void 0) clearTimeout(timer);
+    this.timers.delete(name);
+  }
+  jitter() {
+    var _a;
+    const [lo, hi] = (_a = this.options.refreshJitterSeconds) != null ? _a : [0, 10];
+    return Number.isFinite(lo) && Number.isFinite(hi) && Number.isFinite(hi - lo) && hi >= lo ? Math.max(0, lo + Math.random() * (hi - lo)) : 0;
+  }
+  emit(change) {
+    for (const handler of [...this.handlers]) {
+      try {
+        handler(clone(change));
+      } catch {
+        this.log("Apex listener failed");
+      }
+    }
+  }
+  onChange(handler) {
+    if (typeof handler !== "function") {
+      this.log("Apex ignored invalid change handler");
+      return { cancel() {
+      } };
+    }
+    if (this.handlers.size >= 1024) {
+      this.logFailure("handler-capacity", "Apex ignored change handler: listener capacity");
+      return { cancel() {
+      } };
+    }
+    this.handlers.add(handler);
+    return { cancel: () => {
+      this.handlers.delete(handler);
+    } };
+  }
+  stop(code) {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.generation++;
+    this.logFailure(`auth-stop:${code}`, `Apex SDK stopped: ${code}`);
+    this.cleanup();
+    this.emit({ type: "stopped", code });
+  }
+  cleanup() {
+    this.settleFirstAssignment();
+    for (const settle of this.identifyWaiters.values()) settle();
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    for (const request of this.requests) request.abort();
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibility);
+      document.removeEventListener("pause", this.pause);
+      document.removeEventListener("resume", this.resume);
+    }
+    if (this.shellListener) this.removeShellListener(this.shellListener);
+    this.shellListener = void 0;
+  }
+  removeShellListener(listener) {
+    try {
+      void Promise.resolve(listener.remove()).catch(() => this.log("Apex shell lifecycle cleanup failed"));
+    } catch {
+      this.log("Apex shell lifecycle cleanup failed");
+    }
+  }
+  /** Retire this context before replacing it. Completes outstanding storage operations. */
+  shutdown() {
+    this.stopped = true;
+    this.generation++;
+    this.cleanup();
+    return this.serial.then(() => this.queueWriter);
+  }
+  identify(userId, _attributes) {
+    if (userId !== null && !textInput(userId) || _attributes !== void 0 && (!recordInput(_attributes) || !Object.values(_attributes).every((value) => typeof value === "string" && value.length <= 1024))) {
+      this.log("Apex ignored invalid identity or attributes");
+      return Promise.resolve();
+    }
+    if (this.stopped) return Promise.resolve();
+    const revision = ++this.identityRevision;
+    this.generation++;
+    this.identityPending = true;
+    for (const [earlier, settle] of [...this.identifyWaiters]) if (earlier < revision) settle();
+    const timeoutMs = clamp(this.options.initTimeoutMs, 3e3, 0, 2147483647);
+    const loaded = new Promise((resolve) => {
+      if (timeoutMs === 0) {
+        resolve();
+        return;
+      }
+      const settle = () => {
+        clearTimeout(timer);
+        this.identifyWaiters.delete(revision);
+        resolve();
+      };
+      const timer = setTimeout(settle, timeoutMs);
+      this.identifyWaiters.set(revision, settle);
+    });
+    const persisted = this.task(async () => {
+      var _a, _b;
+      if (this.stopped) {
+        (_a = this.identifyWaiters.get(revision)) == null ? void 0 : _a();
+        return;
+      }
+      const previous = this.identity;
+      this.identity = userId != null ? userId : this.device;
+      const warning = "Apex identity could not be saved; the SDK stopped networking";
+      if (!await this.write("identity", userId, this.identityWriteWarned ? "" : warning)) {
+        this.identity = previous;
+        this.identityWriteWarned = true;
+        this.networkingSuspended = true;
+        this.generation++;
+        this.networkRevision++;
+        for (const timer of this.timers.values()) clearTimeout(timer);
+        this.timers.clear();
+        for (const request of this.requests) request.abort();
+        this.flushing = false;
+        if (revision === this.identityRevision) this.identityPending = this.identity !== this.assignmentIdentity;
+        (_b = this.identifyWaiters.get(revision)) == null ? void 0 : _b();
+        return;
+      }
+      if (this.networkingSuspended) {
+        this.networkingSuspended = false;
+        this.scheduleFlush(this.flushInterval);
+      }
+      if (revision === this.identityRevision) this.requestAssignments();
+    });
+    return persisted.then(() => loaded);
+  }
+  refresh() {
+    return this.task(() => this.requestAssignments());
+  }
+  async send(path, body, background = false) {
+    var _a, _b, _c;
+    if (this.stopped || this.networkingSuspended) return null;
+    const controller = new AbortController();
+    if (path === "assign") {
+      if (this.assignmentRequests.size >= 3) (_a = this.assignmentRequests.values().next().value) == null ? void 0 : _a.abort();
+      this.assignmentRequests.add(controller);
+    }
+    this.requests.add(controller);
+    const timeout = setTimeout(() => controller.abort(), 3e4);
+    let abort = () => {
+    };
+    const aborted = new Promise((_, reject) => {
+      abort = () => {
+        clearTimeout(timeout);
+        this.requests.delete(controller);
+        this.assignmentRequests.delete(controller);
+        reject(new Error("aborted"));
+      };
+      controller.signal.addEventListener("abort", abort, { once: true });
+    });
+    try {
+      const payload = JSON.stringify(body);
+      const keepalive = background && new TextEncoder().encode(payload).byteLength <= 65536;
+      const response = await Promise.race([aborted, ((_b = this.options.fetch) != null ? _b : globalThis.fetch)(`${((_c = this.options.baseUrl) != null ? _c : "https://events.drip-apex.com").replace(/\/+$/, "")}/v1/${path}`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.options.publishableKey}`, "Content-Type": "application/json" },
+        body: payload,
+        signal: controller.signal,
+        redirect: "error",
+        ...keepalive ? { keepalive: true } : {}
+      })]);
+      if (controller.signal.aborted) return null;
+      let parsed = null;
+      try {
+        parsed = await Promise.race([aborted, response.json()]);
+      } catch {
+      }
+      if (controller.signal.aborted) return null;
+      return { status: response.status, body: isRow(parsed) ? parsed : null, retryAfter: response.headers.get("Retry-After") };
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timeout);
+      controller.signal.removeEventListener("abort", abort);
+      this.requests.delete(controller);
+      this.assignmentRequests.delete(controller);
+    }
+  }
+  fatal(reply) {
+    var _a;
+    const code = string((_a = reply == null ? void 0 : reply.body) == null ? void 0 : _a.code);
+    return (reply == null ? void 0 : reply.status) === 401 && (code === "invalid_publishable_key" || code === "publishable_key_not_allowed") ? code : void 0;
+  }
+  requestAssignments() {
+    if (this.stopped || this.networkingSuspended) return;
+    const token = ++this.generation;
+    this.cancelTimer("assign");
+    if (Date.now() < this.assignNotBefore) {
+      this.schedule("assign", (this.assignNotBefore - Date.now()) / 1e3, () => {
+        void this.refresh();
+      });
+      return;
+    }
+    const requested = this.identity;
+    const revision = this.identityRevision;
+    void this.send("assign", { shop_id: this.options.shopId, user_id: requested, environment: this.options.environment }).then((reply) => this.task(async () => {
+      var _a, _b, _c, _d;
+      if (this.stopped || this.networkingSuspended) return;
+      const fatal = this.fatal(reply);
+      if (fatal) {
+        this.stop(fatal);
+        return;
+      }
+      if (token !== this.generation || revision !== this.identityRevision || requested !== this.identity) return;
+      const list = (_a = reply == null ? void 0 : reply.body) == null ? void 0 : _a.assignments;
+      if (reply && reply.status >= 200 && reply.status < 300 && ((_b = reply.body) == null ? void 0 : _b.user_id) === requested && Array.isArray(list) && list.every(isRow)) {
+        const before = this.keyed();
+        this.assignments = list;
+        this.assignmentsLoaded = true;
+        this.assignmentIdentity = requested;
+        this.identityPending = false;
+        this.fetchedAt = Date.now() / 1e3;
+        this.fromCache = false;
+        this.assignFailures = 0;
+        this.assignNotBefore = -Infinity;
+        this.cache.set(requested, { fetched_at: this.fetchedAt, assignments: list });
+        this.trimCache();
+        await this.write("cache", { entries: Object.fromEntries(this.cache) });
+        (_c = this.identifyWaiters.get(revision)) == null ? void 0 : _c();
+        this.changed(before);
+      } else {
+        if (reply && reply.status >= 400 && reply.status < 500 && ![401, 403, 408, 429].includes(reply.status) && ((_d = reply.body) == null ? void 0 : _d.retryable) !== true) {
+          this.logDeliveryFailure("assignment fetch", reply, "no retry scheduled");
+          return;
+        }
+        const delay = this.retryDelay(reply, ++this.assignFailures);
+        this.logDeliveryFailure("assignment fetch", reply, `retry scheduled in ${Math.round(delay * 10) / 10}s`);
+        this.assignNotBefore = Date.now() + delay * 1e3;
+        this.schedule("assign", delay, () => {
+          void this.refresh();
+        });
+      }
+    })).finally(() => this.settleFirstAssignment());
+  }
+  trimCache() {
+    const sorted = [...this.cache].sort(([a, x], [b, y]) => x.fetched_at - y.fetched_at || (a < b ? -1 : a > b ? 1 : 0));
+    for (const [id] of sorted.slice(0, Math.max(0, this.cache.size - 4))) this.cache.delete(id);
+  }
+  keyed() {
+    const result = /* @__PURE__ */ new Map();
+    for (const item of this.assignments) if (item.kind === "feature_flag" && isRow(item.feature_flag) && typeof item.feature_flag.key === "string") result.set(item.feature_flag.key, item);
+    return result;
+  }
+  changed(before) {
+    const after = this.keyed();
+    const keys = [.../* @__PURE__ */ new Set([...before.keys(), ...after.keys()])].filter((key) => !equalJSON(before.get(key), after.get(key))).sort();
+    if (keys.length) this.emit({ type: "changed", keys });
+  }
+  reason() {
+    return this.fetchedAt !== null && Date.now() / 1e3 - this.fetchedAt > 60 ? "stale" : this.fromCache ? "cached" : "fresh";
+  }
+  flag(key, defaultValue, opts = {}) {
+    if (!textInput(key) || !flagOptions(opts) || !jsonValue(defaultValue) || !["boolean", "string", "number"].includes(typeof defaultValue)) return defaultValue;
+    const item = this.keyed().get(key);
+    if (!item) {
+      this.warn(key);
+      return defaultValue;
+    }
+    const value = item.value;
+    if (!jsonValue(value) || typeof value !== typeof defaultValue || typeof defaultValue === "number" && !safeNumber(value)) {
+      this.warn(key);
+      return defaultValue;
+    }
+    if (opts.exposure !== "manual") this.expose(item);
+    return value;
+  }
+  flagObject(key, defaultValue, opts = {}) {
+    if (!textInput(key) || !flagOptions(opts) || !jsonValue(defaultValue)) return defaultValue;
+    const item = this.keyed().get(key);
+    if (!item) {
+      this.warn(key);
+      return defaultValue;
+    }
+    try {
+      if (!jsonValue(item.value) || !Object.prototype.hasOwnProperty.call(item, "value")) throw new Error("missing value");
+      const value = clone(item.value);
+      if (opts.validate ? !opts.validate(value) : !sameJSONType(value, defaultValue)) throw new Error("incompatible value");
+      if (opts.exposure !== "manual") this.expose(item);
+      return value;
+    } catch {
+      this.warn(key);
+      return defaultValue;
+    }
+  }
+  variation(key) {
+    var _a;
+    if (!textInput(key)) return null;
+    const item = this.keyed().get(key);
+    if (!item || typeof item.variation_id !== "string" || !Number.isSafeInteger(item.variation_index)) {
+      return { id: "", index: 0, isControl: false, kind: "", value: null, reason: "default" };
+    }
+    if (item.value !== void 0 && !jsonValue(item.value)) {
+      this.warn(key);
+      return null;
+    }
+    this.expose(item);
+    return {
+      id: item.variation_id,
+      index: item.variation_index,
+      isControl: item.is_control === true,
+      kind: (_a = string(item.kind)) != null ? _a : "",
+      value: item.value === void 0 ? null : clone(item.value),
+      reason: this.reason()
+    };
+  }
+  warn(key) {
+    if (!this.assignmentsLoaded) return;
+    if (this.warnings.size >= 256) return;
+    if (!this.warnings.has(key)) {
+      this.warnings.add(key);
+      this.log(`Apex typed flag '${key}' unavailable or incompatible; using default`);
+    }
+  }
+  logExposure(key) {
+    if (!textInput(key)) return;
+    const item = this.keyed().get(key);
+    if (item) this.expose(item);
+  }
+  expose(item) {
+    var _a;
+    if (this.stopped || this.networkingSuspended || this.identityPending || typeof item.experiment_id !== "string" || typeof item.variation_id !== "string" || !Number.isSafeInteger(item.variation_index)) return;
+    const epoch = (_a = item.assignment_epoch) != null ? _a : null;
+    const key = JSON.stringify([this.session, this.assignmentIdentity, item.experiment_id, item.variation_id, epoch]);
+    if (this.exposures.has(key) || this.pendingExposures.has(key)) return;
+    if (this.exposures.size + this.pendingExposures.size >= 4096) {
+      this.log("Apex dropped exposure: session dedupe capacity");
+      return;
+    }
+    const event = {
+      ...this.event("experiment_viewed", { index: item.variation_index, assignment_epoch: epoch }, this.assignmentIdentity),
+      experiment_id: item.experiment_id,
+      variation_id: item.variation_id
+    };
+    this.pendingExposures.add(key);
+    void this.queueTask(() => this.enqueue([event])).then((saved) => {
+      if (saved) this.exposures.add(key);
+      this.pendingExposures.delete(key);
+    });
+  }
+  validProperties(properties) {
+    const fields = optionRecord(properties);
+    if (!fields) {
+      this.log("Apex ignored non-JSON event properties");
+      return false;
+    }
+    properties = fields;
+    if (Object.prototype.hasOwnProperty.call(properties, "revenue")) {
+      const value = properties.revenue;
+      if (!(typeof value === "number" && Number.isFinite(value)) && !(typeof value === "string" && /^[-+]?\d+(?:[.,]\d+)?$/.test(value.trim()) && Number.isFinite(Number(value.trim().replace(",", "."))))) {
+        this.log("Apex dropped event: revenue must be a finite number");
+        return false;
+      }
+    }
+    const forbidden = /* @__PURE__ */ new Set(["email", "phone", "password", "ssn", "credit_card", "card_number"]);
+    for (const key of Object.keys(properties).sort()) if (forbidden.has(key.normalize("NFD").replace(/\p{Mn}/gu, "").toLowerCase())) {
+      this.log(`Apex dropped event: property ${key} is not allowed`);
+      return false;
+    }
+    if (!jsonValue(properties)) {
+      this.log("Apex ignored non-JSON event properties");
+      return false;
+    }
+    return true;
+  }
+  track(event, properties = {}) {
+    if (!textInput(event, 256)) {
+      this.log("Apex dropped event: invalid event name");
+      return Promise.resolve();
+    }
+    if (!this.validProperties(properties)) return Promise.resolve();
+    const snapshot = clone(properties);
+    return this.queueTask(() => this.enqueue([this.event(event, snapshot, this.identity)])).then(() => {
+    });
+  }
+  trackPurchase(orderId, revenue, currency, properties = {}) {
+    if (!textInput(orderId)) {
+      this.log("Apex dropped purchase: order_id must be a string");
+      return Promise.resolve();
+    }
+    if (!textInput(currency, 32)) {
+      this.log("Apex dropped purchase: currency must be a 3-letter ISO 4217 code");
+      return Promise.resolve();
+    }
+    const order = orderId.trim(), code = currency.trim().toUpperCase();
+    if (!order) {
+      this.log("Apex dropped purchase: order_id is required");
+      return Promise.resolve();
+    }
+    if (!safeNumber(revenue) || revenue < 0) {
+      this.log("Apex dropped purchase: revenue must be a finite non-negative number");
+      return Promise.resolve();
+    }
+    if (!/^[A-Z]{3}$/.test(code)) {
+      this.log("Apex dropped purchase: currency must be a 3-letter ISO 4217 code");
+      return Promise.resolve();
+    }
+    if (!recordInput(properties)) {
+      this.log("Apex ignored non-JSON purchase properties");
+      return Promise.resolve();
+    }
+    const aliases = /* @__PURE__ */ new Set(["orderId", "order_id", "bookingId", "booking_id", "revenue", "currency", "currencyCode", "currency_code"]);
+    const merged = { ...Object.fromEntries(Object.entries(properties).filter(([key]) => !aliases.has(key))), order_id: order, revenue, currency: code };
+    if (!this.validProperties(merged)) return Promise.resolve();
+    const snapshot = clone(merged);
+    return this.queueTask(() => {
+      const base = this.event("purchase", snapshot, this.identity);
+      const batch = [base];
+      for (const assignment of this.assignments) {
+        if (typeof assignment.experiment_id !== "string" || typeof assignment.variation_id !== "string") continue;
+        const copy = { ...base, experiment_id: assignment.experiment_id, variation_id: assignment.variation_id, visitor_id: this.assignmentIdentity };
+        delete copy.user_id;
+        if (this.assignmentIdentity !== this.device) copy.user_id = this.assignmentIdentity;
+        batch.push(copy);
+      }
+      return this.enqueue(batch, "Apex dropped purchase: queue write failed");
+    }).then(() => {
+    });
+  }
+  event(type, properties, visitor) {
+    var _a, _b, _c, _d;
+    let screen = string(properties.screen);
+    if (screen === void 0) {
+      try {
+        screen = string((_b = (_a = this.options).screen) == null ? void 0 : _b.call(_a));
+      } catch {
+      }
+    }
+    return {
+      event_type: type,
+      event_id: uuid(),
+      visitor_id: visitor,
+      session_id: this.session,
+      url: screenURL((_c = this.options.applicationId) != null ? _c : "unknown", screen != null ? screen : "home"),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      platform: this.platform,
+      environment: this.options.environment,
+      app_version: (_d = this.options.appVersion) != null ? _d : "",
+      sdk_version: version,
+      properties,
+      ...visitor !== this.device ? { user_id: visitor } : {},
+      ...this.options.qaMode || this.options.environment !== "production" ? { qa_mode: true } : {}
+    };
+  }
+  retained(events = this.events) {
+    const cutoff = Date.now() - this.retention;
+    const rows = events.filter((event) => typeof event.timestamp === "string" && Date.parse(event.timestamp) > cutoff);
+    const result = [];
+    for (let start = 0; start < rows.length; ) {
+      let end = start + 1;
+      while (end < rows.length && rows[end].event_id === rows[start].event_id) end++;
+      if (end - start <= Math.min(this.capacity, SERVER_MAX_EVENTS)) result.push(...rows.slice(start, end));
+      start = end;
+    }
+    return result;
+  }
+  async prune(events = this.events, force = false) {
+    const retained = this.retained(events);
+    const start = this.capacityStart(retained, this.capacity);
+    if (retained.length < events.length) this.queueDropLogs.add("Apex dropped expired or oversized event rows");
+    if (start) this.queueDropLogs.add("Apex dropped event rows: queue capacity");
+    const next = retained.slice(start);
+    if (!force && next.length === this.events.length && next.every((row, i) => row === this.events[i])) return this.persistQueue();
+    return this.replaceQueue(next);
+  }
+  capacityStart(rows, capacity) {
+    let first = Math.max(0, rows.length - capacity);
+    if (first > 0 && first < rows.length) {
+      const id = rows[first - 1].event_id;
+      while (first < rows.length && rows[first].event_id === id) first++;
+    }
+    return first;
+  }
+  async enqueue(batch, failureLog) {
+    if (batch.length > this.capacity || batch.length > SERVER_MAX_EVENTS) {
+      this.log(`Apex dropped purchase: group exceeds queue capacity or the ${SERVER_MAX_EVENTS}-event request limit`);
+      return false;
+    }
+    const retained = this.retained();
+    const first = this.capacityStart(retained, this.capacity - batch.length);
+    if (retained.length < this.events.length) this.queueDropLogs.add("Apex dropped expired or oversized event rows");
+    if (first) this.queueDropLogs.add("Apex dropped event rows: queue capacity");
+    const next = [...retained.slice(first), ...batch];
+    if (!await this.replaceQueue(next, failureLog)) return false;
+    if (this.events.length >= this.batchSize) void this.flush();
+    return true;
+  }
+  flush() {
+    return this.task(() => this.flushLocked());
+  }
+  scheduleFlush(delay) {
+    this.schedule("flush", delay, () => {
+      void this.flush();
+    });
+  }
+  deliveryKey(event) {
+    var _a, _b;
+    return JSON.stringify([event.event_id, (_a = event.experiment_id) != null ? _a : null, (_b = event.variation_id) != null ? _b : null]);
+  }
+  async flushLocked(background = this.appState === "background") {
+    if (this.stopped || this.networkingSuspended || this.flushing) return;
+    if (Date.now() < this.eventsNotBefore) {
+      this.scheduleFlush((this.eventsNotBefore - Date.now()) / 1e3);
+      return;
+    }
+    await this.prune();
+    const retained = this.retained();
+    let end = Math.min(retained.length, this.batchSize);
+    if (end > 0) {
+      const id = retained[end - 1].event_id;
+      while (end < retained.length && retained[end].event_id === id) end++;
+      if (end > SERVER_MAX_EVENTS) {
+        while (end > 0 && retained[end - 1].event_id === id) end--;
+      }
+    }
+    const batch = retained.slice(0, end);
+    if (!batch.length) {
+      this.scheduleFlush(this.flushInterval);
+      return;
+    }
+    const ids = new Set(batch.map((event) => this.deliveryKey(event)));
+    this.flushing = true;
+    const revision = this.networkRevision;
+    void this.send("events", { _shopId: this.options.shopId, events: batch }, background).then((reply) => this.task(async () => {
+      var _a, _b;
+      if (revision !== this.networkRevision) return;
+      this.flushing = false;
+      if (this.stopped || this.networkingSuspended) return;
+      const fatal = this.fatal(reply);
+      if (fatal) {
+        this.stop(fatal);
+        return;
+      }
+      const accepted = (reply == null ? void 0 : reply.status) === 202 && ((_a = reply.body) == null ? void 0 : _a.ok) === true;
+      const drop = reply !== null && reply.status >= 400 && reply.status < 500 && ![401, 403, 408, 429].includes(reply.status) && ((_b = reply.body) == null ? void 0 : _b.retryable) !== true;
+      if (accepted || drop) {
+        if (drop) this.queueDropLogs.add("Apex dropped event batch: non-retryable response");
+        const next = this.events.filter((event) => !ids.has(this.deliveryKey(event)));
+        const persisted = await this.replaceQueue(next);
+        this.eventFailures = 0;
+        this.eventsNotBefore = persisted ? -Infinity : Date.now() + this.flushInterval * 1e3;
+        if (drop) this.logDeliveryFailure(
+          "event delivery",
+          reply,
+          persisted ? "batch dropped" : `batch retained after storage failure; retry scheduled in ${Math.round(this.flushInterval * 10) / 10}s`
+        );
+        this.scheduleFlush(persisted && next.length ? 0 : this.flushInterval);
+      } else {
+        const delay = this.retryDelay(reply, ++this.eventFailures);
+        this.logDeliveryFailure("event delivery", reply, `retry scheduled in ${Math.round(delay * 10) / 10}s`);
+        this.eventsNotBefore = Date.now() + delay * 1e3;
+        this.scheduleFlush(delay);
+      }
+    }));
+  }
+  retryDelay(reply, failures) {
+    var _a, _b;
+    if (reply && (reply.status === 429 || reply.status >= 500 || ((_a = reply.body) == null ? void 0 : _a.retryable) === true)) {
+      const header = reply.retryAfter;
+      if (header !== null && header.trim() !== "") {
+        const seconds = Number(header);
+        if (Number.isFinite(seconds) && seconds >= 0) return Math.max(0.1, seconds);
+        const time = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{1,2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT$/.test(header) ? Date.parse(header) : NaN;
+        if (Number.isFinite(time)) return Math.max(0.1, (time - Date.now()) / 1e3);
+      }
+      if (((_b = reply.body) == null ? void 0 : _b.code) === "publishable_key_lookup_unavailable") return 5;
+    }
+    if ((reply == null ? void 0 : reply.status) === 401 || (reply == null ? void 0 : reply.status) === 403) return 300;
+    if (reply && reply.status >= 400 && reply.status < 500 && ![408, 429].includes(reply.status)) return 30;
+    return Math.min(60, 5 * 2 ** Math.min(4, Math.max(0, failures - 1)) * (1 + Math.random() * 0.2));
+  }
+};
+function sameJSONType(value, fallback) {
+  if (fallback === null) return value === null;
+  if (Array.isArray(fallback)) return Array.isArray(value);
+  if (isRow(fallback)) return isRow(value);
+  return typeof value === typeof fallback && (typeof value !== "number" || safeNumber(value));
+}
+function equalJSON(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => equalJSON(v, b[i]));
+  if (isRow(a) && isRow(b)) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((k) => Object.prototype.hasOwnProperty.call(b, k) && equalJSON(a[k], b[k]));
+  }
+  return false;
+}
+var Apex = class {
+  // Snapshot event properties at the public call; a non-JSON value is passed through so the client logs and drops it.
+  static snapshot(properties) {
+    if (properties === void 0) return void 0;
+    return recordInput(properties) ? clone(properties) : properties;
+  }
+  static configure(options) {
+    var _a, _b;
+    const snapshot = (_a = optionRecord(options)) != null ? _a : { publishableKey: "", shopId: "", logger: loggerInput(options) };
+    const retired = (_b = this.client) == null ? void 0 : _b.shutdown();
+    this.client = void 0;
+    const sequence = ++this.configureSequence;
+    this.configuring = this.configuring.then(async () => {
+      var _a2, _b2;
+      await retired;
+      await ((_a2 = this.client) == null ? void 0 : _a2.shutdown());
+      this.client = new ApexClient(snapshot);
+      for (const entry of this.pendingHandlers) {
+        (_b2 = entry.subscription) == null ? void 0 : _b2.cancel();
+        entry.subscription = this.client.onChange(entry.handler);
+      }
+      await this.client.ready;
+      if (sequence === this.configureSequence) this.pendingHandlers.clear();
+    });
+    return this.configuring;
+  }
+  static get deviceId() {
+    var _a;
+    return (_a = this.client) == null ? void 0 : _a.deviceId;
+  }
+  static get userId() {
+    var _a;
+    return (_a = this.client) == null ? void 0 : _a.userId;
+  }
+  static identify(userId, attributes) {
+    var _a, _b;
+    return (_b = (_a = this.client) == null ? void 0 : _a.identify(userId, attributes)) != null ? _b : this.configuring.then(() => {
+      var _a2;
+      return (_a2 = this.client) == null ? void 0 : _a2.identify(userId, attributes);
+    });
+  }
+  static flag(key, defaultValue, opts) {
+    var _a, _b;
+    return (_b = (_a = this.client) == null ? void 0 : _a.flag(key, defaultValue, opts)) != null ? _b : defaultValue;
+  }
+  static flagObject(key, defaultValue, opts) {
+    const client = this.client;
+    return client ? client.flagObject(key, defaultValue, opts) : defaultValue;
+  }
+  static variation(key) {
+    var _a, _b;
+    return (_b = (_a = this.client) == null ? void 0 : _a.variation(key)) != null ? _b : null;
+  }
+  static logExposure(key) {
+    var _a;
+    (_a = this.client) == null ? void 0 : _a.logExposure(key);
+  }
+  static track(event, properties) {
+    if (this.client) return this.client.track(event, properties);
+    const snapshot = this.snapshot(properties);
+    return this.configuring.then(() => {
+      var _a;
+      return (_a = this.client) == null ? void 0 : _a.track(event, snapshot);
+    });
+  }
+  static trackPurchase(orderId, revenue, currency, properties) {
+    if (this.client) return this.client.trackPurchase(orderId, revenue, currency, properties);
+    const snapshot = this.snapshot(properties);
+    return this.configuring.then(() => {
+      var _a;
+      return (_a = this.client) == null ? void 0 : _a.trackPurchase(orderId, revenue, currency, snapshot);
+    });
+  }
+  static onChange(handler) {
+    var _a, _b;
+    if (typeof handler !== "function") return (_b = (_a = this.client) == null ? void 0 : _a.onChange(handler)) != null ? _b : { cancel() {
+    } };
+    if (this.client) return this.client.onChange(handler);
+    if (this.pendingHandlers.size >= 1024) return { cancel() {
+    } };
+    const entry = { handler };
+    this.pendingHandlers.add(entry);
+    return { cancel: () => {
+      var _a2;
+      this.pendingHandlers.delete(entry);
+      (_a2 = entry.subscription) == null ? void 0 : _a2.cancel();
+    } };
+  }
+  static refresh() {
+    var _a, _b;
+    return (_b = (_a = this.client) == null ? void 0 : _a.refresh()) != null ? _b : this.configuring.then(() => {
+      var _a2;
+      return (_a2 = this.client) == null ? void 0 : _a2.refresh();
+    });
+  }
+  static flush() {
+    var _a, _b;
+    return (_b = (_a = this.client) == null ? void 0 : _a.flush()) != null ? _b : this.configuring.then(() => {
+      var _a2;
+      return (_a2 = this.client) == null ? void 0 : _a2.flush();
+    });
+  }
+  static setAppState(state) {
+    if (this.client) this.client.setAppState(state);
+    else void this.configuring.then(() => {
+      var _a;
+      return (_a = this.client) == null ? void 0 : _a.setAppState(state);
+    });
+  }
+  static async shutdown() {
+    var _a;
+    await this.configuring;
+    await ((_a = this.client) == null ? void 0 : _a.shutdown());
+    this.client = void 0;
+  }
+};
+Apex.sdkVersion = version;
+Apex.configuring = Promise.resolve();
+Apex.configureSequence = 0;
+// Handlers registered while no client exists attach as soon as the next client is created,
+// so they also see changes emitted during initialization.
+Apex.pendingHandlers = /* @__PURE__ */ new Set();