@mushi-mushi/web 0.8.0 → 1.0.0

package/dist/index.cjs

@@ -2052,6 +2052,17 @@ function createElementSelector() {
   let active = false;
   let overlay = null;
   let resolvePromise = null;
+  function findNearestTestid(el) {
+    let cur = el;
+    let hops = 0;
+    while (cur && hops < 20) {
+      const tid = cur.getAttribute?.("data-testid");
+      if (tid) return tid;
+      cur = cur.parentElement;
+      hops++;
+    }
+    return null;
+  }
   function getXPath(el) {
     const parts = [];
     let current = el;
@@ -2081,7 +2092,13 @@ function createElementSelector() {
         y: Math.round(rect.y),
         width: Math.round(rect.width),
         height: Math.round(rect.height)
-      }
+      },
+      // v2 (whitepaper §4.7): the closest ancestor's `data-testid` lets the
+      // server map this report → an Action node in the inventory graph
+      // without a fuzzy NLP guess. We walk to the body so a deeply nested
+      // span inside a button-with-testid still resolves correctly.
+      nearestTestid: findNearestTestid(el) || void 0,
+      route: typeof window !== "undefined" ? window.location.pathname : void 0
     };
   }
   function createOverlay() {
@@ -2260,45 +2277,402 @@ function textSnippet(el) {
   return text ? text.slice(0, 80) : void 0;
 }
 
+// src/capture/discovery.ts
+var DEFAULT_THROTTLE_MS = 6e4;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var HEX24_RE = /^[0-9a-f]{20,}$/i;
+var NUMERIC_RE = /^\d+$/;
+var SLUG_HASHY_RE = /^[a-z0-9]{16,}$/i;
+function normalizeSegment(seg) {
+  if (seg.length === 0) return seg;
+  if (UUID_RE.test(seg)) return "[id]";
+  if (HEX24_RE.test(seg)) return "[id]";
+  if (NUMERIC_RE.test(seg)) return "[id]";
+  if (SLUG_HASHY_RE.test(seg) && /\d/.test(seg)) return "[id]";
+  return seg;
+}
+function normalizeRoute(pathname, templates) {
+  const clean = pathname.length > 1 && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+  if (templates?.length) {
+    const matched = matchTemplate(clean, templates);
+    if (matched) return matched;
+  }
+  return "/" + clean.split("/").filter((s) => s.length > 0).map(normalizeSegment).join("/");
+}
+function matchTemplate(pathname, templates) {
+  const segs = pathname.split("/").filter((s) => s.length > 0);
+  const sorted = [...templates].sort(
+    (a, b) => b.split("/").length - a.split("/").length
+  );
+  for (const tpl of sorted) {
+    const tplSegs = tpl.split("/").filter((s) => s.length > 0);
+    if (tplSegs.length !== segs.length) continue;
+    let ok = true;
+    for (let i = 0; i < tplSegs.length; i++) {
+      const t = tplSegs[i];
+      const s = segs[i];
+      if (t.startsWith("[") && t.endsWith("]")) continue;
+      if (t.startsWith(":")) continue;
+      if (t === s) continue;
+      ok = false;
+      break;
+    }
+    if (ok) return "/" + tplSegs.join("/");
+  }
+  return null;
+}
+function readTestids() {
+  if (typeof document === "undefined") return [];
+  const out = /* @__PURE__ */ new Set();
+  const els = document.querySelectorAll("[data-testid]");
+  for (const el of Array.from(els)) {
+    const v = el.getAttribute("data-testid");
+    if (v && v.length > 0 && v.length < 120) out.add(v);
+  }
+  return Array.from(out).sort();
+}
+function readQueryParamKeys() {
+  if (typeof window === "undefined") return [];
+  try {
+    const params = new URLSearchParams(window.location.search);
+    const out = /* @__PURE__ */ new Set();
+    params.forEach((_, key) => out.add(key));
+    return Array.from(out).sort();
+  } catch {
+    return [];
+  }
+}
+function readDomSummary() {
+  if (typeof document === "undefined") return null;
+  const trim = (s) => (s ?? "").replace(/\s+/g, " ").trim().slice(0, 200);
+  const h1 = trim(document.querySelector("h1")?.textContent);
+  if (h1) return h1;
+  const title = trim(document.title);
+  if (title) return title;
+  const main = trim(document.querySelector("main")?.textContent);
+  return main || null;
+}
+async function hashUserId(input) {
+  if (!input || typeof crypto === "undefined" || !crypto.subtle) return null;
+  try {
+    const data = new TextEncoder().encode(input);
+    const buf = await crypto.subtle.digest("SHA-256", data);
+    const bytes = new Uint8Array(buf);
+    let hex = "";
+    for (let i = 0; i < bytes.length; i++) {
+      hex += bytes[i].toString(16).padStart(2, "0");
+    }
+    return hex;
+  } catch {
+    return null;
+  }
+}
+function createDiscoveryCapture(opts) {
+  const {
+    config,
+    getRecentNetworkPaths,
+    getUserId,
+    getSessionId: getSessionId2,
+    onEvent
+  } = opts;
+  const throttleMs = config.throttleMs ?? DEFAULT_THROTTLE_MS;
+  const captureSummary = config.captureDomSummary !== false;
+  const userIdSource = config.userIdSource ?? "auto";
+  const lastEmittedAt = /* @__PURE__ */ new Map();
+  let lastPath = null;
+  let pendingTimer = null;
+  async function emitForCurrent() {
+    if (typeof window === "undefined") return;
+    const route = normalizeRoute(window.location.pathname, config.routeTemplates);
+    const now = Date.now();
+    const last = lastEmittedAt.get(route) ?? 0;
+    if (now - last < throttleMs) return;
+    lastEmittedAt.set(route, now);
+    let userIdInput = null;
+    if (userIdSource === "auto") {
+      userIdInput = getUserId() ?? getSessionId2();
+    } else if (userIdSource === "session-only") {
+      userIdInput = getSessionId2();
+    }
+    const event = {
+      route,
+      page_title: typeof document !== "undefined" ? (document.title || "").slice(0, 300) || null : null,
+      dom_summary: captureSummary ? readDomSummary() : null,
+      testids: readTestids(),
+      network_paths: getRecentNetworkPaths().slice(-50),
+      query_param_keys: readQueryParamKeys(),
+      user_id_hash: await hashUserId(userIdInput),
+      observed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    onEvent(event);
+  }
+  function scheduleEmit() {
+    if (pendingTimer) return;
+    pendingTimer = setTimeout(() => {
+      pendingTimer = null;
+      void emitForCurrent();
+    }, 100);
+  }
+  function onMaybeNavigation() {
+    if (typeof window === "undefined") return;
+    const path = window.location.pathname + window.location.search;
+    if (path === lastPath) return;
+    lastPath = path;
+    scheduleEmit();
+  }
+  if (typeof window === "undefined") {
+    return {
+      destroy: () => void 0,
+      flushNow: () => void 0
+    };
+  }
+  const originalPush = window.history.pushState.bind(window.history);
+  const originalReplace = window.history.replaceState.bind(window.history);
+  const patchedPush = function patched(...args) {
+    const out = originalPush(...args);
+    onMaybeNavigation();
+    return out;
+  };
+  const patchedReplace = function patched(...args) {
+    const out = originalReplace(...args);
+    onMaybeNavigation();
+    return out;
+  };
+  window.history.pushState = patchedPush;
+  window.history.replaceState = patchedReplace;
+  const onPop = () => onMaybeNavigation();
+  window.addEventListener("popstate", onPop);
+  scheduleEmit();
+  return {
+    destroy() {
+      window.removeEventListener("popstate", onPop);
+      if (window.history.pushState === patchedPush) {
+        window.history.pushState = originalPush;
+      }
+      if (window.history.replaceState === patchedReplace) {
+        window.history.replaceState = originalReplace;
+      }
+      if (pendingTimer) {
+        clearTimeout(pendingTimer);
+        pendingTimer = null;
+      }
+      lastEmittedAt.clear();
+    },
+    flushNow() {
+      lastEmittedAt.clear();
+      void emitForCurrent();
+    }
+  };
+}
+
 // src/sentry.ts
 function getSentryGlobal() {
   try {
-    const win = globalThis;
-    if (win.__SENTRY__) {
-      const sentry = win.__SENTRY__;
-      const hub = sentry.hub;
-      return hub;
+    const w = globalThis;
+    if (w.Sentry) return w.Sentry;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getSentryReplayGlobal() {
+  try {
+    const w = globalThis;
+    return w.__SENTRY_REPLAY__;
+  } catch {
+    return void 0;
+  }
+}
+function detectSentrySdkFamily() {
+  try {
+    const w = globalThis;
+    const meta = w.__SENTRY__;
+    const sentry = w.Sentry;
+    if (meta?.version === "9" || sentry && typeof sentry.lastEventId === "function") {
+      return meta?.version === "9" ? "v9" : "v8";
+    }
+    if (meta?.version === "8") return "v8";
+    if (sentry && typeof sentry.getCurrentHub === "function") return "v7";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function captureSentryContext(_config, options = {}) {
+  const limit = Math.max(0, options.breadcrumbsLimit ?? 30);
+  const out = {};
+  const sentry = getSentryGlobal();
+  if (!sentry) return out;
+  out.sdk = detectSentrySdkFamily();
+  try {
+    const v8 = sentry;
+    if (typeof v8.lastEventId === "function") {
+      out.eventId = v8.lastEventId() ?? void 0;
+    } else {
+      const v7 = sentry;
+      const scope2 = v7.getCurrentHub?.()?.getScope?.();
+      out.eventId = scope2?.getLastEventId?.() ?? void 0;
+    }
+  } catch {
+  }
+  let scope;
+  try {
+    const v8 = sentry;
+    if (typeof v8.getCurrentScope === "function") {
+      scope = v8.getCurrentScope();
+    } else {
+      const v7 = sentry;
+      scope = v7.getCurrentHub?.()?.getScope?.();
+    }
+  } catch {
+  }
+  if (scope) {
+    try {
+      const user = scope.getUser?.();
+      if (user) {
+        out.user = {
+          id: typeof user.id === "string" ? user.id : void 0,
+          email: typeof user.email === "string" ? user.email : void 0,
+          username: typeof user.username === "string" ? user.username : void 0,
+          ip_address: typeof user.ip_address === "string" ? user.ip_address : void 0
+        };
+      }
+    } catch {
+    }
+    try {
+      const tags = scope.getTags?.();
+      if (tags && typeof tags === "object") {
+        const pruned = {};
+        for (const [k, v] of Object.entries(tags)) {
+          if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+            pruned[k] = v;
+          }
+        }
+        if (Object.keys(pruned).length > 0) out.tags = pruned;
+      }
+    } catch {
+    }
+    try {
+      out.transactionName = scope.getTransactionName?.() ?? scope.getTransaction?.()?.name ?? void 0;
+    } catch {
+    }
+    try {
+      out.sessionId = scope.getSession?.()?.sid ?? void 0;
+    } catch {
     }
-    if (win.Sentry) {
-      return win.Sentry;
+    try {
+      const raw = scope.getBreadcrumbs?.() ?? scope._breadcrumbs ?? [];
+      if (Array.isArray(raw) && raw.length > 0) {
+        const sliced = raw.slice(-limit);
+        out.breadcrumbs = sliced.map((b) => {
+          const r = b;
+          return {
+            timestamp: typeof r.timestamp === "number" ? (
+              // Sentry stores breadcrumb timestamps in seconds; convert
+              // to ms so the field is comparable to Mushi's own.
+              r.timestamp < 1e12 ? Math.round(r.timestamp * 1e3) : r.timestamp
+            ) : void 0,
+            category: typeof r.category === "string" ? r.category : void 0,
+            level: typeof r.level === "string" ? r.level : void 0,
+            message: typeof r.message === "string" ? r.message : void 0,
+            type: typeof r.type === "string" ? r.type : void 0,
+            data: r.data && typeof r.data === "object" ? r.data : void 0
+          };
+        });
+      }
+    } catch {
+    }
+  }
+  try {
+    const v8 = sentry;
+    let span;
+    if (typeof v8.getActiveSpan === "function") {
+      span = v8.getActiveSpan();
+    } else if (scope?.getSpan) {
+      span = scope.getSpan();
+    }
+    if (span) {
+      const ctx = span.spanContext?.();
+      out.traceId = ctx?.traceId ?? span.traceId ?? void 0;
+      out.spanId = ctx?.spanId ?? span.spanId ?? void 0;
+    }
+  } catch {
+  }
+  let client;
+  try {
+    const v8 = sentry;
+    if (typeof v8.getClient === "function") {
+      client = v8.getClient();
+    } else {
+      const v7 = sentry;
+      client = v7.getCurrentHub?.()?.getClient?.();
     }
   } catch {
   }
-  return void 0;
+  if (client) {
+    try {
+      const opts = client.getOptions?.();
+      if (opts?.release) out.release = opts.release;
+      if (opts?.environment) out.environment = opts.environment;
+    } catch {
+    }
+    try {
+      const dsn = client.getDsn?.();
+      if (dsn?.host && dsn?.projectId && out.eventId) {
+        const orgHost = dsn.host.replace(/^o\d+\./, "");
+        out.issueUrl = `https://${orgHost}/issues/?query=${encodeURIComponent(out.eventId)}`;
+      }
+    } catch {
+    }
+  }
+  try {
+    const v8 = sentry;
+    const replay = v8.getReplay?.() ?? getSentryReplayGlobal();
+    out.replayId = replay?.getReplayId?.() ?? void 0;
+  } catch {
+  }
+  return out;
 }
-function captureSentryContext(_config) {
-  const context = {};
+function tagSentryScope(reportId, options = {}) {
+  const sentry = getSentryGlobal();
+  if (!sentry) return;
   try {
-    const hub = getSentryGlobal();
-    if (!hub) return context;
-    const scope = hub.getScope?.();
-    if (scope) {
-      context.eventId = scope.getLastEventId?.() ?? void 0;
+    const v8 = sentry;
+    if (typeof v8.setTag === "function") {
+      v8.setTag("mushi.report_id", reportId);
+      if (options.reportUrl) v8.setTag("mushi.report_url", options.reportUrl);
+    }
+    if (typeof v8.setContext === "function") {
+      v8.setContext("mushi_report", {
+        id: reportId,
+        ...options.reportUrl ? { url: options.reportUrl } : {},
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
     }
-    const client = hub.getClient?.();
-    if (client) {
-      const options = client.getOptions?.();
-      context.release = options?.release;
-      context.environment = options?.environment;
+    if (typeof v8.addBreadcrumb === "function") {
+      v8.addBreadcrumb({
+        category: "mushi",
+        type: "info",
+        level: "info",
+        message: `Mushi report submitted (${reportId})`,
+        data: { report_id: reportId, ...options.reportUrl ? { url: options.reportUrl } : {} }
+      });
     }
-    const win = globalThis;
-    if (win.__SENTRY_REPLAY__) {
-      const replay = win.__SENTRY_REPLAY__;
-      context.replayId = replay.getReplayId?.() ?? void 0;
+  } catch {
+  }
+  try {
+    const v7 = sentry;
+    const scope = v7.getCurrentHub?.()?.getScope?.();
+    if (scope) {
+      scope.setTag?.("mushi.report_id", reportId);
+      if (options.reportUrl) scope.setTag?.("mushi.report_url", options.reportUrl);
+      scope.setContext?.("mushi_report", {
+        id: reportId,
+        ...options.reportUrl ? { url: options.reportUrl } : {}
+      });
     }
   } catch {
   }
-  return context;
 }
 
 // src/proactive-triggers.ts
@@ -2475,7 +2849,7 @@ function createProactiveManager(config = {}) {
 
 // src/version.ts
 var MUSHI_SDK_PACKAGE = "@mushi-mushi/web";
-var MUSHI_SDK_VERSION = "0.8.0" ;
+var MUSHI_SDK_VERSION = "1.0.0" ;
 
 // src/mushi.ts
 var instance = null;
@@ -2523,11 +2897,36 @@ function createInstance(config) {
   const offlineQueue = core.createOfflineQueue(bootstrapConfig.offline);
   const rateLimiter = core.createRateLimiter({ maxBurst: 10, refillRate: 1, refillIntervalMs: 5e3 });
   const piiScrubber = core.createPiiScrubber();
+  function scrubBreadcrumbsForWire(crumbs) {
+    return crumbs.map((c) => {
+      const next = { ...c };
+      if (typeof c.message === "string") {
+        next.message = piiScrubber.scrub(c.message);
+      }
+      if (c.data && typeof c.data === "object") {
+        const cleaned = {};
+        for (const [k, v] of Object.entries(c.data)) {
+          cleaned[k] = typeof v === "string" ? piiScrubber.scrub(v) : v;
+        }
+        next.data = cleaned;
+      }
+      return next;
+    });
+  }
+  function scrubTagsForWire(tags) {
+    if (!tags) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(tags)) {
+      out[k] = typeof v === "string" ? piiScrubber.scrub(v) : v;
+    }
+    return out;
+  }
   let consoleCap = null;
   let networkCap = null;
   let perfCap = null;
   let screenshotCap = null;
   let elementSelector = null;
+  let discoveryCap = null;
   const timelineCap = createTimelineCapture();
   let widget;
   function syncCaptureModules() {
@@ -2576,6 +2975,40 @@ function createInstance(config) {
       elementSelector = null;
       pendingElement = null;
     }
+    const discoveryRaw = activeConfig.capture?.discoverInventory;
+    const discoveryConfig = discoveryRaw === true ? {} : discoveryRaw && typeof discoveryRaw === "object" ? discoveryRaw : null;
+    const discoveryEnabled = discoveryConfig != null && discoveryConfig.enabled !== false;
+    if (discoveryEnabled) {
+      discoveryCap?.destroy();
+      discoveryCap = createDiscoveryCapture({
+        config: discoveryConfig,
+        getRecentNetworkPaths: () => {
+          if (!networkCap) return [];
+          return networkCap.getEntries().map((e) => {
+            try {
+              const u = new URL(e.url, typeof window !== "undefined" ? window.location.href : "http://localhost");
+              if (u.host && typeof window !== "undefined" && u.host !== window.location.host) return null;
+              return u.pathname;
+            } catch {
+              return null;
+            }
+          }).filter((p) => p != null && p.length > 0 && p.length < 200);
+        },
+        getUserId: () => userInfo?.id ?? null,
+        getSessionId: core.getSessionId,
+        onEvent: (event) => {
+          void apiClient.postDiscoveryEvent({
+            ...event,
+            sdk_version: MUSHI_SDK_VERSION
+          }).catch((err) => {
+            log.debug("discovery emit failed", { err: String(err) });
+          });
+        }
+      });
+    } else {
+      discoveryCap?.destroy();
+      discoveryCap = null;
+    }
   }
   const listeners = /* @__PURE__ */ new Map();
   function emit(type, data) {
@@ -2587,6 +3020,16 @@ function createInstance(config) {
   let runtimeConfigLoaded = false;
   let userInfo = null;
   const customMetadata = {};
+  const stickyTags = {};
+  const breadcrumbs = core.createBreadcrumbBuffer({ max: 50 });
+  breadcrumbs.add({
+    category: "lifecycle",
+    level: "info",
+    message: "Mushi SDK init",
+    data: { projectId: bootstrapConfig.projectId, sdkVersion: MUSHI_SDK_VERSION }
+  });
+  let detachAutoBreadcrumbs = null;
+  detachAutoBreadcrumbs = installAutoBreadcrumbs(breadcrumbs);
   widget = new MushiWidget(bootstrapConfig.widget, {
     onSubmit: async ({ category, description, intent }) => {
       log.info("Report submitted", { category, intent });
@@ -2796,6 +3239,15 @@ function createInstance(config) {
     const fingerprintHash = await core.getDeviceFingerprintHash().catch(() => null);
     const consoleLogs = activeConfig.capture?.console === false ? void 0 : consoleCap?.getEntries();
     const networkLogs = activeConfig.capture?.network === false ? void 0 : networkCap?.getEntries();
+    const reportBreadcrumbs = scrubBreadcrumbsForWire(breadcrumbs.getAll());
+    const stickyTagSnapshot = scrubTagsForWire(
+      Object.keys(stickyTags).length > 0 ? { ...stickyTags } : void 0
+    );
+    const sentryCtxScrubbed = sentryCtx ? {
+      ...sentryCtx,
+      ...sentryCtx.breadcrumbs ? { breadcrumbs: scrubBreadcrumbsForWire(sentryCtx.breadcrumbs) } : {},
+      ...sentryCtx.tags ? { tags: scrubTagsForWire(sentryCtx.tags) } : {}
+    } : void 0;
     const report = {
       id: crypto.randomUUID?.() ?? `mushi_${Date.now()}_${Math.random().toString(36).slice(2)}`,
       projectId: config.projectId,
@@ -2821,10 +3273,24 @@ function createInstance(config) {
       sdkPackage: MUSHI_SDK_PACKAGE,
       sdkVersion: MUSHI_SDK_VERSION,
       proactiveTrigger: pendingProactiveTrigger ?? void 0,
+      // Top-level Sentry-grade observability fields. Breadcrumbs are
+      // surfaced separately from `consoleLogs` because they're the
+      // higher-signal "what just happened" trail (vs. the high-volume
+      // raw console mirror), and the admin /reports drawer shows them
+      // in different panes.
+      ...reportBreadcrumbs.length > 0 ? { breadcrumbs: reportBreadcrumbs } : {},
+      ...stickyTagSnapshot ? { tags: stickyTagSnapshot } : {},
+      ...sentryCtxScrubbed ? { sentryContext: sentryCtxScrubbed } : {},
       sentryEventId: sentryCtx?.eventId,
       sentryReplayId: sentryCtx?.replayId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
+    breadcrumbs.add({
+      category: "lifecycle",
+      level: "info",
+      message: `Mushi report submitting (${category})`,
+      data: { reportId: report.id, category }
+    });
     if (config.integrations?.custom) {
       const builder = {
         addMetadata(key, value) {
@@ -2850,10 +3316,26 @@ function createInstance(config) {
     if (result.ok) {
       log.info("Report sent", { reportId: result.data?.reportId });
       emit("report:sent", { reportId: result.data?.reportId });
+      breadcrumbs.add({
+        category: "lifecycle",
+        level: "info",
+        message: `Mushi report sent (${result.data?.reportId ?? report.id})`
+      });
+      try {
+        if (config.sentry && result.data?.reportId) {
+          tagSentryScope(result.data.reportId);
+        }
+      } catch {
+      }
     } else {
       log.warn("Report failed, queuing for retry", { reportId: report.id, error: result.error });
       await offlineQueue.enqueue(report);
       emit("report:failed", { reportId: report.id, error: result.error });
+      breadcrumbs.add({
+        category: "lifecycle",
+        level: "warning",
+        message: `Mushi report queued for retry (${report.id})`
+      });
     }
     pendingScreenshot = null;
     pendingElement = null;
@@ -2922,7 +3404,12 @@ function createInstance(config) {
       perfCap?.destroy();
       elementSelector?.deactivate();
       timelineCap.destroy();
+      discoveryCap?.destroy();
+      discoveryCap = null;
       offlineQueue.stopAutoSync();
+      detachAutoBreadcrumbs?.();
+      detachAutoBreadcrumbs = null;
+      breadcrumbs.clear();
       listeners.clear();
       instance = null;
       log.debug("Destroyed");
@@ -2937,6 +3424,16 @@ function createInstance(config) {
       }
       const description = piiScrubber.scrub(preFilter.truncate(input.description));
       const category = input.category ?? "bug";
+      const sentryCtx = config.sentry ? captureSentryContext(config.sentry) : void 0;
+      const captureBreadcrumbs = scrubBreadcrumbsForWire(breadcrumbs.getAll());
+      const mergedTags = scrubTagsForWire(
+        Object.keys(stickyTags).length === 0 && !input.tags ? void 0 : { ...stickyTags, ...input.tags ?? {} }
+      );
+      const sentryCtxScrubbed = sentryCtx ? {
+        ...sentryCtx,
+        ...sentryCtx.breadcrumbs ? { breadcrumbs: scrubBreadcrumbsForWire(sentryCtx.breadcrumbs) } : {},
+        ...sentryCtx.tags ? { tags: scrubTagsForWire(sentryCtx.tags) } : {}
+      } : void 0;
       const report = {
         id: crypto.randomUUID?.() ?? `mushi_${Date.now()}_${Math.random().toString(36).slice(2)}`,
         projectId: config.projectId,
@@ -2947,16 +3444,20 @@ function createInstance(config) {
         metadata: {
           ...input.metadata ?? {},
           ...userInfo ? { user: userInfo } : {},
-          ...input.tags ? { tags: input.tags } : {},
           ...input.error ? { error: input.error } : {},
           ...input.severity ? { severity: input.severity } : {},
           ...input.component ? { component: input.component } : {},
           ...input.source ? { source: input.source } : { source: "captureEvent" }
         },
+        ...captureBreadcrumbs.length > 0 ? { breadcrumbs: captureBreadcrumbs } : {},
+        ...mergedTags && Object.keys(mergedTags).length > 0 ? { tags: mergedTags } : {},
+        ...sentryCtxScrubbed ? { sentryContext: sentryCtxScrubbed } : {},
         sessionId: core.getSessionId(),
         reporterToken: core.getReporterToken(),
         sdkPackage: MUSHI_SDK_PACKAGE,
         sdkVersion: MUSHI_SDK_VERSION,
+        sentryEventId: sentryCtx?.eventId,
+        sentryReplayId: sentryCtx?.replayId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       emit("report:submitted", { reportId: report.id });
@@ -2968,12 +3469,43 @@ function createInstance(config) {
       const res = await apiClient.submitReport(report);
       if (res.ok) {
         emit("report:sent", { reportId: res.data?.reportId });
+        try {
+          if (config.sentry && res.data?.reportId) tagSentryScope(res.data.reportId);
+        } catch {
+        }
         return res.data?.reportId ?? null;
       }
       await offlineQueue.enqueue(report);
       emit("report:failed", { reportId: report.id, error: res.error });
       return null;
     },
+    async captureException(error, options) {
+      const normalised = core.normaliseThrown(error);
+      breadcrumbs.add({
+        category: "lifecycle",
+        level: "error",
+        message: `Mushi.captureException(${normalised.name}): ${normalised.message}`,
+        ...normalised.stack ? { data: { stack: normalised.stack.slice(0, 500) } } : {}
+      });
+      const description = options?.description?.trim() || `${normalised.name}: ${normalised.message}` || "Uncaught exception";
+      return sdk.captureEvent({
+        description,
+        category: options?.category ?? "bug",
+        severity: options?.severity ?? "high",
+        ...options?.component ? { component: options.component } : {},
+        ...options?.tags ? { tags: options.tags } : {},
+        source: options?.source ?? "captureException",
+        error: {
+          name: normalised.name,
+          message: normalised.message,
+          ...normalised.stack ? { stack: normalised.stack } : {}
+        },
+        metadata: {
+          ...options?.metadata ?? {},
+          ...normalised.cause ? { cause: normalised.cause } : {}
+        }
+      });
+    },
     identify(userId, traits) {
       userInfo = { id: userId, ...traits?.email ? { email: traits.email } : {}, ...traits?.name ? { name: traits.name } : {} };
       if (traits) {
@@ -2981,6 +3513,36 @@ function createInstance(config) {
           if (k !== "email" && k !== "name") customMetadata[`user.${k}`] = v;
         }
       }
+      breadcrumbs.add({
+        category: "lifecycle",
+        level: "info",
+        message: `Mushi.identify(${userId})`
+      });
+    },
+    addBreadcrumb(crumb) {
+      breadcrumbs.add(crumb);
+    },
+    getBreadcrumbs() {
+      return breadcrumbs.getAll();
+    },
+    setTag(key, value) {
+      if (typeof key !== "string" || key.length === 0) return;
+      stickyTags[key] = value;
+    },
+    setTags(tags) {
+      if (!tags || typeof tags !== "object") return;
+      for (const [k, v] of Object.entries(tags)) {
+        if (typeof k === "string" && k.length > 0) {
+          stickyTags[k] = v;
+        }
+      }
+    },
+    clearTag(key) {
+      if (typeof key === "string" && key.length > 0) {
+        delete stickyTags[key];
+        return;
+      }
+      for (const k of Object.keys(stickyTags)) delete stickyTags[k];
     }
   };
   return sdk;
@@ -3218,10 +3780,144 @@ function createNoopInstance() {
       instance = null;
     },
     captureEvent: async () => null,
+    captureException: async () => null,
     identify: () => {
+    },
+    addBreadcrumb: () => {
+    },
+    getBreadcrumbs: () => [],
+    setTag: () => {
+    },
+    setTags: () => {
+    },
+    clearTag: () => {
+    }
+  };
+}
+function installAutoBreadcrumbs(buffer) {
+  if (typeof window === "undefined") return () => {
+  };
+  const cleanups = [];
+  try {
+    const dispatchRouteChange = (kind) => {
+      buffer.add({
+        category: "navigation",
+        level: "info",
+        message: `${kind}: ${window.location.pathname}`,
+        data: { url: window.location.href, kind }
+      });
+    };
+    const onPop = () => dispatchRouteChange("popstate");
+    window.addEventListener("popstate", onPop, { passive: true });
+    cleanups.push(() => window.removeEventListener("popstate", onPop));
+    const origPush = window.history.pushState;
+    const origReplace = window.history.replaceState;
+    window.history.pushState = function patched(...args) {
+      const ret = origPush.apply(this, args);
+      try {
+        dispatchRouteChange("pushState");
+      } catch {
+      }
+      return ret;
+    };
+    window.history.replaceState = function patched(...args) {
+      const ret = origReplace.apply(this, args);
+      try {
+        dispatchRouteChange("replaceState");
+      } catch {
+      }
+      return ret;
+    };
+    cleanups.push(() => {
+      window.history.pushState = origPush;
+      window.history.replaceState = origReplace;
+    });
+  } catch {
+  }
+  try {
+    const origError = console.error;
+    const origWarn = console.warn;
+    console.error = function(...args) {
+      try {
+        buffer.add({
+          category: "console",
+          level: "error",
+          message: args.map(stringifyConsoleArg).join(" ")
+        });
+      } catch {
+      }
+      return origError.apply(this, args);
+    };
+    console.warn = function(...args) {
+      try {
+        buffer.add({
+          category: "console",
+          level: "warning",
+          message: args.map(stringifyConsoleArg).join(" ")
+        });
+      } catch {
+      }
+      return origWarn.apply(this, args);
+    };
+    cleanups.push(() => {
+      console.error = origError;
+      console.warn = origWarn;
+    });
+  } catch {
+  }
+  try {
+    const onClick = (ev) => {
+      try {
+        const target = ev.target;
+        if (!(target instanceof Element)) return;
+        let cur = target;
+        let hops = 0;
+        while (cur && hops < 10) {
+          const tid = cur.getAttribute("data-testid");
+          if (tid) {
+            const text = (cur.textContent ?? "").trim().slice(0, 80);
+            buffer.add({
+              category: "ui.click",
+              level: "info",
+              message: `clicked ${tid}${text ? ` \u2014 ${text}` : ""}`,
+              data: { testid: tid, tag: cur.tagName.toLowerCase() }
+            });
+            return;
+          }
+          cur = cur.parentElement;
+          hops++;
+        }
+      } catch {
+      }
+    };
+    document.addEventListener("click", onClick, { passive: true, capture: true });
+    cleanups.push(() => document.removeEventListener("click", onClick, true));
+  } catch {
+  }
+  return () => {
+    for (const c of cleanups) {
+      try {
+        c();
+      } catch {
+      }
     }
   };
 }
+function stringifyConsoleArg(arg) {
+  try {
+    if (arg instanceof Error) {
+      return `${arg.name}: ${arg.message}`;
+    }
+    if (typeof arg === "object" && arg !== null) {
+      const json = JSON.stringify(arg);
+      return json.length > 200 ? `${json.slice(0, 200)}\u2026` : json;
+    }
+    const s = String(arg);
+    return s.length > 200 ? `${s.slice(0, 200)}\u2026` : s;
+  } catch {
+    return `[${typeof arg}]`;
+  }
+}
 
 exports.Mushi = Mushi;
 exports.MushiWidget = MushiWidget;