@mushi-mushi/core 1.27.2 → 1.29.0

package/dist/index.cjs

@@ -86,7 +86,92 @@ async function hmacSha256Hex(secret, value) {
   return bytesToHex(result);
 }
 
+// src/unload-transport.ts
+var MUSHI_BEACON_MAX_BYTES = 60 * 1024;
+function isMushiBeaconEnvelope(value) {
+  if (!value || typeof value !== "object") return false;
+  const rec = value;
+  return rec.mushiBeacon === true && typeof rec.path === "string" && rec.headers !== null && typeof rec.headers === "object";
+}
+function buildBeaconEnvelope(opts) {
+  return {
+    mushiBeacon: true,
+    path: opts.path,
+    headers: opts.headers,
+    body: opts.body
+  };
+}
+function isSameOriginOrRelative(url, origin = typeof location !== "undefined" ? location.origin : "") {
+  if (!url) return false;
+  if (url.startsWith("/")) return true;
+  if (!origin) return false;
+  try {
+    return new URL(url, origin).origin === origin;
+  } catch {
+    return false;
+  }
+}
+function extractTunnelPath(url) {
+  try {
+    const parsed = url.startsWith("/") ? new URL(url, "https://tunnel.local") : new URL(url);
+    return `${parsed.pathname}${parsed.search}`;
+  } catch {
+    return url;
+  }
+}
+function sendOnUnload(opts) {
+  const fetchImpl = opts.fetchImpl ?? (typeof fetch === "function" ? fetch : void 0);
+  if (fetchImpl) {
+    try {
+      void fetchImpl(opts.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...opts.headers
+        },
+        body: opts.body,
+        keepalive: true
+      });
+      return true;
+    } catch {
+    }
+  }
+  const beacon = opts.sendBeacon ?? (typeof navigator !== "undefined" ? navigator.sendBeacon?.bind(navigator) : void 0);
+  if (!beacon || !isSameOriginOrRelative(opts.url)) return false;
+  let parsedBody = opts.body;
+  try {
+    parsedBody = JSON.parse(opts.body);
+  } catch {
+    parsedBody = opts.body;
+  }
+  const envelope = JSON.stringify(
+    buildBeaconEnvelope({
+      path: opts.path ?? extractTunnelPath(opts.url),
+      headers: opts.headers,
+      body: parsedBody
+    })
+  );
+  if (envelope.length > MUSHI_BEACON_MAX_BYTES) return false;
+  try {
+    return beacon(opts.url, new Blob([envelope], { type: "application/json" }));
+  } catch {
+    return false;
+  }
+}
+var pageUnloading = false;
+function markPageUnloading() {
+  pageUnloading = true;
+}
+function isPageUnloading() {
+  return pageUnloading;
+}
+
 // src/api-client.ts
+var lastOutbound = null;
+function flushLastOutboundOnUnload() {
+  if (!lastOutbound) return false;
+  return sendOnUnload(lastOutbound);
+}
 var _credWarningEmitted = false;
 var MUSHI_USER_TOKEN_HEADER = "X-Mushi-User-Token";
 var MUSHI_PROJECT_HEADER = "X-Mushi-Project";
@@ -107,6 +192,11 @@ function buildSdkIngestHeaders(opts) {
 var DEFAULT_API_ENDPOINT = "https://dxptnwrhwsqckaftyymj.supabase.co/functions/v1/api";
 var MUSHI_INTERNAL_HEADER = "X-Mushi-Internal";
 var MUSHI_INTERNAL_INIT_MARKER = "__mushiInternal";
+function resolveRequestBaseUrl(apiEndpoint, tunnel) {
+  const trimmedTunnel = tunnel?.trim();
+  if (trimmedTunnel) return trimmedTunnel.replace(/\/$/, "");
+  return (apiEndpoint ?? DEFAULT_API_ENDPOINT).replace(/\/$/, "");
+}
 var DEFAULT_TIMEOUT = 1e4;
 var DEFAULT_MAX_RETRIES = 2;
 var DEFAULT_CIRCUIT_THRESHOLD = 4;
@@ -117,6 +207,7 @@ function createApiClient(options) {
     projectId,
     apiKey,
     apiEndpoint = DEFAULT_API_ENDPOINT,
+    tunnel,
     timeout = DEFAULT_TIMEOUT,
     maxRetries = DEFAULT_MAX_RETRIES,
     getUserToken,
@@ -124,7 +215,7 @@ function createApiClient(options) {
     sdkVersion,
     circuitBreaker
   } = options;
-  let baseUrl = apiEndpoint.replace(/\/$/, "");
+  let baseUrl = resolveRequestBaseUrl(apiEndpoint, tunnel);
   const cbEnabled = circuitBreaker?.enabled !== false;
   const cbThreshold = Math.max(1, circuitBreaker?.threshold ?? DEFAULT_CIRCUIT_THRESHOLD);
   const cbCooldownMs = Math.max(1e3, circuitBreaker?.cooldownMs ?? DEFAULT_CIRCUIT_COOLDOWN_MS);
@@ -148,21 +239,27 @@ function createApiClient(options) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeout);
     const userToken = getUserToken?.() ?? null;
+    const headers = {
+      ...buildSdkIngestHeaders({
+        apiKey,
+        projectId,
+        sdkPackage,
+        sdkVersion,
+        userToken,
+        internalKind
+      }),
+      ...extraHeaders
+    };
+    const serialized = body ? JSON.stringify(body) : void 0;
+    if (serialized && method !== "GET") {
+      lastOutbound = { url, headers, body: serialized, path };
+    }
     try {
       const response = await fetch(url, {
         method,
-        headers: {
-          ...buildSdkIngestHeaders({
-            apiKey,
-            projectId,
-            sdkPackage,
-            sdkVersion,
-            userToken,
-            internalKind
-          }),
-          ...extraHeaders
-        },
-        body: body ? JSON.stringify(body) : void 0,
+        headers,
+        body: serialized,
+        keepalive: isPageUnloading(),
         signal: controller.signal,
         ...internalKind ? { [MUSHI_INTERNAL_INIT_MARKER]: internalKind } : {}
       });
@@ -200,7 +297,8 @@ function createApiClient(options) {
           ok: false,
           error: {
             code: errorBody.error?.code || `HTTP_${response.status}`,
-            message: errorBody.error?.message || errorBody.message || `HTTP ${response.status} error`
+            message: errorBody.error?.message || errorBody.message || `HTTP ${response.status} error`,
+            status: response.status
           }
         };
       }
@@ -243,6 +341,7 @@ function createApiClient(options) {
         "X-Reporter-Hmac": hmac
       },
       body: body ? JSON.stringify(body) : void 0,
+      keepalive: isPageUnloading(),
       [MUSHI_INTERNAL_INIT_MARKER]: "reporter-poll"
     });
     if (!response.ok) {
@@ -376,6 +475,18 @@ function createApiClient(options) {
         "discovery"
       );
     },
