@mushi-mushi/web 0.7.0 → 0.9.0

package/dist/index.cjs

@@ -391,6 +391,29 @@ function getWidgetStyles(theme) {
       left: var(--mushi-left, calc(24px + env(safe-area-inset-left, 0px)));
       --mushi-origin: top left;
     }
+    .mushi-outdated {
+      margin: 12px 14px 0;
+      padding: 10px 12px;
+      border: 1px solid ${vermillionWash};
+      background: ${vermillionWash};
+      color: ${vermillionInk};
+      font-family: ${fontBody};
+      font-size: 12px;
+      line-height: 1.4;
+    }
+    .mushi-outdated strong {
+      display: block;
+      font-family: ${fontMono};
+      font-size: 10px;
+      letter-spacing: 0.12em;
+      text-transform: uppercase;
+      margin-bottom: 2px;
+    }
+    .mushi-outdated span {
+      display: block;
+      margin-top: 3px;
+      color: ${inkMuted};
+    }
 
     @keyframes mushi-stamp-in {
       0%   { opacity: 0; transform: scale(0.94) translateY(6px); }
@@ -545,6 +568,75 @@ function getWidgetStyles(theme) {
       transform: translateX(-4px);
       transition: opacity 220ms ${easeStamp}, transform 220ms ${easeStamp}, color 220ms ${easeStamp};
     }
+    .mushi-report-row {
+      width: 100%;
+      display: grid;
+      grid-template-columns: auto 1fr auto;
+      gap: 8px;
+      align-items: center;
+      padding: 10px 0;
+      border: 0;
+      border-bottom: 1px solid ${rule};
+      background: transparent;
+      color: ${ink};
+      cursor: pointer;
+      text-align: left;
+    }
+    .mushi-report-status {
+      font-family: ${fontMono};
+      font-size: 10px;
+      color: ${vermillion};
+      text-transform: uppercase;
+    }
+    .mushi-report-title {
+      font-size: 13px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .mushi-thread-summary {
+      border-bottom: 1px solid ${rule};
+      padding-bottom: 10px;
+      margin-bottom: 10px;
+    }
+    .mushi-thread-summary span {
+      font-family: ${fontMono};
+      font-size: 10px;
+      color: ${vermillion};
+      text-transform: uppercase;
+    }
+    .mushi-thread {
+      display: grid;
+      gap: 8px;
+      max-height: 180px;
+      overflow: auto;
+      margin-bottom: 12px;
+    }
+    .mushi-thread-comment {
+      padding: 8px 10px;
+      border: 1px solid ${rule};
+      background: ${isDark ? "rgba(242,235,221,0.04)" : "rgba(14,13,11,0.03)"};
+    }
+    .mushi-thread-comment.reporter {
+      border-color: ${vermillionWash};
+      background: ${vermillionWash};
+    }
+    .mushi-thread-comment strong {
+      display: block;
+      font-family: ${fontMono};
+      font-size: 10px;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      margin-bottom: 3px;
+    }
+    .mushi-thread-comment p,
+    .mushi-muted,
+    .mushi-error-inline {
+      font-size: 12px;
+      color: ${inkMuted};
+      line-height: 1.45;
+    }
+    .mushi-error-inline { color: ${vermillion}; }
 
     .mushi-selected-category {
       display: inline-flex;
@@ -653,6 +745,16 @@ function getWidgetStyles(theme) {
       border-color: ${vermillion};
       background: ${vermillionWash};
     }
+    .mushi-attach-btn.danger {
+      color: ${vermillionInk};
+      border-color: ${vermillionWash};
+      background: transparent;
+    }
+    .mushi-attach-btn.danger:hover {
+      color: ${vermillion};
+      border-color: ${vermillion};
+      background: ${vermillionWash};
+    }
     .mushi-attach-btn:focus-visible {
       outline: 2px solid ${vermillion};
       outline-offset: 2px;
@@ -722,6 +824,17 @@ function getWidgetStyles(theme) {
     }
     .mushi-submit:hover .mushi-submit-arrow { transform: translateX(3px); }
 
+    .mushi-brand-footer {
+      padding: 9px 14px 11px;
+      border-top: 1px solid ${rule};
+      color: ${inkFaint};
+      font-family: ${fontMono};
+      font-size: 9px;
+      letter-spacing: 0.16em;
+      text-align: center;
+      text-transform: uppercase;
+    }
+
     .mushi-step-indicator {
       display: flex;
       align-items: center;
@@ -851,43 +964,19 @@ var TOTAL_STEPS = 3;
 var STEP_NUMBER = {
   category: 1,
   intent: 2,
-  details: 3
-};
+  details: 3};
 function isSubmitShortcut(e) {
   return (e.metaKey || e.ctrlKey) && e.key === "Enter";
 }
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
 var MushiWidget = class {
-  host;
-  shadow;
-  config;
-  callbacks;
-  locale;
-  isOpen = false;
-  step = "category";
-  selectedCategory = null;
-  selectedIntent = null;
-  screenshotAttached = false;
-  elementSelected = false;
-  submitting = false;
-  triggerVisible = true;
-  triggerShrunk = false;
-  triggerHiddenByScroll = false;
-  attachedLaunchers = [];
-  smartHideCleanup = null;
-  smartHideTimer = null;
-  /** Captured at the moment of submit so the success ledger metadata
-   *  ("REPORT · 14:23:07 JST") doesn't drift while the success step
-   *  is on screen. */
-  submittedAt = null;
-  /** Pending success-state + auto-close timers. Tracked so destroy()
-   *  can clear them — otherwise a host that unmounts mid-submit leaks
-   *  this MushiWidget reference (and re-renders into a detached shadow
-   *  root) for up to ~3.3s after destroy. */
-  successTimer = null;
-  autoCloseTimer = null;
-  constructor(config = {}, callbacks) {
+  constructor(config = {}, callbacks, sdkVersion = "0.7.0") {
+    this.sdkVersion = sdkVersion;
     this.config = {
       position: config.position ?? "bottom-right",
+      anchor: config.anchor ?? {},
       theme: config.theme ?? "auto",
       // Falsy-OR (NOT `??`) on purpose: `triggerText: ''` is semantically
       // nonsense — it would render a labelless, glyphless trigger button
@@ -909,7 +998,9 @@ var MushiWidget = class {
       hideOnRoutes: config.hideOnRoutes ?? [],
       environments: config.environments ?? {},
       smartHide: config.smartHide ?? false,
-      draggable: config.draggable ?? false
+      draggable: config.draggable ?? false,
+      brandFooter: config.brandFooter ?? true,
+      outdatedBanner: config.outdatedBanner ?? "auto"
     };
     this.callbacks = callbacks;
     this.locale = getLocale(this.config.locale === "auto" ? void 0 : this.config.locale);
@@ -917,16 +1008,57 @@ var MushiWidget = class {
     this.host.id = "mushi-mushi-widget";
     this.shadow = this.host.attachShadow({ mode: "closed" });
   }
+  sdkVersion;
+  host;
+  shadow;
+  config;
+  callbacks;
+  locale;
+  isOpen = false;
+  step = "category";
+  selectedCategory = null;
+  selectedIntent = null;
+  screenshotAttached = false;
+  allowScreenshotRemove = true;
+  elementSelected = false;
+  submitting = false;
+  triggerVisible = true;
+  triggerShrunk = false;
+  triggerHiddenByScroll = false;
+  sdkFreshness = null;
+  reporterReports = [];
+  reporterComments = [];
+  selectedReportId = null;
+  reporterLoading = false;
+  reporterError = null;
+  attachedLaunchers = [];
+  smartHideCleanup = null;
+  smartHideTimer = null;
+  /** Captured at the moment of submit so the success ledger metadata
+   *  ("REPORT · 14:23:07 JST") doesn't drift while the success step
+   *  is on screen. */
+  submittedAt = null;
+  /** Pending success-state + auto-close timers. Tracked so destroy()
+   *  can clear them — otherwise a host that unmounts mid-submit leaks
+   *  this MushiWidget reference (and re-renders into a detached shadow
+   *  root) for up to ~3.3s after destroy. */
+  successTimer = null;
+  autoCloseTimer = null;
   mount() {
+    if (this.host.isConnected) return;
     document.body.appendChild(this.host);
     this.syncAttachedLaunchers();
     this.syncSmartHide();
     this.render();
   }
+  getIsMounted() {
+    return this.host.isConnected;
+  }
   updateConfig(config = {}) {
     this.config = {
       ...this.config,
       ...config.position ? { position: config.position } : {},
+      ...config.anchor !== void 0 ? { anchor: config.anchor } : {},
       ...config.theme ? { theme: config.theme } : {},
       ...config.triggerText !== void 0 ? { triggerText: config.triggerText || "\u{1F41B}" } : {},
       ...config.expandedTitle !== void 0 ? { expandedTitle: config.expandedTitle } : {},
@@ -941,7 +1073,9 @@ var MushiWidget = class {
       ...config.hideOnRoutes !== void 0 ? { hideOnRoutes: config.hideOnRoutes } : {},
       ...config.environments !== void 0 ? { environments: config.environments } : {},
       ...config.smartHide !== void 0 ? { smartHide: config.smartHide } : {},
-      ...config.draggable !== void 0 ? { draggable: config.draggable } : {}
+      ...config.draggable !== void 0 ? { draggable: config.draggable } : {},
+      ...config.brandFooter !== void 0 ? { brandFooter: config.brandFooter } : {},
+      ...config.outdatedBanner !== void 0 ? { outdatedBanner: config.outdatedBanner } : {}
     };
     this.locale = getLocale(this.config.locale === "auto" ? void 0 : this.config.locale);
     this.syncAttachedLaunchers();
@@ -1004,10 +1138,18 @@ var MushiWidget = class {
     this.screenshotAttached = attached;
     if (this.isOpen) this.render();
   }
+  setAllowScreenshotRemove(allow) {
+    this.allowScreenshotRemove = allow;
+    if (this.isOpen) this.render();
+  }
   setElementSelected(selected) {
     this.elementSelected = selected;
     if (this.isOpen) this.render();
   }
+  setSdkFreshness(info) {
+    this.sdkFreshness = info;
+    if (this.isOpen) this.render();
+  }
   destroy() {
     if (this.successTimer !== null) {
       clearTimeout(this.successTimer);
@@ -1133,13 +1275,22 @@ var MushiWidget = class {
     panel.style.zIndex = String(this.config.zIndex + 1);
     this.applyInsetVars(panel);
     if (this.isOpen) {
-      panel.innerHTML = this.renderStep();
+      panel.innerHTML = `${this.renderOutdatedBanner()}${this.renderStep()}${this.renderBrandFooter()}`;
       this.shadow.appendChild(panel);
       this.attachHandlers(panel);
       this.trapFocus(panel);
     }
   }
   applyInsetVars(el) {
+    const { anchor } = this.config;
+    if (anchor && Object.keys(anchor).length > 0) {
+      ["top", "right", "bottom", "left"].forEach((edge) => {
+        const value = anchor[edge];
+        if (value !== void 0) el.style.setProperty(`--mushi-${edge}`, value);
+      });
+      el.style.setProperty("--mushi-safe-area", this.config.respectSafeArea ? "1" : "0");
+      return;
+    }
     const { inset } = this.config;
     if (!this.config.respectSafeArea) {
       ["top", "right", "bottom", "left"].forEach((edge) => {
@@ -1163,8 +1314,29 @@ var MushiWidget = class {
         return this.renderDetailsStep();
       case "success":
         return this.renderSuccessStep();
+      case "reports":
+        return this.renderReportsStep();
+      case "report-detail":
+        return this.renderReportDetailStep();
     }
   }
+  renderOutdatedBanner() {
+    if (!this.sdkFreshness) return "";
+    if (this.config.outdatedBanner === "off" || this.config.outdatedBanner === "console-only") return "";
+    const { latest, current, deprecated, message } = this.sdkFreshness;
+    if (!latest && !deprecated) return "";
+    return `
+      <div class="mushi-outdated" role="status">
+        <strong>Mushi SDK ${escapeHtml(current)}</strong>
+        ${latest ? `latest is ${escapeHtml(latest)}.` : "needs attention."}
+        ${message ? `<span>${escapeHtml(message)}</span>` : ""}
+      </div>
+    `;
+  }
+  renderBrandFooter() {
+    if (this.config.brandFooter === false) return "";
+    return `<div class="mushi-brand-footer">Powered by Mushi v${escapeHtml(this.sdkVersion)}</div>`;
+  }
   /**
    * Editorial masthead. Always carries:
    *   • the brand mark (虫 kanji on vermillion, "MUSHI" in mono above)
@@ -1223,11 +1395,61 @@ var MushiWidget = class {
     return `
       ${this.renderHeader({ title: t.step1.heading, step: STEP_NUMBER.category })}
       <div class="mushi-body" role="radiogroup" aria-label="${t.step1.heading}">
+        <button type="button" class="mushi-option-btn mushi-reports-entry" data-action="reports">
+          <span class="mushi-option-icon" aria-hidden="true">\u{1F4EC}</span>
+          <div class="mushi-option-text">
+            <span class="mushi-option-label">Your reports${this.unreadCount() ? ` (${this.unreadCount()} new)` : ""}</span>
+            <span class="mushi-option-desc">See status, developer replies, and respond</span>
+          </div>
+          <span class="mushi-option-arrow" aria-hidden="true">\u2192</span>
+        </button>
         ${categories}
       </div>
       ${this.renderStepIndicator(STEP_NUMBER.category)}
     `;
   }
+  renderReportsStep() {
+    const reports = this.reporterReports.map((report) => `
+      <button type="button" class="mushi-report-row" data-report-id="${escapeHtml(report.id)}">
+        <span class="mushi-report-status">${escapeHtml(report.status)}</span>
+        <span class="mushi-report-title">${escapeHtml(report.summary ?? report.description ?? `Report ${report.id.slice(0, 8)}`)}</span>
+        ${report.unread_count ? `<b>${report.unread_count}</b>` : ""}
+      </button>
+    `).join("");
+    return `
+      ${this.renderHeader({ title: "Your reports", showBack: true, eyebrow: "Mushi \xB7 Inbox" })}
+      <div class="mushi-body">
+        ${this.reporterLoading ? '<p class="mushi-muted">Loading reports\u2026</p>' : ""}
+        ${this.reporterError ? `<p class="mushi-error-inline">${escapeHtml(this.reporterError)}</p>` : ""}
+        ${reports || (!this.reporterLoading ? '<p class="mushi-muted">No reports from this browser yet.</p>' : "")}
+      </div>
+    `;
+  }
+  renderReportDetailStep() {
+    const report = this.reporterReports.find((r) => r.id === this.selectedReportId);
+    const comments = this.reporterComments.map((comment) => `
+      <div class="mushi-thread-comment ${comment.author_kind}">
+        <strong>${escapeHtml(comment.author_kind === "reporter" ? "You" : comment.author_name ?? "Developer")}</strong>
+        <p>${escapeHtml(comment.body)}</p>
+      </div>
+    `).join("");
+    return `
+      ${this.renderHeader({ title: "Report thread", showBack: true, eyebrow: "Mushi \xB7 Inbox" })}
+      <div class="mushi-body">
+        <div class="mushi-thread-summary">
+          <span>${escapeHtml(report?.status ?? "unknown")}</span>
+          <p>${escapeHtml(report?.summary ?? report?.description ?? "Report details")}</p>
+        </div>
+        <div class="mushi-thread">
+          ${this.reporterLoading ? '<p class="mushi-muted">Loading thread\u2026</p>' : comments || '<p class="mushi-muted">No developer replies yet.</p>'}
+        </div>
+        <textarea class="mushi-textarea" data-role="reporter-reply" rows="3" placeholder="Reply to the developer\u2026"></textarea>
+        <button type="button" class="mushi-submit" data-action="reporter-reply">
+          <span>Reply</span><span class="mushi-submit-arrow" aria-hidden="true">\u2192</span>
+        </button>
+      </div>
+    `;
+  }
   renderIntentStep() {
     const t = this.locale;
     const cat = this.selectedCategory;
@@ -1267,6 +1489,7 @@ var MushiWidget = class {
           <button type="button" class="mushi-attach-btn${this.screenshotAttached ? " active" : ""}" data-action="screenshot">
             \u{1F4F8} ${this.screenshotAttached ? t.step3.screenshotAttached : t.step3.screenshotButton}
           </button>
+          ${this.screenshotAttached && this.allowScreenshotRemove ? '<button type="button" class="mushi-attach-btn danger" data-action="remove-screenshot">\u2715 Remove screenshot</button>' : ""}
           <button type="button" class="mushi-attach-btn${this.elementSelected ? " active" : ""}" data-action="element">
             \u{1F3AF} ${this.elementSelected ? t.step3.elementSelected : t.step3.elementButton}
           </button>
@@ -1319,9 +1542,26 @@ var MushiWidget = class {
       } else if (this.step === "details") {
         this.step = "intent";
         this.selectedIntent = null;
+      } else if (this.step === "reports") {
+        this.step = "category";
+      } else if (this.step === "report-detail") {
+        this.step = "reports";
+        this.selectedReportId = null;
       }
       this.render();
     });
+    panel.querySelector('[data-action="reports"]')?.addEventListener("click", () => {
+      void this.loadReporterReports();
+    });
+    panel.querySelectorAll("[data-report-id]").forEach((btn) => {
+      btn.addEventListener("click", () => {
+        const reportId = btn.dataset.reportId;
+        if (reportId) void this.loadReporterComments(reportId);
+      });
+    });
+    panel.querySelector('[data-action="reporter-reply"]')?.addEventListener("click", () => {
+      void this.submitReporterReply(panel);
+    });
     panel.querySelectorAll("[data-category]").forEach((btn) => {
       btn.addEventListener("click", () => {
         this.selectedCategory = btn.dataset.category;
@@ -1339,6 +1579,9 @@ var MushiWidget = class {
     panel.querySelector('[data-action="screenshot"]')?.addEventListener("click", () => {
       this.callbacks.onScreenshotRequest();
     });
+    panel.querySelector('[data-action="remove-screenshot"]')?.addEventListener("click", () => {
+      this.callbacks.onScreenshotRemove?.();
+    });
     panel.querySelector('[data-action="element"]')?.addEventListener("click", () => {
       this.callbacks.onElementSelectorRequest?.();
     });
@@ -1396,6 +1639,57 @@ var MushiWidget = class {
       if (focusable.length > 0) focusable[0].focus();
     });
   }
+  unreadCount() {
+    return this.reporterReports.reduce((sum, report) => sum + (report.unread_count ?? 0), 0);
+  }
+  async loadReporterReports() {
+    this.step = "reports";
+    this.reporterLoading = true;
+    this.reporterError = null;
+    this.render();
+    try {
+      this.reporterReports = await this.callbacks.onReporterReportsRequest?.() ?? [];
+    } catch (err) {
+      this.reporterError = err instanceof Error ? err.message : "Could not load reports.";
+    } finally {
+      this.reporterLoading = false;
+      this.render();
+    }
+  }
+  async loadReporterComments(reportId) {
+    this.selectedReportId = reportId;
+    this.step = "report-detail";
+    this.reporterLoading = true;
+    this.reporterError = null;
+    this.render();
+    try {
+      this.reporterComments = await this.callbacks.onReporterCommentsRequest?.(reportId) ?? [];
+    } catch (err) {
+      this.reporterError = err instanceof Error ? err.message : "Could not load thread.";
+    } finally {
+      this.reporterLoading = false;
+      this.render();
+    }
+  }
+  async submitReporterReply(panel) {
+    const reportId = this.selectedReportId;
+    const textarea = panel.querySelector('[data-role="reporter-reply"]');
+    const replyButton = panel.querySelector('[data-action="reporter-reply"]');
+    const body = textarea?.value.trim() ?? "";
+    if (!reportId || !body || this.reporterLoading) return;
+    this.reporterLoading = true;
+    if (replyButton) replyButton.disabled = true;
+    this.render();
+    try {
+      await this.callbacks.onReporterReply?.(reportId, body);
+      if (textarea) textarea.value = "";
+      await this.loadReporterComments(reportId);
+    } catch (err) {
+      this.reporterError = err instanceof Error ? err.message : "Could not send reply.";
+      this.reporterLoading = false;
+      this.render();
+    }
+  }
 };
 
 // src/capture/console.ts
@@ -1447,35 +1741,109 @@ function createConsoleCapture() {
     }
   };
 }
+var DEFAULT_INTERNAL_URL_MATCHERS = [
+  /\/v1\/sdk(?:\/|$)/,
+  /\/v1\/reports(?:\/|$)/,
+  /\/v1\/notifications(?:\/|$)/,
+  /\/v1\/reputation(?:\/|$)/
+];
+function getRequestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+function getInternalRequestKind(input, init) {
+  const marker = init?.[core.MUSHI_INTERNAL_INIT_MARKER];
+  if (marker) return marker;
+  const initHeader = readHeader(init?.headers, core.MUSHI_INTERNAL_HEADER);
+  if (initHeader) return initHeader;
+  if (typeof Request !== "undefined" && input instanceof Request) {
+    const requestHeader = input.headers.get(core.MUSHI_INTERNAL_HEADER);
+    if (requestHeader) return requestHeader;
+  }
+  return null;
+}
+function shouldIgnoreMushiUrl(url, options = {}) {
+  const matchers = [...DEFAULT_INTERNAL_URL_MATCHERS, ...options.ignoreUrls ?? []];
+  if (matchers.some((matcher) => matchesUrl(url, matcher))) return true;
+  const endpoint = normalizeUrlPrefix(options.apiEndpoint);
+  return endpoint ? normalizeComparableUrl(url).startsWith(endpoint) : false;
+}
+function matchesUrl(url, matcher) {
+  if (typeof matcher === "string") {
+    return normalizeComparableUrl(url).includes(matcher);
+  }
+  matcher.lastIndex = 0;
+  return matcher.test(url);
+}
+function normalizeUrlPrefix(url) {
+  if (!url) return null;
+  return normalizeComparableUrl(url).replace(/\/+$/, "");
+}
+function isLocalhostEndpoint(url) {
+  if (!url) return false;
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "::1" || parsed.hostname.endsWith(".localhost");
+  } catch {
+    return /\blocalhost\b|127\.0\.0\.1/.test(url);
+  }
+}
+function normalizeComparableUrl(url) {
+  try {
+    return new URL(url, typeof location !== "undefined" ? location.href : "http://localhost").href;
+  } catch {
+    return url;
+  }
+}
+function readHeader(headers, name) {
+  if (!headers) return null;
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    return headers.get(name);
+  }
+  if (Array.isArray(headers)) {
+    const found = headers.find(([key]) => key.toLowerCase() === name.toLowerCase());
+    return found?.[1] ?? null;
+  }
+  const record = headers;
+  return record[name] ?? record[name.toLowerCase()] ?? null;
+}
 
 // src/capture/network.ts
 var MAX_ENTRIES2 = 30;
-function createNetworkCapture() {
+function createNetworkCapture(options = {}) {
   const entries = [];
   const originalFetch = globalThis.fetch;
+  let activeOptions = options;
   globalThis.fetch = async function mushiFetchInterceptor(input, init) {
     const startTime = Date.now();
     const method = init?.method?.toUpperCase() ?? "GET";
-    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const url = getRequestUrl(input);
+    const internalKind = getInternalRequestKind(input, init);
+    const shouldRecord = !internalKind && !shouldIgnoreMushiUrl(url, activeOptions);
     try {
       const response = await originalFetch.call(globalThis, input, init);
-      addEntry({
-        method,
-        url: truncateUrl(url),
-        status: response.status,
-        duration: Date.now() - startTime,
-        timestamp: startTime
-      });
+      if (shouldRecord) {
+        addEntry({
+          method,
+          url: truncateUrl(url),
+          status: response.status,
+          duration: Date.now() - startTime,
+          timestamp: startTime
+        });
+      }
       return response;
     } catch (error) {
-      addEntry({
-        method,
-        url: truncateUrl(url),
-        status: 0,
-        duration: Date.now() - startTime,
-        timestamp: startTime,
-        error: error instanceof Error ? error.message : "Network error"
-      });
+      if (shouldRecord) {
+        addEntry({
+          method,
+          url: truncateUrl(url),
+          status: 0,
+          duration: Date.now() - startTime,
+          timestamp: startTime,
+          error: error instanceof Error ? error.message : "Network error"
+        });
+      }
       throw error;
     }
   };
@@ -1492,6 +1860,9 @@ function createNetworkCapture() {
     clear() {
       entries.length = 0;
     },
+    updateOptions(nextOptions) {
+      activeOptions = nextOptions;
+    },
     destroy() {
       globalThis.fetch = originalFetch;
     }
@@ -1511,7 +1882,8 @@ function truncateUrl(url) {
 }
 
 // src/capture/screenshot.ts
-function createScreenshotCapture() {
+function createScreenshotCapture(options = {}) {
+  let activeOptions = options;
   async function take() {
     try {
       if (typeof document === "undefined") return null;
@@ -1524,11 +1896,12 @@ function createScreenshotCapture() {
       canvas.width = width * dpr;
       canvas.height = height * dpr;
       ctx.scale(dpr, dpr);
+      const safeDocument = buildPrivacySafeDocument(activeOptions.privacy);
       const svgData = `
         <svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">
           <foreignObject width="100%" height="100%">
             <div xmlns="http://www.w3.org/1999/xhtml">
-              ${new XMLSerializer().serializeToString(document.documentElement)}
+              ${new XMLSerializer().serializeToString(safeDocument)}
             </div>
           </foreignObject>
         </svg>
@@ -1557,7 +1930,46 @@ function createScreenshotCapture() {
       return null;
     }
   }
-  return { take };
+  return {
+    take,
+    updateOptions(nextOptions) {
+      activeOptions = nextOptions;
+    }
+  };
+}
+function buildPrivacySafeDocument(privacy) {
+  const clone = document.documentElement.cloneNode(true);
+  for (const selector of privacy?.blockSelectors ?? []) {
+    for (const el of safeQueryAll(clone, selector)) {
+      el.remove();
+    }
+  }
+  for (const selector of privacy?.maskSelectors ?? []) {
+    for (const el of safeQueryAll(clone, selector)) {
+      maskElement(el);
+    }
+  }
+  return clone;
+}
+function safeQueryAll(root, selector) {
+  try {
+    return Array.from(root.querySelectorAll(selector));
+  } catch {
+    return [];
+  }
+}
+function maskElement(el) {
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+    el.value = "";
+    el.setAttribute("value", "");
+    el.setAttribute("placeholder", "\u2022\u2022\u2022\u2022");
+  }
+  el.textContent = el.children.length === 0 ? "\u2022\u2022\u2022\u2022" : el.textContent;
+  el.setAttribute(
+    "style",
+    `${el.getAttribute("style") ?? ""};background:#8f8f8f!important;color:transparent!important;text-shadow:none!important;`
+  );
+  el.setAttribute("data-mushi-masked", "true");
 }
 
 // src/capture/performance.ts
@@ -1640,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;
@@ -1669,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() {
@@ -1746,6 +2175,296 @@ function createElementSelector() {
   return { activate, deactivate, isActive: () => active };
 }
 
+// src/capture/timeline.ts
+var MAX_TIMELINE_ENTRIES = 120;
+function createTimelineCapture() {
+  const entries = [];
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  const handlePopState = () => recordRoute("popstate");
+  const handleHashChange = () => recordRoute("hashchange");
+  recordRoute("initial");
+  function record(entry) {
+    entries.push(entry);
+    if (entries.length > MAX_TIMELINE_ENTRIES) entries.shift();
+  }
+  function recordRoute(source) {
+    if (typeof location === "undefined") return;
+    record({
+      ts: Date.now(),
+      kind: "route",
+      payload: {
+        source,
+        route: `${location.pathname}${location.search}${location.hash}`,
+        href: location.href
+      }
+    });
+  }
+  function handleClick(event) {
+    const target = event.target instanceof Element ? event.target : null;
+    if (!target) return;
+    const el = target.closest('button,a,[role="button"],input,textarea,select,[data-mushi-track]') ?? target;
+    record({
+      ts: Date.now(),
+      kind: "click",
+      payload: {
+        tag: el.tagName.toLowerCase(),
+        id: el.id || void 0,
+        text: textSnippet(el)
+      }
+    });
+  }
+  history.pushState = function mushiPushState(...args) {
+    const result = originalPushState.apply(this, args);
+    recordRoute("pushState");
+    return result;
+  };
+  history.replaceState = function mushiReplaceState(...args) {
+    const result = originalReplaceState.apply(this, args);
+    recordRoute("replaceState");
+    return result;
+  };
+  window.addEventListener("popstate", handlePopState);
+  window.addEventListener("hashchange", handleHashChange);
+  document.addEventListener("click", handleClick, true);
+  return {
+    setScreen(screen) {
+      record({
+        ts: Date.now(),
+        kind: "screen",
+        payload: screen
+      });
+    },
+    getEntries(input = {}) {
+      const merged = [
+        ...entries,
+        ...(input.consoleLogs ?? []).map((log) => ({
+          ts: log.timestamp,
+          kind: "log",
+          payload: {
+            level: log.level,
+            message: log.message
+          }
+        })),
+        ...(input.networkLogs ?? []).map((network) => ({
+          ts: network.timestamp,
+          kind: "request",
+          payload: {
+            method: network.method,
+            url: network.url,
+            status: network.status,
+            duration: network.duration,
+            error: network.error
+          }
+        }))
+      ].sort((a, b) => a.ts - b.ts);
+      return merged.slice(-MAX_TIMELINE_ENTRIES);
+    },
+    clear() {
+      entries.length = 0;
+    },
+    destroy() {
+      history.pushState = originalPushState;
+      history.replaceState = originalReplaceState;
+      window.removeEventListener("popstate", handlePopState);
+      window.removeEventListener("hashchange", handleHashChange);
+      document.removeEventListener("click", handleClick, true);
+    }
+  };
+}
+function textSnippet(el) {
+  const text = (el.textContent ?? "").replace(/\s+/g, " ").trim();
+  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 {
@@ -1832,36 +2551,25 @@ function setupProactiveTriggers(callbacks, config = {}) {
     } catch {
     }
   }
-  if (config.apiCascade !== false) {
+  const apiCascade = normalizeApiCascadeConfig(config.apiCascade);
+  if (apiCascade.enabled) {
     const failedRequests = [];
     const origFetch = globalThis.fetch;
     globalThis.fetch = async function(...args) {
+      const [input, init] = args;
+      const url = getRequestUrl(input);
+      const ignoreFailure = Boolean(getInternalRequestKind(input, init)) || shouldIgnoreMushiUrl(url, {
+        apiEndpoint: config.apiEndpoint,
+        ignoreUrls: apiCascade.ignoreUrls
+      });
       try {
         const res = await origFetch.apply(this, args);
-        if (!res.ok && res.status >= 400) {
-          const now = Date.now();
-          failedRequests.push(now);
-          const recentFailures = failedRequests.filter((t) => now - t < 1e4);
-          if (recentFailures.length >= 3) {
-            callbacks.onTrigger("api_cascade", {
-              failureCount: recentFailures.length,
-              windowMs: 1e4
-            });
-            failedRequests.length = 0;
-          }
+        if (!ignoreFailure && !res.ok && res.status >= 400) {
+          recordApiFailure(failedRequests, callbacks);
         }
         return res;
       } catch (err) {
-        const now = Date.now();
-        failedRequests.push(now);
-        const recentFailures = failedRequests.filter((t) => now - t < 1e4);
-        if (recentFailures.length >= 3) {
-          callbacks.onTrigger("api_cascade", {
-            failureCount: recentFailures.length,
-            windowMs: 1e4
-          });
-          failedRequests.length = 0;
-        }
+        if (!ignoreFailure) recordApiFailure(failedRequests, callbacks);
         throw err;
       }
     };
@@ -1896,6 +2604,28 @@ function setupProactiveTriggers(callbacks, config = {}) {
     }
   };
 }
+function normalizeApiCascadeConfig(config) {
+  if (config === false) return { enabled: false, ignoreUrls: [] };
+  if (config && typeof config === "object") {
+    return {
+      enabled: config.enabled !== false,
+      ignoreUrls: config.ignoreUrls ?? []
+    };
+  }
+  return { enabled: true, ignoreUrls: [] };
+}
+function recordApiFailure(failedRequests, callbacks) {
+  const now = Date.now();
+  failedRequests.push(now);
+  const recentFailures = failedRequests.filter((t) => now - t < 1e4);
+  if (recentFailures.length >= 3) {
+    callbacks.onTrigger("api_cascade", {
+      failureCount: recentFailures.length,
+      windowMs: 1e4
+    });
+    failedRequests.length = 0;
+  }
+}
 
 // src/proactive-manager.ts
 var STORAGE_KEY_LAST_DISMISS = "mushi:lastDismiss";
@@ -1948,6 +2678,10 @@ function createProactiveManager(config = {}) {
   return { shouldShow, recordDismissal, recordSubmission, reset };
 }
 
+// src/version.ts
+var MUSHI_SDK_PACKAGE = "@mushi-mushi/web";
+var MUSHI_SDK_VERSION = "0.9.0" ;
+
 // src/mushi.ts
 var instance = null;
 var Mushi = class {
@@ -1977,18 +2711,21 @@ var Mushi = class {
     instance?.destroy();
     instance = null;
   }
+  static diagnose() {
+    return instance?.diagnose() ?? diagnoseWithoutInstance();
+  }
 };
 function createInstance(config) {
-  const bootstrapConfig = config;
-  let activeConfig = config;
+  const bootstrapConfig = applyPresetConfig(config);
+  let activeConfig = bootstrapConfig;
   const log = config.debug ?? false ? core.createLogger({ scope: "mushi", level: "debug", format: "pretty" }) : core.noopLogger;
   const apiClient = core.createApiClient({
-    projectId: config.projectId,
-    apiKey: config.apiKey,
-    ...config.apiEndpoint ? { apiEndpoint: config.apiEndpoint } : {}
+    projectId: bootstrapConfig.projectId,
+    apiKey: bootstrapConfig.apiKey,
+    ...bootstrapConfig.apiEndpoint ? { apiEndpoint: bootstrapConfig.apiEndpoint } : {}
   });
-  const preFilter = core.createPreFilter(config.preFilter);
-  const offlineQueue = core.createOfflineQueue(config.offline);
+  const preFilter = core.createPreFilter(bootstrapConfig.preFilter);
+  const offlineQueue = core.createOfflineQueue(bootstrapConfig.offline);
   const rateLimiter = core.createRateLimiter({ maxBurst: 10, refillRate: 1, refillIntervalMs: 5e3 });
   const piiScrubber = core.createPiiScrubber();
   let consoleCap = null;
@@ -1996,6 +2733,9 @@ function createInstance(config) {
   let perfCap = null;
   let screenshotCap = null;
   let elementSelector = null;
+  let discoveryCap = null;
+  const timelineCap = createTimelineCapture();
+  let widget;
   function syncCaptureModules() {
     if (activeConfig.capture?.console !== false) {
       consoleCap ??= createConsoleCapture();
@@ -2004,7 +2744,15 @@ function createInstance(config) {
       consoleCap = null;
     }
     if (activeConfig.capture?.network !== false) {
-      networkCap ??= createNetworkCapture();
+      const networkOptions = {
+        apiEndpoint: resolveApiEndpoint(activeConfig),
+        ignoreUrls: activeConfig.capture?.ignoreUrls
+      };
+      if (networkCap) {
+        networkCap.updateOptions(networkOptions);
+      } else {
+        networkCap = createNetworkCapture(networkOptions);
+      }
     } else {
       networkCap?.destroy();
       networkCap = null;
@@ -2015,8 +2763,18 @@ function createInstance(config) {
       perfCap?.destroy();
       perfCap = null;
     }
-    screenshotCap = activeConfig.capture?.screenshot !== "off" ? screenshotCap ?? createScreenshotCapture() : null;
+    if (activeConfig.capture?.screenshot !== "off") {
+      const screenshotOptions = { privacy: activeConfig.privacy };
+      if (screenshotCap) {
+        screenshotCap.updateOptions(screenshotOptions);
+      } else {
+        screenshotCap = createScreenshotCapture(screenshotOptions);
+      }
+    } else {
+      screenshotCap = null;
+    }
     if (!screenshotCap) pendingScreenshot = null;
+    widget.setAllowScreenshotRemove(activeConfig.privacy?.allowUserRemoveScreenshot !== false);
     if (activeConfig.capture?.elementSelector !== false) {
       elementSelector ??= createElementSelector();
     } else {
@@ -2024,6 +2782,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) {
@@ -2032,10 +2824,10 @@ function createInstance(config) {
   let pendingScreenshot = null;
   let pendingElement = null;
   let pendingProactiveTrigger = null;
+  let runtimeConfigLoaded = false;
   let userInfo = null;
   const customMetadata = {};
-  syncCaptureModules();
-  const widget = new MushiWidget(config.widget, {
+  widget = new MushiWidget(bootstrapConfig.widget, {
     onSubmit: async ({ category, description, intent }) => {
       log.info("Report submitted", { category, intent });
       proactiveManager?.recordSubmission();
@@ -2062,6 +2854,11 @@ function createInstance(config) {
       pendingScreenshot = await screenshotCap.take();
       widget.setScreenshotAttached(pendingScreenshot !== null);
     },
+    onScreenshotRemove: () => {
+      log.debug("Screenshot attachment removed");
+      pendingScreenshot = null;
+      widget.setScreenshotAttached(false);
+    },
     onElementSelectorRequest: async () => {
       if (!elementSelector || activeConfig.capture?.elementSelector === false) return;
       log.debug("Element selector activated");
@@ -2071,8 +2868,23 @@ function createInstance(config) {
         widget.setElementSelected(true);
         log.debug("Element selected", { tagName: el.tagName, xpath: el.xpath });
       }
+    },
+    async onReporterReportsRequest() {
+      const result = await apiClient.listReporterReports(core.getReporterToken());
+      if (!result.ok) throw new Error(result.error?.message ?? "Could not load reports");
+      return result.data?.reports ?? [];
+    },
+    async onReporterCommentsRequest(reportId) {
+      const result = await apiClient.listReporterComments(reportId, core.getReporterToken());
+      if (!result.ok) throw new Error(result.error?.message ?? "Could not load thread");
+      return result.data?.comments ?? [];
+    },
+    async onReporterReply(reportId, body) {
+      const result = await apiClient.replyToReporterReport(reportId, core.getReporterToken(), body);
+      if (!result.ok) throw new Error(result.error?.message ?? "Could not send reply");
     }
-  });
+  }, MUSHI_SDK_VERSION);
+  syncCaptureModules();
   if (typeof document !== "undefined") {
     if (document.readyState === "loading") {
       document.addEventListener("DOMContentLoaded", () => widget.mount());
@@ -2082,7 +2894,7 @@ function createInstance(config) {
   }
   let proactiveTriggers = null;
   let proactiveManager = null;
-  const proactiveCfg = config.proactive;
+  const proactiveCfg = activeConfig.proactive;
   const hasAnyProactive = proactiveCfg && (proactiveCfg.rageClick !== false || proactiveCfg.longTask !== false || proactiveCfg.apiCascade !== false || proactiveCfg.errorBoundary === true);
   if (hasAnyProactive && typeof document !== "undefined") {
     proactiveManager = createProactiveManager(proactiveCfg?.cooldown);
@@ -2103,6 +2915,7 @@ function createInstance(config) {
         rageClick: proactiveCfg?.rageClick,
         longTask: proactiveCfg?.longTask,
         apiCascade: proactiveCfg?.apiCascade,
+        apiEndpoint: resolveApiEndpoint(activeConfig),
         errorBoundary: proactiveCfg?.errorBoundary
       }
     );
@@ -2118,6 +2931,7 @@ function createInstance(config) {
     if (result.sent > 0) log.info("Synced offline reports", { sent: result.sent });
   });
   function applyRuntimeConfig(runtime) {
+    runtimeConfigLoaded = true;
     if (runtime.enabled === false) {
       activeConfig = bootstrapConfig;
       clearCachedRuntimeConfig(config.projectId);
@@ -2131,7 +2945,7 @@ function createInstance(config) {
     if (runtime.widget) widget.updateConfig(activeConfig.widget);
     log.debug("Applied runtime SDK config", { version: runtime.version });
   }
-  if (config.runtimeConfig !== false) {
+  if (shouldUseRuntimeConfig(config)) {
     const cached = readCachedRuntimeConfig(config.projectId);
     if (cached) applyRuntimeConfig(cached);
     apiClient.getSdkConfig().then((result) => {
@@ -2144,8 +2958,41 @@ function createInstance(config) {
     }).catch((err) => {
       log.debug("Runtime SDK config fetch failed", { error: err instanceof Error ? err.message : String(err) });
     });
+  } else if (config.runtimeConfig !== false && isLocalhostEndpoint(resolveApiEndpoint(config))) {
+    log.debug("Runtime SDK config skipped for localhost apiEndpoint; set runtimeConfig: true to force it");
   }
+  void checkSdkFreshness();
   log.info("Initialized", { projectId: config.projectId });
+  async function checkSdkFreshness() {
+    if (activeConfig.widget?.outdatedBanner === "off") return;
+    const cached = readCachedSdkVersion(MUSHI_SDK_PACKAGE);
+    if (cached) applySdkFreshness(cached);
+    const result = await apiClient.getLatestSdkVersion(MUSHI_SDK_PACKAGE);
+    if (!result.ok || !result.data) return;
+    cacheSdkVersion(MUSHI_SDK_PACKAGE, result.data);
+    applySdkFreshness(result.data);
+  }
+  function applySdkFreshness(info) {
+    const latest = info.latest;
+    const outdated = Boolean(latest && isVersionOlder(MUSHI_SDK_VERSION, latest));
+    if (!outdated && !info.deprecated) return;
+    const message = info.deprecationMessage ?? (outdated ? `Update ${MUSHI_SDK_PACKAGE} to ${latest}.` : null);
+    log.warn("Mushi SDK is outdated", {
+      package: MUSHI_SDK_PACKAGE,
+      current: MUSHI_SDK_VERSION,
+      latest,
+      deprecated: info.deprecated,
+      message
+    });
+    if (activeConfig.widget?.outdatedBanner !== "console-only") {
+      widget.setSdkFreshness({
+        latest,
+        current: MUSHI_SDK_VERSION,
+        deprecated: info.deprecated,
+        message
+      });
+    }
+  }
   async function submitReport(category, description, intent) {
     const filterResult = preFilter.check(description);
     if (!filterResult.passed) {
@@ -2187,6 +3034,8 @@ function createInstance(config) {
     const scrubbedDescription = piiScrubber.scrub(preFilter.truncate(description));
     const sentryCtx = config.sentry ? captureSentryContext(config.sentry) : void 0;
     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 report = {
       id: crypto.randomUUID?.() ?? `mushi_${Date.now()}_${Math.random().toString(36).slice(2)}`,
       projectId: config.projectId,
@@ -2194,9 +3043,10 @@ function createInstance(config) {
       description: scrubbedDescription,
       userIntent: intent,
       environment: core.captureEnvironment(),
-      consoleLogs: activeConfig.capture?.console === false ? void 0 : consoleCap?.getEntries(),
-      networkLogs: activeConfig.capture?.network === false ? void 0 : networkCap?.getEntries(),
+      consoleLogs,
+      networkLogs,
       performanceMetrics: activeConfig.capture?.performance === false ? void 0 : perfCap?.getMetrics(),
+      timeline: timelineCap.getEntries({ consoleLogs, networkLogs }),
       screenshotDataUrl: pendingScreenshot ?? void 0,
       selectedElement: pendingElement ?? void 0,
       metadata: {
@@ -2208,6 +3058,8 @@ function createInstance(config) {
       reporterToken: core.getReporterToken(),
       ...fingerprintHash ? { fingerprintHash } : {},
       appVersion: config.integrations?.vercel?.analyticsId,
+      sdkPackage: MUSHI_SDK_PACKAGE,
+      sdkVersion: MUSHI_SDK_VERSION,
       proactiveTrigger: pendingProactiveTrigger ?? void 0,
       sentryEventId: sentryCtx?.eventId,
       sentryReplayId: sentryCtx?.replayId,
@@ -2262,6 +3114,9 @@ function createInstance(config) {
     setMetadata(key, value) {
       customMetadata[key] = value;
     },
+    setScreen(screen) {
+      timelineCap.setScreen(screen);
+    },
     isOpen() {
       return widget.getIsOpen();
     },
@@ -2289,6 +3144,15 @@ function createInstance(config) {
     updateConfig(runtimeConfig) {
       applyRuntimeConfig(runtimeConfig);
     },
+    diagnose() {
+      return runDiagnostics({
+        apiEndpoint: resolveApiEndpoint(activeConfig),
+        widgetMounted: widget.getIsMounted(),
+        runtimeConfigLoaded,
+        captureScreenshotAvailable: screenshotCap !== null,
+        captureNetworkIntercepting: networkCap !== null
+      });
+    },
     destroy() {
       proactiveTriggers?.destroy();
       proactiveManager?.reset();
@@ -2297,6 +3161,9 @@ function createInstance(config) {
       networkCap?.destroy();
       perfCap?.destroy();
       elementSelector?.deactivate();
+      timelineCap.destroy();
+      discoveryCap?.destroy();
+      discoveryCap = null;
       offlineQueue.stopAutoSync();
       listeners.clear();
       instance = null;
@@ -2318,6 +3185,7 @@ function createInstance(config) {
         category,
         description,
         environment: core.captureEnvironment(),
+        timeline: timelineCap.getEntries(),
         metadata: {
           ...input.metadata ?? {},
           ...userInfo ? { user: userInfo } : {},
@@ -2329,6 +3197,8 @@ function createInstance(config) {
         },
         sessionId: core.getSessionId(),
         reporterToken: core.getReporterToken(),
+        sdkPackage: MUSHI_SDK_PACKAGE,
+        sdkVersion: MUSHI_SDK_VERSION,
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       emit("report:submitted", { reportId: report.id });
@@ -2370,12 +3240,128 @@ function mergeRuntimeConfig(config, runtime) {
     capture: {
       ...config.capture,
       ...runtime.capture
+    },
+    privacy: {
+      ...config.privacy
     }
   };
 }
+function applyPresetConfig(config) {
+  if (!config.preset) return config;
+  const preset = presetDefaults(config.preset);
+  return {
+    ...config,
+    widget: {
+      ...preset.widget,
+      ...config.widget
+    },
+    capture: {
+      ...preset.capture,
+      ...config.capture
+    },
+    proactive: {
+      ...preset.proactive,
+      ...config.proactive,
+      cooldown: {
+        ...preset.proactive?.cooldown,
+        ...config.proactive?.cooldown
+      }
+    }
+  };
+}
+function presetDefaults(preset) {
+  switch (preset) {
+    case "manual-only":
+      return {
+        widget: { trigger: "manual", outdatedBanner: "console-only" },
+        capture: { console: true, network: true, performance: false, screenshot: "on-report", elementSelector: false },
+        proactive: { rageClick: false, longTask: false, apiCascade: false, errorBoundary: false }
+      };
+    case "beta-loud":
+      return {
+        widget: { trigger: "auto", outdatedBanner: "banner" },
+        capture: { console: true, network: true, performance: true, screenshot: "auto", elementSelector: true },
+        proactive: { rageClick: true, longTask: true, apiCascade: true, errorBoundary: true }
+      };
+    case "internal-debug":
+      return {
+        widget: { trigger: "auto", outdatedBanner: "banner", brandFooter: true },
+        capture: { console: true, network: true, performance: true, screenshot: "auto", elementSelector: true },
+        proactive: {
+          rageClick: true,
+          longTask: true,
+          apiCascade: true,
+          errorBoundary: true,
+          cooldown: { maxProactivePerSession: 10, dismissCooldownHours: 0, suppressAfterDismissals: 99 }
+        }
+      };
+    case "production-calm":
+      return {
+        widget: { trigger: "auto", outdatedBanner: "console-only" },
+        capture: { console: true, network: true, performance: false, screenshot: "on-report", elementSelector: false },
+        proactive: { rageClick: false, longTask: false, apiCascade: false, errorBoundary: false }
+      };
+  }
+}
+function resolveApiEndpoint(config) {
+  return config.apiEndpoint ?? core.DEFAULT_API_ENDPOINT;
+}
+function shouldUseRuntimeConfig(config) {
+  if (config.runtimeConfig === false) return false;
+  if (config.runtimeConfig === true) return true;
+  return !isLocalhostEndpoint(resolveApiEndpoint(config));
+}
+async function runDiagnostics(options) {
+  const endpoint = await probeApiEndpoint(options.apiEndpoint);
+  return {
+    apiEndpointReachable: endpoint.reachable,
+    cspAllowsEndpoint: endpoint.cspAllowed,
+    widgetMounted: options.widgetMounted,
+    shadowDomAvailable: typeof HTMLElement !== "undefined" && typeof HTMLElement.prototype.attachShadow === "function",
+    dialogSupported: typeof HTMLDialogElement !== "undefined",
+    runtimeConfigLoaded: options.runtimeConfigLoaded,
+    captureScreenshotAvailable: options.captureScreenshotAvailable,
+    captureNetworkIntercepting: options.captureNetworkIntercepting,
+    sdkVersion: MUSHI_SDK_VERSION
+  };
+}
+async function diagnoseWithoutInstance() {
+  return {
+    apiEndpointReachable: false,
+    cspAllowsEndpoint: false,
+    widgetMounted: false,
+    shadowDomAvailable: typeof HTMLElement !== "undefined" && typeof HTMLElement.prototype.attachShadow === "function",
+    dialogSupported: typeof HTMLDialogElement !== "undefined",
+    runtimeConfigLoaded: false,
+    captureScreenshotAvailable: false,
+    captureNetworkIntercepting: false,
+    sdkVersion: MUSHI_SDK_VERSION
+  };
+}
+async function probeApiEndpoint(apiEndpoint) {
+  if (typeof fetch === "undefined") return { reachable: false, cspAllowed: false };
+  const controller = typeof AbortController !== "undefined" ? new AbortController() : null;
+  const timer = controller ? setTimeout(() => controller.abort(), 3e3) : null;
+  try {
+    const response = await fetch(`${apiEndpoint.replace(/\/$/, "")}/health`, {
+      method: "GET",
+      cache: "no-store",
+      ...controller ? { signal: controller.signal } : {},
+      [core.MUSHI_INTERNAL_INIT_MARKER]: "diagnose"
+    });
+    return { reachable: response.ok, cspAllowed: true };
+  } catch {
+    return { reachable: false, cspAllowed: false };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function runtimeConfigCacheKey(projectId) {
   return `mushi:sdk-config:${projectId}`;
 }
+function sdkVersionCacheKey(packageName) {
+  return `mushi:sdk-version:${packageName}`;
+}
 function readCachedRuntimeConfig(projectId) {
   if (typeof localStorage === "undefined") return null;
   try {
@@ -2404,6 +3390,42 @@ function clearCachedRuntimeConfig(projectId) {
   } catch {
   }
 }
+function readCachedSdkVersion(packageName) {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(sdkVersionCacheKey(packageName));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed.data || !parsed.cachedAt || Date.now() - parsed.cachedAt > 864e5) return null;
+    return parsed.data;
+  } catch {
+    return null;
+  }
+}
+function cacheSdkVersion(packageName, data) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(sdkVersionCacheKey(packageName), JSON.stringify({
+      cachedAt: Date.now(),
+      data
+    }));
+  } catch {
+  }
+}
+function isVersionOlder(current, latest) {
+  const currentParts = parseVersion(current);
+  const latestParts = parseVersion(latest);
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const cur = currentParts[i] ?? 0;
+    const next = latestParts[i] ?? 0;
+    if (cur < next) return true;
+    if (cur > next) return false;
+  }
+  return false;
+}
+function parseVersion(version) {
+  return version.split(/[.-]/).map((part) => Number.parseInt(part, 10)).filter((part) => Number.isFinite(part));
+}
 function createNoopInstance() {
   return {
     report: () => {
@@ -2414,6 +3436,8 @@ function createNoopInstance() {
     },
     setMetadata: () => {
     },
+    setScreen: () => {
+    },
     isOpen: () => false,
     open: () => {
     },
@@ -2421,6 +3445,7 @@ function createNoopInstance() {
     },
     updateConfig: () => {
     },
+    diagnose: diagnoseWithoutInstance,
     openWith: () => {
     },
     show: () => {
@@ -2448,6 +3473,7 @@ exports.createNetworkCapture = createNetworkCapture;
 exports.createPerformanceCapture = createPerformanceCapture;
 exports.createProactiveManager = createProactiveManager;
 exports.createScreenshotCapture = createScreenshotCapture;
+exports.createTimelineCapture = createTimelineCapture;
 exports.getAvailableLocales = getAvailableLocales;
 exports.getLocale = getLocale;
 exports.setupProactiveTriggers = setupProactiveTriggers;