@botim/mp-debug-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1375 @@
+// 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/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 = 500;
+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,
+        keepalive: true
+      });
+      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());
+      try {
+        await this.internalFetch(this.opts.ingestUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.opts.deviceToken}`
+          },
+          body: JSON.stringify({
+            sessionToken: this.opts.deviceToken,
+            events
+          }),
+          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) {
+  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 res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    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 ?? generateDeviceId(),
+    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";
+}
+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,
+        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
+      });
+      throw err;
+    }
+  };
+  return () => {
+    target.fetch = original;
+  };
+}
+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;
+    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,
+        durationMs: Date.now() - s.start,
+        resHeaders: headers,
+        resBody
+      });
+    };
+    const onError = () => {
+      opts.emit({
+        phase: "error",
+        reqId: s.reqId,
+        method: s.method,
+        url: s.url,
+        durationMs: Date.now() - s.start,
+        errorMessage: this.statusText || "xhr error"
+      });
+    };
+    this.addEventListener("load", onLoad);
+    this.addEventListener("error", onError);
+    this.addEventListener("timeout", onError);
+    this.addEventListener("abort", onError);
+    return origSend.apply(this, [body]);
+  };
+  return () => {
+    proto.open = origOpen;
+    proto.send = origSend;
+    proto.setRequestHeader = origSetReqHeader;
+  };
+}
+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)
+        }
+      };
+    }
+  }
+};
+
+// src/commands/builtins.ts
+var MAX_DUMP_BYTES = 64 * 1024;
+var MAX_SCREENSHOT_BYTES = 1024 * 1024;
+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)."
+    );
+  }
+  try {
+    return await captureViaSvgForeignObject();
+  } catch (err) {
+    try {
+      console.warn(
+        "[@botim/debug-sdk] SVG/canvas screenshot failed, falling back to HTML snapshot:",
+        err instanceof Error ? err.message : err
+      );
+    } catch {
+    }
+    return await captureViaHtmlSnapshot();
+  }
+}
+async function captureViaSvgForeignObject() {
+  const dpr = Math.min(window.devicePixelRatio || 1, 2);
+  const w = Math.max(1, Math.min(window.innerWidth || document.documentElement.clientWidth || 1024, 2400));
+  const h = Math.max(1, Math.min(document.documentElement.scrollHeight, 4e3));
+  const inlinedCss = readInlineableStyles();
+  const clone = document.documentElement.cloneNode(true);
+  clone.querySelectorAll('link[rel="stylesheet"]').forEach((el) => el.remove());
+  clone.querySelectorAll("script,noscript,template").forEach((el) => el.remove());
+  clone.querySelectorAll("canvas").forEach((el) => el.remove());
+  clone.querySelectorAll("img").forEach((img) => {
+    const src = img.getAttribute("src") || "";
+    if (src && /^(https?:|\/\/)/i.test(src)) {
+      try {
+        const u = new URL(src, location.href);
+        if (u.origin !== location.origin) img.remove();
+      } catch {
+        img.remove();
+      }
+    }
+  });
+  clone.querySelectorAll("*").forEach((el) => {
+    if (el.tagName.includes("-")) el.remove();
+  });
+  clone.setAttribute("xmlns", "http://www.w3.org/1999/xhtml");
+  const xs = new XMLSerializer();
+  const htmlStr = xs.serializeToString(clone);
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}"><foreignObject width="100%" height="100%">` + (inlinedCss ? `<style xmlns="http://www.w3.org/1999/xhtml">${escapeForXml(inlinedCss)}</style>` : "") + htmlStr + `</foreignObject></svg>`;
+  const blobUrl = URL.createObjectURL(
+    new Blob([svg], { type: "image/svg+xml;charset=utf-8" })
+  );
+  try {
+    const img = await loadImage(blobUrl);
+    const canvas = document.createElement("canvas");
+    canvas.width = w * dpr;
+    canvas.height = h * dpr;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("canvas 2D context unavailable");
+    const pageBg = getComputedStyle(document.body).backgroundColor || "#ffffff";
+    ctx.fillStyle = pageBg.startsWith("rgba(0, 0, 0, 0)") ? "#ffffff" : pageBg;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+    const dataUrl = canvas.toDataURL("image/jpeg", 0.85);
+    return { data: dataUrl.split(",")[1], format: "jpeg-base64" };
+  } finally {
+    URL.revokeObjectURL(blobUrl);
+  }
+}
+function loadImage(src) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.crossOrigin = "anonymous";
+    img.onload = () => resolve(img);
+    img.onerror = () => reject(new Error("failed to render snapshot SVG"));
+    img.src = src;
+  });
+}
+function escapeForXml(s) {
+  return s.replace(/]]>/g, "]]&gt;").replace(/<\//g, "&lt;/");
+}
+function readInlineableStyles() {
+  const chunks = [];
+  for (const sheet of Array.from(document.styleSheets)) {
+    try {
+      const rules = sheet.cssRules;
+      for (const rule of Array.from(rules)) chunks.push(rule.cssText);
+    } catch {
+    }
+  }
+  return chunks.join("\n");
+}
+async function captureViaHtmlSnapshot() {
+  const inlinedCss = readInlineableStyles();
+  const clone = document.documentElement.cloneNode(true);
+  clone.querySelectorAll('link[rel="stylesheet"]').forEach((el) => el.remove());
+  clone.querySelectorAll("script").forEach((el) => el.remove());
+  const head = clone.querySelector("head");
+  if (head && inlinedCss) {
+    const styleEl = document.createElement("style");
+    styleEl.setAttribute("data-botim-snapshot", "1");
+    styleEl.textContent = inlinedCss;
+    head.insertBefore(styleEl, head.firstChild);
+  }
+  const html = "<!DOCTYPE html>\n" + clone.outerHTML;
+  return {
+    data: JSON.stringify({
+      html,
+      viewport: { w: window.innerWidth, h: window.innerHeight },
+      url: location.href,
+      capturedAt: Date.now()
+    }),
+    format: "html-snapshot"
+  };
+}
+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));
+}
+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 };
+  };
+}
+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 = 8e3;
+var DEFAULT_BUFFER_SIZE = 1e3;
+var DEFAULT_MAX_BATCH_SIZE = 50;
+var NOOP_HANDLE = {
+  sid: null,
+  async flush() {
+  },
+  async stop() {
+  },
+  registerCommand() {
+  },
+  unregisterCommand() {
+    return false;
+  }
+};
+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(
+      'options.config is required (import botimConfig from "virtual:botim/config")',
+      { 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;
+  assertConfig(options.config);
+  assertConsent(options.config, options.consent);
+  const onError = options.onError ?? (() => {
+  });
+  const app = options.app ?? {
+    name: options.config.appName ?? options.config.miniProgramId,
+    version: options.config.appVersion ?? "0.0.0"
+  };
+  const deviceInfo = detectDeviceInfo(app, options.device);
+  const consent = options.consent ?? {};
+  const session = await attachDevice(options.endpoint, options.config, deviceInfo, consent);
+  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);
+    }
+  };
+}
+
+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, enableRemoteDebug };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map