@botim/mp-debug-sdk 0.7.2 → 1.0.0

package/dist/auto.js

@@ -0,0 +1,1857 @@
+import { botimConfig } from 'virtual:botim/config';
+import { snapshot } from 'rrweb-snapshot';
+
+// src/auto.ts
+
+// src/types.ts
+var SCHEMA_VERSION = 2;
+
+// src/errors.ts
+var BRAND = "@botim/debug-sdk";
+var BotimConfigError = class extends Error {
+  constructor(message, opts = { code: "invalid-config" }) {
+    super(`[${BRAND}] ${message}`);
+    this.name = "BotimConfigError";
+    this.code = opts.code;
+    this.path = opts.path;
+  }
+};
+var BotimConsentError = class extends Error {
+  constructor(message) {
+    super(`[${BRAND}] ${message}`);
+    this.name = "BotimConsentError";
+  }
+};
+
+// src/consent-ui.ts
+var STORAGE_PREFIX = "__botim_debug_consent_";
+var CSS_PREFIX = "__botim-debug-consent";
+var STYLE_ELEMENT_ID = `${CSS_PREFIX}-styles`;
+var DEFAULT_COPY = {
+  title: "Enable BOTIM debug logging?",
+  body: [
+    "This shares your screen content, console logs, and network calls with the BOTIM team to help debug this mini-program.",
+    "No data leaves your device unless you agree. You can revoke this anytime by clearing site data or via developer tools."
+  ],
+  acceptLabel: "Allow",
+  declineLabel: "Skip"
+};
+function readConsentDecision(mpId) {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(STORAGE_PREFIX + mpId);
+    if (raw === "granted" || raw === "denied") return raw;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeConsentDecision(mpId, decision) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(STORAGE_PREFIX + mpId, decision);
+  } catch {
+  }
+}
+function clearConsentDecision(mpId) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.removeItem(STORAGE_PREFIX + mpId);
+  } catch {
+  }
+}
+var inflightPrompt = null;
+async function promptForConsent(mpId, copy = {}) {
+  if (inflightPrompt) return inflightPrompt;
+  if (typeof document === "undefined" || typeof window === "undefined") {
+    return "denied";
+  }
+  const merged = {
+    title: copy.title ?? DEFAULT_COPY.title,
+    body: copy.body ?? DEFAULT_COPY.body,
+    acceptLabel: copy.acceptLabel ?? DEFAULT_COPY.acceptLabel,
+    declineLabel: copy.declineLabel ?? DEFAULT_COPY.declineLabel
+  };
+  inflightPrompt = new Promise((resolve) => {
+    injectStylesheet();
+    const overlay = buildOverlay(merged, (decision) => {
+      writeConsentDecision(mpId, decision);
+      try {
+        overlay.remove();
+      } catch {
+      }
+      inflightPrompt = null;
+      resolve(decision);
+    });
+    document.body.appendChild(overlay);
+  });
+  return inflightPrompt;
+}
+function injectStylesheet() {
+  if (document.getElementById(STYLE_ELEMENT_ID)) return;
+  const style = document.createElement("style");
+  style.id = STYLE_ELEMENT_ID;
+  style.textContent = `
+    .${CSS_PREFIX}-overlay {
+      position: fixed !important;
+      inset: 0 !important;
+      z-index: 2147483647 !important;
+      display: flex !important;
+      align-items: flex-end !important;
+      justify-content: center !important;
+      background: rgba(0, 0, 0, 0.45) !important;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI",
+                   Roboto, "Helvetica Neue", sans-serif !important;
+      animation: ${CSS_PREFIX}-fade-in 160ms ease-out !important;
+      box-sizing: border-box !important;
+      padding: 16px !important;
+    }
+    @media (min-width: 480px) {
+      .${CSS_PREFIX}-overlay {
+        align-items: center !important;
+      }
+    }
+    @keyframes ${CSS_PREFIX}-fade-in {
+      from { opacity: 0; }
+      to   { opacity: 1; }
+    }
+    .${CSS_PREFIX}-card {
+      background: #ffffff !important;
+      color: #0e1116 !important;
+      border-radius: 16px !important;
+      max-width: 420px !important;
+      width: 100% !important;
+      padding: 20px 20px 16px !important;
+      box-shadow: 0 12px 40px rgba(0, 0, 0, 0.18) !important;
+      box-sizing: border-box !important;
+    }
+    .${CSS_PREFIX}-title {
+      font-size: 17px !important;
+      font-weight: 600 !important;
+      margin: 0 0 12px !important;
+      line-height: 1.3 !important;
+    }
+    .${CSS_PREFIX}-body {
+      font-size: 14px !important;
+      line-height: 1.5 !important;
+      color: #4a5160 !important;
+      margin: 0 0 8px !important;
+    }
+    .${CSS_PREFIX}-actions {
+      display: flex !important;
+      justify-content: flex-end !important;
+      gap: 8px !important;
+      margin-top: 16px !important;
+    }
+    .${CSS_PREFIX}-btn {
+      font-family: inherit !important;
+      font-size: 14px !important;
+      font-weight: 500 !important;
+      padding: 9px 16px !important;
+      border-radius: 10px !important;
+      border: none !important;
+      cursor: pointer !important;
+      line-height: 1 !important;
+      min-height: 36px !important;
+      box-sizing: border-box !important;
+    }
+    .${CSS_PREFIX}-btn-decline {
+      background: transparent !important;
+      color: #4a5160 !important;
+    }
+    .${CSS_PREFIX}-btn-decline:hover {
+      background: #f3f4f6 !important;
+    }
+    .${CSS_PREFIX}-btn-accept {
+      background: #0066ff !important;
+      color: #ffffff !important;
+    }
+    .${CSS_PREFIX}-btn-accept:hover {
+      background: #0055d4 !important;
+    }
+    @media (prefers-color-scheme: dark) {
+      .${CSS_PREFIX}-card {
+        background: #1c1f24 !important;
+        color: #e8eaed !important;
+      }
+      .${CSS_PREFIX}-body {
+        color: #b9bec7 !important;
+      }
+      .${CSS_PREFIX}-btn-decline {
+        color: #b9bec7 !important;
+      }
+      .${CSS_PREFIX}-btn-decline:hover {
+        background: #2a2e35 !important;
+      }
+    }
+  `;
+  document.head.appendChild(style);
+}
+function buildOverlay(copy, onDecision) {
+  const overlay = document.createElement("div");
+  overlay.className = `${CSS_PREFIX}-overlay`;
+  overlay.setAttribute("role", "dialog");
+  overlay.setAttribute("aria-modal", "true");
+  overlay.setAttribute("aria-labelledby", `${CSS_PREFIX}-title`);
+  const card = document.createElement("div");
+  card.className = `${CSS_PREFIX}-card`;
+  const title = document.createElement("h2");
+  title.id = `${CSS_PREFIX}-title`;
+  title.className = `${CSS_PREFIX}-title`;
+  title.textContent = copy.title;
+  card.appendChild(title);
+  for (const para of copy.body) {
+    const p = document.createElement("p");
+    p.className = `${CSS_PREFIX}-body`;
+    p.textContent = para;
+    card.appendChild(p);
+  }
+  const actions = document.createElement("div");
+  actions.className = `${CSS_PREFIX}-actions`;
+  const declineBtn = document.createElement("button");
+  declineBtn.type = "button";
+  declineBtn.className = `${CSS_PREFIX}-btn ${CSS_PREFIX}-btn-decline`;
+  declineBtn.textContent = copy.declineLabel;
+  declineBtn.addEventListener("click", () => onDecision("denied"));
+  const acceptBtn = document.createElement("button");
+  acceptBtn.type = "button";
+  acceptBtn.className = `${CSS_PREFIX}-btn ${CSS_PREFIX}-btn-accept`;
+  acceptBtn.textContent = copy.acceptLabel;
+  acceptBtn.addEventListener("click", () => onDecision("granted"));
+  actions.appendChild(declineBtn);
+  actions.appendChild(acceptBtn);
+  card.appendChild(actions);
+  overlay.appendChild(card);
+  requestAnimationFrame(() => {
+    try {
+      acceptBtn.focus();
+    } catch {
+    }
+  });
+  return overlay;
+}
+
+// src/buffer.ts
+var RingBuffer = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.items = [];
+    this.dropped = 0;
+  }
+  push(event) {
+    if (this.items.length >= this.opts.capacity) {
+      this.items.shift();
+      this.dropped++;
+      this.opts.onDrop?.(1);
+    }
+    this.items.push(event);
+  }
+  drain(max) {
+    if (max >= this.items.length) {
+      const out = this.items;
+      this.items = [];
+      return out;
+    }
+    return this.items.splice(0, max);
+  }
+  size() {
+    return this.items.length;
+  }
+  droppedCount() {
+    return this.dropped;
+  }
+};
+
+// src/transport.ts
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_POLL_TIMEOUT_MS = 25e3;
+var DEFAULT_MIN_BACKOFF_MS = 2e3;
+var DEFAULT_MAX_BACKOFF_MS = 3e4;
+var Transport = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.timer = null;
+    this.inflightUpload = null;
+    this.inflightPoll = null;
+    this.commandLoopRunning = false;
+    this.stopped = false;
+    this.flushing = false;
+    this.internalFetch = typeof fetch === "function" ? fetch.bind(globalThis) : ((..._args) => {
+      throw new Error("[@botim/debug-sdk] fetch is not available in this environment");
+    });
+  }
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(
+      () => void this.flush().catch((err) => this.opts.onError?.(err)),
+      this.opts.flushIntervalMs
+    );
+  }
+  async flush() {
+    while (!this.stopped && this.opts.buffer.size() > 0) {
+      await this.flushOnce();
+    }
+  }
+  async flushOnce() {
+    if (this.flushing || this.opts.buffer.size() === 0) return;
+    this.flushing = true;
+    try {
+      const events = this.opts.buffer.drain(this.opts.maxBatchSize);
+      if (events.length === 0) return;
+      const batch = {
+        sessionToken: this.opts.deviceToken,
+        events
+      };
+      await this.send(batch, 0);
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async send(batch, attempt) {
+    if (this.stopped) return;
+    this.inflightUpload = new AbortController();
+    try {
+      const res = await this.internalFetch(this.opts.ingestUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.opts.deviceToken}`
+        },
+        body: JSON.stringify(batch),
+        signal: this.inflightUpload.signal
+      });
+      if (!res.ok) {
+        throw new Error(`ingest http ${res.status}`);
+      }
+    } catch (err) {
+      if (this.stopped) return;
+      const max = this.opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+      if (attempt >= max) {
+        this.opts.onError?.(err);
+        return;
+      }
+      const backoff = 250 * Math.pow(4, attempt);
+      await new Promise((r) => setTimeout(r, backoff));
+      return this.send(batch, attempt + 1);
+    } finally {
+      this.inflightUpload = null;
+    }
+  }
+  /**
+   * Start the AI command long-poll loop. Maintains AT MOST ONE in-flight
+   * request to `commandPollUrl` at any time. Errors are reported via
+   * `onError` and trigger exponential backoff. Stop with `transport.stop()`.
+   */
+  startCommandLoop(opts) {
+    if (this.commandLoopRunning) return;
+    this.commandLoopRunning = true;
+    const pollTimeout = opts.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+    const minBackoff = opts.minBackoffMs ?? DEFAULT_MIN_BACKOFF_MS;
+    const maxBackoff = opts.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+    let attempt = 0;
+    const loop = async () => {
+      while (!this.stopped) {
+        this.inflightPoll = new AbortController();
+        const timeoutId = setTimeout(() => {
+          this.inflightPoll?.abort();
+        }, pollTimeout);
+        try {
+          const res = await this.internalFetch(opts.commandPollUrl, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${this.opts.deviceToken}` },
+            signal: this.inflightPoll.signal
+          });
+          if (!res.ok) {
+            throw new Error(`command-poll http ${res.status}`);
+          }
+          if (res.status === 204) {
+            await sleep(minBackoff);
+            attempt = 0;
+            continue;
+          }
+          const json = await res.json();
+          attempt = 0;
+          for (const cmd of json.commands ?? []) {
+            try {
+              await opts.onCommand(cmd);
+            } catch (err) {
+              this.opts.onError?.(err);
+            }
+          }
+          if (typeof json.nextDelayMs === "number" && json.nextDelayMs > 0) {
+            await sleep(Math.min(json.nextDelayMs, maxBackoff));
+          }
+        } catch (err) {
+          if (this.stopped) return;
+          const aborted = err instanceof Error && (err.name === "AbortError" || /aborted/i.test(err.message));
+          if (!aborted) {
+            this.opts.onError?.(err);
+            attempt += 1;
+          } else {
+            attempt = 0;
+          }
+          const backoff = Math.min(
+            maxBackoff,
+            minBackoff * Math.pow(2, Math.max(0, attempt - 1))
+          );
+          await sleep(backoff);
+        } finally {
+          clearTimeout(timeoutId);
+          this.inflightPoll = null;
+        }
+      }
+    };
+    void loop();
+  }
+  async stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.opts.buffer.size() > 0) {
+      const events = this.opts.buffer.drain(this.opts.buffer.size());
+      const body = JSON.stringify({
+        sessionToken: this.opts.deviceToken,
+        events
+      });
+      const KEEPALIVE_BODY_LIMIT = 60 * 1024;
+      const useKeepalive = body.length <= KEEPALIVE_BODY_LIMIT;
+      try {
+        await this.internalFetch(this.opts.ingestUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.opts.deviceToken}`
+          },
+          body,
+          ...useKeepalive ? { keepalive: true } : {}
+        });
+      } catch (err) {
+        this.opts.onError?.(err);
+      }
+    }
+    this.stopped = true;
+    this.commandLoopRunning = false;
+    this.inflightUpload?.abort();
+    this.inflightPoll?.abort();
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/attach.ts
+async function attachDevice(endpoint, config, deviceInfo, consent, token) {
+  const base = endpoint.replace(/\/$/, "");
+  const url = `${base}/v1/attach`;
+  const body = {
+    miniProgramId: config.miniProgramId,
+    env: config.env,
+    buildSignature: config.buildSignature,
+    deviceInfo,
+    consent,
+    schemaVersion: SCHEMA_VERSION
+  };
+  const headers = { "Content-Type": "application/json" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(
+      `[@botim/debug-sdk] attach failed: ${res.status} ${res.statusText} ${text}`.trim()
+    );
+  }
+  const json = await res.json();
+  if (!json?.sid || !json?.deviceToken || !json?.ingestUrl || !json?.commandPollUrl) {
+    throw new Error("[@botim/debug-sdk] attach response missing required fields");
+  }
+  return {
+    ...json,
+    ingestUrl: resolveAgainstEndpoint(json.ingestUrl, base),
+    commandPollUrl: resolveAgainstEndpoint(json.commandPollUrl, base)
+  };
+}
+function resolveAgainstEndpoint(url, base) {
+  if (/^https?:\/\//i.test(url)) return url;
+  const path = url.startsWith("/") ? url : "/" + url;
+  return base + path;
+}
+function detectDeviceInfo(app, override) {
+  const ua = typeof navigator !== "undefined" ? navigator.userAgent : void 0;
+  return {
+    deviceId: override?.deviceId ?? loadOrCreateDeviceId(),
+    platform: override?.platform ?? detectPlatform(ua),
+    osVersion: override?.osVersion,
+    appName: override?.appName ?? app.name,
+    appVersion: override?.appVersion ?? app.version,
+    appBuild: override?.appBuild ?? app.build,
+    userAgent: override?.userAgent ?? ua
+  };
+}
+function detectPlatform(ua) {
+  if (!ua) return "unknown";
+  if (/Android/i.test(ua)) return "android";
+  if (/iPhone|iPad|iPod/i.test(ua)) return "ios";
+  if (/Mozilla|Chrome|Safari|Firefox/i.test(ua)) return "web";
+  return "unknown";
+}
+var DEVICE_ID_STORAGE_KEY = "botim-debug-sdk:device-id";
+function loadOrCreateDeviceId() {
+  try {
+    const ls = typeof localStorage !== "undefined" ? localStorage : null;
+    if (ls) {
+      const stored = ls.getItem(DEVICE_ID_STORAGE_KEY);
+      if (stored && stored.length > 0) return stored;
+      const fresh = generateDeviceId();
+      ls.setItem(DEVICE_ID_STORAGE_KEY, fresh);
+      return fresh;
+    }
+  } catch {
+  }
+  return generateDeviceId();
+}
+function generateDeviceId() {
+  const c = typeof crypto !== "undefined" ? crypto : void 0;
+  if (c?.randomUUID) return c.randomUUID();
+  return "dev-" + Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+// src/redact.ts
+var REDACTED = "[REDACTED]";
+function redactHeaders(headers, redactList) {
+  if (!headers) return headers;
+  const lower = new Set(redactList.map((h) => h.toLowerCase()));
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    out[k] = lower.has(k.toLowerCase()) ? REDACTED : v;
+  }
+  return out;
+}
+function redactBody(body, patterns, maxBytes) {
+  if (body === void 0) return { body: void 0, truncated: false };
+  let out = body;
+  for (const pat of patterns) {
+    if (pat.global) pat.lastIndex = 0;
+    out = out.replace(pat, REDACTED);
+  }
+  let truncated = false;
+  if (out.length > maxBytes) {
+    out = out.slice(0, maxBytes);
+    truncated = true;
+  }
+  return { body: out, truncated };
+}
+function headersFromInit(init) {
+  if (!init) return void 0;
+  const out = {};
+  if (init instanceof Headers) {
+    init.forEach((v, k) => out[k] = v);
+  } else if (Array.isArray(init)) {
+    for (const [k, v] of init) out[k] = v;
+  } else {
+    Object.assign(out, init);
+  }
+  return out;
+}
+function headersFromResponse(res) {
+  const out = {};
+  res.headers.forEach((v, k) => out[k] = v);
+  return out;
+}
+async function readBodyForCapture(body) {
+  if (body == null) return void 0;
+  if (typeof body === "string") return body;
+  if (body instanceof URLSearchParams) return body.toString();
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    try {
+      return new TextDecoder().decode(body);
+    } catch {
+      return "[binary]";
+    }
+  }
+  if (body instanceof Blob) {
+    try {
+      return await body.text();
+    } catch {
+      return "[blob]";
+    }
+  }
+  if (body instanceof FormData) {
+    const parts = [];
+    body.forEach((v, k) => parts.push(`${k}=${typeof v === "string" ? v : "[file]"}`));
+    return parts.join("&");
+  }
+  return void 0;
+}
+
+// src/serialize.ts
+var MAX_STRING_LEN = 2048;
+var MAX_OBJECT_BYTES = 4096;
+function serializeArg(value) {
+  if (value === void 0) return { k: "undefined" };
+  if (value === null) return { k: "primitive", v: null };
+  const t = typeof value;
+  if (t === "boolean" || t === "number") {
+    return { k: "primitive", v: value };
+  }
+  if (t === "bigint") {
+    return { k: "primitive", v: value.toString() + "n" };
+  }
+  if (t === "string") {
+    const s = value;
+    if (s.length > MAX_STRING_LEN) {
+      return { k: "string", v: s.slice(0, MAX_STRING_LEN), truncated: true };
+    }
+    return { k: "string", v: s };
+  }
+  if (t === "function") {
+    return { k: "function", name: value.name || void 0 };
+  }
+  if (value instanceof Error) {
+    return { k: "error", name: value.name, message: value.message, stack: value.stack };
+  }
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const json = JSON.stringify(value, function replacer(_k, v) {
+      if (typeof v === "bigint") return v.toString() + "n";
+      if (typeof v === "function") return `[Function: ${v.name || "anonymous"}]`;
+      if (typeof v === "object" && v !== null) {
+        if (seen.has(v)) return "[Circular]";
+        seen.add(v);
+      }
+      return v;
+    });
+    if (json === void 0) {
+      return { k: "unserializable", reason: "undefined-result" };
+    }
+    if (json.length > MAX_OBJECT_BYTES) {
+      return { k: "json", v: json.slice(0, MAX_OBJECT_BYTES), truncated: true };
+    }
+    return { k: "json", v: json };
+  } catch (err) {
+    return {
+      k: "unserializable",
+      reason: err instanceof Error ? err.message : "unknown"
+    };
+  }
+}
+
+// src/interceptors/console.ts
+var METHODS = ["log", "info", "warn", "error", "debug"];
+var LEVEL = {
+  log: "info",
+  info: "info",
+  warn: "warn",
+  error: "error",
+  debug: "debug"
+};
+function installConsoleInterceptor(opts) {
+  const originals = {};
+  let active = false;
+  for (const m of METHODS) {
+    const original = console[m];
+    originals[m] = original;
+    console[m] = function patched(...args) {
+      original.apply(console, args);
+      if (active) return;
+      if (opts.sample < 1 && Math.random() > opts.sample) return;
+      active = true;
+      try {
+        const payload = {
+          method: m,
+          args: args.map(serializeArg)
+        };
+        opts.emit(LEVEL[m], payload);
+      } catch {
+      } finally {
+        active = false;
+      }
+    };
+  }
+  return () => {
+    for (const m of METHODS) {
+      const original = originals[m];
+      if (original) {
+        console[m] = original;
+      }
+    }
+  };
+}
+
+// src/interceptors/errors.ts
+function installErrorInterceptor(opts) {
+  const target = resolveTarget();
+  if (!target) return () => {
+  };
+  const onError = (ev) => {
+    const e = ev;
+    const err = e.error;
+    opts.emit({
+      message: e.message || (err instanceof Error ? err.message : "unknown error"),
+      name: err instanceof Error ? err.name : void 0,
+      stack: err instanceof Error ? err.stack : void 0,
+      source: "window.error",
+      filename: e.filename,
+      lineno: e.lineno,
+      colno: e.colno
+    });
+  };
+  const onRejection = (ev) => {
+    const e = ev;
+    const reason = e.reason;
+    opts.emit({
+      message: reason instanceof Error ? reason.message : safeString(reason),
+      name: reason instanceof Error ? reason.name : void 0,
+      stack: reason instanceof Error ? reason.stack : void 0,
+      source: "unhandledrejection"
+    });
+  };
+  target.addEventListener("error", onError);
+  target.addEventListener("unhandledrejection", onRejection);
+  return () => {
+    target.removeEventListener("error", onError);
+    target.removeEventListener("unhandledrejection", onRejection);
+  };
+}
+function resolveTarget() {
+  const w = typeof window !== "undefined" ? window : globalThis;
+  if (w && typeof w.addEventListener === "function" && typeof w.removeEventListener === "function") {
+    return w;
+  }
+  return void 0;
+}
+function safeString(v) {
+  try {
+    return typeof v === "string" ? v : JSON.stringify(v) ?? String(v);
+  } catch {
+    return String(v);
+  }
+}
+
+// src/interceptors/network.ts
+function installNetworkInterceptor(opts) {
+  const restoreFetch = wrapFetch(opts);
+  const restoreXHR = wrapXHR(opts);
+  return () => {
+    restoreFetch();
+    restoreXHR();
+  };
+}
+function shouldSample(rate) {
+  return rate >= 1 || Math.random() < rate;
+}
+function newReqId() {
+  return "r_" + Math.random().toString(36).slice(2, 10);
+}
+function wrapFetch(opts) {
+  if (typeof fetch !== "function") return () => {
+  };
+  const original = fetch;
+  const target = globalThis;
+  target.fetch = async function patchedFetch(input, init) {
+    if (!shouldSample(opts.sample)) return original.call(this, input, init);
+    const reqId = newReqId();
+    const start = Date.now();
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    if (opts.shouldSkip && opts.shouldSkip(url, method)) {
+      return original.call(this, input, init);
+    }
+    let reqHeaders;
+    let reqBody;
+    try {
+      if (input instanceof Request) {
+        reqHeaders = headersFromResponse(input.clone());
+        reqBody = await input.clone().text().catch(() => void 0);
+      } else {
+        reqHeaders = headersFromInit(init?.headers);
+        reqBody = await readBodyForCapture(init?.body);
+      }
+    } catch {
+    }
+    opts.emit({ phase: "request", reqId, method, url, reqHeaders, reqBody });
+    try {
+      const res = await original.call(this, input, init);
+      let resBody;
+      try {
+        resBody = await res.clone().text();
+      } catch {
+        resBody = void 0;
+      }
+      opts.emit({
+        phase: "response",
+        reqId,
+        method,
+        url,
+        status: res.status,
+        // statusText carries the human label ("OK", "Not Found"). Pre-HTTP/2
+        // responses always have it; HTTP/2+ defines it as empty by spec but
+        // most browsers synthesize one from the code, so this is reliable
+        // enough to display alongside the status code.
+        statusText: res.statusText || void 0,
+        durationMs: Date.now() - start,
+        resHeaders: headersFromResponse(res),
+        resBody
+      });
+      return res;
+    } catch (err) {
+      opts.emit({
+        phase: "error",
+        reqId,
+        method,
+        url,
+        durationMs: Date.now() - start,
+        errorMessage: err instanceof Error ? err.message : String(err),
+        errorName: err instanceof Error ? err.name : void 0,
+        // Stack from the rejected promise — points into fetch internals
+        // and (when present) the call site that issued the request.
+        errorStack: err instanceof Error ? err.stack : void 0,
+        // undici frequently wraps the real reason in `cause` (e.g.
+        // `TypeError: fetch failed` outside, `Error: ECONNREFUSED` inside).
+        // Flatten the chain so operators don't have to dig.
+        errorCause: collectCauseChain(err)
+      });
+      throw err;
+    }
+  };
+  return () => {
+    target.fetch = original;
+  };
+}
+function collectCauseChain(err) {
+  if (!err || typeof err !== "object") return void 0;
+  const lines = [];
+  let cur = err.cause;
+  const seen = /* @__PURE__ */ new Set();
+  while (cur && lines.length < 5) {
+    if (seen.has(cur)) break;
+    seen.add(cur);
+    if (cur instanceof Error) {
+      lines.push(`${cur.name}: ${cur.message}`);
+      cur = cur.cause;
+    } else {
+      lines.push(String(cur));
+      cur = cur?.cause;
+    }
+  }
+  return lines.length ? lines.join("\n") : void 0;
+}
+function wrapXHR(opts) {
+  if (typeof XMLHttpRequest === "undefined") return () => {
+  };
+  const proto = XMLHttpRequest.prototype;
+  const states = /* @__PURE__ */ new WeakMap();
+  const origOpen = proto.open;
+  const origSend = proto.send;
+  const origSetReqHeader = proto.setRequestHeader;
+  proto.open = function patchedOpen(method, url, ...rest) {
+    const resolvedUrl = typeof url === "string" ? url : url.toString();
+    const upperMethod = method.toUpperCase();
+    const skipped = opts.shouldSkip ? opts.shouldSkip(resolvedUrl, upperMethod) : false;
+    const state = {
+      reqId: newReqId(),
+      start: 0,
+      method: upperMethod,
+      url: resolvedUrl,
+      reqHeaders: {},
+      sampled: !skipped && shouldSample(opts.sample)
+    };
+    states.set(this, state);
+    return origOpen.apply(this, [method, url, ...rest]);
+  };
+  proto.setRequestHeader = function patchedSetHeader(name, value) {
+    const s = states.get(this);
+    if (s) s.reqHeaders[name] = value;
+    return origSetReqHeader.call(this, name, value);
+  };
+  proto.send = function patchedSend(body) {
+    const s = states.get(this);
+    if (!s || !s.sampled) {
+      return origSend.apply(this, [body]);
+    }
+    s.start = Date.now();
+    s.reqBody = typeof body === "string" ? body : void 0;
+    const sendSiteStack = captureCallSiteStack();
+    opts.emit({
+      phase: "request",
+      reqId: s.reqId,
+      method: s.method,
+      url: s.url,
+      reqHeaders: s.reqHeaders,
+      reqBody: s.reqBody
+    });
+    const onLoad = () => {
+      const headers = parseXhrHeaders(this.getAllResponseHeaders());
+      const resBody = typeof this.response === "string" ? this.response : void 0;
+      opts.emit({
+        phase: "response",
+        reqId: s.reqId,
+        method: s.method,
+        url: s.url,
+        status: this.status,
+        // XHR exposes statusText directly; same display purpose as fetch.
+        statusText: this.statusText || void 0,
+        durationMs: Date.now() - s.start,
+        resHeaders: headers,
+        resBody
+      });
+    };
+    const onError = (kind) => () => {
+      opts.emit({
+        phase: "error",
+        reqId: s.reqId,
+        method: s.method,
+        url: s.url,
+        durationMs: Date.now() - s.start,
+        // Distinguish error/timeout/abort in the message — the standard
+        // XHR `statusText` is empty for `error` and unhelpful for the
+        // others, so we synthesise a clear label.
+        errorMessage: this.statusText || `xhr ${kind}`,
+        errorName: `XHR${kind[0].toUpperCase()}${kind.slice(1)}`,
+        errorStack: sendSiteStack
+      });
+    };
+    this.addEventListener("load", onLoad);
+    this.addEventListener("error", onError("error"));
+    this.addEventListener("timeout", onError("timeout"));
+    this.addEventListener("abort", onError("abort"));
+    return origSend.apply(this, [body]);
+  };
+  return () => {
+    proto.open = origOpen;
+    proto.send = origSend;
+    proto.setRequestHeader = origSetReqHeader;
+  };
+}
+function captureCallSiteStack() {
+  try {
+    throw new Error("xhr-callsite");
+  } catch (err) {
+    if (!(err instanceof Error) || !err.stack) return void 0;
+    const lines = err.stack.split("\n");
+    return lines.slice(2).join("\n") || void 0;
+  }
+}
+function parseXhrHeaders(raw) {
+  const out = {};
+  if (!raw) return out;
+  for (const line of raw.split(/\r?\n/)) {
+    const idx = line.indexOf(":");
+    if (idx < 0) continue;
+    const k = line.slice(0, idx).trim();
+    const v = line.slice(idx + 1).trim();
+    if (k) out[k] = v;
+  }
+  return out;
+}
+
+// src/commands/registry.ts
+var NAME_PATTERN = /^[a-z][a-z0-9-]{1,47}$/;
+var CommandRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.overrideListeners = [];
+  }
+  register(name, handler) {
+    if (typeof name !== "string" || !NAME_PATTERN.test(name)) {
+      throw new Error(
+        `[@botim/debug-sdk] invalid command name ${JSON.stringify(name)}; expected kebab-case matching ${NAME_PATTERN}`
+      );
+    }
+    if (typeof handler !== "function") {
+      throw new Error(`[@botim/debug-sdk] command "${name}" handler must be a function`);
+    }
+    const isOverride = this.handlers.has(name);
+    this.handlers.set(name, handler);
+    if (isOverride) {
+      for (const fn of this.overrideListeners) {
+        try {
+          fn(name);
+        } catch {
+        }
+      }
+    }
+  }
+  unregister(name) {
+    return this.handlers.delete(name);
+  }
+  has(name) {
+    return this.handlers.has(name);
+  }
+  /** Subscribe to override events; returns an unsubscribe fn. */
+  onOverride(fn) {
+    this.overrideListeners.push(fn);
+    return () => {
+      this.overrideListeners = this.overrideListeners.filter((f) => f !== fn);
+    };
+  }
+  /**
+   * Dispatch a single command. Never throws; returns a typed result.
+   * Caller is responsible for mapping the result onto an event envelope.
+   */
+  async dispatch(req, signal) {
+    const handler = this.handlers.get(req.name);
+    if (!handler) {
+      return {
+        kind: "rejected",
+        payload: { command: req.name, reason: "unknown-command" }
+      };
+    }
+    const start = Date.now();
+    try {
+      const args = req.args ?? {};
+      const result = await Promise.resolve(
+        handler(args, { commandId: req.id, command: req.name, signal })
+      );
+      return {
+        kind: "ack",
+        payload: {
+          command: req.name,
+          ok: true,
+          result,
+          durationMs: Date.now() - start
+        }
+      };
+    } catch (err) {
+      return {
+        kind: "rejected",
+        payload: {
+          command: req.name,
+          reason: "handler-threw",
+          details: err instanceof Error ? err.message : String(err)
+        }
+      };
+    }
+  }
+};
+var MAX_DUMP_BYTES = 64 * 1024;
+var MAX_SCREENSHOT_BYTES = 1024 * 1024;
+var MAX_EXEC_CODE_BYTES = 8 * 1024;
+var DEFAULT_EXEC_TIMEOUT_MS = 5e3;
+var MIN_EXEC_TIMEOUT_MS = 250;
+var MAX_EXEC_TIMEOUT_MS = 3e4;
+async function defaultDomScreenshot() {
+  if (typeof document === "undefined" || typeof window === "undefined") {
+    throw new Error(
+      "[@botim/debug-sdk] default screenshot requires a DOM. Provide builtins.screenshot for non-browser runtimes (e.g. native bridge)."
+    );
+  }
+  const injected = injectAdoptedStyleSheets();
+  let tree;
+  try {
+    tree = snapshot(document, {
+      inlineStylesheet: true,
+      inlineImages: true,
+      recordCanvas: true,
+      // Deliberately NOT slimming. SlimDOM drops <link rel="preload">,
+      // hidden form metadata, and other "noise" that's actually relevant
+      // when reproducing a layout bug.
+      slimDOM: false,
+      // Don't mask anything by default — debug-relay already runs a
+      // top-level redactor on console payloads, and on-screen text is the
+      // whole point of capturing a screenshot. Hosts that need PII masking
+      // can wire their own builtins.screenshot using rrweb-snapshot's
+      // `maskTextSelector` / `maskInputOptions`.
+      maskAllInputs: false
+    });
+  } finally {
+    for (const node of injected) {
+      try {
+        node.remove();
+      } catch {
+      }
+    }
+  }
+  if (!tree) {
+    throw new Error("[@botim/debug-sdk] rrweb-snapshot returned null tree");
+  }
+  const payload = {
+    snapshot: tree,
+    viewport: {
+      w: window.innerWidth || document.documentElement.clientWidth || 0,
+      h: window.innerHeight || document.documentElement.clientHeight || 0
+    },
+    url: location.href,
+    capturedAt: Date.now()
+  };
+  return {
+    data: JSON.stringify(payload),
+    format: "rrweb-snapshot"
+  };
+}
+function injectAdoptedStyleSheets() {
+  const injected = [];
+  const collect = (sheets) => {
+    if (!sheets || sheets.length === 0) return "";
+    const chunks = [];
+    for (const sheet of sheets) {
+      try {
+        const rules = sheet.cssRules;
+        for (const rule of Array.from(rules)) chunks.push(rule.cssText);
+      } catch {
+      }
+    }
+    return chunks.join("\n");
+  };
+  const inject = (parent, css) => {
+    if (!css) return;
+    const ownerDoc = parent instanceof Document ? parent : parent.ownerDocument;
+    if (!ownerDoc) return;
+    const style = ownerDoc.createElement("style");
+    style.setAttribute("data-botim-adopted", "1");
+    style.textContent = css;
+    const target = parent instanceof Document ? parent.head ?? parent.documentElement ?? parent.body : parent;
+    if (target) {
+      target.insertBefore(style, target.firstChild);
+      injected.push(style);
+    }
+  };
+  try {
+    inject(
+      document,
+      collect(document.adoptedStyleSheets)
+    );
+  } catch {
+  }
+  const walkRoot = (root) => {
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+    let n = walker.currentNode;
+    while (n) {
+      const el = n;
+      const sr = el.shadowRoot;
+      if (sr) {
+        try {
+          inject(
+            sr,
+            collect(sr.adoptedStyleSheets)
+          );
+        } catch {
+        }
+        walkRoot(sr);
+      }
+      n = walker.nextNode();
+    }
+  };
+  try {
+    walkRoot(document);
+  } catch {
+  }
+  return injected;
+}
+function registerBuiltins(registry, hooks = {}) {
+  registry.register("ping", ping);
+  registry.register("reload", makeReload(hooks.reload));
+  registry.register("dump-state", makeDumpState(hooks.getState));
+  registry.register("set-feature-flag", makeSetFlag(hooks.setFeatureFlag));
+  registry.register("screenshot", makeScreenshot(hooks.screenshot));
+  if (hooks.exec !== false) {
+    registry.register("exec", makeExec(hooks.exec ?? {}));
+  }
+}
+var ping = () => ({ ok: true, ts: Date.now() });
+function makeReload(reload) {
+  return async () => {
+    if (!reload) throw new Error("reload hook not registered by host");
+    await reload();
+    return { reloaded: true };
+  };
+}
+function makeDumpState(getState) {
+  return async () => {
+    if (!getState) throw new Error("getState hook not registered by host");
+    const snapshot = await getState();
+    const json = safeStringify(snapshot);
+    const truncated = json.length > MAX_DUMP_BYTES;
+    return {
+      state: truncated ? json.slice(0, MAX_DUMP_BYTES) : json,
+      truncated,
+      bytes: json.length
+    };
+  };
+}
+function makeSetFlag(setFeatureFlag) {
+  return async (args) => {
+    if (!setFeatureFlag) throw new Error("setFeatureFlag hook not registered by host");
+    const key = args.key;
+    if (typeof key !== "string" || key.length === 0) {
+      throw new Error("args.key must be a non-empty string");
+    }
+    if (!("value" in args)) {
+      throw new Error("args.value is required");
+    }
+    await setFeatureFlag(key, args.value);
+    return { applied: true, key };
+  };
+}
+function makeScreenshot(screenshot) {
+  const capture = screenshot ?? defaultDomScreenshot;
+  return async () => {
+    const result = await capture();
+    let data;
+    let format;
+    if (typeof result === "string") {
+      data = result;
+      format = "png-base64";
+    } else if (result && typeof result.data === "string") {
+      data = result.data;
+      format = result.format ?? "png-base64";
+    } else {
+      throw new Error(
+        "screenshot hook must return a base64 string or { data, format }"
+      );
+    }
+    if (data.length === 0) throw new Error("screenshot hook returned empty data");
+    if (data.length > MAX_SCREENSHOT_BYTES) {
+      throw new Error(
+        `screenshot ${data.length} bytes exceeds limit ${MAX_SCREENSHOT_BYTES}`
+      );
+    }
+    return { format, data, bytes: data.length };
+  };
+}
+var cachedBOT = void 0;
+function getBOT() {
+  if (cachedBOT !== void 0) return cachedBOT;
+  if (typeof window === "undefined") {
+    cachedBOT = null;
+    return null;
+  }
+  try {
+    const w = window;
+    if (w.BOT) {
+      cachedBOT = w.BOT;
+      return cachedBOT;
+    }
+  } catch {
+  }
+  try {
+    const w = window;
+    const ng = w.angular;
+    if (ng?.element && typeof document !== "undefined") {
+      const injector = ng.element(document).injector?.();
+      const bot = injector?.get?.("BOT");
+      if (bot != null) {
+        cachedBOT = bot;
+        return cachedBOT;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function makeExec(opts) {
+  const extraGlobalNames = Object.keys(opts.globals ?? {});
+  const extraGlobalValues = extraGlobalNames.map((k) => opts.globals[k]);
+  return async (args, ctx) => {
+    if (typeof args.code !== "string" || args.code.length === 0) {
+      throw new Error("args.code (non-empty string) is required");
+    }
+    if (args.code.length > MAX_EXEC_CODE_BYTES) {
+      throw new Error(`args.code ${args.code.length} bytes exceeds limit ${MAX_EXEC_CODE_BYTES}`);
+    }
+    const timeoutMs = clamp(
+      typeof args.timeoutMs === "number" ? args.timeoutMs : DEFAULT_EXEC_TIMEOUT_MS,
+      MIN_EXEC_TIMEOUT_MS,
+      MAX_EXEC_TIMEOUT_MS
+    );
+    const start = Date.now();
+    const logs = [];
+    const consoleMethods = ["log", "info", "warn", "error", "debug"];
+    const originals = {};
+    if (typeof console !== "undefined") {
+      for (const m of consoleMethods) {
+        const orig = console[m];
+        if (typeof orig !== "function") continue;
+        originals[m] = orig;
+        const captured = (...callArgs) => {
+          logs.push({ method: m, args: callArgs.map(execSafeClone), ts: Date.now() });
+          try {
+            orig.call(console, ...callArgs);
+          } catch {
+          }
+        };
+        console[m] = captured;
+      }
+    }
+    let value;
+    let threw = void 0;
+    try {
+      const AsyncFunction = Object.getPrototypeOf(async function() {
+      }).constructor;
+      const localNames = ["BOT", "window", "document", ...extraGlobalNames];
+      const localValues = [
+        getBOT(),
+        typeof window !== "undefined" ? window : void 0,
+        typeof document !== "undefined" ? document : void 0,
+        ...extraGlobalValues
+      ];
+      let fnTry = null;
+      try {
+        fnTry = new AsyncFunction(...localNames, `return (${args.code});`);
+      } catch (e) {
+        if (!(e instanceof SyntaxError)) throw e;
+      }
+      const fn = fnTry ?? new AsyncFunction(...localNames, args.code);
+      let timer = null;
+      let abortReject = null;
+      const onAbort = () => abortReject?.(new Error("exec cancelled"));
+      ctx.signal?.addEventListener?.("abort", onAbort);
+      try {
+        value = await Promise.race([
+          fn(...localValues),
+          new Promise((_, reject) => {
+            timer = setTimeout(
+              () => reject(new Error(`exec exceeded ${timeoutMs}ms`)),
+              timeoutMs
+            );
+          }),
+          new Promise((_, reject) => {
+            abortReject = reject;
+          })
+        ]);
+      } finally {
+        if (timer) clearTimeout(timer);
+        ctx.signal?.removeEventListener?.("abort", onAbort);
+      }
+    } catch (err) {
+      threw = err;
+    } finally {
+      if (typeof console !== "undefined") {
+        for (const m of consoleMethods) {
+          if (originals[m]) {
+            console[m] = originals[m];
+          }
+        }
+      }
+    }
+    if (threw !== void 0) {
+      const e = threw instanceof Error ? threw : new Error(String(threw));
+      const stackTruncated = typeof e.stack === "string" ? e.stack.split("\n").slice(0, 20).join("\n") : void 0;
+      const detail = {
+        name: e.name,
+        message: e.message,
+        stack: stackTruncated,
+        logs,
+        durationMs: Date.now() - start
+      };
+      const wrapped = new Error(JSON.stringify(detail));
+      wrapped.detail = detail;
+      throw wrapped;
+    }
+    return {
+      ok: true,
+      value: execSafeClone(value),
+      logs,
+      durationMs: Date.now() - start
+    };
+  };
+}
+function clamp(n, lo, hi) {
+  if (!Number.isFinite(n)) return lo;
+  return Math.min(Math.max(n, lo), hi);
+}
+function execSafeClone(v) {
+  try {
+    return JSON.parse(JSON.stringify(v, (_k, val) => {
+      if (typeof val === "function") {
+        return `[Function: ${val.name || "anonymous"}]`;
+      }
+      if (val instanceof Error) {
+        return { name: val.name, message: val.message, stack: val.stack };
+      }
+      if (typeof val === "bigint") return val.toString() + "n";
+      if (typeof val === "undefined") return null;
+      if (val && typeof val === "object" && val.nodeType === 1) {
+        const el = val;
+        return `[${el.tagName ?? "Element"}${el.id ? "#" + el.id : ""}]`;
+      }
+      return val;
+    }));
+  } catch {
+    return { __unserializable: typeof v };
+  }
+}
+function safeStringify(v) {
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(v, function replacer(_k, val) {
+      if (typeof val === "bigint") return val.toString() + "n";
+      if (typeof val === "function") return `[Function: ${val.name ?? "anonymous"}]`;
+      if (typeof val === "object" && val !== null) {
+        if (seen.has(val)) return "[Circular]";
+        seen.add(val);
+      }
+      return val;
+    }) ?? "";
+  } catch (err) {
+    return JSON.stringify({ __unserializable: err instanceof Error ? err.message : "unknown" });
+  }
+}
+
+// src/dedup.ts
+var DEFAULT_WINDOW_MS = 1e3;
+var DEFAULT_MAX_SIGNATURES = 500;
+var DEDUPED_TYPES = ["console", "network", "error"];
+var EventDeduper = class {
+  constructor(onSummary, opts = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.timer = null;
+    this.enabled = opts.enabled !== false;
+    this.windowMs = opts.windowMs ?? DEFAULT_WINDOW_MS;
+    this.maxSig = opts.maxSignatures ?? DEFAULT_MAX_SIGNATURES;
+    this.onSummary = onSummary;
+    if (this.enabled) {
+      this.timer = setInterval(() => this.sweep(Date.now()), Math.max(250, Math.floor(this.windowMs / 2)));
+    }
+  }
+  /**
+   * Returns true if the SDK should emit `ev` to the buffer; false if it's a
+   * duplicate within the current window and should be suppressed.
+   */
+  shouldEmit(ev) {
+    if (!this.enabled) return true;
+    if (!DEDUPED_TYPES.includes(ev.type)) return true;
+    const sig = this.signatureOf(ev);
+    const now = ev.ts;
+    const existing = this.entries.get(sig);
+    if (!existing) {
+      this.evictIfFull();
+      this.entries.set(sig, {
+        type: ev.type,
+        level: ev.level,
+        firstTs: now,
+        lastTs: now,
+        count: 1,
+        label: this.labelOf(ev),
+        lastPayload: ev.payload
+      });
+      return true;
+    }
+    if (now - existing.firstTs >= this.windowMs) {
+      if (existing.count > 1) this.emitSummary(sig, existing);
+      this.entries.set(sig, {
+        type: ev.type,
+        level: ev.level,
+        firstTs: now,
+        lastTs: now,
+        count: 1,
+        label: this.labelOf(ev),
+        lastPayload: ev.payload
+      });
+      return true;
+    }
+    existing.lastTs = now;
+    existing.count++;
+    existing.lastPayload = ev.payload;
+    return false;
+  }
+  /**
+   * Force-flush any pending rollups (e.g. before stop). After this returns,
+   * the internal map is empty.
+   */
+  flushAll() {
+    for (const [sig, e] of this.entries) {
+      if (e.count > 1) this.emitSummary(sig, e);
+    }
+    this.entries.clear();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.flushAll();
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  sweep(now) {
+    for (const [sig, e] of this.entries) {
+      if (now - e.firstTs >= this.windowMs) {
+        if (e.count > 1) this.emitSummary(sig, e);
+        this.entries.delete(sig);
+      }
+    }
+  }
+  emitSummary(sig, e) {
+    try {
+      this.onSummary({
+        signature: sig,
+        type: e.type,
+        level: e.level,
+        count: e.count - 1,
+        // first occurrence already emitted as a real event
+        firstTs: e.firstTs,
+        lastTs: e.lastTs,
+        label: e.label,
+        examplePayload: e.lastPayload
+      });
+    } catch {
+    }
+  }
+  evictIfFull() {
+    if (this.entries.size < this.maxSig) return;
+    const firstKey = this.entries.keys().next().value;
+    if (typeof firstKey === "string") {
+      const e = this.entries.get(firstKey);
+      if (e && e.count > 1) this.emitSummary(firstKey, e);
+      this.entries.delete(firstKey);
+    }
+  }
+  // ─── Signature & label generators ───────────────────────────────────────
+  // Signatures are STRUCTURAL: they identify "the same kind of event" rather
+  // than the same bytes. So `console.error("x" + Date.now())` collapses by
+  // method + first-token of args; an HTTP 500 on the same URL collapses
+  // regardless of body content.
+  signatureOf(ev) {
+    if (ev.type === "console") {
+      const p = ev.payload;
+      const args = (p.args || []).map(consoleArgToken).join(" ").slice(0, 240);
+      return `c:${p.method}:${args}`;
+    }
+    if (ev.type === "network") {
+      const p = ev.payload;
+      return `n:${p.phase}:${p.method}:${p.url}:${p.status ?? ""}:${p.errorName ?? ""}`;
+    }
+    if (ev.type === "error") {
+      const p = ev.payload;
+      return `e:${p.source}:${p.name ?? ""}:${(p.message ?? "").slice(0, 240)}`;
+    }
+    return `${ev.type}:${ev.level}`;
+  }
+  labelOf(ev) {
+    if (ev.type === "console") {
+      const p = ev.payload;
+      return `console.${p.method}: ${(p.args || []).map(consoleArgToken).join(" ").slice(0, 160)}`;
+    }
+    if (ev.type === "network") {
+      const p = ev.payload;
+      return `${p.method} ${p.url} (${p.phase}${p.status ? " " + p.status : ""})`;
+    }
+    if (ev.type === "error") {
+      const p = ev.payload;
+      return `${p.name ?? "Error"}: ${(p.message ?? "").slice(0, 160)}`;
+    }
+    return ev.type;
+  }
+};
+function consoleArgToken(a) {
+  switch (a.k) {
+    case "primitive":
+      return String(a.v);
+    case "string":
+    case "json":
+      return String(a.v).slice(0, 80);
+    case "error":
+      return `${a.name ?? "Error"}:${a.message ?? ""}`;
+    case "undefined":
+      return "undefined";
+    case "function":
+      return `[fn:${a.name ?? "?"}]`;
+    case "circular":
+      return "[Circular]";
+    case "unserializable":
+      return `[unser:${a.reason}]`;
+    default:
+      return "?";
+  }
+}
+
+// src/index.ts
+var DEFAULT_REDACT_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "proxy-authorization"
+];
+var DEFAULT_BODY_PATTERNS = [
+  /(?:bearer\s+)?[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/gi,
+  /[A-Za-z0-9_-]{40,}/g
+];
+var DEFAULT_MAX_BODY_BYTES = 4096;
+var DEFAULT_FLUSH_INTERVAL_MS = 4e3;
+var DEFAULT_BUFFER_SIZE = 1e3;
+var DEFAULT_MAX_BATCH_SIZE = 50;
+var NOOP_HANDLE = {
+  sid: null,
+  async flush() {
+  },
+  async stop() {
+  },
+  registerCommand() {
+  },
+  unregisterCommand() {
+    return false;
+  }
+};
+var defaultBotimConfig = null;
+function setDefaultBotimConfig(config) {
+  defaultBotimConfig = config;
+}
+function assertConsent(config, consent) {
+  if (config.env !== "prod") return;
+  const hasHostToken = typeof consent?.hostToken === "string" && consent.hostToken.length > 0;
+  const hasOptIn = consent?.userOptIn === true;
+  if (hasHostToken || hasOptIn) return;
+  throw new BotimConsentError(
+    "prod debug sessions require consent.hostToken or consent.userOptIn === true"
+  );
+}
+function assertConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new BotimConfigError(
+      'config is required \u2014 pass options.config, or register a default via "@botim/mp-debug-sdk/auto"',
+      { code: "config-missing" }
+    );
+  }
+  if (typeof config.miniProgramId !== "string" || config.miniProgramId.length === 0) {
+    throw new BotimConfigError("options.config.miniProgramId must be a non-empty string", {
+      code: "config-missing-field"
+    });
+  }
+  if (config.env !== "dev" && config.env !== "uat" && config.env !== "beta" && config.env !== "prod") {
+    throw new BotimConfigError(
+      `options.config.env must be one of dev|uat|beta|prod (got ${JSON.stringify(config.env)})`,
+      { code: "config-invalid-env" }
+    );
+  }
+}
+async function enableRemoteDebug(options) {
+  if (options.enabled === false) return NOOP_HANDLE;
+  if (!options.endpoint || typeof options.endpoint !== "string") {
+    throw new BotimConfigError(
+      'relay server URL is required \u2014 pass options.endpoint (e.g. "https://relay.example.com")',
+      { code: "endpoint-missing" }
+    );
+  }
+  const resolvedConfig = options.config ?? defaultBotimConfig;
+  if (!resolvedConfig) {
+    throw new BotimConfigError(
+      'no config provided and no default registered \u2014 import { enableRemoteDebug } from "@botim/mp-debug-sdk/auto" (Vite), or pass options.config',
+      { code: "config-missing" }
+    );
+  }
+  assertConfig(resolvedConfig);
+  const consentInput = options.consent ?? {};
+  const hasExplicitConsent = consentInput.userOptIn === true || typeof consentInput.hostToken === "string" && consentInput.hostToken.length > 0;
+  const promptDisabled = consentInput.promptUser === false;
+  const canPrompt = typeof document !== "undefined" && typeof window !== "undefined";
+  const shouldPrompt = !hasExplicitConsent && !promptDisabled && canPrompt;
+  if (shouldPrompt) {
+    const cached = readConsentDecision(resolvedConfig.miniProgramId);
+    let decision = cached;
+    if (decision === null) {
+      decision = await promptForConsent(
+        resolvedConfig.miniProgramId,
+        consentInput.promptCopy
+      );
+    }
+    if (decision === "denied") return NOOP_HANDLE;
+    options = {
+      ...options,
+      consent: { ...consentInput, userOptIn: true }
+    };
+  }
+  assertConsent(resolvedConfig, options.consent);
+  const onError = options.onError ?? (() => {
+  });
+  const app = options.app ?? {
+    name: resolvedConfig.appName ?? resolvedConfig.miniProgramId,
+    version: resolvedConfig.appVersion ?? "0.0.0"
+  };
+  const deviceInfo = detectDeviceInfo(app, options.device);
+  const consent = options.consent ?? {};
+  const session = await attachDevice(options.endpoint, resolvedConfig, deviceInfo, consent, options.token);
+  const buffer = new RingBuffer({
+    capacity: options.bufferSize ?? DEFAULT_BUFFER_SIZE
+  });
+  const transport = new Transport({
+    ingestUrl: session.ingestUrl,
+    deviceToken: session.deviceToken,
+    buffer,
+    flushIntervalMs: options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+    maxBatchSize: options.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE,
+    maxRetries: options.maxRetries,
+    onError
+  });
+  const registry = new CommandRegistry();
+  registerBuiltins(registry, options.builtins);
+  let seq = 0;
+  const baseMeta = {
+    appVersion: app.version,
+    build: app.build,
+    deviceId: deviceInfo.deviceId
+  };
+  const sampleConsole = options.sampling?.console ?? 1;
+  const sampleNetwork = options.sampling?.network ?? 1;
+  const redactHeaderList = options.redact?.headers ?? DEFAULT_REDACT_HEADERS;
+  const bodyPatterns = options.redact?.bodyPatterns ?? DEFAULT_BODY_PATTERNS;
+  const maxBodyBytes = options.redact?.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+  const redactNetwork = (p) => {
+    if (p.reqHeaders) p.reqHeaders = redactHeaders(p.reqHeaders, redactHeaderList);
+    if (p.resHeaders) p.resHeaders = redactHeaders(p.resHeaders, redactHeaderList);
+    if (p.reqBody !== void 0) {
+      const r = redactBody(p.reqBody, bodyPatterns, maxBodyBytes);
+      p.reqBody = r.body;
+      p.reqBodyTruncated = r.truncated;
+    }
+    if (p.resBody !== void 0) {
+      const r = redactBody(p.resBody, bodyPatterns, maxBodyBytes);
+      p.resBody = r.body;
+      p.resBodyTruncated = r.truncated;
+    }
+    return p;
+  };
+  const redactConsoleArgs = (p) => {
+    for (const arg of p.args) {
+      if (arg.k === "string" || arg.k === "json") {
+        const r = redactBody(arg.v, bodyPatterns, maxBodyBytes);
+        arg.v = r.body ?? "";
+        if (r.truncated) arg.truncated = true;
+      }
+    }
+    return p;
+  };
+  const deduper = options.dedup === false ? null : new EventDeduper((s) => {
+    const rollupPayload = s.type === "console" ? {
+      method: s.examplePayload?.method ?? "info",
+      args: [
+        {
+          k: "string",
+          v: `[dedup] ${s.label} \u2014 repeated ${s.count} more time${s.count === 1 ? "" : "s"} in ${s.lastTs - s.firstTs}ms`
+        }
+      ]
+    } : s.examplePayload;
+    const ev = {
+      v: SCHEMA_VERSION,
+      sid: session.sid,
+      seq: ++seq,
+      ts: s.lastTs,
+      type: s.type,
+      level: s.level,
+      payload: rollupPayload,
+      meta: {
+        ...baseMeta,
+        dedup: {
+          signature: s.signature,
+          count: s.count,
+          firstTs: s.firstTs,
+          lastTs: s.lastTs
+        }
+      }
+    };
+    buffer.push(ev);
+  }, options.dedup || void 0);
+  const pushOrSuppress = (ev) => {
+    if (!deduper || deduper.shouldEmit(ev)) buffer.push(ev);
+  };
+  const emitConsole = (level, payload) => {
+    const ev = {
+      v: SCHEMA_VERSION,
+      sid: session.sid,
+      seq: ++seq,
+      ts: Date.now(),
+      type: "console",
+      level,
+      payload: redactConsoleArgs(payload),
+      meta: baseMeta
+    };
+    pushOrSuppress(ev);
+  };
+  const emitError = (payload) => {
+    const ev = {
+      v: SCHEMA_VERSION,
+      sid: session.sid,
+      seq: ++seq,
+      ts: Date.now(),
+      type: "error",
+      level: "error",
+      payload,
+      meta: baseMeta
+    };
+    pushOrSuppress(ev);
+  };
+  const emitNetwork = (payload) => {
+    const ev = {
+      v: SCHEMA_VERSION,
+      sid: session.sid,
+      seq: ++seq,
+      ts: Date.now(),
+      type: "network",
+      level: payload.phase === "error" ? "error" : "info",
+      payload: redactNetwork(payload),
+      meta: baseMeta
+    };
+    pushOrSuppress(ev);
+  };
+  const emitCommandResult = (req, kind, payload) => {
+    const ev = {
+      v: SCHEMA_VERSION,
+      sid: session.sid,
+      seq: ++seq,
+      ts: Date.now(),
+      type: kind,
+      level: kind === "command-rejected" ? "warn" : "info",
+      payload,
+      meta: { ...baseMeta, commandId: req.id }
+    };
+    buffer.push(ev);
+  };
+  registry.onOverride((name) => {
+    emitCommandResult(
+      { id: "override-" + name + "-" + Date.now()},
+      "command-rejected",
+      { command: name, reason: "overridden" }
+    );
+  });
+  const uninstallConsole = installConsoleInterceptor({
+    emit: emitConsole,
+    sample: sampleConsole
+  });
+  const uninstallErrors = installErrorInterceptor({ emit: emitError });
+  const internalEndpoints = [session.ingestUrl, session.commandPollUrl];
+  const uninstallNetwork = installNetworkInterceptor({
+    emit: emitNetwork,
+    sample: sampleNetwork,
+    shouldSkip: (url) => internalEndpoints.some((ep) => ep && url.startsWith(ep))
+  });
+  transport.start();
+  transport.startCommandLoop({
+    commandPollUrl: session.commandPollUrl,
+    onCommand: async (req) => {
+      const ctl = new AbortController();
+      const result = await registry.dispatch(req, ctl.signal);
+      emitCommandResult(req, result.kind === "ack" ? "command-ack" : "command-rejected", result.payload);
+    }
+  });
+  return {
+    sid: session.sid,
+    async flush() {
+      await transport.flush();
+    },
+    async stop() {
+      uninstallConsole();
+      uninstallErrors();
+      uninstallNetwork();
+      if (deduper) deduper.stop();
+      await transport.stop();
+    },
+    registerCommand(name, handler) {
+      registry.register(name, handler);
+    },
+    unregisterCommand(name) {
+      return registry.unregister(name);
+    }
+  };
+}
+
+// src/auto.ts
+setDefaultBotimConfig(botimConfig);
+
+export { BotimConfigError, BotimConsentError, DEFAULT_BODY_PATTERNS, DEFAULT_BUFFER_SIZE, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_MAX_BATCH_SIZE, DEFAULT_MAX_BODY_BYTES, DEFAULT_REDACT_HEADERS, SCHEMA_VERSION, clearConsentDecision, enableRemoteDebug, getBOT, promptForConsent, readConsentDecision, setDefaultBotimConfig, writeConsentDecision };
+//# sourceMappingURL=auto.js.map
+//# sourceMappingURL=auto.js.map