+    /** POST /v1/sdk/events — batched product-analytics events (Mushi.track()).
+     *  Best-effort (1 retry); the event tracker spills unsent batches to
+     *  localStorage and replays them on the next page load. */
+    async postProductEvents(payload) {
+      return request(
+        "POST",
+        "/v1/sdk/events",
+        payload,
+        1,
+        "discovery"
+      );
+    },
     async submitActivity(userId, events, opts) {
       return request(
         "POST",
@@ -502,7 +613,7 @@ function sleep(ms) {
 function getBackoffDelay(attempt) {
   return Math.min(1e3 * 2 ** attempt + Math.random() * 500, 1e4);
 }
-function parseRetryAfter(value, now2 = Date.now()) {
+function parseRetryAfter(value, now3 = Date.now()) {
   if (!value) return null;
   const raw = value.trim();
   if (!raw) return null;
@@ -510,7 +621,7 @@ function parseRetryAfter(value, now2 = Date.now()) {
   if (Number.isFinite(seconds)) return seconds < 0 ? null : seconds * 1e3;
   const at = Date.parse(raw);
   if (Number.isNaN(at)) return null;
-  return Math.max(at - now2, 0);
+  return Math.max(at - now3, 0);
 }
 function isRetryable(error) {
   if (error instanceof DOMException && error.name === "AbortError") return true;
@@ -518,6 +629,32 @@ function isRetryable(error) {
   return false;
 }
 
+// src/error-filters.ts
+function matchesErrorFilter(value, filters) {
+  if (!value || !filters || filters.length === 0) return false;
+  for (const filter of filters) {
+    if (typeof filter === "string") {
+      if (value.includes(filter)) return true;
+      continue;
+    }
+    try {
+      if (filter.test(value)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function shouldDropCapturedError(input) {
+  if (matchesErrorFilter(input.message, input.ignoreErrors)) return true;
+  const filename = input.filename?.trim() || "";
+  if (filename && matchesErrorFilter(filename, input.denyUrls)) return true;
+  if (input.allowUrls && input.allowUrls.length > 0) {
+    if (!filename) return true;
+    if (!matchesErrorFilter(filename, input.allowUrls)) return true;
+  }
+  return false;
+}
+
 // src/region.ts
 var REGION_ENDPOINTS = {
   us: DEFAULT_API_ENDPOINT,
@@ -696,11 +833,14 @@ var KNOWN_CONFIG_KEYS = [
   "projectId",
   "apiKey",
   "apiEndpoint",
+  "tunnel",
   "timeout",
   "maxRetries",
   "circuitBreaker",
   "preset",
   "runtimeConfig",
+  "analytics",
+  "trackSessions",
   "sentry",
   "widget",
   "capture",
@@ -715,8 +855,13 @@ var KNOWN_CONFIG_KEYS = [
   "enabled",
   "appVersion",
   "sampleRate",
+  "replaySampleRate",
+  "replaysOnErrorSampleRate",
   "beforeSend",
   "beforeSendFeedback",
+  "ignoreErrors",
+  "denyUrls",
+  "allowUrls",
   "onCrashedLastRun"
 ];
 function presetDefaults(preset) {
@@ -787,23 +932,23 @@ function presetDefaults(preset) {
   }
 }
 function expandPreset(config) {
-  const defaults = presetDefaults(config.preset);
-  if (!defaults) return config;
+  const defaults2 = presetDefaults(config.preset);
+  if (!defaults2) return config;
   return {
     ...config,
     widget: {
-      ...defaults.widget,
+      ...defaults2.widget,
       ...config.widget
     },
     capture: {
-      ...defaults.capture,
+      ...defaults2.capture,
       ...config.capture
     },
     proactive: {
-      ...defaults.proactive,
+      ...defaults2.proactive,
       ...config.proactive,
       cooldown: {
-        ...defaults.proactive?.cooldown,
+        ...defaults2.proactive?.cooldown,
         ...config.proactive?.cooldown
       }
     }
@@ -1214,12 +1359,12 @@ function createOfflineQueue(config = {}) {
     const n = row.attempts;
     return typeof n === "number" && Number.isFinite(n) ? n : 0;
   }
-  function isExpired(row, now2) {
+  function isExpired(row, now3) {
     const queuedAt = row.queuedAt;
     if (!queuedAt) return false;
     const ts = Date.parse(queuedAt);
     if (Number.isNaN(ts)) return false;
-    return now2 - ts > MAX_QUEUE_AGE_MS;
+    return now3 - ts > MAX_QUEUE_AGE_MS;
   }
   function detectBackend() {
     if (backendType) return backendType;
@@ -1406,7 +1551,7 @@ function createOfflineQueue(config = {}) {
     await lsEnqueue(report);
     return "localstorage";
   }
-  async function enqueue(report) {
+  async function enqueue2(report) {
     if (!enabled) return;
     const currentSize = await size();
     if (currentSize >= maxQueueSize) {
@@ -1424,10 +1569,10 @@ function createOfflineQueue(config = {}) {
   async function runFlush(client) {
     const { backend, rows: storedRows } = await readRows();
     let rows = storedRows;
-    const now2 = Date.now();
+    const now3 = Date.now();
     const fresh = [];
     for (const row of rows) {
-      if (isExpired(row, now2)) {
+      if (isExpired(row, now3)) {
         const rowId = row.id;
         await removeRow(backend, rowId);
         queueLog.debug("Offline queue: evicting stale report", { id: rowId });
@@ -1575,7 +1720,7 @@ function createOfflineQueue(config = {}) {
     syncCleanup?.();
     syncCleanup = null;
   }
-  return { enqueue, flush, size, clear, startAutoSync, stopAutoSync };
+  return { enqueue: enqueue2, flush, size, clear, startAutoSync, stopAutoSync };
 }
 
 // src/environment.ts
@@ -1917,21 +2062,94 @@ function randomSuffix() {
   return n.toString(36).padStart(6, "0").slice(0, 6);
 }
 
+// src/analytics-gate.ts
+var AUTOMATED_UA_RE = /HeadlessChrome|PhantomJS|Lighthouse|\bbot\b|bot[/-]|crawler|spider/i;
+function consentKey(projectId) {
+  return "mushi_events_consent_" + projectId;
+}
+var listeners = /* @__PURE__ */ new Set();
+function dntActive() {
+  if (typeof navigator === "undefined") return false;
+  const nav = navigator;
+  if (nav.globalPrivacyControl === true) return true;
+  const winDnt = typeof window !== "undefined" ? window.doNotTrack : void 0;
+  const dnt = nav.doNotTrack ?? nav.msDoNotTrack ?? winDnt;
+  return dnt === "1" || dnt === "yes";
+}
+function isAutomatedBrowser() {
+  if (typeof navigator === "undefined") return false;
+  if (navigator.webdriver === true) return true;
+  return AUTOMATED_UA_RE.test(navigator.userAgent ?? "");
+}
+function analyticsBlockReason(config) {
+  if (config?.enabled === false) return "disabled";
+  if (config?.respectDoNotTrack !== false && dntActive()) return "dnt";
+  if (config?.excludeBots !== false && isAutomatedBrowser()) return "automation";
+  return null;
+}
+function readStoredConsent(projectId) {
+  if (!projectId) return null;
+  try {
+    const v = localStorage.getItem(consentKey(projectId));
+    return v === "granted" || v === "denied" ? v : null;
+  } catch {
+    return null;
+  }
+}
+function writeStoredConsent(projectId, state) {
+  if (!projectId) return;
+  try {
+    localStorage.setItem(consentKey(projectId), state);
+  } catch {
+  }
+}
+function resolveAnalyticsConsent(projectId, config) {
+  const stored = readStoredConsent(projectId);
+  if (config?.consent === "required") return stored ?? "pending";
+  return stored === "denied" ? "denied" : "granted";
+}
+function setAnalyticsConsent(projectId, state) {
+  writeStoredConsent(projectId, state);
+  for (const listener of [...listeners]) {
+    try {
+      listener(state);
+    } catch {
+    }
+  }
+}
+function onAnalyticsConsentChange(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
 // src/session-tracker.ts
 var HEARTBEAT_INTERVAL_MS = 6e4;
 var _client = null;
 var _sdkVersion;
 var _userIdHash = null;
-var _reporterTokenHash = null;
+var _reporterToken = null;
 var _pageViewCount = 0;
 var _heartbeatTimer = null;
 var _initialized = false;
+var _active = false;
+var _started = false;
+var _unsubscribeConsent = null;
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function currentRoute() {
   if (typeof window === "undefined") return "";
-  return window.location.pathname + window.location.search;
+  return window.location.pathname;
+}
+function referrerOrigin() {
+  if (typeof document === "undefined" || !document.referrer) return null;
+  try {
+    return new URL(document.referrer).origin;
+  } catch {
+    return null;
+  }
 }
 function userAgent() {
   if (typeof navigator === "undefined") return null;
@@ -1943,7 +2161,8 @@ function buildPayload(kind, extra) {
     session_id: getSessionId(),
     ts: now(),
     page_view_count: _pageViewCount,
-    reporter_token_hash: _reporterTokenHash,
+    // Wire name kept for older servers; the value is the raw token (hashed server-side).
+    reporter_token_hash: _reporterToken,
     user_id_hash: _userIdHash,
     user_agent: userAgent(),
     sdk_version: _sdkVersion,
@@ -1951,26 +2170,42 @@ function buildPayload(kind, extra) {
   };
 }
 function send(payload) {
-  if (!_client) return;
+  if (!_client || !_active) return;
   _client.postSessionEvent(payload).catch(() => {
   });
 }
+function recordPageView(route) {
+  if (!_active) return;
+  _pageViewCount += 1;
+  send(buildPayload("page_view", { route }));
+}
+function activate() {
+  if (_active || !_initialized) return;
+  _active = true;
+  if (!_started) {
+    _started = true;
+    _pageViewCount = 1;
+    send(buildPayload("session_start", { route: currentRoute(), referrer: referrerOrigin() }));
+  }
+  _heartbeatTimer = setInterval(() => {
+    send(buildPayload("session_heartbeat", { route: currentRoute() }));
+  }, HEARTBEAT_INTERVAL_MS);
+}
+function deactivate() {
+  _active = false;
+  if (_heartbeatTimer != null) {
+    clearInterval(_heartbeatTimer);
+    _heartbeatTimer = null;
+  }
+}
 function initSessionTracker(opts) {
   if (_initialized || typeof window === "undefined") return;
+  if (analyticsBlockReason(opts.analytics) !== null) return;
   _initialized = true;
   _client = opts.client;
   _sdkVersion = opts.sdkVersion;
-  _reporterTokenHash = opts.reporterTokenHash ?? null;
+  _reporterToken = opts.reporterToken ?? opts.reporterTokenHash ?? null;
   _userIdHash = opts.userIdHash ?? null;
-  const entryRoute = currentRoute();
-  _pageViewCount = 1;
-  send(buildPayload("session_start", {
-    route: entryRoute,
-    referrer: typeof document !== "undefined" ? document.referrer ?? null : null
-  }));
-  _heartbeatTimer = setInterval(() => {
-    send(buildPayload("session_heartbeat", { route: currentRoute() }));
-  }, HEARTBEAT_INTERVAL_MS);
   const onHide = () => {
     if (typeof document !== "undefined" && document.visibilityState === "hidden") {
       send(buildPayload("session_end", { route: currentRoute() }));
@@ -1979,46 +2214,421 @@ function initSessionTracker(opts) {
   if (typeof document !== "undefined") {
     document.addEventListener("visibilitychange", onHide, { passive: true });
   }
-  if (typeof window !== "undefined") {
-    window.addEventListener("pagehide", () => {
-      send(buildPayload("session_end", { route: currentRoute() }));
-    }, { passive: true });
+  window.addEventListener("pagehide", () => {
+    send(buildPayload("session_end", { route: currentRoute() }));
+  }, { passive: true });
+  if (opts.patchHistory !== false) {
+    patchHistoryForPageViews();
   }
-  patchHistoryForPageViews();
+  _unsubscribeConsent = onAnalyticsConsentChange((state) => {
+    if (state === "granted") activate();
+    else deactivate();
+  });
+  if (resolveAnalyticsConsent(opts.projectId ?? "", opts.analytics) === "granted") activate();
 }
 function trackPageView(route) {
   if (!_initialized || !_client) return;
-  _pageViewCount += 1;
-  send(buildPayload("page_view", { route: route ?? currentRoute() }));
+  recordPageView(route ?? currentRoute());
 }
 function updateSessionIdentity(userIdHash) {
   _userIdHash = userIdHash;
 }
 function destroySessionTracker() {
-  if (_heartbeatTimer != null) {
-    clearInterval(_heartbeatTimer);
-    _heartbeatTimer = null;
-  }
+  deactivate();
+  _unsubscribeConsent?.();
+  _unsubscribeConsent = null;
   _initialized = false;
+  _started = false;
   _client = null;
 }
 var _historyPatched = false;
 function patchHistoryForPageViews() {
   if (_historyPatched || typeof history === "undefined") return;
   _historyPatched = true;
-  const wrap = (original) => function(...args) {
+  const wrap = (original, countsAsPageView) => function(...args) {
     const result = original.apply(this, args);
-    if (original === history.pushState) {
-      _pageViewCount += 1;
-      send(buildPayload("page_view", { route: currentRoute() }));
+    if (countsAsPageView) recordPageView(currentRoute());
+    return result;
+  };
+  history.pushState = wrap(history.pushState, true);
+  history.replaceState = wrap(history.replaceState, false);
+  window.addEventListener("popstate", () => {
+    recordPageView(currentRoute());
+  }, { passive: true });
+}
+
+// src/analytics-taxonomy.ts
+var EVENT_NAME_RE = /^[a-z][a-z0-9_]{1,63}$/;
+var EVENT_PROPERTY_LIMITS = {
+  maxKeys: 40,
+  maxKeyLength: 64,
+  maxValueLength: 256,
+  maxBytes: 8192,
+  /** Client batch size before an immediate flush. */
+  maxClientBatch: 20,
+  /** Server-side per-request ceiling. */
+  maxServerBatch: 50,
+  /** Distinct event names per project before the server returns 422. */
+  maxEventNamesPerProject: 200
+};
+var RESERVED_PROPERTY_PREFIX = "$";
+var PII_PROPERTY_KEY_RE = /(email|phone|password|passwd|token|secret|ssn|address|credit|card|iban)/i;
+var MUSHI_SURFACES = ["web", "console", "docs", "cli", "mcp", "server", "mobile"];
+var MUSHI_EVENTS = {
+  // ── Any surface (SDK `analytics.autoPageviews`) ──────────────────────────
+  page_view: { surface: ["web", "docs", "console"], required: [] },
+  // ── Landing + docs (apps/docs) ───────────────────────────────────────────
+  // Every docs route; `route` repeats the reserved `$route` as a host prop so
+  // the requirement is checkable. company_funnel_weekly counts visits from
+  // this and landing_view.
+  docs_page_view: { surface: "docs", required: ["route"] },
+  landing_view: { surface: "docs", required: [] },
+  cta_click: { surface: "docs", required: ["cta_id", "location"] },
+  quickstart_view: { surface: "docs", required: [] },
+  pricing_view: { surface: "docs", required: [] },
+  connect_demo_click: { surface: "docs", required: ["href"] },
+  signup_click: { surface: "docs", required: ["href"] },
+  // ── Console (apps/admin) ─────────────────────────────────────────────────
+  signup_completed: { surface: "console", required: ["signup_source"] },
+  report_opened: { surface: ["console", "mcp"], required: ["report_id"] },
+  fix_context_pulled: { surface: ["console", "mcp"], required: ["report_id"] },
+  fix_dispatched: { surface: ["console", "mcp"], required: ["report_id", "agent"] },
+  invite_sent: { surface: "console", required: [] },
+  upgrade_clicked: { surface: "console", required: ["plan"] },
+  test_report_sent: { surface: "console", required: ["project_id"] },
+  // ── Server-emitted (edge functions) ──────────────────────────────────────
+  project_created: { surface: "server", required: ["project_id"] },
+  key_minted: { surface: "server", required: ["project_id"] },
+  first_report_received: { surface: "server", required: ["project_id"] },
+  fix_merged: { surface: "server", required: ["project_id"] },
+  upgrade_completed: { surface: "server", required: ["project_id", "plan"] },
+  // ── Growth loop (widget "Bug reports by Mushi" mark) ─────────────────────
+  loop_impression: { surface: "web", required: [] },
+  loop_click: { surface: "web", required: [] },
+  loop_signup: { surface: "console", required: ["ref"] }
+};
+var MUSHI_EVENT_NAMES = Object.keys(MUSHI_EVENTS);
+var ACTIVATION_EVENT = "first_report_received";
+var HABIT_EVENTS = ["report_opened", "fix_context_pulled", "fix_dispatched"];
+function isValidEventName(name) {
+  return typeof name === "string" && EVENT_NAME_RE.test(name);
+}
+function sanitizeEventProperties(input, opts = {}) {
+  const out = {};
+  const dropped = [];
+  if (!input || typeof input !== "object" || Array.isArray(input)) return { properties: out, dropped };
+  const allow = new Set(opts.allowlist ?? []);
+  let keys = 0;
+  for (const [rawKey, rawValue] of Object.entries(input)) {
+    if (keys >= EVENT_PROPERTY_LIMITS.maxKeys) {
+      dropped.push(rawKey);
+      continue;
+    }
+    const key = rawKey.slice(0, EVENT_PROPERTY_LIMITS.maxKeyLength);
+    if (key.startsWith(RESERVED_PROPERTY_PREFIX) && !opts.allowReserved) {
+      dropped.push(key);
+      continue;
+    }
+    if (PII_PROPERTY_KEY_RE.test(key) && !allow.has(key)) {
+      dropped.push(key);
+      continue;
     }
+    let value;
+    if (rawValue === null || typeof rawValue === "boolean") value = rawValue;
+    else if (typeof rawValue === "number") value = Number.isFinite(rawValue) ? rawValue : null;
+    else if (typeof rawValue === "string") {
+      const s = rawValue.slice(0, EVENT_PROPERTY_LIMITS.maxValueLength);
+      value = opts.scrub ? opts.scrub(s) : s;
+    } else if (rawValue instanceof Date) value = rawValue.toISOString();
+    else {
+      dropped.push(key);
+      continue;
+    }
+    out[key] = value;
+    keys += 1;
+  }
+  return { properties: out, dropped };
+}
+function propertiesWithinByteLimit(properties) {
+  try {
+    return JSON.stringify(properties).length <= EVENT_PROPERTY_LIMITS.maxBytes;
+  } catch {
+    return false;
+  }
+}
+
+// src/event-tracker.ts
+var _client2 = null;
+var _projectId = "";
+var _anonId = null;
+var _userId = null;
+var _userTraits = null;
+var _sdkVersion2;
+var _config = defaults();
+var _scrub;
+var _getSessionId;
+var _buffer = [];
+var _consentBuffer = [];
+var _consent = "granted";
+var _sampledIn = true;
+var _flushTimer = null;
+var _initialized2 = false;
+var _flushing = false;
+var _pendingIdentify = false;
+var _unsubscribeConsent2 = null;
+var CONSENT_BUFFER_MAX = 50;
+var SPILL_MAX = 200;
+var SPILL_TTL_MS = 24 * 60 * 60 * 1e3;
+function defaults() {
+  return {
+    sampleRate: 1,
+    autoPageviews: false,
+    flushIntervalMs: 5e3,
+    surface: "web",
+    propertyAllowlist: []
+  };
+}
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function spillKey() {
+  return "mushi_events_spill_" + _projectId;
+}
+function isRetryableStatus(status) {
+  return status === void 0 || status === 429 || status >= 500;
+}
+function analyticsIdKey() {
+  return "mushi_analytics_id_" + _projectId;
+}
+function loadOrMintAnalyticsId() {
+  try {
+    const stored = localStorage.getItem(analyticsIdKey());
+    if (stored) return stored;
+  } catch {
+  }
+  return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : "a-" + Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+function persistAnalyticsId() {
+  if (!_anonId) return;
+  try {
+    if (localStorage.getItem(analyticsIdKey()) !== _anonId) localStorage.setItem(analyticsIdKey(), _anonId);
+  } catch {
+  }
+}
+function hashToUnit(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return (h >>> 0) / 4294967296;
+}
+function readSpill() {
+  try {
+    const raw = localStorage.getItem(spillKey());
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (!parsed || Date.now() - parsed.at > SPILL_TTL_MS) {
+      localStorage.removeItem(spillKey());
+      return [];
+    }
+    return Array.isArray(parsed.events) ? parsed.events.slice(0, SPILL_MAX) : [];
+  } catch {
+    return [];
+  }
+}
+function writeSpill(events) {
+  try {
+    if (events.length === 0) {
+      localStorage.removeItem(spillKey());
+      return;
+    }
+    localStorage.setItem(spillKey(), JSON.stringify({ at: Date.now(), events: events.slice(-SPILL_MAX) }));
+  } catch {
+  }
+}
+function takeSpill() {
+  const events = readSpill();
+  if (events.length > 0) writeSpill([]);
+  return events;
+}
+function buildPayload2(events) {
+  return {
+    anon_id: _anonId,
+    user_id: _userId,
+    user_traits: _userTraits,
+    session_id: _getSessionId ? _getSessionId() : null,
+    sdk_version: _sdkVersion2,
+    surface: _config.surface,
+    events
+  };
+}
+async function flushNow() {
+  if (!_client2 || _flushing || _consent !== "granted") return;
+  if (_buffer.length === 0 && !_pendingIdentify) return;
+  _flushing = true;
+  persistAnalyticsId();
+  const batch = _buffer.splice(0, EVENT_PROPERTY_LIMITS.maxServerBatch);
+  if (_pendingIdentify) {
+    batch.unshift({ name: "identify", ts: now2(), properties: {} });
+    _pendingIdentify = false;
+  }
+  try {
+    const res = await _client2.postProductEvents(buildPayload2(batch));
+    if (res.ok) {
+      writeSpill([]);
+    } else if (isRetryableStatus(res.error?.status)) {
+      writeSpill([...readSpill(), ...batch.filter((e) => e.name !== "identify")]);
+    }
+  } catch {
+    writeSpill([...readSpill(), ...batch.filter((e) => e.name !== "identify")]);
+  } finally {
+    _flushing = false;
+  }
+  if (_buffer.length >= EVENT_PROPERTY_LIMITS.maxClientBatch) void flushNow();
+}
+function enqueue(ev) {
+  if (_consent === "denied") return false;
+  if (_consent === "pending") {
+    if (_consentBuffer.length >= CONSENT_BUFFER_MAX) return false;
+    _consentBuffer.push(ev);
+    return true;
+  }
+  _buffer.push(ev);
+  if (_buffer.length >= EVENT_PROPERTY_LIMITS.maxClientBatch) void flushNow();
+  return true;
+}
+function applyConsent(state) {
+  if (state === "denied") {
+    _consent = "denied";
+    _buffer = [];
+    _consentBuffer = [];
+    _pendingIdentify = false;
+    writeSpill([]);
+    return;
+  }
+  const wasPending = _consent === "pending";
+  _consent = "granted";
+  if (wasPending) {
+    _buffer.push(...takeSpill(), ..._consentBuffer);
+    _consentBuffer = [];
+  }
+  if (_buffer.length > 0 || _pendingIdentify) void flushNow();
+}
+function stripUndefined(o) {
+  const out = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+function isEventTrackingActive() {
+  return _initialized2 && _consent === "granted" && _sampledIn;
+}
+function getEventAnonymousId() {
+  if (!_initialized2 || _consent === "denied") return null;
+  return _anonId;
+}
+function initEventTracker(opts) {
+  if (_initialized2) return;
+  if (typeof window === "undefined") return;
+  const cfg = opts.config ?? {};
+  _config = { ...defaults(), ...stripUndefined(cfg), propertyAllowlist: cfg.propertyAllowlist ?? [] };
+  _projectId = opts.projectId;
+  if (analyticsBlockReason(cfg) !== null) return;
+  _initialized2 = true;
+  _client2 = opts.client;
+  _anonId = opts.anonId ?? loadOrMintAnalyticsId();
+  _userId = opts.userId ?? null;
+  _sdkVersion2 = opts.sdkVersion;
+  _scrub = opts.scrub;
+  _getSessionId = opts.getSessionId;
+  const rate = Math.min(1, Math.max(0, _config.sampleRate));
+  _sampledIn = rate >= 1 ? true : rate <= 0 ? false : hashToUnit(_anonId ?? "anon") < rate;
+  if (!_sampledIn) return;
+  _consent = resolveAnalyticsConsent(_projectId, cfg);
+  if (_consent === "granted") _buffer.push(...takeSpill());
+  else if (_consent === "denied") writeSpill([]);
+  _unsubscribeConsent2 = onAnalyticsConsentChange(applyConsent);
+  const interval = Math.max(1e3, _config.flushIntervalMs);
+  _flushTimer = setInterval(() => {
+    void flushNow();
+  }, interval);
+  const onHide = () => {
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") void flushNow();
+  };
+  if (typeof document !== "undefined") document.addEventListener("visibilitychange", onHide, { passive: true });
+  window.addEventListener("pagehide", () => {
+    void flushNow();
+  }, { passive: true });
+  if (_config.autoPageviews) patchHistory();
+}
+function trackEvent(name, properties, opts) {
+  if (!_initialized2 || !_sampledIn) return false;
+  if (!isValidEventName(name)) return false;
+  const { properties: props } = sanitizeEventProperties(properties, {
+    allowlist: _config.propertyAllowlist,
+    scrub: _scrub
+  });
+  let merged = props;
+  if (opts?.reserved) {
+    const { properties: res } = sanitizeEventProperties(opts.reserved, { allowReserved: true, scrub: _scrub });
+    merged = { ...props, ...res };
+  }
+  merged.$surface = _config.surface;
+  if (typeof location !== "undefined" && merged.$route === void 0) merged.$route = location.pathname;
+  if (!propertiesWithinByteLimit(merged)) return false;
+  return enqueue({
+    name,
+    ts: opts?.ts ?? now2(),
+    properties: merged,
+    ...opts?.dedupKey ? { dedup_key: opts.dedupKey } : {}
+  });
+}
+function setEventConsent(state) {
+  if (!_initialized2) _consent = state;
+  setAnalyticsConsent(_projectId, state);
+}
+function updateEventIdentity(userId, traits) {
+  _userId = userId;
+  _userTraits = traits ?? null;
+  if (!_initialized2 || !_sampledIn || !userId || _consent === "denied") return;
+  _pendingIdentify = true;
+  if (_consent === "granted") void flushNow();
+}
+function flushEvents() {
+  return flushNow();
+}
+function destroyEventTracker() {
+  if (_flushTimer != null) {
+    clearInterval(_flushTimer);
+    _flushTimer = null;
+  }
+  _unsubscribeConsent2?.();
+  _unsubscribeConsent2 = null;
+  _initialized2 = false;
+  _client2 = null;
+  _buffer = [];
+  _consentBuffer = [];
+  _consent = "granted";
+  _sampledIn = true;
+  _pendingIdentify = false;
+  _userId = null;
+  _userTraits = null;
+  _config = defaults();
+}
+var _historyPatched2 = false;
+function patchHistory() {
+  if (_historyPatched2 || typeof history === "undefined") return;
+  _historyPatched2 = true;
+  const original = history.pushState;
+  history.pushState = function(...args) {
+    const result = original.apply(this, args);
+    trackEvent("page_view");
     return result;
   };
-  history.pushState = wrap(history.pushState);
-  history.replaceState = wrap(history.replaceState);
   window.addEventListener("popstate", () => {
-    _pageViewCount += 1;
-    send(buildPayload("page_view", { route: currentRoute() }));
+    trackEvent("page_view");
   }, { passive: true });
 }
 
@@ -2035,12 +2645,12 @@ function createRateLimiter(config = {}) {
   let tokens = maxBurst;
   let lastRefill = Date.now();
   function refill() {
-    const now2 = Date.now();
-    const elapsed = now2 - lastRefill;
+    const now3 = Date.now();
+    const elapsed = now3 - lastRefill;
     const refills = Math.floor(elapsed / refillIntervalMs);
     if (refills > 0) {
       tokens = Math.min(maxBurst, tokens + refills * refillRate);
-      lastRefill = now2;
+      lastRefill = now3;
     }
   }
   function tryConsume() {
@@ -2438,15 +3048,15 @@ function mushiTokens(mode) {
 // src/identity.ts
 var MUSHI_IDENTITY_TOKEN_PREFIX = "mushi.identity";
 function buildIdentityClaims(input) {
-  const now2 = Math.floor(Date.now() / 1e3);
+  const now3 = Math.floor(Date.now() / 1e3);
   const ttl = input.ttlSeconds && input.ttlSeconds > 0 ? Math.min(input.ttlSeconds, 3600) : 600;
   return {
     projectId: input.projectId,
     sub: input.userId,
     ...input.email ? { email: input.email } : {},
     ...input.name ? { name: input.name } : {},
-    iat: now2,
-    exp: now2 + ttl
+    iat: now3,
+    exp: now3 + ttl
   };
 }
 function base64UrlDecode(segment) {
@@ -2486,13 +3096,22 @@ var SLUG_DOMAIN_HINTS = {
   "glot-it": "glot.it",
   glotit: "glot.it",
   "solo-boss-cloud": "solo-boss.kensaur.us",
-  "mushi-mushi": "kensaur.us"
+  "mushi-mushi": "kensaur.us",
+  "how-to-talk-to-girls": "talk.kensaur.us",
+  htttg: "talk.kensaur.us",
+  tsumagoi: "tsumagoi.kensaur.us"
 };
 var SLUG_ICON_URL_HINTS = {
   "mushi-mushi": "https://kensaur.us/mushi-mushi/admin/favicon.svg",
   "solo-boss-cloud": "https://solo-boss.kensaur.us/favicon.svg",
   "glot-it": "https://kensaur.us/glot-it/apple-touch-icon.png",
-  glotit: "https://kensaur.us/glot-it/apple-touch-icon.png"
+  glotit: "https://kensaur.us/glot-it/apple-touch-icon.png",
+  "the-wanting-mind": "https://kensaur.us/the-wanting-mind/pwa-512x512.png",
+  "how-to-talk-to-girls": "https://talk.kensaur.us/pwa-192.png",
+  htttg: "https://talk.kensaur.us/pwa-192.png",
+  tsumagoi: "https://tsumagoi.kensaur.us/apple-touch-icon.png",
+  "help-her-take-photo": "https://kensaur.us/help-her-take-photo/assets/apple-touch-icon.png",
+  "yen-yen": "https://kensaur.us/yen-yen/icon.svg"
 };
 var UNTRUSTED_FAVICON_HOSTS = [
   "www.google.com",
@@ -2664,20 +3283,27 @@ function isSafeFaviconHref(href) {
   }
 }
 
+exports.ACTIVATION_EVENT = ACTIVATION_EVENT;
 exports.DEFAULT_API_ENDPOINT = DEFAULT_API_ENDPOINT;
 exports.DEFAULT_MAX_RETRIES = DEFAULT_MAX_RETRIES;
 exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+exports.EVENT_NAME_RE = EVENT_NAME_RE;
+exports.EVENT_PROPERTY_LIMITS = EVENT_PROPERTY_LIMITS;
+exports.HABIT_EVENTS = HABIT_EVENTS;
 exports.MAX_REPORT_PAYLOAD_BYTES = MAX_REPORT_PAYLOAD_BYTES;
 exports.MAX_SCREENSHOT_DATA_URL_BYTES = MAX_SCREENSHOT_DATA_URL_BYTES;
 exports.MUSHI_ACCENT_SHADOW = MUSHI_ACCENT_SHADOW;
 exports.MUSHI_BANNER_BRAND_BORDER = MUSHI_BANNER_BRAND_BORDER;
 exports.MUSHI_BANNER_NEON = MUSHI_BANNER_NEON;
+exports.MUSHI_BEACON_MAX_BYTES = MUSHI_BEACON_MAX_BYTES;
 exports.MUSHI_BORDER = MUSHI_BORDER;
 exports.MUSHI_COLORS_DARK = MUSHI_COLORS_DARK;
 exports.MUSHI_COLORS_LIGHT = MUSHI_COLORS_LIGHT;
 exports.MUSHI_CONTROL_DISABLED = MUSHI_CONTROL_DISABLED;
 exports.MUSHI_COPY = MUSHI_COPY;
 exports.MUSHI_DURATION = MUSHI_DURATION;
+exports.MUSHI_EVENTS = MUSHI_EVENTS;
+exports.MUSHI_EVENT_NAMES = MUSHI_EVENT_NAMES;
 exports.MUSHI_GEOMETRY = MUSHI_GEOMETRY;
 exports.MUSHI_IDENTITY_TOKEN_PREFIX = MUSHI_IDENTITY_TOKEN_PREFIX;
 exports.MUSHI_INTERNAL_HEADER = MUSHI_INTERNAL_HEADER;
@@ -2694,11 +3320,14 @@ exports.MUSHI_SDK_PACKAGE_HEADER = MUSHI_SDK_PACKAGE_HEADER;
 exports.MUSHI_SDK_VERSION_HEADER = MUSHI_SDK_VERSION_HEADER;
 exports.MUSHI_SHADOW_INK = MUSHI_SHADOW_INK;
 exports.MUSHI_SPACING = MUSHI_SPACING;
+exports.MUSHI_SURFACES = MUSHI_SURFACES;
 exports.MUSHI_TIER_COLORS = MUSHI_TIER_COLORS;
 exports.MUSHI_TYPE = MUSHI_TYPE;
 exports.MUSHI_USER_TOKEN_HEADER = MUSHI_USER_TOKEN_HEADER;
 exports.MUSHI_Z = MUSHI_Z;
 exports.REGION_ENDPOINTS = REGION_ENDPOINTS;
+exports.analyticsBlockReason = analyticsBlockReason;
+exports.buildBeaconEnvelope = buildBeaconEnvelope;
 exports.buildIdentityClaims = buildIdentityClaims;
 exports.buildSdkIngestHeaders = buildSdkIngestHeaders;
 exports.captureEnvironment = captureEnvironment;
@@ -2710,41 +3339,69 @@ exports.createOfflineQueue = createOfflineQueue;
 exports.createPiiScrubber = createPiiScrubber;
 exports.createPreFilter = createPreFilter;
 exports.createRateLimiter = createRateLimiter;
+exports.destroyEventTracker = destroyEventTracker;
 exports.destroySessionTracker = destroySessionTracker;
 exports.diagnoseEnvConfig = diagnoseEnvConfig;
+exports.dntActive = dntActive;
 exports.estimateJsonBytes = estimateJsonBytes;
 exports.expandPreset = expandPreset;
+exports.extractTunnelPath = extractTunnelPath;
 exports.faviconUrlCandidates = faviconUrlCandidates;
+exports.flushEvents = flushEvents;
+exports.flushLastOutboundOnUnload = flushLastOutboundOnUnload;
 exports.formatBytes = formatBytes;
+exports.getBackoffDelay = getBackoffDelay;
 exports.getDeviceFingerprintHash = getDeviceFingerprintHash;
+exports.getEventAnonymousId = getEventAnonymousId;
 exports.getReporterToken = getReporterToken;
 exports.getSessionId = getSessionId;
 exports.githubRepoDomainHint = githubRepoDomainHint;
 exports.hmacSha256Hex = hmacSha256Hex;
+exports.initEventTracker = initEventTracker;
 exports.initSessionTracker = initSessionTracker;
+exports.isAutomatedBrowser = isAutomatedBrowser;
+exports.isEventTrackingActive = isEventTrackingActive;
 exports.isLikelyGenericFavicon = isLikelyGenericFavicon;
+exports.isMushiBeaconEnvelope = isMushiBeaconEnvelope;
+exports.isPageUnloading = isPageUnloading;
+exports.isSameOriginOrRelative = isSameOriginOrRelative;
 exports.isUntrustedFaviconUrl = isUntrustedFaviconUrl;
+exports.isValidEventName = isValidEventName;
+exports.markPageUnloading = markPageUnloading;
+exports.matchesErrorFilter = matchesErrorFilter;
 exports.mushiPalette = mushiPalette;
 exports.mushiTokens = mushiTokens;
 exports.newUuid = newUuid;
 exports.noopLogger = noopLogger;
 exports.normaliseThrown = normaliseThrown;
+exports.onAnalyticsConsentChange = onAnalyticsConsentChange;
 exports.originToDomain = originToDomain;
 exports.parseIdentityToken = parseIdentityToken;
+exports.parseRetryAfter = parseRetryAfter;
 exports.projectFaviconUrlCandidates = projectFaviconUrlCandidates;
 exports.projectInitials = projectInitials;
 exports.projectInitialsThemeIndex = projectInitialsThemeIndex;
+exports.propertiesWithinByteLimit = propertiesWithinByteLimit;
 exports.readPageFaviconHref = readPageFaviconHref;
+exports.resolveAnalyticsConsent = resolveAnalyticsConsent;
 exports.resolveEnvConfig = resolveEnvConfig;
 exports.resolveProjectDomain = resolveProjectDomain;
 exports.resolveProjectFaviconDomains = resolveProjectFaviconDomains;
 exports.resolveRegionEndpoint = resolveRegionEndpoint;
+exports.resolveRequestBaseUrl = resolveRequestBaseUrl;
 exports.resolveWidgetAccent = resolveWidgetAccent;
 exports.safeWidgetHex = safeWidgetHex;
+exports.sanitizeEventProperties = sanitizeEventProperties;
 exports.scrubPii = scrubPii;
 exports.scrubUrl = scrubUrl;
+exports.sendOnUnload = sendOnUnload;
+exports.setAnalyticsConsent = setAnalyticsConsent;
+exports.setEventConsent = setEventConsent;
 exports.sha256Hex = sha256Hex;
+exports.shouldDropCapturedError = shouldDropCapturedError;
+exports.trackEvent = trackEvent;
 exports.trackPageView = trackPageView;
+exports.updateEventIdentity = updateEventIdentity;
 exports.updateSessionIdentity = updateSessionIdentity;
 exports.validateConfig = validateConfig;
 //# sourceMappingURL=index.cjs.map