@drakkar.software/sunglasses-core 0.2.0

package/dist/index.js

@@ -0,0 +1,1612 @@
+"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, {
+  ConsentManager: () => ConsentManager,
+  EventCounter: () => EventCounter,
+  EventQueue: () => EventQueue,
+  FrequencyMiddleware: () => FrequencyMiddleware,
+  IdentityManager: () => IdentityManager,
+  LocalEventArchive: () => LocalEventArchive,
+  MiddlewarePipeline: () => MiddlewarePipeline,
+  PiiSanitizer: () => PiiSanitizer,
+  SamplingMiddleware: () => SamplingMiddleware,
+  SessionManager: () => SessionManager,
+  SunglassesCore: () => SunglassesCore,
+  TraitManager: () => TraitManager,
+  asTyped: () => asTyped,
+  createLogger: () => createLogger,
+  generateUUID: () => generateUUID,
+  nowISO: () => nowISO,
+  sha256Hex: () => sha256Hex
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/timestamp.ts
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/ConsentManager.ts
+var STORAGE_KEY = "sunglasses:consent";
+var MAX_HISTORY_LENGTH = 10;
+var ConsentManager = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+    this.state = { status: "unknown", updatedAt: null };
+  }
+  /**
+   * Load persisted consent state. Must be called once during SDK initialization.
+   * @param defaultOptIn — when no persisted state exists, opt-in (true) or opt-out (false)
+   * @param policyVersion — current policy version; if it differs from stored, consent resets
+   * @param expiryMs — if set, consent older than this resets to 'unknown'
+   */
+  async initialize(defaultOptIn, policyVersion, expiryMs) {
+    try {
+      const raw = await this.storage.read(STORAGE_KEY);
+      if (raw !== null) {
+        const parsed = JSON.parse(raw);
+        if (expiryMs !== void 0 && parsed.status !== "unknown" && parsed.updatedAt !== null) {
+          const ageMs = Date.now() - new Date(parsed.updatedAt).getTime();
+          if (ageMs > expiryMs) {
+            this.logger.debug("ConsentManager: consent expired, resetting to unknown");
+            await this.resetToUnknown(policyVersion);
+            return;
+          }
+        }
+        if (policyVersion !== void 0 && parsed.policyVersion !== void 0 && parsed.policyVersion !== policyVersion) {
+          this.logger.debug(
+            "ConsentManager: policy version changed",
+            parsed.policyVersion,
+            "\u2192",
+            policyVersion,
+            "\u2014 resetting consent"
+          );
+          const historyEntry = {
+            status: "unknown",
+            policyVersion,
+            timestamp: nowISO()
+          };
+          this.state = {
+            status: "unknown",
+            updatedAt: nowISO(),
+            policyVersion,
+            history: this.appendHistory(parsed.history ?? [], historyEntry)
+          };
+          await this.persist();
+          return;
+        }
+        this.state = parsed;
+        if (policyVersion !== void 0 && this.state.policyVersion !== policyVersion) {
+          this.state = { ...this.state, policyVersion };
+          await this.persist();
+        }
+        this.logger.debug("ConsentManager: loaded persisted state", parsed.status);
+        return;
+      }
+    } catch (err) {
+      this.logger.warn("ConsentManager: failed to read persisted consent", err);
+    }
+    const initialStatus = defaultOptIn ? "opted-in" : "opted-out";
+    this.state = {
+      status: initialStatus,
+      updatedAt: null,
+      policyVersion,
+      history: []
+    };
+    this.logger.debug(
+      "ConsentManager: first run, defaultOptIn=",
+      defaultOptIn,
+      "\u2192",
+      this.state.status
+    );
+    await this.persist();
+  }
+  get status() {
+    return this.state.status;
+  }
+  isOptedIn() {
+    return this.state.status === "opted-in";
+  }
+  isOptedOut() {
+    return this.state.status === "opted-out";
+  }
+  async optIn(policyVersion) {
+    const timestamp = nowISO();
+    const entry = {
+      status: "opted-in",
+      policyVersion: policyVersion ?? this.state.policyVersion,
+      timestamp
+    };
+    this.state = {
+      ...this.state,
+      status: "opted-in",
+      updatedAt: timestamp,
+      policyVersion: policyVersion ?? this.state.policyVersion,
+      history: this.appendHistory(this.state.history ?? [], entry)
+    };
+    this.logger.debug("ConsentManager: opted in");
+    await this.persist();
+  }
+  async optOut(policyVersion) {
+    const timestamp = nowISO();
+    const entry = {
+      status: "opted-out",
+      policyVersion: policyVersion ?? this.state.policyVersion,
+      timestamp
+    };
+    this.state = {
+      ...this.state,
+      status: "opted-out",
+      updatedAt: timestamp,
+      policyVersion: policyVersion ?? this.state.policyVersion,
+      history: this.appendHistory(this.state.history ?? [], entry)
+    };
+    this.logger.debug("ConsentManager: opted out");
+    await this.persist();
+  }
+  /** Returns a copy of the consent audit trail (oldest first). */
+  getHistory() {
+    return [...this.state.history ?? []];
+  }
+  /**
+   * Reset consent status to 'unknown'.
+   * Used internally by consent expiry and deleteUserData().
+   * Appends a history entry so the reset is auditable.
+   */
+  async resetToUnknown(policyVersion) {
+    const timestamp = nowISO();
+    const entry = {
+      status: "unknown",
+      policyVersion: policyVersion ?? this.state.policyVersion,
+      timestamp
+    };
+    this.state = {
+      status: "unknown",
+      updatedAt: timestamp,
+      policyVersion: policyVersion ?? this.state.policyVersion,
+      history: this.appendHistory(this.state.history ?? [], entry)
+    };
+    this.logger.debug("ConsentManager: reset to unknown");
+    await this.persist();
+  }
+  // ── Private ─────────────────────────────────────────────────────────────────
+  appendHistory(existing, entry) {
+    const updated = [...existing, entry];
+    return updated.length > MAX_HISTORY_LENGTH ? updated.slice(updated.length - MAX_HISTORY_LENGTH) : updated;
+  }
+  async persist() {
+    try {
+      await this.storage.write(STORAGE_KEY, JSON.stringify(this.state));
+    } catch (err) {
+      this.logger.warn("ConsentManager: failed to persist consent state", err);
+    }
+  }
+};
+
+// src/EventCounter.ts
+var KEY_PREFIX = "sunglasses:count";
+var EventCounter = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+    /**
+     * In-memory cache of counts keyed by storage key.
+     * Updated synchronously on increment so getCount() can return immediately
+     * without waiting for storage writes to complete.
+     */
+    this.cache = /* @__PURE__ */ new Map();
+    /**
+     * Tracks all storage keys written during this session.
+     * Used to reliably clear an event's timed buckets on reset(),
+     * even when they fall outside the 90-day sweep window.
+     */
+    this.writtenKeys = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Increment the count for `eventName` across all four periods for `date`.
+   */
+  async increment(eventName, date = /* @__PURE__ */ new Date()) {
+    const periods = ["daily", "weekly", "monthly", "all-time"];
+    await Promise.all(periods.map((period) => this.incrementPeriod(eventName, period, date)));
+  }
+  async getCount(eventName, period, date = /* @__PURE__ */ new Date()) {
+    const key = this.storageKey(eventName, period, date);
+    const cached = this.cache.get(key);
+    if (cached !== void 0) return cached;
+    try {
+      const raw = await this.storage.read(key);
+      if (raw === null) return 0;
+      const n = parseInt(raw, 10);
+      const count = Number.isNaN(n) ? 0 : n;
+      this.cache.set(key, count);
+      return count;
+    } catch (err) {
+      this.logger.warn("EventCounter: failed to read count", err);
+      return 0;
+    }
+  }
+  /**
+   * Reset counts for a specific event (all periods), or all events if omitted.
+   *
+   * Note: resetting all events requires listing storage keys. This is a best-effort
+   * operation — adapters that don't support key enumeration will only clear
+   * the provided event name's keys.
+   */
+  async reset(eventName) {
+    if (eventName) {
+      await this.clearEvent(eventName);
+    } else {
+      const allKeys = [...this.writtenKeys];
+      for (const key of allKeys) {
+        try {
+          await this.storage.delete(key);
+        } catch {
+        }
+        this.writtenKeys.delete(key);
+        this.cache.delete(key);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const seenKeys = new Set(allKeys);
+      const periods = ["daily", "weekly", "monthly", "all-time"];
+      const eventNames = new Set(
+        allKeys.map((k) => k.split(":").pop()).filter(Boolean)
+      );
+      for (let i = 0; i < 90; i++) {
+        const d = new Date(now);
+        d.setDate(d.getDate() - i);
+        for (const name of eventNames) {
+          for (const period of periods) {
+            const key = this.storageKey(name, period, d);
+            if (!seenKeys.has(key)) {
+              seenKeys.add(key);
+              try {
+                await this.storage.delete(key);
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      this.logger.debug("EventCounter.reset(): cleared all tracked event counters");
+    }
+  }
+  // ── Private ──────────────────────────────────────────────────────────────
+  async incrementPeriod(eventName, period, date) {
+    const key = this.storageKey(eventName, period, date);
+    this.writtenKeys.add(key);
+    const currentCached = this.cache.get(key) ?? 0;
+    const next = currentCached + 1;
+    this.cache.set(key, next);
+    try {
+      await this.storage.write(key, String(next));
+    } catch (err) {
+      this.logger.warn("EventCounter: failed to persist count", err);
+    }
+  }
+  async clearEvent(eventName) {
+    const safeEvent = eventName.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    const sessionKeys = [...this.writtenKeys].filter(
+      (k) => k.endsWith(`:${safeEvent}`)
+    );
+    for (const key of sessionKeys) {
+      try {
+        await this.storage.delete(key);
+      } catch {
+      }
+      this.writtenKeys.delete(key);
+      this.cache.delete(key);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const seenBuckets = new Set(sessionKeys);
+    for (let i = 0; i < 90; i++) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      const periods = ["daily", "weekly", "monthly"];
+      for (const period of periods) {
+        const key = this.storageKey(eventName, period, d);
+        if (!seenBuckets.has(key)) {
+          seenBuckets.add(key);
+          try {
+            await this.storage.delete(key);
+          } catch {
+          }
+        }
+      }
+    }
+    try {
+      await this.storage.delete(this.storageKey(eventName, "all-time", /* @__PURE__ */ new Date()));
+    } catch {
+    }
+  }
+  /** Build the storage key for a given event, period, and date. */
+  storageKey(eventName, period, date) {
+    const bucket = this.bucketFor(period, date);
+    const safeEvent = eventName.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    return `${KEY_PREFIX}:${period}:${bucket}:${safeEvent}`;
+  }
+  /**
+   * Return the time-bucket string for a given period and date.
+   * - daily:    "2024-01-15"
+   * - weekly:   "2024-W03"
+   * - monthly:  "2024-01"
+   * - all-time: "all"
+   */
+  bucketFor(period, date) {
+    switch (period) {
+      case "daily":
+        return date.toISOString().slice(0, 10);
+      // "YYYY-MM-DD"
+      case "weekly": {
+        const iso = toISOWeek(date);
+        return iso;
+      }
+      case "monthly":
+        return date.toISOString().slice(0, 7);
+      // "YYYY-MM"
+      case "all-time":
+        return "all";
+    }
+  }
+};
+function toISOWeek(date) {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNumber = Math.ceil(
+    ((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
+  );
+  return `${d.getUTCFullYear()}-W${String(weekNumber).padStart(2, "0")}`;
+}
+
+// src/EventQueue.ts
+var STORAGE_KEY2 = "sunglasses:queue";
+var EventQueue = class {
+  constructor(storage, logger, maxSize) {
+    this.storage = storage;
+    this.logger = logger;
+    this.maxSize = maxSize;
+    this.queue = [];
+    this.persistTimer = null;
+    this.persistPending = false;
+  }
+  /** Load persisted queue. Call once during SDK initialization. */
+  async initialize() {
+    try {
+      const raw = await this.storage.read(STORAGE_KEY2);
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        this.queue = Array.isArray(parsed) ? parsed : [];
+        this.logger.debug(`EventQueue: loaded ${this.queue.length} events from storage`);
+      }
+    } catch (err) {
+      this.logger.warn("EventQueue: failed to load persisted queue \u2014 starting empty", err);
+      this.queue = [];
+    }
+  }
+  /** Add an event to the queue. Triggers async persistence (debounced). */
+  enqueue(event) {
+    try {
+      JSON.stringify(event);
+    } catch {
+      this.logger.warn("EventQueue: event contains non-serialisable data \u2014 dropped", event.event);
+      return;
+    }
+    if (this.queue.length >= this.maxSize) {
+      this.queue.shift();
+      this.logger.warn("EventQueue: maxSize reached \u2014 oldest event dropped");
+    }
+    this.queue.push(event);
+    this.schedulePersist();
+  }
+  /** Return up to `batchSize` events without removing them. */
+  peek(batchSize) {
+    return this.queue.slice(0, batchSize);
+  }
+  /** Remove the first `count` events (call after successful adapter.send). */
+  remove(count) {
+    this.queue.splice(0, count);
+    this.schedulePersist();
+  }
+  get size() {
+    return this.queue.length;
+  }
+  /** Force-persist the queue immediately. */
+  async persist() {
+    if (this.persistTimer !== null) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+    this.persistPending = false;
+    try {
+      await this.storage.write(STORAGE_KEY2, JSON.stringify(this.queue));
+    } catch (err) {
+      this.logger.warn("EventQueue: failed to persist queue", err);
+    }
+  }
+  /** Clear queue from memory and storage. */
+  async clear() {
+    this.queue = [];
+    try {
+      await this.storage.delete(STORAGE_KEY2);
+    } catch (err) {
+      this.logger.warn("EventQueue: failed to clear persisted queue", err);
+    }
+  }
+  schedulePersist() {
+    if (this.persistPending) return;
+    this.persistPending = true;
+    this.persistTimer = setTimeout(() => {
+      this.persistPending = false;
+      this.persistTimer = null;
+      this.persist().catch(() => {
+      });
+    }, 0);
+  }
+};
+
+// src/utils/uuid.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+async function sha256Hex(input) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(input);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/IdentityManager.ts
+var ANON_ID_KEY = "sunglasses:anon_id";
+var DISTINCT_ID_KEY = "sunglasses:distinct_id";
+var IdentityManager = class {
+  constructor(storage, logger, anonymizeUserId) {
+    this.storage = storage;
+    this.logger = logger;
+    this.anonymizeUserId = anonymizeUserId;
+    this.anonymousId = "";
+    this.distinctId = null;
+  }
+  /** Load persisted identity. Must be called once during SDK initialization. */
+  async initialize() {
+    try {
+      const storedAnon = await this.storage.read(ANON_ID_KEY);
+      if (storedAnon) {
+        this.anonymousId = storedAnon;
+      } else {
+        this.anonymousId = generateUUID();
+        await this.storage.write(ANON_ID_KEY, this.anonymousId);
+      }
+    } catch (err) {
+      this.logger.warn("IdentityManager: failed to load anonymousId, generating new one", err);
+      this.anonymousId = generateUUID();
+    }
+    try {
+      const storedDistinct = await this.storage.read(DISTINCT_ID_KEY);
+      this.distinctId = storedDistinct ?? null;
+    } catch (err) {
+      this.logger.warn("IdentityManager: failed to load distinctId", err);
+    }
+    this.logger.debug("IdentityManager: initialized", {
+      anonymousId: this.anonymousId,
+      isIdentified: this.distinctId !== null
+    });
+  }
+  getState() {
+    return {
+      anonymousId: this.anonymousId,
+      distinctId: this.distinctId,
+      isIdentified: this.distinctId !== null
+    };
+  }
+  getAnonymousId() {
+    return this.anonymousId;
+  }
+  /**
+   * Resolved identity for use in events.
+   * Returns distinctId if set, otherwise anonymousId.
+   */
+  getEffectiveDistinctId() {
+    return this.distinctId ?? this.anonymousId;
+  }
+  /**
+   * Link current session to a known user.
+   * @param userId — the raw user identifier (hashed if anonymizeUserId=true)
+   * @throws if userId is empty or whitespace-only
+   */
+  async identify(userId) {
+    if (!userId || userId.trim().length === 0) {
+      throw new Error("IdentityManager: userId cannot be empty");
+    }
+    const resolvedId = this.anonymizeUserId ? await sha256Hex(userId) : userId;
+    this.distinctId = resolvedId;
+    try {
+      await this.storage.write(DISTINCT_ID_KEY, resolvedId);
+    } catch (err) {
+      this.logger.warn("IdentityManager: failed to persist distinctId", err);
+    }
+    this.logger.debug("IdentityManager: identified", { isAnonymized: this.anonymizeUserId });
+    return resolvedId;
+  }
+  /**
+   * Clear identity and generate a fresh anonymous ID.
+   * Adapters should also call their own reset() if applicable.
+   */
+  async reset() {
+    this.distinctId = null;
+    this.anonymousId = generateUUID();
+    try {
+      await this.storage.delete(DISTINCT_ID_KEY);
+      await this.storage.write(ANON_ID_KEY, this.anonymousId);
+    } catch (err) {
+      this.logger.warn("IdentityManager: failed to persist reset identity", err);
+    }
+    this.logger.debug("IdentityManager: reset \u2014 new anonymousId generated");
+  }
+};
+
+// src/LocalEventArchive.ts
+var STORAGE_KEY3 = "sunglasses:archive";
+var LocalEventArchive = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+    this.events = [];
+  }
+  /**
+   * Load all previously archived events from storage.
+   * Call once during SDK initialization.
+   */
+  async initialize() {
+    try {
+      const raw = await this.storage.read(STORAGE_KEY3);
+      if (raw !== null) {
+        const store = JSON.parse(raw);
+        this.events = store.events ?? [];
+        this.logger.debug(
+          "LocalEventArchive: loaded",
+          this.events.length,
+          "archived events"
+        );
+      }
+    } catch (err) {
+      this.logger.warn("LocalEventArchive: failed to load archive", err);
+      this.events = [];
+    }
+  }
+  /**
+   * Append events to the archive.
+   * Deduplicates by `messageId` — safe to call multiple times with the same batch.
+   */
+  async append(events) {
+    if (events.length === 0) return;
+    const existingIds = new Set(this.events.map((e) => e.messageId));
+    const newEvents = events.filter((e) => !existingIds.has(e.messageId));
+    if (newEvents.length === 0) return;
+    this.events = [...this.events, ...newEvents];
+    await this.persist();
+  }
+  /** All archived events (oldest first). */
+  getAll() {
+    return [...this.events];
+  }
+  /** Number of archived events. */
+  get size() {
+    return this.events.length;
+  }
+  /**
+   * Prune archived events by age and/or count.
+   * `maxEventsPerIdentity` is applied **per distinctId** — each identity keeps its
+   * most recent N events independently. If neither option is set, nothing is removed.
+   */
+  async cleanup(config = {}) {
+    let filtered = [...this.events];
+    if (config.maxAgeMs && config.maxAgeMs > 0) {
+      const cutoff = Date.now() - config.maxAgeMs;
+      filtered = filtered.filter((e) => {
+        const ts = new Date(e.timestamp).getTime();
+        return !Number.isNaN(ts) && ts >= cutoff;
+      });
+    }
+    const maxN = config.maxEventsPerIdentity ?? 0;
+    if (maxN > 0) {
+      const byIdentity = /* @__PURE__ */ new Map();
+      for (const event of filtered) {
+        const id = event.distinctId;
+        if (!byIdentity.has(id)) byIdentity.set(id, []);
+        byIdentity.get(id).push(event);
+      }
+      const kept = /* @__PURE__ */ new Set();
+      for (const events of byIdentity.values()) {
+        const slice = events.slice(Math.max(0, events.length - maxN));
+        for (const e of slice) kept.add(e.messageId);
+      }
+      filtered = filtered.filter((e) => kept.has(e.messageId));
+    }
+    this.events = filtered;
+    await this.persist();
+    this.logger.debug("LocalEventArchive: after cleanup, size =", this.events.length);
+  }
+  /**
+   * Remove all archived events and clear storage.
+   * This is irreversible.
+   */
+  async clear() {
+    this.events = [];
+    try {
+      await this.storage.delete(STORAGE_KEY3);
+    } catch (err) {
+      this.logger.warn("LocalEventArchive: failed to clear storage", err);
+    }
+  }
+  // ── Private ─────────────────────────────────────────────────────────────────
+  async persist() {
+    try {
+      const store = { version: "1", events: this.events };
+      await this.storage.write(STORAGE_KEY3, JSON.stringify(store));
+    } catch (err) {
+      this.logger.warn("LocalEventArchive: failed to persist archive", err);
+    }
+  }
+};
+
+// src/MiddlewarePipeline.ts
+var MiddlewarePipeline = class {
+  constructor(middleware, logger) {
+    this.middleware = middleware;
+    this.logger = logger;
+  }
+  async run(event) {
+    let index = 0;
+    const next = async (current) => {
+      if (index >= this.middleware.length) {
+        return current;
+      }
+      const mw = this.middleware[index++];
+      try {
+        const result = await mw.process(current, next);
+        if (result === null) {
+          this.logger.debug(`MiddlewarePipeline: event dropped by "${mw.name}"`);
+        }
+        return result;
+      } catch (err) {
+        this.logger.error(
+          `MiddlewarePipeline: middleware "${mw.name}" threw an error (event dropped)`,
+          err
+        );
+        return null;
+      }
+    };
+    return next(event);
+  }
+};
+
+// src/PiiSanitizer.ts
+var BUILTIN_DENIED_KEYS = /* @__PURE__ */ new Set([
+  "email",
+  "phone",
+  "password",
+  "passwd",
+  "secret",
+  "ssn",
+  "social_security",
+  "credit_card",
+  "card_number",
+  "cvv",
+  "ip",
+  "ip_address"
+]);
+var PII_PATTERNS = [
+  // Email (requires letter-only TLD)
+  /[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/,
+  // Phone (US/international, various formats)
+  /(\+?1?\s?)?\(?\d{3}\)?[\s.\-]\d{3}[\s.\-]\d{4}/,
+  // IPv4
+  /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,
+  // Credit card (major formats: 16 digits with optional separators)
+  /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/
+];
+var PiiSanitizer = class {
+  constructor(allowedProperties, deniedProperties) {
+    this.allowedProperties = allowedProperties;
+    this.deniedProperties = deniedProperties;
+    this.name = "PiiSanitizer";
+  }
+  async process(event, next) {
+    const sanitized = this.sanitizeProperties(event.properties);
+    return next({ ...event, properties: sanitized });
+  }
+  sanitizeProperties(props) {
+    let result = { ...props };
+    if (this.allowedProperties && this.allowedProperties.length > 0) {
+      const allowed = new Set(this.allowedProperties);
+      result = Object.fromEntries(
+        Object.entries(result).filter(([key]) => allowed.has(key))
+      );
+      return this.deepSanitizeValues(result);
+    }
+    if (this.deniedProperties && this.deniedProperties.length > 0) {
+      const denied = new Set(this.deniedProperties);
+      result = Object.fromEntries(
+        Object.entries(result).filter(([key]) => !denied.has(key))
+      );
+    }
+    return this.deepSanitizeValues(result);
+  }
+  /**
+   * Recursively traverse an object or array:
+   * - Remove keys in BUILTIN_DENIED_KEYS (case-insensitive)
+   * - Redact string values that contain PII
+   * - Recurse into nested objects and arrays
+   */
+  deepSanitizeValues(value) {
+    if (Array.isArray(value)) {
+      return value.map((item) => this.deepSanitizeValues(item));
+    }
+    if (value !== null && typeof value === "object") {
+      const obj = value;
+      const result = {};
+      for (const [key, val] of Object.entries(obj)) {
+        if (BUILTIN_DENIED_KEYS.has(key.toLowerCase())) continue;
+        result[key] = this.deepSanitizeValues(val);
+      }
+      return result;
+    }
+    if (typeof value === "string" && this.containsPii(value)) {
+      return "[redacted]";
+    }
+    return value;
+  }
+  containsPii(value) {
+    for (const pattern of PII_PATTERNS) {
+      if (pattern.test(value)) return true;
+    }
+    return false;
+  }
+};
+
+// src/SessionManager.ts
+var STORAGE_KEY4 = "sunglasses:session";
+var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+var SessionManager = class {
+  constructor(storage, logger, idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS) {
+    this.storage = storage;
+    this.logger = logger;
+    this.idleTimeoutMs = idleTimeoutMs;
+    this.session = null;
+    this.idleTimer = null;
+  }
+  /**
+   * Load the previous session from storage. If it has already expired, it is
+   * discarded so that `getOrCreate()` will start a fresh one.
+   */
+  async initialize() {
+    try {
+      const raw = await this.storage.read(STORAGE_KEY4);
+      if (raw !== null) {
+        const state = JSON.parse(raw);
+        const idleSinceMs = Date.now() - new Date(state.lastActiveAt).getTime();
+        if (idleSinceMs < this.idleTimeoutMs) {
+          this.session = state;
+          this.logger.debug("SessionManager: resumed session", state.sessionId);
+          this.resetIdleTimer();
+          return;
+        }
+        this.logger.debug("SessionManager: previous session expired");
+      }
+    } catch (err) {
+      this.logger.warn("SessionManager: failed to load persisted session", err);
+    }
+    this.session = null;
+  }
+  /**
+   * Return the current session, creating a new one if none exists.
+   * A `$session_start` event should be emitted by the caller whenever this
+   * method creates a new session (detectable by checking whether the returned
+   * `eventCount` is 0).
+   */
+  getOrCreate() {
+    if (this.session === null) {
+      this.session = {
+        sessionId: generateUUID(),
+        startedAt: nowISO(),
+        lastActiveAt: nowISO(),
+        eventCount: 0
+      };
+      this.logger.debug("SessionManager: new session", this.session.sessionId);
+      this.persist().catch(() => {
+      });
+      this.resetIdleTimer();
+    }
+    return this.session;
+  }
+  /**
+   * Record activity — resets the idle expiry timer and updates `lastActiveAt`.
+   * Call this after every event is successfully enqueued.
+   */
+  touch(now = /* @__PURE__ */ new Date()) {
+    if (this.session === null) return;
+    this.session = {
+      ...this.session,
+      lastActiveAt: now.toISOString(),
+      eventCount: this.session.eventCount + 1
+    };
+    this.persist().catch(() => {
+    });
+    this.resetIdleTimer();
+  }
+  /**
+   * Explicitly end the current session (e.g. on sign-out or reset).
+   * Clears both in-memory state and storage.
+   */
+  async end() {
+    this.session = null;
+    this.clearIdleTimer();
+    try {
+      await this.storage.delete(STORAGE_KEY4);
+    } catch (err) {
+      this.logger.warn("SessionManager: failed to clear persisted session", err);
+    }
+  }
+  /** The current session ID, or null if no session is active. */
+  get sessionId() {
+    return this.session?.sessionId ?? null;
+  }
+  // ── Private ─────────────────────────────────────────────────────────────────
+  resetIdleTimer() {
+    this.clearIdleTimer();
+    this.idleTimer = setTimeout(() => {
+      this.logger.debug("SessionManager: session expired due to inactivity");
+      this.session = null;
+      this.storage.delete(STORAGE_KEY4).catch(() => {
+      });
+    }, this.idleTimeoutMs);
+  }
+  clearIdleTimer() {
+    if (this.idleTimer !== null) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+  }
+  async persist() {
+    if (this.session === null) return;
+    try {
+      await this.storage.write(STORAGE_KEY4, JSON.stringify(this.session));
+    } catch (err) {
+      this.logger.warn("SessionManager: failed to persist session", err);
+    }
+  }
+};
+
+// src/TraitManager.ts
+var STORAGE_KEY5 = "sunglasses:traits";
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "email",
+  "phone",
+  "password",
+  "passwd",
+  "secret",
+  "ssn",
+  "social_security",
+  "credit_card",
+  "card_number",
+  "cvv",
+  "ip",
+  "ip_address"
+]);
+var TraitManager = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+    this.traits = {};
+  }
+  /**
+   * Load persisted traits from storage. Call once during SDK initialization.
+   */
+  async initialize() {
+    try {
+      const raw = await this.storage.read(STORAGE_KEY5);
+      if (raw !== null) {
+        this.traits = JSON.parse(raw);
+        this.logger.debug("TraitManager: loaded traits", Object.keys(this.traits));
+      }
+    } catch (err) {
+      this.logger.warn("TraitManager: failed to load persisted traits", err);
+      this.traits = {};
+    }
+  }
+  /**
+   * Merge new traits into the persisted set.
+   * Sensitive keys (email, phone, password, etc.) are stripped silently.
+   * Passing `null` as a value removes that key.
+   */
+  async setTraits(traits) {
+    const sanitized = this.sanitize(traits);
+    for (const [key, value] of Object.entries(sanitized)) {
+      if (value === null) {
+        delete this.traits[key];
+      } else {
+        this.traits[key] = value;
+      }
+    }
+    await this.persist();
+  }
+  /** Return a shallow copy of the current traits object. */
+  getTraits() {
+    return { ...this.traits };
+  }
+  /** Remove all stored traits (called on reset()). */
+  async clearTraits() {
+    this.traits = {};
+    try {
+      await this.storage.delete(STORAGE_KEY5);
+    } catch (err) {
+      this.logger.warn("TraitManager: failed to clear persisted traits", err);
+    }
+  }
+  // ── Private ─────────────────────────────────────────────────────────────────
+  sanitize(traits) {
+    const result = {};
+    for (const [key, value] of Object.entries(traits)) {
+      if (SENSITIVE_KEYS.has(key.toLowerCase())) {
+        this.logger.debug("TraitManager: stripped sensitive key", key);
+        continue;
+      }
+      result[key] = deepClone(value);
+    }
+    return result;
+  }
+  async persist() {
+    try {
+      await this.storage.write(STORAGE_KEY5, JSON.stringify(this.traits));
+    } catch (err) {
+      this.logger.warn("TraitManager: failed to persist traits", err);
+    }
+  }
+};
+function deepClone(value) {
+  if (value === null || typeof value !== "object") return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+
+// src/utils/logger.ts
+var PREFIX = "[SunGlasses]";
+function createLogger(debug) {
+  return {
+    debug(...args) {
+      if (debug) {
+        console.log(PREFIX, "[debug]", ...args);
+      }
+    },
+    info(...args) {
+      if (debug) {
+        console.log(PREFIX, "[info]", ...args);
+      }
+    },
+    warn(...args) {
+      console.warn(PREFIX, "[warn]", ...args);
+    },
+    error(...args) {
+      console.error(PREFIX, "[error]", ...args);
+    }
+  };
+}
+
+// src/SunglassesCore.ts
+var LIBRARY_NAME = "@drakkar.software/sunglasses-core";
+var LIBRARY_VERSION = "0.2.0";
+var DEFAULT_FLUSH_INTERVAL = 3e4;
+var DEFAULT_MAX_QUEUE_SIZE = 500;
+var DEFAULT_MAX_BATCH_SIZE = 50;
+var DEFAULT_SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+var SunglassesCore = class _SunglassesCore {
+  constructor(config, consent, identity, queue, pipeline, eventCounter, sessionManager, traitManager, localArchive) {
+    this.flushTimer = null;
+    this.isShutdown = false;
+    /** Guard against concurrent flushes — prevents double-send. */
+    this.flushInFlight = false;
+    /** In-memory super properties merged into every event's properties. */
+    this.superProperties = /* @__PURE__ */ new Map();
+    /** In-memory group ID attached to every event's context after group() is called. */
+    this.groupId = null;
+    this.config = {
+      defaultOptIn: config.defaultOptIn ?? false,
+      flushInterval: config.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
+      maxBatchSize: config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE,
+      maxQueueSize: config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE,
+      platform: config.platform ?? "web",
+      appName: config.appName ?? "",
+      appVersion: config.appVersion ?? "",
+      appBuild: config.appBuild ?? "",
+      debug: config.debug ?? false,
+      disabled: config.disabled ?? false,
+      anonymizeUserId: config.anonymizeUserId ?? false,
+      consentPolicyVersion: config.consentPolicyVersion
+    };
+    this.consent = consent;
+    this.identity = identity;
+    this.queue = queue;
+    this.pipeline = pipeline;
+    this.adapters = config.adapters;
+    this._eventCounter = eventCounter;
+    this.cleanupConfig = config.cleanupAfterFlush ?? null;
+    this.sessionManager = sessionManager;
+    this.traitManager = traitManager;
+    this.localArchive = localArchive;
+  }
+  /**
+   * Create and initialize a SunglassesCore instance.
+   * This is the only way to construct the SDK.
+   */
+  static async create(config) {
+    if (!config.adapters || config.adapters.length === 0) {
+      throw new Error("SunglassesCore: at least one adapter is required");
+    }
+    const logger = createLogger(config.debug ?? false);
+    const consent = new ConsentManager(config.storage, logger);
+    const identity = new IdentityManager(
+      config.storage,
+      logger,
+      config.anonymizeUserId ?? false
+    );
+    const queue = new EventQueue(
+      config.storage,
+      logger,
+      config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE
+    );
+    const piiSanitizer = new PiiSanitizer(config.allowedProperties, config.deniedProperties);
+    const middlewares = [piiSanitizer, ...config.middleware ?? []];
+    const pipeline = new MiddlewarePipeline(middlewares, logger);
+    const eventCounter = config.enableEventCounting ? new EventCounter(config.storage, logger) : null;
+    const sessionManager = config.enableSessionTracking ? new SessionManager(
+      config.storage,
+      logger,
+      config.sessionIdleTimeoutMs ?? DEFAULT_SESSION_IDLE_TIMEOUT_MS
+    ) : null;
+    const traitManager = new TraitManager(config.storage, logger);
+    const localArchive = config.enableLocalArchive ? new LocalEventArchive(config.storage, logger) : null;
+    const instance = new _SunglassesCore(
+      config,
+      consent,
+      identity,
+      queue,
+      pipeline,
+      eventCounter,
+      sessionManager,
+      traitManager,
+      localArchive
+    );
+    await consent.initialize(config.defaultOptIn ?? false, config.consentPolicyVersion, config.consentExpiryMs);
+    await identity.initialize();
+    await queue.initialize();
+    await traitManager.initialize();
+    if (sessionManager) {
+      await sessionManager.initialize();
+    }
+    if (localArchive) {
+      await localArchive.initialize();
+    }
+    if (config.respectDoNotTrack !== false && (config.platform ?? "web") === "web" && consent.status === "unknown" && "navigator" in globalThis) {
+      const nav = globalThis["navigator"];
+      const hasGpc = nav.globalPrivacyControl === true;
+      const hasDnt = nav.doNotTrack === "1";
+      if (hasGpc || hasDnt) {
+        await consent.optOut();
+        logger.debug("SunglassesCore: auto opted-out via privacy signal", { gpc: hasGpc, dnt: hasDnt });
+      }
+    }
+    if (!(config.disabled ?? false)) {
+      instance.startFlushTimer();
+    }
+    logger.debug("SunglassesCore: initialized", {
+      platform: config.platform ?? "web",
+      defaultOptIn: config.defaultOptIn ?? false,
+      consentStatus: consent.status,
+      eventCounting: config.enableEventCounting ?? false,
+      sessionTracking: config.enableSessionTracking ?? false,
+      localArchive: config.enableLocalArchive ?? false
+    });
+    return instance;
+  }
+  // ── Public API ─────────────────────────────────────────────────────────────
+  capture(eventName, properties, options) {
+    this.enqueueEvent("capture", eventName, properties, options);
+  }
+  screen(screenName, properties) {
+    this.enqueueEvent("screen", "$screen", {
+      ...properties,
+      $screen_name: screenName
+    });
+  }
+  identify(userId, traits) {
+    if (!this.canCapture()) return;
+    if (traits && Object.keys(traits).length > 0) {
+      this.traitManager.setTraits(traits).catch(() => {
+      });
+    }
+    this.identity.identify(userId).then((resolvedId) => {
+      this.enqueueEvent("identify", "$identify", {
+        ...traits,
+        $user_id: resolvedId
+      });
+    }).catch(() => {
+      this.enqueueEvent("identify", "$identify", { ...traits });
+    });
+  }
+  alias(newId, existingId) {
+    this.enqueueEvent("alias", "$alias", {
+      alias: newId,
+      previous_id: existingId
+    });
+  }
+  group(groupId, groupTraits) {
+    if (!this.canCapture()) return;
+    this.groupId = groupId;
+    this.enqueueEvent("group", "$group", {
+      ...groupTraits,
+      $group_id: groupId
+    });
+  }
+  // ── Super properties ──────────────────────────────────────────────────────
+  register(properties) {
+    for (const [key, value] of Object.entries(properties)) {
+      this.superProperties.set(key, value);
+    }
+  }
+  unregister(...keys) {
+    if (keys.length === 0) {
+      this.superProperties.clear();
+      return;
+    }
+    for (const key of keys) {
+      this.superProperties.delete(key);
+    }
+  }
+  getRegisteredProperties() {
+    return Object.fromEntries(this.superProperties);
+  }
+  async reset() {
+    await this.identity.reset();
+    await this.queue.clear();
+    await this.traitManager.clearTraits();
+    this.groupId = null;
+    if (this.sessionManager) {
+      await this.sessionManager.end();
+    }
+    for (const adapter of this.adapters) {
+      await adapter.reset?.();
+    }
+  }
+  async optIn() {
+    await this.consent.optIn();
+    this.startFlushTimer();
+  }
+  async optOut() {
+    await this.consent.optOut();
+    this.stopFlushTimer();
+    await this.queue.clear();
+  }
+  hasOptedIn() {
+    return this.consent.isOptedIn();
+  }
+  hasOptedOut() {
+    return this.consent.isOptedOut();
+  }
+  getConsentStatus() {
+    return this.consent.status;
+  }
+  getConsentHistory() {
+    return this.consent.getHistory();
+  }
+  async flush() {
+    if (!this.canCapture()) return;
+    await this.flushOnce();
+  }
+  async shutdown() {
+    if (this.isShutdown) return;
+    this.isShutdown = true;
+    this.stopFlushTimer();
+    if (this.canCapture()) {
+      await this.flushOnce();
+    }
+    for (const adapter of this.adapters) {
+      await adapter.shutdown?.();
+    }
+  }
+  // ── Event counting ─────────────────────────────────────────────────────────
+  get eventCounter() {
+    return this._eventCounter;
+  }
+  async getEventCount(eventName, period, date) {
+    if (!this._eventCounter) return 0;
+    return this._eventCounter.getCount(eventName, period, date);
+  }
+  async resetEventCount(eventName) {
+    await this._eventCounter?.reset(eventName);
+  }
+  getQueuedEventCount() {
+    return this.queue.size;
+  }
+  // ── Local event archive ────────────────────────────────────────────────────
+  /**
+   * Prune the local event archive by age/count, or clear it entirely.
+   * Pass `{}` to clear all archived events.
+   * No-op when `enableLocalArchive` was not set in config.
+   */
+  async clearLocalArchive(config = {}) {
+    if (!this.localArchive) return;
+    if (config.maxAgeMs === void 0 && config.maxEventsPerIdentity === void 0) {
+      await this.localArchive.clear();
+    } else {
+      await this.localArchive.cleanup(config);
+    }
+  }
+  // ── Data portability ───────────────────────────────────────────────────────
+  /**
+   * Export all locally held user data as a machine-readable object.
+   * GDPR Article 20 — right to data portability.
+   */
+  async exportUserData() {
+    const identityState = this.identity.getState();
+    const queuedEvents = this.queue.peek(this.config.maxQueueSize);
+    const eventCountSummary = {};
+    if (this._eventCounter) {
+      const eventNames = [...new Set(queuedEvents.map((e) => e.event))];
+      for (const name of eventNames) {
+        const [daily, weekly, monthly, allTime] = await Promise.all([
+          this._eventCounter.getCount(name, "daily"),
+          this._eventCounter.getCount(name, "weekly"),
+          this._eventCounter.getCount(name, "monthly"),
+          this._eventCounter.getCount(name, "all-time")
+        ]);
+        eventCountSummary[name] = { daily, weekly, monthly, "all-time": allTime };
+      }
+    }
+    return {
+      exportedAt: nowISO(),
+      anonymousId: identityState.anonymousId,
+      distinctId: identityState.distinctId,
+      consentStatus: this.consent.status,
+      consentHistory: this.consent.getHistory(),
+      traits: this.traitManager.getTraits(),
+      queuedEvents,
+      archivedEvents: this.localArchive ? this.localArchive.getAll() : [],
+      eventCountSummary
+    };
+  }
+  // ── Data erasure ───────────────────────────────────────────────────────────
+  /**
+   * Erase all locally held user data. GDPR Article 17 — right to erasure.
+   */
+  async deleteUserData(options = {}) {
+    await this.queue.clear();
+    await this.traitManager.clearTraits();
+    await this._eventCounter?.reset();
+    if (this.sessionManager) await this.sessionManager.end();
+    if (this.localArchive) await this.localArchive.clear();
+    await this.identity.reset();
+    this.groupId = null;
+    this.superProperties.clear();
+    if (options.resetConsent) {
+      await this.consent.resetToUnknown(this.config.consentPolicyVersion);
+      this.stopFlushTimer();
+    }
+    for (const adapter of this.adapters) {
+      await adapter.reset?.();
+    }
+  }
+  // ── Private helpers ────────────────────────────────────────────────────────
+  canCapture() {
+    if (this.config.disabled) return false;
+    if (this.isShutdown) return false;
+    if (!this.consent.isOptedIn()) return false;
+    return true;
+  }
+  enqueueEvent(type, eventName, properties, options) {
+    if (!this.canCapture()) return;
+    const identityState = this.identity.getState();
+    let sessionId;
+    let isNewSession = false;
+    if (this.sessionManager) {
+      const before = this.sessionManager.sessionId;
+      const session = this.sessionManager.getOrCreate();
+      sessionId = session.sessionId;
+      isNewSession = before !== session.sessionId;
+    }
+    const mergedProperties = {
+      ...Object.fromEntries(this.superProperties),
+      ...properties ?? {}
+    };
+    const event = {
+      type,
+      event: eventName,
+      distinctId: this.identity.getEffectiveDistinctId(),
+      anonymousId: identityState.anonymousId,
+      timestamp: options?.timestamp ?? nowISO(),
+      messageId: options?.messageId ?? generateUUID(),
+      properties: mergedProperties,
+      context: this.buildContext(sessionId)
+    };
+    if (this._eventCounter && type === "capture") {
+      this._eventCounter.increment(eventName).catch(() => {
+      });
+    }
+    if (isNewSession) {
+      this.emitSessionStart(sessionId);
+    }
+    this.pipeline.run(event).then((processed) => {
+      if (processed !== null) {
+        this.queue.enqueue(processed);
+        this.localArchive?.append([processed]).catch(() => {
+        });
+        this.sessionManager?.touch();
+        if (this.queue.size >= this.config.maxBatchSize) {
+          this.flushOnce().catch(() => {
+          });
+        }
+      }
+    }).catch(() => {
+    });
+  }
+  emitSessionStart(sessionId) {
+    const identityState = this.identity.getState();
+    const event = {
+      type: "capture",
+      event: "$session_start",
+      distinctId: this.identity.getEffectiveDistinctId(),
+      anonymousId: identityState.anonymousId,
+      timestamp: nowISO(),
+      messageId: generateUUID(),
+      properties: { $session_id: sessionId },
+      context: this.buildContext(sessionId)
+    };
+    this.pipeline.run(event).then((processed) => {
+      if (processed !== null) {
+        this.queue.enqueue(processed);
+      }
+    }).catch(() => {
+    });
+  }
+  buildContext(sessionId) {
+    const ctx = {
+      library: { name: LIBRARY_NAME, version: LIBRARY_VERSION },
+      platform: this.config.platform
+    };
+    if (this.config.appName || this.config.appVersion) {
+      ctx.app = {
+        name: this.config.appName || void 0,
+        version: this.config.appVersion || void 0,
+        build: this.config.appBuild || void 0
+      };
+    }
+    if (sessionId !== void 0) {
+      ctx.sessionId = sessionId;
+    }
+    const traits = this.traitManager.getTraits();
+    if (Object.keys(traits).length > 0) {
+      ctx.traits = traits;
+    }
+    if (this.groupId !== null) {
+      ctx.group = { id: this.groupId };
+    }
+    if (this.config.platform === "web") {
+      if ("navigator" in globalThis) {
+        const nav = globalThis["navigator"];
+        const ua = nav.userAgent ?? "";
+        let os = "Unknown";
+        if (/iPhone|iPad|iPod/.test(ua)) os = "iOS";
+        else if (/Android/.test(ua)) os = "Android";
+        else if (/Windows/.test(ua)) os = "Windows";
+        else if (/Mac OS X/.test(ua)) os = "macOS";
+        else if (/Linux/.test(ua)) os = "Linux";
+        let deviceType = "desktop";
+        if (/iPhone|iPod/.test(ua) || /Android/.test(ua) && !/Tablet|tablet/.test(ua) && !/iPad/.test(ua)) {
+          deviceType = "mobile";
+        } else if (/iPad/.test(ua) || /Tablet|tablet/.test(ua)) {
+          deviceType = "tablet";
+        }
+        ctx.device = { type: deviceType, os };
+        if (nav.language) ctx.locale = nav.language;
+      }
+      if ("screen" in globalThis) {
+        const scr = globalThis["screen"];
+        if (scr.width && scr.height) {
+          ctx.screen = { width: scr.width, height: scr.height };
+        }
+      }
+    }
+    return ctx;
+  }
+  /**
+   * Flush up to maxBatchSize events to every adapter.
+   *
+   * Guards:
+   * - If a flush is already in flight, returns immediately (no double-send).
+   * - If ALL adapters succeed, events are removed from the queue.
+   * - If ANY adapter fails, events stay in the queue for the next flush attempt.
+   *   The failed adapter's own retry logic handles re-delivery.
+   */
+  async flushOnce() {
+    if (this.flushInFlight) return;
+    if (this.queue.size === 0) return;
+    const batch = this.queue.peek(this.config.maxBatchSize);
+    if (batch.length === 0) return;
+    const safeBatch = Object.freeze([...batch]);
+    this.flushInFlight = true;
+    try {
+      let allSucceeded = true;
+      for (const adapter of this.adapters) {
+        try {
+          await adapter.send(safeBatch);
+        } catch {
+          allSucceeded = false;
+        }
+      }
+      if (allSucceeded) {
+        this.queue.remove(batch.length);
+        await this.queue.persist();
+        if (this.cleanupConfig) {
+          for (const adapter of this.adapters) {
+            adapter.cleanupAfterFlush?.(safeBatch, this.cleanupConfig)?.catch(() => {
+            });
+          }
+        }
+      }
+    } finally {
+      this.flushInFlight = false;
+    }
+  }
+  startFlushTimer() {
+    if (this.flushTimer !== null) return;
+    if (this.config.disabled) return;
+    this.flushTimer = setInterval(() => {
+      this.flushOnce().catch(() => {
+      });
+    }, this.config.flushInterval);
+  }
+  stopFlushTimer() {
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+};
+
+// src/middleware/FrequencyMiddleware.ts
+var FrequencyMiddleware = class {
+  constructor(options) {
+    this.name = "FrequencyMiddleware";
+    this.counter = options.counter;
+    this.periods = options.periods ?? ["daily", "monthly"];
+    this.onlyFor = options.onlyFor ? new Set(options.onlyFor) : null;
+  }
+  async process(event, next) {
+    if (event.type !== "capture") return next(event);
+    if (this.onlyFor !== null && !this.onlyFor.has(event.event)) return next(event);
+    const now = new Date(event.timestamp);
+    const counts = await Promise.all(
+      this.periods.map(async (period) => {
+        const count = await this.counter.getCount(event.event, period, now);
+        return [periodPropKey(period), count];
+      })
+    );
+    const countProps = Object.fromEntries(counts);
+    return next({
+      ...event,
+      properties: { ...event.properties, ...countProps }
+    });
+  }
+};
+function periodPropKey(period) {
+  const keys = {
+    "daily": "$count_daily",
+    "weekly": "$count_weekly",
+    "monthly": "$count_monthly",
+    "all-time": "$count_all_time"
+  };
+  return keys[period];
+}
+
+// src/middleware/SamplingMiddleware.ts
+var SamplingMiddleware = class {
+  constructor(options) {
+    this.name = "SamplingMiddleware";
+    if (options.sampleRate < 0 || options.sampleRate > 1) {
+      throw new Error("SamplingMiddleware: sampleRate must be between 0 and 1");
+    }
+    this.sampleRate = options.sampleRate;
+    this.onlyFor = options.onlyFor ? new Set(options.onlyFor) : null;
+    this.consistentSampling = options.consistentSampling ?? false;
+  }
+  async process(event, next) {
+    if (event.type !== "capture") return next(event);
+    if (this.onlyFor !== null && !this.onlyFor.has(event.event)) return next(event);
+    const shouldKeep = this.consistentSampling ? this.isIncludedByIdentity(event.anonymousId) : Math.random() < this.sampleRate;
+    if (!shouldKeep) return null;
+    return next({
+      ...event,
+      properties: {
+        ...event.properties,
+        $sample_rate: this.sampleRate
+      }
+    });
+  }
+  /**
+   * Determine inclusion based on anonymousId hash.
+   * Produces a stable 0–1 value for the identity so the decision is consistent
+   * across all events in the same session.
+   */
+  isIncludedByIdentity(anonymousId) {
+    let hash = 2166136261;
+    for (let i = 0; i < anonymousId.length; i++) {
+      hash ^= anonymousId.charCodeAt(i);
+      hash = hash * 16777619 >>> 0;
+    }
+    const fraction = hash / 4294967295;
+    return fraction < this.sampleRate;
+  }
+};
+
+// src/asTyped.ts
+function asTyped(client) {
+  return client;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsentManager,
+  EventCounter,
+  EventQueue,
+  FrequencyMiddleware,
+  IdentityManager,
+  LocalEventArchive,
+  MiddlewarePipeline,
+  PiiSanitizer,
+  SamplingMiddleware,
+  SessionManager,
+  SunglassesCore,
+  TraitManager,
+  asTyped,
+  createLogger,
+  generateUUID,
+  nowISO,
+  sha256Hex
+});