@mushi-mushi/web 1.3.0 → 1.5.0

package/dist/index.cjs

@@ -3090,6 +3090,15 @@ function maskElement(el) {
 }
 
 // src/capture/performance.ts
+var INP_DURATION_THRESHOLD_MS = 40;
+function describeElement(target) {
+  if (!target || !target.tagName) return void 0;
+  const el = target;
+  const tag = el.tagName.toLowerCase();
+  const id = el.id ? `#${el.id}` : "";
+  const cls = el.classList && el.classList.length > 0 ? `.${el.classList[0]}` : "";
+  return `${tag}${id}${cls}`;
+}
 function createPerformanceCapture() {
   const metrics = {};
   const observers = [];
@@ -3141,6 +3150,53 @@ function createPerformanceCapture() {
       observers.push(longTaskObserver);
     } catch {
     }
+    try {
+      const seenInteractions = /* @__PURE__ */ new Map();
+      const inpObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const interactionId = entry.interactionId;
+          if (!interactionId) continue;
+          const prev = seenInteractions.get(interactionId) ?? 0;
+          if (entry.duration > prev) {
+            seenInteractions.set(interactionId, entry.duration);
+          }
+          if (entry.duration > (metrics.inp ?? 0)) {
+            metrics.inp = entry.duration;
+            const inputDelay = entry.processingStart - entry.startTime;
+            const processingDuration = entry.processingEnd - entry.processingStart;
+            const presentationDelay = entry.startTime + entry.duration - entry.processingEnd;
+            metrics.inpAttribution = {
+              eventType: entry.name,
+              targetSelector: describeElement(entry.target),
+              inputDelay: Math.max(0, inputDelay),
+              processingDuration: Math.max(0, processingDuration),
+              presentationDelay: Math.max(0, presentationDelay)
+            };
+          }
+        }
+      });
+      inpObserver.observe({
+        type: "event",
+        // `durationThreshold` filters out fast (< 40 ms) interactions
+        // that sit below human perception. Spec-recommended floor.
+        durationThreshold: INP_DURATION_THRESHOLD_MS,
+        buffered: true
+      });
+      observers.push(inpObserver);
+    } catch {
+    }
+    try {
+      const fidObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          if (metrics.fid === void 0) {
+            metrics.fid = entry.processingStart - entry.startTime;
+          }
+        }
+      });
+      fidObserver.observe({ type: "first-input", buffered: true });
+      observers.push(fidObserver);
+    } catch {
+    }
   }
   if (typeof performance !== "undefined" && performance.getEntriesByType) {
     try {
@@ -3971,7 +4027,7 @@ function createProactiveManager(config = {}) {
 
 // src/version.ts
 var MUSHI_SDK_PACKAGE = "@mushi-mushi/web";
-var MUSHI_SDK_VERSION = "1.3.0" ;
+var MUSHI_SDK_VERSION = "1.5.0" ;
 
 // src/mushi.ts
 var instance = null;
@@ -4448,17 +4504,43 @@ function createInstance(config) {
       };
       config.integrations.custom(builder);
     }
-    emit("report:submitted", { reportId: report.id });
+    let finalReport = report;
+    if (config.beforeSendFeedback) {
+      try {
+        const hookResult = await Promise.race([
+          Promise.resolve(config.beforeSendFeedback(report)),
+          // 2s timeout — async hooks must not block the user's "submit"
+          // for longer than the network would. Falls back to original.
+          new Promise(
+            (resolve) => setTimeout(() => resolve(report), 2e3)
+          )
+        ]);
+        if (hookResult === null) {
+          log.info("Report dropped by beforeSendFeedback hook", { reportId: report.id });
+          return;
+        }
+        finalReport = hookResult;
+      } catch (err) {
+        log.warn("beforeSendFeedback hook threw \u2014 sending unmodified report", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    emit("report:submitted", { reportId: finalReport.id });
     if (typeof navigator !== "undefined" && !navigator.onLine) {
-      await offlineQueue.enqueue(report);
-      log.info("Offline \u2014 report queued", { reportId: report.id });
-      emit("report:queued", { reportId: report.id });
+      await offlineQueue.enqueue(finalReport);
+      log.info("Offline \u2014 report queued", { reportId: finalReport.id });
+      emit("report:queued", { reportId: finalReport.id });
       return;
     }
-    const result = await apiClient2.submitReport(report);
+    const result = await apiClient2.submitReport(finalReport);
     if (result.ok) {
       log.info("Report sent", { reportId: result.data?.reportId });
       emit("report:sent", { reportId: result.data?.reportId });
+      if (result.data?.cursorAgentId) {
+        const d = result.data;
+        emit("report:dispatched", { reportId: d.reportId, agentId: d.cursorAgentId, fixId: d.fixId });
+      }
       breadcrumbs.add({
         category: "lifecycle",
         level: "info",
@@ -4475,13 +4557,13 @@ function createInstance(config) {
       } 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 });
+      log.warn("Report failed, queuing for retry", { reportId: finalReport.id, error: result.error });
+      await offlineQueue.enqueue(finalReport);
+      emit("report:failed", { reportId: finalReport.id, error: result.error });
       breadcrumbs.add({
         category: "lifecycle",
         level: "warning",
-        message: `Mushi report queued for retry (${report.id})`
+        message: `Mushi report queued for retry (${finalReport.id})`
       });
     }
     pendingScreenshot = null;
@@ -4743,6 +4825,35 @@ function createInstance(config) {
   if (typeof globalThis !== "undefined" && (bootstrapConfig.debug ?? false)) {
     exposeMarketingRecorder(widget);
   }
+  if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+    const SENTINEL_KEY = "mushi:last-run";
+    let crashed = null;
+    try {
+      const previous = localStorage.getItem(SENTINEL_KEY);
+      crashed = previous === null ? null : previous === "unfinished";
+      localStorage.setItem(SENTINEL_KEY, "unfinished");
+    } catch {
+      crashed = null;
+    }
+    try {
+      window.addEventListener("pagehide", () => {
+        try {
+          localStorage.setItem(SENTINEL_KEY, "clean");
+        } catch {
+        }
+      });
+    } catch {
+    }
+    if (typeof bootstrapConfig.onCrashedLastRun === "function") {
+      try {
+        bootstrapConfig.onCrashedLastRun({ crashed });
+      } catch (err) {
+        log.warn("onCrashedLastRun hook threw", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
   return sdk;
 }
 function mergeRuntimeConfig(config, runtime) {