@techts/sdk 3.0.2

package/dist/index.js

@@ -0,0 +1,708 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DebuggerSDK: () => DebuggerSDK
+});
+module.exports = __toCommonJS(index_exports);
+var DebuggerSDK = class {
+  constructor(config) {
+    this.queue = [];
+    this.batchTimer = null;
+    this.metricsTimer = null;
+    this.navigationCount = 0;
+    this.errorCount = 0;
+    this.networkFailCount = 0;
+    this.longTaskCount = 0;
+    this.originalFetch = null;
+    this.originalXhrOpen = null;
+    this.originalXhrSend = null;
+    this.originalWsConstructor = null;
+    this.config = {
+      platform: "Browser",
+      version: "1.0.0",
+      batchInterval: 2e3,
+      maxBatchSize: 50,
+      captureConsole: true,
+      captureErrors: true,
+      captureNetwork: true,
+      captureResources: true,
+      captureWebVitals: true,
+      captureLongTasks: true,
+      captureNavigation: true,
+      captureVisibility: true,
+      captureCSP: true,
+      captureWebSockets: true,
+      slowRequestThresholdMs: 3e3,
+      metricsInterval: 3e4,
+      sessionId: "",
+      userId: "",
+      ...config
+    };
+    this.sessionId = this.config.sessionId || this.generateSessionId();
+    this.pageLoadTime = performance.now();
+    this.originalConsole = {};
+    for (const m of ["log", "warn", "error", "debug", "info", "trace", "assert"]) {
+      this.originalConsole[m] = console[m]?.bind(console);
+    }
+    if (this.config.captureConsole) this.interceptConsole();
+    if (this.config.captureErrors) this.captureGlobalErrors();
+    if (this.config.captureNetwork) this.interceptNetwork();
+    if (this.config.captureResources) this.captureResourceErrors();
+    if (this.config.captureWebVitals) this.captureWebVitals();
+    if (this.config.captureLongTasks) this.captureLongTasks();
+    if (this.config.captureNavigation) this.captureNavigation();
+    if (this.config.captureVisibility) this.captureVisibilityChanges();
+    if (this.config.captureCSP) this.captureCSPViolations();
+    if (this.config.captureWebSockets) this.interceptWebSockets();
+    this.batchTimer = setInterval(() => this.flush(), this.config.batchInterval);
+    if (this.config.metricsInterval > 0) {
+      this.metricsTimer = setInterval(
+        () => this.collectBrowserMetrics(),
+        this.config.metricsInterval
+      );
+    }
+    this.heartbeat();
+    this.log("info", `debugger.help SDK v3 initialized (session: ${this.sessionId})`, {
+      userAgent: navigator.userAgent,
+      url: location.href,
+      viewport: `${innerWidth}x${innerHeight}`,
+      devicePixelRatio,
+      language: navigator.language,
+      cookiesEnabled: navigator.cookieEnabled,
+      onLine: navigator.onLine
+    });
+    if (typeof window !== "undefined") {
+      window.addEventListener("beforeunload", () => this.flush());
+      window.addEventListener("online", () => this.log("info", "Network: back online"));
+      window.addEventListener("offline", () => this.log("warn", "Network: went offline"));
+    }
+  }
+  // ── Public API ───────────────────────────────────────────
+  log(level, message, context) {
+    this.enqueue({
+      type: "log",
+      level,
+      message,
+      context: { ...context, sessionId: this.sessionId, userId: this.config.userId || void 0 }
+    });
+  }
+  debug(msg, ctx) {
+    this.log("debug", msg, ctx);
+  }
+  info(msg, ctx) {
+    this.log("info", msg, ctx);
+  }
+  warn(msg, ctx) {
+    this.log("warn", msg, ctx);
+  }
+  error(msg, ctx) {
+    this.log("error", msg, ctx);
+  }
+  critical(msg, ctx) {
+    this.log("critical", msg, ctx);
+  }
+  captureError(err, context) {
+    this.errorCount++;
+    this.enqueue({
+      type: "error",
+      title: err.message,
+      stackTrace: err.stack || "",
+      context: {
+        name: err.name,
+        sessionId: this.sessionId,
+        userId: this.config.userId || void 0,
+        errorCount: this.errorCount,
+        ...context
+      }
+    });
+  }
+  /**
+   * Capture React error boundary errors.
+   * Call from componentDidCatch or ErrorBoundary fallback.
+   */
+  captureReactError(error, errorInfo) {
+    this.captureError(error, {
+      capturedFrom: "react_error_boundary",
+      componentStack: errorInfo.componentStack?.slice(0, 3e3)
+    });
+  }
+  metric(data) {
+    this.enqueue({
+      type: "metric",
+      ...data,
+      custom: { ...data.custom || {}, sessionId: this.sessionId }
+    });
+  }
+  inspect(variables) {
+    this.enqueue({ type: "inspect", variables });
+  }
+  heartbeat() {
+    this.enqueue({ type: "heartbeat" });
+  }
+  setUserId(userId) {
+    this.config.userId = userId;
+    this.log("info", `User identified: ${userId}`);
+  }
+  /**
+   * Track image generation results from the frontend
+   */
+  captureImageGenResult(jobId, model, params, result, error, durationMs) {
+    const ctx = { jobId, model, params, durationMs };
+    if (error) {
+      this.enqueue({
+        type: "error",
+        title: `Image gen failed: ${model} \u2014 ${error}`,
+        context: { ...ctx, capturedFrom: "image_gen" }
+      });
+    } else {
+      this.log("info", `Image gen complete: ${model} (${durationMs}ms)`, {
+        ...ctx,
+        result,
+        capturedFrom: "image_gen"
+      });
+    }
+  }
+  // ── Console Interception ─────────────────────────────────
+  interceptConsole() {
+    const self = this;
+    const levelMap = {
+      log: "info",
+      info: "info",
+      warn: "warn",
+      error: "error",
+      debug: "debug",
+      trace: "debug"
+    };
+    for (const [method, level] of Object.entries(levelMap)) {
+      const original = self.originalConsole[method];
+      if (!original) continue;
+      console[method] = function(...args) {
+        original(...args);
+        const message = args.map((a) => {
+          if (a instanceof Error) return `${a.name}: ${a.message}
+${a.stack}`;
+          if (typeof a === "object") {
+            try {
+              return JSON.stringify(a, null, 0);
+            } catch {
+              return String(a);
+            }
+          }
+          return String(a);
+        }).join(" ");
+        self.enqueue({
+          type: "log",
+          level,
+          message: `[console.${method}] ${message.slice(0, 3e3)}`,
+          context: { capturedFrom: "console", sessionId: self.sessionId }
+        });
+      };
+    }
+    const origAssert = self.originalConsole.assert;
+    if (origAssert) {
+      console.assert = function(condition, ...args) {
+        origAssert(condition, ...args);
+        if (!condition) {
+          const message = args.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ");
+          self.enqueue({
+            type: "error",
+            title: `Assertion failed: ${message.slice(0, 500)}`,
+            context: { capturedFrom: "console.assert", sessionId: self.sessionId }
+          });
+        }
+      };
+    }
+  }
+  // ── Global Error Capture ─────────────────────────────────
+  captureGlobalErrors() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("error", (event) => {
+      if (event.target && event.target.tagName) return;
+      this.captureError(event.error || new Error(event.message), {
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+        capturedFrom: "window.onerror"
+      });
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+      const err = event.reason instanceof Error ? event.reason : new Error(String(event.reason));
+      this.captureError(err, { capturedFrom: "unhandledrejection" });
+    });
+  }
+  // ── Resource Error Capture ───────────────────────────────
+  captureResourceErrors() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("error", (event) => {
+      const target = event.target;
+      if (!target?.tagName) return;
+      const tag = target.tagName.toLowerCase();
+      const src = target.src || target.href || target.src;
+      if (src) {
+        this.enqueue({
+          type: "error",
+          title: `Resource failed to load: <${tag}> ${src}`,
+          context: {
+            capturedFrom: "resource_error",
+            tagName: tag,
+            src,
+            sessionId: this.sessionId
+          }
+        });
+      }
+    }, true);
+  }
+  // ── Network Interception (Fetch + XHR) ───────────────────
+  interceptNetwork() {
+    if (typeof window === "undefined") return;
+    this.interceptFetch();
+    this.interceptXHR();
+  }
+  interceptFetch() {
+    if (typeof fetch === "undefined") return;
+    this.originalFetch = fetch.bind(window);
+    const self = this;
+    const originalFetch = this.originalFetch;
+    window.fetch = async function(input, init) {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      const method = init?.method || "GET";
+      const start = performance.now();
+      try {
+        const response = await originalFetch(input, init);
+        const duration = Math.round(performance.now() - start);
+        if (!url.includes("/ingest") && !url.includes("/debug")) {
+          if (response.status >= 400) {
+            self.networkFailCount++;
+            let responseBody = "";
+            try {
+              const cloned = response.clone();
+              responseBody = (await cloned.text()).slice(0, 1e3);
+            } catch {
+            }
+            self.enqueue({
+              type: response.status >= 500 ? "error" : "log",
+              ...response.status >= 500 ? { title: `[fetch] ${method} ${url} \u2192 ${response.status}` } : {},
+              level: response.status >= 500 ? "error" : "warn",
+              message: `[fetch] ${method} ${url} \u2192 ${response.status} (${duration}ms)`,
+              context: {
+                capturedFrom: "fetch",
+                url,
+                method,
+                status: response.status,
+                statusText: response.statusText,
+                duration,
+                responseBody,
+                requestHeaders: self.sanitizeHeaders(init?.headers),
+                sessionId: self.sessionId
+              }
+            });
+          } else if (duration > self.config.slowRequestThresholdMs) {
+            self.log("warn", `[fetch] Slow request: ${method} ${url} (${duration}ms)`, {
+              capturedFrom: "fetch",
+              url,
+              method,
+              status: response.status,
+              duration
+            });
+          }
+        }
+        return response;
+      } catch (err) {
+        const duration = Math.round(performance.now() - start);
+        if (!url.includes("/ingest") && !url.includes("/debug")) {
+          self.networkFailCount++;
+          self.enqueue({
+            type: "error",
+            title: `Network request failed: ${method} ${url}`,
+            stackTrace: err instanceof Error ? err.stack || "" : "",
+            context: {
+              capturedFrom: "fetch",
+              url,
+              method,
+              duration,
+              errorMessage: err instanceof Error ? err.message : String(err),
+              sessionId: self.sessionId
+            }
+          });
+        }
+        throw err;
+      }
+    };
+  }
+  interceptXHR() {
+    if (typeof XMLHttpRequest === "undefined") return;
+    const self = this;
+    const origOpen = XMLHttpRequest.prototype.open;
+    const origSend = XMLHttpRequest.prototype.send;
+    this.originalXhrOpen = origOpen;
+    this.originalXhrSend = origSend;
+    XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+      this.__ys_method = method;
+      this.__ys_url = typeof url === "string" ? url : url.href;
+      return origOpen.apply(this, [method, url, ...rest]);
+    };
+    XMLHttpRequest.prototype.send = function(body) {
+      const xhrUrl = this.__ys_url;
+      const xhrMethod = this.__ys_method;
+      if (xhrUrl?.includes("/ingest") || xhrUrl?.includes("/debug")) {
+        return origSend.call(this, body);
+      }
+      const start = performance.now();
+      this.addEventListener("loadend", function() {
+        const duration = Math.round(performance.now() - start);
+        if (this.status >= 400) {
+          self.networkFailCount++;
+          self.enqueue({
+            type: this.status >= 500 ? "error" : "log",
+            ...this.status >= 500 ? { title: `[xhr] ${xhrMethod} ${xhrUrl} \u2192 ${this.status}` } : {},
+            level: this.status >= 500 ? "error" : "warn",
+            message: `[xhr] ${xhrMethod} ${xhrUrl} \u2192 ${this.status} (${duration}ms)`,
+            context: {
+              capturedFrom: "xhr",
+              url: xhrUrl,
+              method: xhrMethod,
+              status: this.status,
+              duration,
+              responseBody: (this.responseText || "").slice(0, 500),
+              sessionId: self.sessionId
+            }
+          });
+        } else if (duration > self.config.slowRequestThresholdMs) {
+          self.log("warn", `[xhr] Slow request: ${xhrMethod} ${xhrUrl} (${duration}ms)`, {
+            capturedFrom: "xhr",
+            url: xhrUrl,
+            method: xhrMethod,
+            status: this.status,
+            duration
+          });
+        }
+      });
+      this.addEventListener("error", function() {
+        self.networkFailCount++;
+        self.enqueue({
+          type: "error",
+          title: `XHR request failed: ${xhrMethod} ${xhrUrl}`,
+          context: { capturedFrom: "xhr", url: xhrUrl, method: xhrMethod, sessionId: self.sessionId }
+        });
+      });
+      return origSend.call(this, body);
+    };
+  }
+  // ── Web Vitals ───────────────────────────────────────────
+  captureWebVitals() {
+    if (typeof PerformanceObserver === "undefined") return;
+    try {
+      const lcpObserver = new PerformanceObserver((list) => {
+        const entries = list.getEntries();
+        const last = entries[entries.length - 1];
+        if (last) {
+          this.log("info", `[perf] LCP: ${Math.round(last.startTime)}ms`, {
+            capturedFrom: "web_vitals",
+            metric: "LCP",
+            value: Math.round(last.startTime),
+            element: last.element?.tagName
+          });
+        }
+      });
+      lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+    } catch {
+    }
+    try {
+      const fidObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const fid = entry.processingStart - entry.startTime;
+          this.log("info", `[perf] FID: ${Math.round(fid)}ms`, {
+            capturedFrom: "web_vitals",
+            metric: "FID",
+            value: Math.round(fid)
+          });
+        }
+      });
+      fidObserver.observe({ type: "first-input", buffered: true });
+    } catch {
+    }
+    try {
+      let clsValue = 0;
+      const clsObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          if (!entry.hadRecentInput) {
+            clsValue += entry.value;
+          }
+        }
+      });
+      clsObserver.observe({ type: "layout-shift", buffered: true });
+      if (typeof document !== "undefined") {
+        document.addEventListener("visibilitychange", () => {
+          if (document.visibilityState === "hidden") {
+            this.log("info", `[perf] CLS: ${clsValue.toFixed(4)}`, {
+              capturedFrom: "web_vitals",
+              metric: "CLS",
+              value: clsValue
+            });
+          }
+        });
+      }
+    } catch {
+    }
+    try {
+      const fcpObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          if (entry.name === "first-contentful-paint") {
+            this.log("info", `[perf] FCP: ${Math.round(entry.startTime)}ms`, {
+              capturedFrom: "web_vitals",
+              metric: "FCP",
+              value: Math.round(entry.startTime)
+            });
+          }
+        }
+      });
+      fcpObserver.observe({ type: "paint", buffered: true });
+    } catch {
+    }
+    try {
+      const nav = performance.getEntriesByType("navigation")[0];
+      if (nav) {
+        const ttfb = Math.round(nav.responseStart - nav.requestStart);
+        this.log("info", `[perf] TTFB: ${ttfb}ms`, {
+          capturedFrom: "web_vitals",
+          metric: "TTFB",
+          value: ttfb
+        });
+      }
+    } catch {
+    }
+  }
+  // ── Long Tasks ───────────────────────────────────────────
+  captureLongTasks() {
+    if (typeof PerformanceObserver === "undefined") return;
+    try {
+      const observer = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          this.longTaskCount++;
+          if (entry.duration > 100) {
+            this.log("warn", `[perf] Long task: ${Math.round(entry.duration)}ms`, {
+              capturedFrom: "long_task",
+              duration: Math.round(entry.duration),
+              startTime: Math.round(entry.startTime),
+              longTaskCount: this.longTaskCount
+            });
+          }
+        }
+      });
+      observer.observe({ type: "longtask", buffered: true });
+    } catch {
+    }
+  }
+  // ── Navigation Tracking ──────────────────────────────────
+  captureNavigation() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("popstate", () => {
+      this.navigationCount++;
+      this.log("info", `[nav] popstate \u2192 ${location.href}`, {
+        capturedFrom: "navigation",
+        type: "popstate",
+        navigationCount: this.navigationCount
+      });
+    });
+    const origPush = history.pushState.bind(history);
+    const origReplace = history.replaceState.bind(history);
+    const self = this;
+    history.pushState = function(...args) {
+      origPush(...args);
+      self.navigationCount++;
+      self.log("info", `[nav] pushState \u2192 ${location.href}`, {
+        capturedFrom: "navigation",
+        type: "pushState",
+        navigationCount: self.navigationCount
+      });
+    };
+    history.replaceState = function(...args) {
+      origReplace(...args);
+      self.log("info", `[nav] replaceState \u2192 ${location.href}`, {
+        capturedFrom: "navigation",
+        type: "replaceState"
+      });
+    };
+  }
+  // ── Visibility Changes ───────────────────────────────────
+  captureVisibilityChanges() {
+    if (typeof document === "undefined") return;
+    document.addEventListener("visibilitychange", () => {
+      const state = document.visibilityState;
+      this.log("info", `[visibility] Tab ${state}`, {
+        capturedFrom: "visibility",
+        state,
+        hiddenDuration: state === "visible" ? Math.round(performance.now() - this.pageLoadTime) : void 0
+      });
+    });
+  }
+  // ── CSP Violations ───────────────────────────────────────
+  captureCSPViolations() {
+    if (typeof document === "undefined") return;
+    document.addEventListener("securitypolicyviolation", (e) => {
+      this.enqueue({
+        type: "error",
+        title: `CSP violation: ${e.violatedDirective}`,
+        context: {
+          capturedFrom: "csp_violation",
+          blockedURI: e.blockedURI,
+          violatedDirective: e.violatedDirective,
+          effectiveDirective: e.effectiveDirective,
+          originalPolicy: e.originalPolicy?.slice(0, 500),
+          sourceFile: e.sourceFile,
+          lineNumber: e.lineNumber,
+          sessionId: this.sessionId
+        }
+      });
+    });
+  }
+  // ── WebSocket Interception ───────────────────────────────
+  interceptWebSockets() {
+    if (typeof WebSocket === "undefined") return;
+    const self = this;
+    const OriginalWebSocket = WebSocket;
+    this.originalWsConstructor = OriginalWebSocket;
+    window.WebSocket = function(url, protocols) {
+      const ws = new OriginalWebSocket(url, protocols);
+      const wsUrl = typeof url === "string" ? url : url.href;
+      ws.addEventListener("error", () => {
+        self.enqueue({
+          type: "error",
+          title: `WebSocket error: ${wsUrl}`,
+          context: { capturedFrom: "websocket", url: wsUrl, readyState: ws.readyState }
+        });
+      });
+      ws.addEventListener("close", (event) => {
+        if (!event.wasClean) {
+          self.log("warn", `[ws] Unclean close: ${wsUrl} (code: ${event.code})`, {
+            capturedFrom: "websocket",
+            url: wsUrl,
+            code: event.code,
+            reason: event.reason
+          });
+        }
+      });
+      return ws;
+    };
+    window.WebSocket.prototype = OriginalWebSocket.prototype;
+    window.WebSocket.CONNECTING = OriginalWebSocket.CONNECTING;
+    window.WebSocket.OPEN = OriginalWebSocket.OPEN;
+    window.WebSocket.CLOSING = OriginalWebSocket.CLOSING;
+    window.WebSocket.CLOSED = OriginalWebSocket.CLOSED;
+  }
+  // ── Browser Metrics ──────────────────────────────────────
+  collectBrowserMetrics() {
+    if (typeof window === "undefined") return;
+    const perf = performance;
+    const memory = perf.memory ? {
+      usedJSHeapSize: Math.round(perf.memory.usedJSHeapSize / 1e6),
+      totalJSHeapSize: Math.round(perf.memory.totalJSHeapSize / 1e6),
+      jsHeapSizeLimit: Math.round(perf.memory.jsHeapSizeLimit / 1e6)
+    } : null;
+    const nav = performance.getEntriesByType("navigation")[0];
+    const domNodeCount = document.querySelectorAll("*").length;
+    const resourceEntries = performance.getEntriesByType("resource");
+    const failedResources = resourceEntries.filter((e) => e.transferSize === 0 && e.decodedBodySize === 0);
+    this.metric({
+      memory: memory?.usedJSHeapSize ?? null,
+      custom: {
+        ...memory || {},
+        loadTime: nav ? Math.round(nav.loadEventEnd - nav.startTime) : null,
+        domInteractive: nav ? Math.round(nav.domInteractive - nav.startTime) : null,
+        domContentLoaded: nav ? Math.round(nav.domContentLoadedEventEnd - nav.startTime) : null,
+        domNodeCount,
+        resourceCount: resourceEntries.length,
+        failedResourceCount: failedResources.length,
+        url: location.href,
+        sessionId: this.sessionId,
+        errorCount: this.errorCount,
+        networkFailCount: this.networkFailCount,
+        longTaskCount: this.longTaskCount,
+        navigationCount: this.navigationCount,
+        sessionDurationMs: Math.round(performance.now() - this.pageLoadTime),
+        onLine: navigator.onLine
+      }
+    });
+  }
+  // ── Internal ─────────────────────────────────────────────
+  enqueue(item) {
+    item.source = this.config.source;
+    item.platform = this.config.platform;
+    item.version = this.config.version;
+    this.queue.push(item);
+    if (this.queue.length >= this.config.maxBatchSize) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.queue.length === 0) return;
+    const batch = this.queue.splice(0, this.config.maxBatchSize);
+    const doFetch = this.originalFetch || fetch;
+    const promises = batch.map(
+      (item) => doFetch(this.config.ingestUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(item)
+      }).catch(() => {
+      })
+    );
+    await Promise.allSettled(promises);
+  }
+  generateSessionId() {
+    return "ses_" + Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+  }
+  sanitizeHeaders(headers) {
+    if (!headers) return void 0;
+    const result = {};
+    const h = headers instanceof Headers ? headers : new Headers(headers);
+    h.forEach((value, key) => {
+      const lower = key.toLowerCase();
+      if (lower.includes("auth") || lower.includes("cookie") || lower.includes("token")) {
+        result[key] = "[REDACTED]";
+      } else {
+        result[key] = value;
+      }
+    });
+    return result;
+  }
+  destroy() {
+    if (this.batchTimer) clearInterval(this.batchTimer);
+    if (this.metricsTimer) clearInterval(this.metricsTimer);
+    if (this.config.captureConsole) {
+      for (const [method, original] of Object.entries(this.originalConsole)) {
+        if (original) console[method] = original;
+      }
+    }
+    if (this.originalFetch) window.fetch = this.originalFetch;
+    if (this.originalXhrOpen) XMLHttpRequest.prototype.open = this.originalXhrOpen;
+    if (this.originalXhrSend) XMLHttpRequest.prototype.send = this.originalXhrSend;
+    if (this.originalWsConstructor) window.WebSocket = this.originalWsConstructor;
+    this.flush();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DebuggerSDK
+});