@mushi-mushi/web 0.1.0

package/dist/index.js

@@ -0,0 +1,1564 @@
+import { createLogger, noopLogger, createApiClient, createPreFilter, createOfflineQueue, createRateLimiter, createPiiScrubber, getReporterToken, getSessionId, captureEnvironment } from '@mushi-mushi/core';
+
+// src/mushi.ts
+
+// src/i18n/en.ts
+var en = {
+  widget: {
+    trigger: "Report Issue",
+    title: "Report an Issue",
+    close: "Close",
+    back: "Back",
+    submit: "Submit",
+    submitting: "Submitting\u2026",
+    submitted: "Thank you! Your report has been submitted.",
+    error: "Something went wrong. Please try again."
+  },
+  step1: {
+    heading: "What kind of issue?",
+    categories: {
+      bug: "Bug",
+      slow: "Slow / Laggy",
+      visual: "Visual Glitch",
+      confusing: "Confusing",
+      other: "Other"
+    },
+    categoryDescriptions: {
+      bug: "Something is broken or not working",
+      slow: "Performance issue or slow loading",
+      visual: "Layout, styling, or display problem",
+      confusing: "Hard to understand or navigate",
+      other: "Something else"
+    }
+  },
+  step2: {
+    heading: "What happened?",
+    intents: {
+      bug: ["Crash", "Unresponsive", "Data loss", "Wrong result", "Other"],
+      slow: ["Page load", "Interaction", "API call", "Animation", "Other"],
+      visual: ["Layout broken", "Overlapping", "Missing element", "Wrong color/font", "Other"],
+      confusing: ["Unclear label", "Missing help", "Unexpected flow", "Lost navigation", "Other"],
+      other: ["Feature request", "Accessibility", "Typo", "Other"]
+    }
+  },
+  step3: {
+    heading: "Tell us more",
+    descriptionPlaceholder: "Describe what happened\u2026",
+    screenshotButton: "Attach Screenshot",
+    screenshotAttached: "Screenshot attached",
+    elementButton: "Select Element",
+    elementSelected: "Element selected",
+    optional: "(optional)"
+  }
+};
+
+// src/i18n/ja.ts
+var ja = {
+  widget: {
+    trigger: "\u554F\u984C\u3092\u5831\u544A",
+    title: "\u554F\u984C\u3092\u5831\u544A\u3059\u308B",
+    close: "\u9589\u3058\u308B",
+    back: "\u623B\u308B",
+    submit: "\u9001\u4FE1",
+    submitting: "\u9001\u4FE1\u4E2D\u2026",
+    submitted: "\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\uFF01\u30EC\u30DD\u30FC\u30C8\u304C\u9001\u4FE1\u3055\u308C\u307E\u3057\u305F\u3002",
+    error: "\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F\u3002\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044\u3002"
+  },
+  step1: {
+    heading: "\u3069\u306E\u3088\u3046\u306A\u554F\u984C\u3067\u3059\u304B\uFF1F",
+    categories: {
+      bug: "\u30D0\u30B0",
+      slow: "\u9045\u3044\u30FB\u91CD\u3044",
+      visual: "\u8868\u793A\u306E\u554F\u984C",
+      confusing: "\u308F\u304B\u308A\u306B\u304F\u3044",
+      other: "\u305D\u306E\u4ED6"
+    },
+    categoryDescriptions: {
+      bug: "\u52D5\u4F5C\u3057\u306A\u3044\u3001\u58CA\u308C\u3066\u3044\u308B",
+      slow: "\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u304C\u60AA\u3044\u3001\u8AAD\u307F\u8FBC\u307F\u304C\u9045\u3044",
+      visual: "\u30EC\u30A4\u30A2\u30A6\u30C8\u3001\u30C7\u30B6\u30A4\u30F3\u3001\u8868\u793A\u306E\u554F\u984C",
+      confusing: "\u7406\u89E3\u3057\u306B\u304F\u3044\u3001\u64CD\u4F5C\u304C\u308F\u304B\u308A\u306B\u304F\u3044",
+      other: "\u305D\u306E\u4ED6\u306E\u554F\u984C"
+    }
+  },
+  step2: {
+    heading: "\u4F55\u304C\u8D77\u304D\u307E\u3057\u305F\u304B\uFF1F",
+    intents: {
+      bug: ["\u30AF\u30E9\u30C3\u30B7\u30E5", "\u7121\u53CD\u5FDC", "\u30C7\u30FC\u30BF\u6D88\u5931", "\u8AA4\u3063\u305F\u7D50\u679C", "\u305D\u306E\u4ED6"],
+      slow: ["\u30DA\u30FC\u30B8\u8AAD\u8FBC", "\u64CD\u4F5C\u53CD\u5FDC", "API\u901A\u4FE1", "\u30A2\u30CB\u30E1\u30FC\u30B7\u30E7\u30F3", "\u305D\u306E\u4ED6"],
+      visual: ["\u30EC\u30A4\u30A2\u30A6\u30C8\u5D29\u308C", "\u8981\u7D20\u306E\u91CD\u306A\u308A", "\u8981\u7D20\u304C\u8868\u793A\u3055\u308C\u306A\u3044", "\u8272/\u30D5\u30A9\u30F3\u30C8\u304C\u9055\u3046", "\u305D\u306E\u4ED6"],
+      confusing: ["\u30E9\u30D9\u30EB\u304C\u4E0D\u660E\u77AD", "\u30D8\u30EB\u30D7\u304C\u306A\u3044", "\u4E88\u60F3\u5916\u306E\u30D5\u30ED\u30FC", "\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3\u8FF7\u5B50", "\u305D\u306E\u4ED6"],
+      other: ["\u6A5F\u80FD\u8981\u671B", "\u30A2\u30AF\u30BB\u30B7\u30D3\u30EA\u30C6\u30A3", "\u8AA4\u5B57\u8131\u5B57", "\u305D\u306E\u4ED6"]
+    }
+  },
+  step3: {
+    heading: "\u8A73\u7D30\u3092\u6559\u3048\u3066\u304F\u3060\u3055\u3044",
+    descriptionPlaceholder: "\u4F55\u304C\u8D77\u304D\u305F\u304B\u8AAC\u660E\u3057\u3066\u304F\u3060\u3055\u3044\u2026",
+    screenshotButton: "\u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u6DFB\u4ED8",
+    screenshotAttached: "\u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u6DFB\u4ED8\u6E08\u307F",
+    elementButton: "\u8981\u7D20\u3092\u9078\u629E",
+    elementSelected: "\u8981\u7D20\u9078\u629E\u6E08\u307F",
+    optional: "\uFF08\u4EFB\u610F\uFF09"
+  }
+};
+
+// src/i18n/th.ts
+var th = {
+  widget: {
+    trigger: "\u0E23\u0E32\u0E22\u0E07\u0E32\u0E19\u0E1B\u0E31\u0E0D\u0E2B\u0E32",
+    title: "\u0E23\u0E32\u0E22\u0E07\u0E32\u0E19\u0E1B\u0E31\u0E0D\u0E2B\u0E32",
+    close: "\u0E1B\u0E34\u0E14",
+    back: "\u0E01\u0E25\u0E31\u0E1A",
+    submit: "\u0E2A\u0E48\u0E07",
+    submitting: "\u0E01\u0E33\u0E25\u0E31\u0E07\u0E2A\u0E48\u0E07\u2026",
+    submitted: "\u0E02\u0E2D\u0E1A\u0E04\u0E38\u0E13\u0E04\u0E23\u0E31\u0E1A/\u0E04\u0E48\u0E30! \u0E23\u0E32\u0E22\u0E07\u0E32\u0E19\u0E02\u0E2D\u0E07\u0E04\u0E38\u0E13\u0E16\u0E39\u0E01\u0E2A\u0E48\u0E07\u0E41\u0E25\u0E49\u0E27",
+    error: "\u0E40\u0E01\u0E34\u0E14\u0E02\u0E49\u0E2D\u0E1C\u0E34\u0E14\u0E1E\u0E25\u0E32\u0E14 \u0E01\u0E23\u0E38\u0E13\u0E32\u0E25\u0E2D\u0E07\u0E43\u0E2B\u0E21\u0E48\u0E2D\u0E35\u0E01\u0E04\u0E23\u0E31\u0E49\u0E07"
+  },
+  step1: {
+    heading: "\u0E1B\u0E31\u0E0D\u0E2B\u0E32\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E44\u0E2B\u0E19?",
+    categories: {
+      bug: "\u0E1A\u0E31\u0E01",
+      slow: "\u0E0A\u0E49\u0E32 / \u0E41\u0E25\u0E04",
+      visual: "\u0E41\u0E2A\u0E14\u0E07\u0E1C\u0E25\u0E1C\u0E34\u0E14\u0E1B\u0E01\u0E15\u0E34",
+      confusing: "\u0E2A\u0E31\u0E1A\u0E2A\u0E19",
+      other: "\u0E2D\u0E37\u0E48\u0E19\u0E46"
+    },
+    categoryDescriptions: {
+      bug: "\u0E21\u0E35\u0E1A\u0E32\u0E07\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E40\u0E2A\u0E35\u0E22\u0E2B\u0E23\u0E37\u0E2D\u0E17\u0E33\u0E07\u0E32\u0E19\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07",
+      slow: "\u0E1B\u0E31\u0E0D\u0E2B\u0E32\u0E1B\u0E23\u0E30\u0E2A\u0E34\u0E17\u0E18\u0E34\u0E20\u0E32\u0E1E\u0E2B\u0E23\u0E37\u0E2D\u0E42\u0E2B\u0E25\u0E14\u0E0A\u0E49\u0E32",
+      visual: "\u0E1B\u0E31\u0E0D\u0E2B\u0E32\u0E40\u0E25\u0E22\u0E4C\u0E40\u0E2D\u0E32\u0E15\u0E4C \u0E2A\u0E44\u0E15\u0E25\u0E4C \u0E2B\u0E23\u0E37\u0E2D\u0E01\u0E32\u0E23\u0E41\u0E2A\u0E14\u0E07\u0E1C\u0E25",
+      confusing: "\u0E40\u0E02\u0E49\u0E32\u0E43\u0E08\u0E22\u0E32\u0E01\u0E2B\u0E23\u0E37\u0E2D\u0E19\u0E33\u0E17\u0E32\u0E07\u0E22\u0E32\u0E01",
+      other: "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E2D\u0E37\u0E48\u0E19"
+    }
+  },
+  step2: {
+    heading: "\u0E40\u0E01\u0E34\u0E14\u0E2D\u0E30\u0E44\u0E23\u0E02\u0E36\u0E49\u0E19?",
+    intents: {
+      bug: ["\u0E41\u0E04\u0E23\u0E0A", "\u0E44\u0E21\u0E48\u0E15\u0E2D\u0E1A\u0E2A\u0E19\u0E2D\u0E07", "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E2B\u0E32\u0E22", "\u0E1C\u0E25\u0E25\u0E31\u0E1E\u0E18\u0E4C\u0E1C\u0E34\u0E14", "\u0E2D\u0E37\u0E48\u0E19\u0E46"],
+      slow: ["\u0E42\u0E2B\u0E25\u0E14\u0E2B\u0E19\u0E49\u0E32", "\u0E01\u0E32\u0E23\u0E42\u0E15\u0E49\u0E15\u0E2D\u0E1A", "API", "\u0E41\u0E2D\u0E19\u0E34\u0E40\u0E21\u0E0A\u0E31\u0E19", "\u0E2D\u0E37\u0E48\u0E19\u0E46"],
+      visual: ["\u0E40\u0E25\u0E22\u0E4C\u0E40\u0E2D\u0E32\u0E15\u0E4C\u0E40\u0E2A\u0E35\u0E22", "\u0E0B\u0E49\u0E2D\u0E19\u0E17\u0E31\u0E1A", "\u0E2D\u0E07\u0E04\u0E4C\u0E1B\u0E23\u0E30\u0E01\u0E2D\u0E1A\u0E2B\u0E32\u0E22", "\u0E2A\u0E35/\u0E1F\u0E2D\u0E19\u0E15\u0E4C\u0E1C\u0E34\u0E14", "\u0E2D\u0E37\u0E48\u0E19\u0E46"],
+      confusing: ["\u0E1B\u0E49\u0E32\u0E22\u0E44\u0E21\u0E48\u0E0A\u0E31\u0E14", "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E33\u0E41\u0E19\u0E30\u0E19\u0E33", "\u0E02\u0E31\u0E49\u0E19\u0E15\u0E2D\u0E19\u0E44\u0E21\u0E48\u0E04\u0E32\u0E14\u0E04\u0E34\u0E14", "\u0E2B\u0E25\u0E07\u0E17\u0E32\u0E07", "\u0E2D\u0E37\u0E48\u0E19\u0E46"],
+      other: ["\u0E02\u0E2D\u0E1F\u0E35\u0E40\u0E08\u0E2D\u0E23\u0E4C", "\u0E01\u0E32\u0E23\u0E40\u0E02\u0E49\u0E32\u0E16\u0E36\u0E07", "\u0E1E\u0E34\u0E21\u0E1E\u0E4C\u0E1C\u0E34\u0E14", "\u0E2D\u0E37\u0E48\u0E19\u0E46"]
+    }
+  },
+  step3: {
+    heading: "\u0E1A\u0E2D\u0E01\u0E40\u0E23\u0E32\u0E40\u0E1E\u0E34\u0E48\u0E21\u0E40\u0E15\u0E34\u0E21",
+    descriptionPlaceholder: "\u0E2D\u0E18\u0E34\u0E1A\u0E32\u0E22\u0E2A\u0E34\u0E48\u0E07\u0E17\u0E35\u0E48\u0E40\u0E01\u0E34\u0E14\u0E02\u0E36\u0E49\u0E19\u2026",
+    screenshotButton: "\u0E41\u0E19\u0E1A\u0E2A\u0E01\u0E23\u0E35\u0E19\u0E0A\u0E47\u0E2D\u0E15",
+    screenshotAttached: "\u0E41\u0E19\u0E1A\u0E2A\u0E01\u0E23\u0E35\u0E19\u0E0A\u0E47\u0E2D\u0E15\u0E41\u0E25\u0E49\u0E27",
+    elementButton: "\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E2D\u0E07\u0E04\u0E4C\u0E1B\u0E23\u0E30\u0E01\u0E2D\u0E1A",
+    elementSelected: "\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E2D\u0E07\u0E04\u0E4C\u0E1B\u0E23\u0E30\u0E01\u0E2D\u0E1A\u0E41\u0E25\u0E49\u0E27",
+    optional: "(\u0E44\u0E21\u0E48\u0E1A\u0E31\u0E07\u0E04\u0E31\u0E1A)"
+  }
+};
+
+// src/i18n/es.ts
+var es = {
+  widget: {
+    trigger: "Reportar problema",
+    title: "Reportar un problema",
+    close: "Cerrar",
+    back: "Volver",
+    submit: "Enviar",
+    submitting: "Enviando\u2026",
+    submitted: "\xA1Gracias! Tu reporte ha sido enviado.",
+    error: "Algo sali\xF3 mal. Por favor, int\xE9ntalo de nuevo."
+  },
+  step1: {
+    heading: "\xBFQu\xE9 tipo de problema?",
+    categories: {
+      bug: "Error",
+      slow: "Lento",
+      visual: "Problema visual",
+      confusing: "Confuso",
+      other: "Otro"
+    },
+    categoryDescriptions: {
+      bug: "Algo est\xE1 roto o no funciona",
+      slow: "Problema de rendimiento o carga lenta",
+      visual: "Problema de dise\xF1o, estilo o visualizaci\xF3n",
+      confusing: "Dif\xEDcil de entender o navegar",
+      other: "Otro problema"
+    }
+  },
+  step2: {
+    heading: "\xBFQu\xE9 pas\xF3?",
+    intents: {
+      bug: ["Crash", "Sin respuesta", "P\xE9rdida de datos", "Resultado incorrecto", "Otro"],
+      slow: ["Carga de p\xE1gina", "Interacci\xF3n", "Llamada API", "Animaci\xF3n", "Otro"],
+      visual: ["Layout roto", "Superposici\xF3n", "Elemento faltante", "Color/fuente incorrecta", "Otro"],
+      confusing: ["Etiqueta confusa", "Sin ayuda", "Flujo inesperado", "Navegaci\xF3n perdida", "Otro"],
+      other: ["Solicitud de funci\xF3n", "Accesibilidad", "Error tipogr\xE1fico", "Otro"]
+    }
+  },
+  step3: {
+    heading: "Cu\xE9ntanos m\xE1s",
+    descriptionPlaceholder: "Describe lo que pas\xF3\u2026",
+    screenshotButton: "Adjuntar captura",
+    screenshotAttached: "Captura adjunta",
+    elementButton: "Seleccionar elemento",
+    elementSelected: "Elemento seleccionado",
+    optional: "(opcional)"
+  }
+};
+
+// src/i18n/index.ts
+var locales = { en, ja, th, es };
+function getLocale(code) {
+  if (!code) return en;
+  const base = code.split("-")[0].toLowerCase();
+  return locales[base] ?? en;
+}
+function getAvailableLocales() {
+  return Object.keys(locales);
+}
+
+// src/styles.ts
+function getWidgetStyles(theme) {
+  const isDark = theme === "dark";
+  const accent = "#7c3aed";
+  const accentHover = "#6d28d9";
+  const accentBgLight = isDark ? "#2e2440" : "#f5f3ff";
+  const accentBgSelected = isDark ? "#2e2440" : "#ede9fe";
+  const border = isDark ? "#3f3f46" : "#e4e4e7";
+  const bgSurface = isDark ? "#18181b" : "#ffffff";
+  const bgMuted = isDark ? "#27272a" : "#fafafa";
+  const textMuted = isDark ? "#a1a1aa" : "#71717a";
+  return `
+    :host {
+      all: initial;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      font-size: 14px;
+      line-height: 1.5;
+      color: ${isDark ? "#e4e4e7" : "#18181b"};
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    /* Trigger button */
+    .mushi-trigger {
+      position: fixed;
+      width: 48px;
+      height: 48px;
+      border-radius: 50%;
+      border: none;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 22px;
+      background: ${bgMuted};
+      box-shadow: 0 2px 12px rgba(0, 0, 0, 0.15);
+      transition: transform 0.2s ease, box-shadow 0.2s ease;
+    }
+    .mushi-trigger:hover {
+      transform: scale(1.08);
+      box-shadow: 0 4px 20px rgba(0, 0, 0, 0.2);
+    }
+    .mushi-trigger.bottom-right { bottom: 20px; right: 20px; }
+    .mushi-trigger.bottom-left  { bottom: 20px; left: 20px; }
+    .mushi-trigger.top-right    { top: 20px; right: 20px; }
+    .mushi-trigger.top-left     { top: 20px; left: 20px; }
+
+    /* Panel */
+    .mushi-panel {
+      position: fixed;
+      width: 380px;
+      max-height: 560px;
+      border-radius: 12px;
+      background: ${bgSurface};
+      box-shadow: 0 8px 32px rgba(0, 0, 0, 0.18);
+      border: 1px solid ${border};
+      overflow: hidden;
+      display: flex;
+      flex-direction: column;
+    }
+    .mushi-panel.open {
+      animation: mushi-slide-in 0.25s ease forwards;
+    }
+    .mushi-panel.closed { display: none; }
+    .mushi-panel.bottom-right { bottom: 76px; right: 20px; }
+    .mushi-panel.bottom-left  { bottom: 76px; left: 20px; }
+    .mushi-panel.top-right    { top: 76px; right: 20px; }
+    .mushi-panel.top-left     { top: 76px; left: 20px; }
+
+    @keyframes mushi-slide-in {
+      from { opacity: 0; transform: translateY(8px) scale(0.98); }
+      to   { opacity: 1; transform: translateY(0) scale(1); }
+    }
+
+    /* Header */
+    .mushi-header {
+      padding: 14px 16px;
+      border-bottom: 1px solid ${border};
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    .mushi-header h3 {
+      font-size: 15px;
+      font-weight: 600;
+      flex: 1;
+    }
+    .mushi-close, .mushi-back {
+      background: none;
+      border: none;
+      cursor: pointer;
+      font-size: 18px;
+      color: ${textMuted};
+      padding: 4px;
+      border-radius: 4px;
+      line-height: 1;
+    }
+    .mushi-close:hover, .mushi-back:hover {
+      background: ${bgMuted};
+    }
+
+    /* Body */
+    .mushi-body {
+      padding: 12px 16px;
+      overflow-y: auto;
+      flex: 1;
+    }
+
+    /* Step 1: Category options */
+    .mushi-option-btn {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      width: 100%;
+      padding: 12px 14px;
+      margin-bottom: 8px;
+      border-radius: 10px;
+      border: 1px solid ${border};
+      background: ${bgMuted};
+      cursor: pointer;
+      font-size: 14px;
+      color: inherit;
+      text-align: left;
+      transition: border-color 0.15s, background 0.15s, transform 0.1s;
+    }
+    .mushi-option-btn:hover {
+      border-color: ${isDark ? "#a78bfa" : accent};
+      background: ${accentBgLight};
+      transform: translateX(2px);
+    }
+    .mushi-option-btn:focus-visible {
+      outline: 2px solid ${accent};
+      outline-offset: 2px;
+    }
+    .mushi-option-icon { font-size: 20px; flex-shrink: 0; }
+    .mushi-option-text { display: flex; flex-direction: column; gap: 2px; }
+    .mushi-option-label { font-weight: 500; }
+    .mushi-option-desc { font-size: 12px; color: ${textMuted}; }
+
+    /* Step 2: Intent chips */
+    .mushi-selected-category {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 8px 12px;
+      border-radius: 8px;
+      background: ${accentBgSelected};
+      font-size: 13px;
+      font-weight: 500;
+      margin-bottom: 12px;
+    }
+    .mushi-intents {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+    .mushi-intent-btn {
+      padding: 8px 16px;
+      border-radius: 20px;
+      border: 1px solid ${border};
+      background: ${bgMuted};
+      cursor: pointer;
+      font-size: 13px;
+      color: inherit;
+      transition: border-color 0.15s, background 0.15s;
+    }
+    .mushi-intent-btn:hover {
+      border-color: ${isDark ? "#a78bfa" : accent};
+      background: ${accentBgLight};
+    }
+    .mushi-intent-btn:focus-visible {
+      outline: 2px solid ${accent};
+      outline-offset: 2px;
+    }
+
+    /* Step 3: Details */
+    .mushi-textarea {
+      width: 100%;
+      min-height: 90px;
+      padding: 10px 12px;
+      border-radius: 8px;
+      border: 1px solid ${border};
+      background: ${bgMuted};
+      color: inherit;
+      font-family: inherit;
+      font-size: 14px;
+      resize: vertical;
+      outline: none;
+      transition: border-color 0.15s, box-shadow 0.15s;
+    }
+    .mushi-textarea:focus {
+      border-color: ${isDark ? "#a78bfa" : accent};
+      box-shadow: 0 0 0 2px ${isDark ? "rgba(167,139,250,0.2)" : "rgba(124,58,237,0.1)"};
+    }
+
+    .mushi-attachments {
+      display: flex;
+      gap: 8px;
+      margin-top: 10px;
+    }
+    .mushi-attach-btn {
+      padding: 6px 12px;
+      border-radius: 6px;
+      border: 1px solid ${border};
+      background: none;
+      cursor: pointer;
+      font-size: 12px;
+      color: ${textMuted};
+      transition: border-color 0.15s, color 0.15s;
+    }
+    .mushi-attach-btn:hover {
+      border-color: ${isDark ? "#a78bfa" : accent};
+      color: inherit;
+    }
+    .mushi-attach-btn.active {
+      border-color: ${isDark ? "#a78bfa" : accent};
+      color: ${isDark ? "#a78bfa" : accent};
+      background: ${accentBgLight};
+    }
+
+    /* Footer */
+    .mushi-footer {
+      padding: 12px 16px;
+      border-top: 1px solid ${border};
+      display: flex;
+      align-items: center;
+      justify-content: flex-end;
+    }
+    .mushi-submit {
+      padding: 8px 24px;
+      border-radius: 8px;
+      border: none;
+      background: ${accent};
+      color: #ffffff;
+      font-size: 14px;
+      font-weight: 500;
+      cursor: pointer;
+      transition: background 0.15s;
+    }
+    .mushi-submit:hover { background: ${accentHover}; }
+    .mushi-submit:disabled { opacity: 0.5; cursor: not-allowed; }
+    .mushi-submit:focus-visible {
+      outline: 2px solid ${accent};
+      outline-offset: 2px;
+    }
+
+    /* Step indicator dots */
+    .mushi-step-indicator {
+      display: flex;
+      justify-content: center;
+      gap: 6px;
+      padding: 10px;
+    }
+    .mushi-dot {
+      width: 6px;
+      height: 6px;
+      border-radius: 50%;
+      background: ${border};
+      transition: background 0.2s, transform 0.2s;
+    }
+    .mushi-dot.active {
+      background: ${accent};
+      transform: scale(1.3);
+    }
+    .mushi-dot.done {
+      background: ${isDark ? "#a78bfa" : "#8b5cf6"};
+    }
+
+    /* Success */
+    .mushi-success {
+      text-align: center;
+      padding: 32px 16px;
+    }
+    .mushi-success-icon {
+      font-size: 40px;
+      margin-bottom: 12px;
+    }
+    .mushi-success p {
+      color: ${textMuted};
+      font-size: 14px;
+    }
+
+    /* Error */
+    .mushi-error {
+      color: #ef4444;
+      font-size: 12px;
+      margin-top: 8px;
+    }
+  `;
+}
+
+// src/widget.ts
+var CATEGORY_ICONS = {
+  bug: "\u26A0\uFE0F",
+  slow: "\u{1F40C}",
+  visual: "\u{1F3A8}",
+  confusing: "\u{1F615}",
+  other: "\u{1F4DD}"
+};
+var MushiWidget = class {
+  host;
+  shadow;
+  config;
+  callbacks;
+  locale;
+  isOpen = false;
+  step = "category";
+  selectedCategory = null;
+  selectedIntent = null;
+  screenshotAttached = false;
+  elementSelected = false;
+  submitting = false;
+  constructor(config = {}, callbacks) {
+    this.config = {
+      position: config.position ?? "bottom-right",
+      theme: config.theme ?? "auto",
+      triggerText: config.triggerText ?? "\u{1F41B}",
+      expandedTitle: config.expandedTitle ?? "",
+      mode: config.mode ?? "conversational",
+      locale: config.locale ?? "auto",
+      zIndex: config.zIndex ?? 99999
+    };
+    this.callbacks = callbacks;
+    this.locale = getLocale(this.config.locale === "auto" ? void 0 : this.config.locale);
+    this.host = document.createElement("div");
+    this.host.id = "mushi-mushi-widget";
+    this.shadow = this.host.attachShadow({ mode: "closed" });
+  }
+  mount() {
+    document.body.appendChild(this.host);
+    this.render();
+  }
+  open() {
+    if (this.isOpen) return;
+    this.isOpen = true;
+    this.step = "category";
+    this.selectedCategory = null;
+    this.selectedIntent = null;
+    this.screenshotAttached = false;
+    this.elementSelected = false;
+    this.submitting = false;
+    this.render();
+    this.callbacks.onOpen();
+  }
+  close() {
+    if (!this.isOpen) return;
+    this.isOpen = false;
+    this.render();
+    this.callbacks.onClose();
+  }
+  getIsOpen() {
+    return this.isOpen;
+  }
+  setScreenshotAttached(attached) {
+    this.screenshotAttached = attached;
+    if (this.isOpen) this.render();
+  }
+  setElementSelected(selected) {
+    this.elementSelected = selected;
+    if (this.isOpen) this.render();
+  }
+  destroy() {
+    this.host.remove();
+  }
+  getTheme() {
+    if (this.config.theme !== "auto") return this.config.theme;
+    if (typeof window !== "undefined" && window.matchMedia("(prefers-color-scheme: dark)").matches) {
+      return "dark";
+    }
+    return "light";
+  }
+  render() {
+    const theme = this.getTheme();
+    const pos = this.config.position;
+    const t = this.locale;
+    this.shadow.innerHTML = "";
+    const style = document.createElement("style");
+    style.textContent = getWidgetStyles(theme);
+    this.shadow.appendChild(style);
+    const trigger = document.createElement("button");
+    trigger.className = `mushi-trigger ${pos}`;
+    trigger.textContent = this.config.triggerText;
+    trigger.setAttribute("aria-label", t.widget.trigger);
+    trigger.style.zIndex = String(this.config.zIndex);
+    trigger.addEventListener("click", () => {
+      if (this.isOpen) this.close();
+      else this.open();
+    });
+    this.shadow.appendChild(trigger);
+    const panel = document.createElement("div");
+    panel.className = `mushi-panel ${pos}${this.isOpen ? " open" : " closed"}`;
+    panel.setAttribute("role", "dialog");
+    panel.setAttribute("aria-label", t.widget.title);
+    panel.style.zIndex = String(this.config.zIndex + 1);
+    if (this.isOpen) {
+      panel.innerHTML = this.renderStep();
+      this.shadow.appendChild(panel);
+      this.attachHandlers(panel);
+      this.trapFocus(panel);
+    }
+  }
+  renderStep() {
+    switch (this.step) {
+      case "category":
+        return this.renderCategoryStep();
+      case "intent":
+        return this.renderIntentStep();
+      case "details":
+        return this.renderDetailsStep();
+      case "success":
+        return this.renderSuccessStep();
+    }
+  }
+  renderHeader(title, showBack = false) {
+    const t = this.locale;
+    return `
+      <div class="mushi-header">
+        ${showBack ? `<button class="mushi-back" data-action="back" aria-label="${t.widget.back}">\u2190</button>` : ""}
+        <h3>${title}</h3>
+        <button class="mushi-close" data-action="close" aria-label="${t.widget.close}">\u2715</button>
+      </div>
+    `;
+  }
+  renderCategoryStep() {
+    const t = this.locale;
+    const categories = ["bug", "slow", "visual", "confusing", "other"].map((id) => `
+        <button class="mushi-option-btn" data-category="${id}" role="radio" aria-checked="false">
+          <span class="mushi-option-icon">${CATEGORY_ICONS[id]}</span>
+          <div class="mushi-option-text">
+            <span class="mushi-option-label">${t.step1.categories[id]}</span>
+            <span class="mushi-option-desc">${t.step1.categoryDescriptions[id]}</span>
+          </div>
+        </button>
+      `).join("");
+    return `
+      ${this.renderHeader(t.step1.heading)}
+      <div class="mushi-body" role="radiogroup" aria-label="${t.step1.heading}">
+        ${categories}
+      </div>
+      <div class="mushi-step-indicator">
+        <span class="mushi-dot active"></span>
+        <span class="mushi-dot"></span>
+        <span class="mushi-dot"></span>
+      </div>
+    `;
+  }
+  renderIntentStep() {
+    const t = this.locale;
+    const cat = this.selectedCategory;
+    const intents = t.step2.intents[cat] || [];
+    const options = intents.map((intent) => `
+      <button class="mushi-intent-btn" data-intent="${intent}">
+        ${intent}
+      </button>
+    `).join("");
+    return `
+      ${this.renderHeader(t.step2.heading, true)}
+      <div class="mushi-body">
+        <div class="mushi-selected-category">
+          <span>${CATEGORY_ICONS[cat]}</span>
+          <span>${t.step1.categories[cat]}</span>
+        </div>
+        <div class="mushi-intents">
+          ${options}
+        </div>
+      </div>
+      <div class="mushi-step-indicator">
+        <span class="mushi-dot done"></span>
+        <span class="mushi-dot active"></span>
+        <span class="mushi-dot"></span>
+      </div>
+    `;
+  }
+  renderDetailsStep() {
+    const t = this.locale;
+    return `
+      ${this.renderHeader(t.step3.heading, true)}
+      <div class="mushi-body">
+        <textarea
+          class="mushi-textarea"
+          placeholder="${t.step3.descriptionPlaceholder}"
+          rows="4"
+          aria-label="${t.step3.heading}"
+          autofocus
+        ></textarea>
+        <div class="mushi-attachments">
+          <button class="mushi-attach-btn${this.screenshotAttached ? " active" : ""}" data-action="screenshot">
+            \u{1F4F8} ${this.screenshotAttached ? t.step3.screenshotAttached : t.step3.screenshotButton}
+          </button>
+          <button class="mushi-attach-btn${this.elementSelected ? " active" : ""}" data-action="element">
+            \u{1F3AF} ${this.elementSelected ? t.step3.elementSelected : t.step3.elementButton}
+          </button>
+        </div>
+        <div class="mushi-error" style="display:none" role="alert"></div>
+      </div>
+      <div class="mushi-footer">
+        <button class="mushi-submit" data-action="submit"${this.submitting ? " disabled" : ""}>
+          ${this.submitting ? t.widget.submitting : t.widget.submit}
+        </button>
+      </div>
+      <div class="mushi-step-indicator">
+        <span class="mushi-dot done"></span>
+        <span class="mushi-dot done"></span>
+        <span class="mushi-dot active"></span>
+      </div>
+    `;
+  }
+  renderSuccessStep() {
+    const t = this.locale;
+    return `
+      ${this.renderHeader(t.widget.title)}
+      <div class="mushi-body">
+        <div class="mushi-success">
+          <div class="mushi-success-icon">\u2705</div>
+          <p>${t.widget.submitted}</p>
+        </div>
+      </div>
+    `;
+  }
+  attachHandlers(panel) {
+    const t = this.locale;
+    panel.querySelector('[data-action="close"]')?.addEventListener("click", () => this.close());
+    panel.querySelector('[data-action="back"]')?.addEventListener("click", () => {
+      if (this.step === "intent") {
+        this.step = "category";
+        this.selectedCategory = null;
+      } else if (this.step === "details") {
+        this.step = "intent";
+        this.selectedIntent = null;
+      }
+      this.render();
+    });
+    panel.querySelectorAll("[data-category]").forEach((btn) => {
+      btn.addEventListener("click", () => {
+        this.selectedCategory = btn.dataset.category;
+        this.step = "intent";
+        this.render();
+      });
+    });
+    panel.querySelectorAll("[data-intent]").forEach((btn) => {
+      btn.addEventListener("click", () => {
+        this.selectedIntent = btn.dataset.intent ?? null;
+        this.step = "details";
+        this.render();
+      });
+    });
+    panel.querySelector('[data-action="screenshot"]')?.addEventListener("click", () => {
+      this.callbacks.onScreenshotRequest();
+    });
+    panel.querySelector('[data-action="element"]')?.addEventListener("click", () => {
+      this.callbacks.onElementSelectorRequest?.();
+    });
+    panel.querySelector('[data-action="submit"]')?.addEventListener("click", () => {
+      const textarea = panel.querySelector(".mushi-textarea");
+      const description = textarea?.value?.trim() ?? "";
+      const errorEl = panel.querySelector(".mushi-error");
+      if (description.length < 5) {
+        if (errorEl) {
+          errorEl.textContent = t.widget.error;
+          errorEl.style.display = "block";
+        }
+        return;
+      }
+      this.submitting = true;
+      this.render();
+      this.callbacks.onSubmit({
+        category: this.selectedCategory,
+        description,
+        intent: this.selectedIntent ?? void 0
+      });
+      setTimeout(() => {
+        this.submitting = false;
+        this.step = "success";
+        this.render();
+        setTimeout(() => {
+          if (this.step === "success") this.close();
+        }, 2500);
+      }, 500);
+    });
+    panel.addEventListener("keydown", (e) => {
+      if (e.key === "Escape") this.close();
+    });
+  }
+  trapFocus(panel) {
+    requestAnimationFrame(() => {
+      const focusable = panel.querySelectorAll("button, textarea, [tabindex]");
+      if (focusable.length > 0) focusable[0].focus();
+    });
+  }
+};
+
+// src/capture/console.ts
+var MAX_ENTRIES = 50;
+var MAX_MESSAGE_LENGTH = 500;
+function createConsoleCapture() {
+  const entries = [];
+  const originals = {};
+  const levels = ["log", "warn", "error", "info", "debug"];
+  for (const level of levels) {
+    const original = console[level];
+    originals[level] = original;
+    console[level] = (...args) => {
+      const message = args.map((arg) => {
+        try {
+          return typeof arg === "string" ? arg : JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+      }).join(" ").slice(0, MAX_MESSAGE_LENGTH);
+      const entry = {
+        level,
+        message,
+        timestamp: Date.now()
+      };
+      if (level === "error" && args[0] instanceof Error) {
+        entry.stack = args[0].stack?.slice(0, 1e3);
+      }
+      entries.push(entry);
+      if (entries.length > MAX_ENTRIES) {
+        entries.shift();
+      }
+      original.call(console, ...args);
+    };
+  }
+  return {
+    getEntries() {
+      return [...entries];
+    },
+    clear() {
+      entries.length = 0;
+    },
+    destroy() {
+      for (const level of levels) {
+        if (originals[level]) {
+          console[level] = originals[level];
+        }
+      }
+    }
+  };
+}
+
+// src/capture/network.ts
+var MAX_ENTRIES2 = 30;
+function createNetworkCapture() {
+  const entries = [];
+  const originalFetch = globalThis.fetch;
+  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;
+    try {
+      const response = await originalFetch.call(globalThis, input, init);
+      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"
+      });
+      throw error;
+    }
+  };
+  function addEntry(entry) {
+    entries.push(entry);
+    if (entries.length > MAX_ENTRIES2) {
+      entries.shift();
+    }
+  }
+  return {
+    getEntries() {
+      return [...entries];
+    },
+    clear() {
+      entries.length = 0;
+    },
+    destroy() {
+      globalThis.fetch = originalFetch;
+    }
+  };
+}
+function truncateUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname + parsed.search;
+    if (path.length > 200) {
+      return parsed.origin + path.slice(0, 200) + "...";
+    }
+    return parsed.origin + path;
+  } catch {
+    return url.slice(0, 200);
+  }
+}
+
+// src/capture/screenshot.ts
+function createScreenshotCapture() {
+  async function take() {
+    try {
+      if (typeof document === "undefined") return null;
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return null;
+      const width = window.innerWidth;
+      const height = window.innerHeight;
+      const dpr = Math.min(window.devicePixelRatio || 1, 2);
+      canvas.width = width * dpr;
+      canvas.height = height * dpr;
+      ctx.scale(dpr, dpr);
+      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)}
+            </div>
+          </foreignObject>
+        </svg>
+      `;
+      const img = new Image();
+      const blob = new Blob([svgData], { type: "image/svg+xml;charset=utf-8" });
+      const url = URL.createObjectURL(blob);
+      return new Promise((resolve) => {
+        img.onload = () => {
+          ctx.drawImage(img, 0, 0, width, height);
+          URL.revokeObjectURL(url);
+          try {
+            const dataUrl = canvas.toDataURL("image/jpeg", 0.7);
+            resolve(dataUrl);
+          } catch {
+            resolve(null);
+          }
+        };
+        img.onerror = () => {
+          URL.revokeObjectURL(url);
+          resolve(null);
+        };
+        img.src = url;
+      });
+    } catch {
+      return null;
+    }
+  }
+  return { take };
+}
+
+// src/capture/performance.ts
+function createPerformanceCapture() {
+  const metrics = {};
+  const observers = [];
+  if (typeof PerformanceObserver !== "undefined") {
+    try {
+      const paintObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          if (entry.name === "first-contentful-paint") {
+            metrics.fcp = entry.startTime;
+          }
+        }
+      });
+      paintObserver.observe({ type: "paint", buffered: true });
+      observers.push(paintObserver);
+    } catch {
+    }
+    try {
+      const lcpObserver = new PerformanceObserver((list) => {
+        const entries = list.getEntries();
+        if (entries.length > 0) {
+          metrics.lcp = entries[entries.length - 1].startTime;
+        }
+      });
+      lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+      observers.push(lcpObserver);
+    } catch {
+    }
+    try {
+      let clsValue = 0;
+      const clsObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          if (!entry.hadRecentInput) {
+            clsValue += entry.value ?? 0;
+            metrics.cls = clsValue;
+          }
+        }
+      });
+      clsObserver.observe({ type: "layout-shift", buffered: true });
+      observers.push(clsObserver);
+    } catch {
+    }
+    try {
+      let longTaskCount = 0;
+      const longTaskObserver = new PerformanceObserver((list) => {
+        longTaskCount += list.getEntries().length;
+        metrics.longTasks = longTaskCount;
+      });
+      longTaskObserver.observe({ type: "longtask", buffered: true });
+      observers.push(longTaskObserver);
+    } catch {
+    }
+  }
+  if (typeof performance !== "undefined" && performance.getEntriesByType) {
+    try {
+      const navEntries = performance.getEntriesByType("navigation");
+      if (navEntries.length > 0 && navEntries[0]) {
+        metrics.ttfb = navEntries[0].responseStart - navEntries[0].requestStart;
+      }
+    } catch {
+    }
+  }
+  return {
+    getMetrics() {
+      return { ...metrics };
+    },
+    destroy() {
+      for (const obs of observers) {
+        obs.disconnect();
+      }
+      observers.length = 0;
+    }
+  };
+}
+
+// src/capture/element-selector.ts
+function createElementSelector() {
+  let active = false;
+  let overlay = null;
+  let resolvePromise = null;
+  function getXPath(el) {
+    const parts = [];
+    let current = el;
+    while (current && current !== document.body) {
+      let index = 1;
+      let sibling = current.previousElementSibling;
+      while (sibling) {
+        if (sibling.tagName === current.tagName) index++;
+        sibling = sibling.previousElementSibling;
+      }
+      const tag = current.tagName.toLowerCase();
+      parts.unshift(index > 1 ? `${tag}[${index}]` : tag);
+      current = current.parentElement;
+    }
+    return "//" + parts.join("/");
+  }
+  function captureElement(el) {
+    const rect = el.getBoundingClientRect();
+    return {
+      tagName: el.tagName.toLowerCase(),
+      id: el.id || void 0,
+      className: el.className || void 0,
+      textContent: el.textContent?.trim().slice(0, 200) || void 0,
+      xpath: getXPath(el),
+      rect: {
+        x: Math.round(rect.x),
+        y: Math.round(rect.y),
+        width: Math.round(rect.width),
+        height: Math.round(rect.height)
+      }
+    };
+  }
+  function createOverlay() {
+    const el = document.createElement("div");
+    el.style.cssText = `
+      position: fixed;
+      pointer-events: none;
+      z-index: 2147483647;
+      border: 2px solid #6366f1;
+      background: rgba(99, 102, 241, 0.1);
+      border-radius: 4px;
+      transition: all 0.1s ease;
+      display: none;
+    `;
+    document.body.appendChild(el);
+    return el;
+  }
+  function positionOverlay(target) {
+    if (!overlay) return;
+    const rect = target.getBoundingClientRect();
+    overlay.style.left = `${rect.left}px`;
+    overlay.style.top = `${rect.top}px`;
+    overlay.style.width = `${rect.width}px`;
+    overlay.style.height = `${rect.height}px`;
+    overlay.style.display = "block";
+  }
+  function handleMouseMove(e) {
+    const target = e.target;
+    if (target === overlay) return;
+    positionOverlay(target);
+  }
+  function handleClick(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    const target = e.target;
+    if (target === overlay) return;
+    const captured = captureElement(target);
+    finish(captured);
+  }
+  function handleKeyDown(e) {
+    if (e.key === "Escape") {
+      finish(null);
+    }
+  }
+  function finish(result) {
+    deactivate();
+    resolvePromise?.(result);
+    resolvePromise = null;
+  }
+  function activate() {
+    if (active) deactivate();
+    return new Promise((resolve) => {
+      resolvePromise = resolve;
+      active = true;
+      overlay = createOverlay();
+      document.body.style.cursor = "crosshair";
+      document.addEventListener("mousemove", handleMouseMove, true);
+      document.addEventListener("click", handleClick, true);
+      document.addEventListener("keydown", handleKeyDown, true);
+    });
+  }
+  function deactivate() {
+    if (!active) return;
+    active = false;
+    document.body.style.cursor = "";
+    document.removeEventListener("mousemove", handleMouseMove, true);
+    document.removeEventListener("click", handleClick, true);
+    document.removeEventListener("keydown", handleKeyDown, true);
+    if (overlay) {
+      overlay.remove();
+      overlay = null;
+    }
+  }
+  return { activate, deactivate, isActive: () => active };
+}
+
+// src/sentry.ts
+function getSentryGlobal() {
+  try {
+    const win = globalThis;
+    if (win.__SENTRY__) {
+      const sentry = win.__SENTRY__;
+      const hub = sentry.hub;
+      return hub;
+    }
+    if (win.Sentry) {
+      return win.Sentry;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function captureSentryContext(_config) {
+  const context = {};
+  try {
+    const hub = getSentryGlobal();
+    if (!hub) return context;
+    const scope = hub.getScope?.();
+    if (scope) {
+      context.eventId = scope.getLastEventId?.() ?? void 0;
+    }
+    const client = hub.getClient?.();
+    if (client) {
+      const options = client.getOptions?.();
+      context.release = options?.release;
+      context.environment = options?.environment;
+    }
+    const win = globalThis;
+    if (win.__SENTRY_REPLAY__) {
+      const replay = win.__SENTRY_REPLAY__;
+      context.replayId = replay.getReplayId?.() ?? void 0;
+    }
+  } catch {
+  }
+  return context;
+}
+
+// src/mushi.ts
+var instance = null;
+var Mushi = class {
+  constructor() {
+  }
+  static init(config) {
+    if (instance) {
+      createLogger({ scope: "mushi", level: "warn", format: "pretty" }).warn("Already initialized \u2014 call destroy() first to reinitialize");
+      return instance;
+    }
+    if (!config.projectId) {
+      throw new Error("[mushi] projectId is required");
+    }
+    if (!config.apiKey) {
+      throw new Error("[mushi] apiKey is required");
+    }
+    if (config.enabled === false) {
+      return createNoopInstance();
+    }
+    instance = createInstance(config);
+    return instance;
+  }
+  static getInstance() {
+    return instance;
+  }
+  static destroy() {
+    instance?.destroy();
+    instance = null;
+  }
+};
+function createInstance(config) {
+  const log = config.debug ?? false ? createLogger({ scope: "mushi", level: "debug", format: "pretty" }) : noopLogger;
+  const apiClient = createApiClient({
+    projectId: config.projectId,
+    apiKey: config.apiKey,
+    apiEndpoint: config.apiEndpoint ?? "https://api.mushimushi.dev"
+  });
+  const preFilter = createPreFilter(config.preFilter);
+  const offlineQueue = createOfflineQueue(config.offline);
+  const rateLimiter = createRateLimiter({ maxBurst: 10, refillRate: 1, refillIntervalMs: 5e3 });
+  const piiScrubber = createPiiScrubber();
+  const consoleCap = config.capture?.console !== false ? createConsoleCapture() : null;
+  const networkCap = config.capture?.network !== false ? createNetworkCapture() : null;
+  const perfCap = config.capture?.performance !== false ? createPerformanceCapture() : null;
+  const screenshotCap = config.capture?.screenshot !== "off" ? createScreenshotCapture() : null;
+  const elementSelector = config.capture?.elementSelector !== false ? createElementSelector() : null;
+  const listeners = /* @__PURE__ */ new Map();
+  function emit(type, data) {
+    listeners.get(type)?.forEach((handler) => handler({ type, data }));
+  }
+  let userInfo = null;
+  const customMetadata = {};
+  let pendingScreenshot = null;
+  let pendingElement = null;
+  const widget = new MushiWidget(config.widget, {
+    onSubmit: async ({ category, description, intent }) => {
+      log.info("Report submitted", { category, intent });
+      await submitReport(category, description, intent);
+    },
+    onOpen: () => {
+      log.debug("Widget opened");
+      emit("widget:opened");
+    },
+    onClose: () => {
+      log.debug("Widget closed");
+      pendingScreenshot = null;
+      pendingElement = null;
+      emit("widget:closed");
+    },
+    onScreenshotRequest: async () => {
+      if (!screenshotCap) return;
+      log.debug("Taking screenshot");
+      pendingScreenshot = await screenshotCap.take();
+      widget.setScreenshotAttached(pendingScreenshot !== null);
+    },
+    onElementSelectorRequest: async () => {
+      if (!elementSelector) return;
+      log.debug("Element selector activated");
+      const el = await elementSelector.activate();
+      if (el) {
+        pendingElement = el;
+        widget.setElementSelected(true);
+        log.debug("Element selected", { tagName: el.tagName, xpath: el.xpath });
+      }
+    }
+  });
+  if (typeof document !== "undefined") {
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => widget.mount());
+    } else {
+      widget.mount();
+    }
+  }
+  offlineQueue.startAutoSync(apiClient);
+  offlineQueue.flush(apiClient).then((result) => {
+    if (result.sent > 0) log.info("Synced offline reports", { sent: result.sent });
+  });
+  log.info("Initialized", { projectId: config.projectId });
+  async function submitReport(category, description, intent) {
+    const filterResult = preFilter.check(description);
+    if (!filterResult.passed) {
+      log.info("Report blocked by pre-filter", { reason: filterResult.reason });
+      return;
+    }
+    if (!rateLimiter.tryConsume()) {
+      log.warn("Report throttled \u2014 rate limit exceeded");
+      return;
+    }
+    const scrubbedDescription = piiScrubber.scrub(preFilter.truncate(description));
+    const sentryCtx = config.sentry ? captureSentryContext(config.sentry) : void 0;
+    const report = {
+      id: crypto.randomUUID?.() ?? `mushi_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+      projectId: config.projectId,
+      category,
+      description: scrubbedDescription,
+      userIntent: intent,
+      environment: captureEnvironment(),
+      consoleLogs: consoleCap?.getEntries(),
+      networkLogs: networkCap?.getEntries(),
+      performanceMetrics: perfCap?.getMetrics(),
+      screenshotDataUrl: pendingScreenshot ?? void 0,
+      selectedElement: pendingElement ?? void 0,
+      metadata: {
+        ...customMetadata,
+        ...userInfo ? { user: userInfo } : {},
+        ...sentryCtx?.release ? { sentryRelease: sentryCtx.release } : {}
+      },
+      sessionId: getSessionId(),
+      reporterToken: getReporterToken(),
+      appVersion: config.integrations?.vercel?.analyticsId,
+      sentryEventId: sentryCtx?.eventId,
+      sentryReplayId: sentryCtx?.replayId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (config.integrations?.custom) {
+      const builder = {
+        addMetadata(key, value) {
+          report.metadata[key] = value;
+        },
+        setCategory(cat) {
+          report.category = cat;
+        },
+        setDescription(desc) {
+          report.description = desc;
+        }
+      };
+      config.integrations.custom(builder);
+    }
+    emit("report:submitted", { reportId: report.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 });
+      return;
+    }
+    const result = await apiClient.submitReport(report);
+    if (result.ok) {
+      log.info("Report sent", { reportId: result.data?.reportId });
+      emit("report:sent", { reportId: result.data?.reportId });
+    } 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 });
+    }
+    pendingScreenshot = null;
+    pendingElement = null;
+  }
+  const sdk = {
+    report() {
+      widget.open();
+    },
+    on(event, handler) {
+      if (!listeners.has(event)) listeners.set(event, /* @__PURE__ */ new Set());
+      listeners.get(event).add(handler);
+      return () => listeners.get(event)?.delete(handler);
+    },
+    setUser(user) {
+      userInfo = user;
+    },
+    setMetadata(key, value) {
+      customMetadata[key] = value;
+    },
+    isOpen() {
+      return widget.getIsOpen();
+    },
+    open() {
+      widget.open();
+    },
+    close() {
+      widget.close();
+    },
+    destroy() {
+      widget.destroy();
+      consoleCap?.destroy();
+      networkCap?.destroy();
+      perfCap?.destroy();
+      elementSelector?.deactivate();
+      offlineQueue.stopAutoSync();
+      listeners.clear();
+      instance = null;
+      log.debug("Destroyed");
+    }
+  };
+  return sdk;
+}
+function createNoopInstance() {
+  return {
+    report: () => {
+    },
+    on: () => () => {
+    },
+    setUser: () => {
+    },
+    setMetadata: () => {
+    },
+    isOpen: () => false,
+    open: () => {
+    },
+    close: () => {
+    },
+    destroy: () => {
+      instance = null;
+    }
+  };
+}
+
+// src/proactive-manager.ts
+var STORAGE_KEY_LAST_DISMISS = "mushi:lastDismiss";
+var STORAGE_KEY_CONSEC_DISMISS = "mushi:consecDismiss";
+function readStorage(key) {
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeStorage(key, value) {
+  try {
+    localStorage.setItem(key, value);
+  } catch {
+  }
+}
+function createProactiveManager(config = {}) {
+  const maxPerSession = config.maxProactivePerSession ?? 2;
+  const cooldownHours = config.dismissCooldownHours ?? 24;
+  const suppressThreshold = config.suppressAfterDismissals ?? 3;
+  let sessionPromptCount = 0;
+  const sessionTriggerTypes = /* @__PURE__ */ new Set();
+  function shouldShow(triggerType) {
+    const consecDismissals = parseInt(readStorage(STORAGE_KEY_CONSEC_DISMISS) ?? "0", 10);
+    if (consecDismissals >= suppressThreshold) return false;
+    const lastDismiss = readStorage(STORAGE_KEY_LAST_DISMISS);
+    if (lastDismiss) {
+      const elapsed = Date.now() - parseInt(lastDismiss, 10);
+      if (elapsed < cooldownHours * 60 * 60 * 1e3) return false;
+    }
+    if (sessionPromptCount >= maxPerSession) return false;
+    if (sessionTriggerTypes.has(triggerType)) return false;
+    sessionTriggerTypes.add(triggerType);
+    sessionPromptCount++;
+    return true;
+  }
+  function recordDismissal() {
+    writeStorage(STORAGE_KEY_LAST_DISMISS, String(Date.now()));
+    const current = parseInt(readStorage(STORAGE_KEY_CONSEC_DISMISS) ?? "0", 10);
+    writeStorage(STORAGE_KEY_CONSEC_DISMISS, String(current + 1));
+  }
+  function recordSubmission() {
+    writeStorage(STORAGE_KEY_CONSEC_DISMISS, "0");
+  }
+  function reset() {
+    sessionPromptCount = 0;
+    sessionTriggerTypes.clear();
+  }
+  return { shouldShow, recordDismissal, recordSubmission, reset };
+}
+
+// src/proactive-triggers.ts
+function setupProactiveTriggers(callbacks) {
+  const cleanups = [];
+  let clickTimes = [];
+  let lastClickTarget = null;
+  function handleClick(e) {
+    const now = Date.now();
+    if (e.target === lastClickTarget) {
+      clickTimes.push(now);
+      clickTimes = clickTimes.filter((t) => now - t < 500);
+      if (clickTimes.length >= 3) {
+        const el = e.target;
+        callbacks.onTrigger("rage_click", {
+          element: el.tagName,
+          id: el.id,
+          text: el.textContent?.slice(0, 50)
+        });
+        clickTimes = [];
+      }
+    } else {
+      lastClickTarget = e.target;
+      clickTimes = [now];
+    }
+  }
+  document.addEventListener("click", handleClick, true);
+  cleanups.push(() => document.removeEventListener("click", handleClick, true));
+  if (typeof PerformanceObserver !== "undefined") {
+    try {
+      const observer = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          if (entry.duration > 5e3) {
+            callbacks.onTrigger("long_task", {
+              duration: Math.round(entry.duration),
+              startTime: Math.round(entry.startTime)
+            });
+          }
+        }
+      });
+      observer.observe({ entryTypes: ["longtask"] });
+      cleanups.push(() => observer.disconnect());
+    } catch {
+    }
+  }
+  const failedRequests = [];
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = async function(...args) {
+    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;
+        }
+      }
+      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;
+      }
+      throw err;
+    }
+  };
+  cleanups.push(() => {
+    globalThis.fetch = origFetch;
+  });
+  return {
+    destroy() {
+      cleanups.forEach((fn) => fn());
+    }
+  };
+}
+
+export { Mushi, MushiWidget, createConsoleCapture, createElementSelector, createNetworkCapture, createPerformanceCapture, createProactiveManager, createScreenshotCapture, getAvailableLocales, getLocale, setupProactiveTriggers };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map