@hakam-aldeen-kh/blix 0.4.2 → 0.6.0

package/dist/chunk-4JZEVUOR.js

@@ -0,0 +1,735 @@
+import {
+  MONITOR_ENABLED,
+  PERSIST_MAX_ENTRY_BYTES,
+  __spreadProps,
+  __spreadValues,
+  captureFrames,
+  configureDbName,
+  estimateBytes,
+  flattenHeaders,
+  getOwner,
+  networkMonitor,
+  now,
+  serializeBody,
+  serializeHeaders,
+  truncateForPersist
+} from "./chunk-FIYP47QZ.js";
+
+// src/capture/monitorStamp.ts
+var MONITOR_ID = /* @__PURE__ */ Symbol.for("blix.monitorId");
+var stampFallback = /* @__PURE__ */ new WeakMap();
+function stampMonitorId(config, id) {
+  try {
+    Object.defineProperty(config, MONITOR_ID, {
+      value: id,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  } catch (e) {
+    stampFallback.set(config, id);
+  }
+}
+function readMonitorId(config) {
+  if (config === null || typeof config !== "object") return void 0;
+  const stamped = config;
+  const direct = stamped[MONITOR_ID];
+  if (typeof direct === "string") return direct;
+  if (typeof stamped.__monitorId === "string") return stamped.__monitorId;
+  return stampFallback.get(config);
+}
+var AXIOS_FETCH = /* @__PURE__ */ Symbol.for("blix.axiosFetch");
+function stampAxiosFetchOptions(config, id) {
+  try {
+    const current = config.fetchOptions;
+    if (current != null && typeof current !== "object") return;
+    config.fetchOptions = __spreadProps(__spreadValues({}, current), { [AXIOS_FETCH]: id });
+  } catch (e) {
+  }
+}
+function isAxiosCapturedFetch(init) {
+  if (init === null || typeof init !== "object") return false;
+  try {
+    return init[AXIOS_FETCH] !== void 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/capture/attachHttp.ts
+var attached = /* @__PURE__ */ new WeakSet();
+function attachHttpMonitor(instance, options) {
+  if (!MONITOR_ENABLED) return () => {
+  };
+  const managers = instance.interceptors;
+  if (attached.has(managers)) return () => {
+  };
+  attached.add(managers);
+  if (options == null ? void 0 : options.dbName) configureDbName(options.dbName);
+  const requestId = managers.request.use((config) => {
+    var _a, _b;
+    if (networkMonitor.isPaused) return config;
+    try {
+      const id = networkMonitor.nextId();
+      config.__monitorId = id;
+      stampMonitorId(config, id);
+      stampAxiosFetchOptions(config, id);
+      const hadFormData = typeof FormData !== "undefined" && config.data instanceof FormData;
+      const requestPayload = serializeBody(config.data);
+      const owner = getOwner();
+      networkMonitor.start({
+        id,
+        client: "axios",
+        method: ((_a = config.method) != null ? _a : "post").toUpperCase(),
+        url: (_b = config.url) != null ? _b : "",
+        baseURL: config.baseURL,
+        at: Date.now(),
+        startTime: now(),
+        requestPayload,
+        requestHeaders: serializeHeaders(config.headers),
+        sizeBytes: estimateBytes(requestPayload),
+        skipEncryption: config.skipEncryption === true,
+        hadFormData,
+        replayOf: config.__monitorReplayOf,
+        initiator: config.__monitorInitiator,
+        ownerId: owner == null ? void 0 : owner.id,
+        initiatorKind: owner == null ? void 0 : owner.kind
+      });
+      if (owner) networkMonitor.linkChild(owner.id, id);
+    } catch (e) {
+    }
+    return config;
+  });
+  const responseId = managers.response.use(
+    (response) => {
+      const id = response.config.__monitorId;
+      if (!id) return response;
+      try {
+        const payload = response.data;
+        networkMonitor.update(id, {
+          state: "success",
+          status: response.status,
+          endTime: now(),
+          responsePayload: payload,
+          responseHeaders: serializeHeaders(response.headers),
+          sizeBytes: estimateBytes(payload)
+        });
+      } catch (e) {
+      }
+      return response;
+    },
+    (error) => {
+      var _a, _b, _c, _d, _e;
+      const id = (_a = error.config) == null ? void 0 : _a.__monitorId;
+      if (id) {
+        try {
+          const payload = (_c = (_b = error.response) == null ? void 0 : _b.data) != null ? _c : error.message;
+          networkMonitor.update(id, {
+            // axios's own `isCancel` is exactly `!!value.__CANCEL__`, set by
+            // `CanceledError` for `AbortController` and `CancelToken`
+            // cancellation alike — duck-typed because Blix never imports axios
+            // at runtime. A timeout is not a cancel, and stays "error".
+            state: error.__CANCEL__ ? "aborted" : "error",
+            status: (_d = error.response) == null ? void 0 : _d.status,
+            endTime: now(),
+            error: payload,
+            responseHeaders: serializeHeaders((_e = error.response) == null ? void 0 : _e.headers),
+            sizeBytes: estimateBytes(payload)
+          });
+        } catch (e) {
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return () => {
+    managers.request.eject(requestId);
+    managers.response.eject(responseId);
+    attached.delete(managers);
+  };
+}
+
+// src/capture/attachFetch.ts
+var DEFAULT_MAX_BODY_BYTES = 5 * 1024 * 1024;
+var DEFAULT_IGNORE = Object.freeze([
+  "/_next/",
+  "/__nextjs",
+  /[?&]_rsc=/,
+  ".hot-update.",
+  "/__webpack_hmr"
+]);
+var WRAPPER_MARK = /* @__PURE__ */ Symbol.for("blix.fetchMonitor");
+var noop = () => {
+};
+function describeBytes(n) {
+  if (n >= 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  if (n >= 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${n} B`;
+}
+function notCaptured(reason) {
+  return `\xABbody not captured: ${reason}\xBB`;
+}
+function binarySummary(contentType, bytes) {
+  return `\xABbinary body: ${contentType || "unknown type"} \u2014 ${bytes} bytes\xBB`;
+}
+function errorName(error) {
+  if (error === null || typeof error !== "object") return void 0;
+  const name = error.name;
+  return typeof name === "string" ? name : void 0;
+}
+function describeError(error) {
+  try {
+    if (error !== null && typeof error === "object") {
+      const message = error.message;
+      const name = errorName(error);
+      if (typeof message === "string") return name ? `${name}: ${message}` : message;
+    }
+    return String(error);
+  } catch (e) {
+    return "unknown error";
+  }
+}
+function headerValue(headers, name) {
+  const wanted = name.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === wanted) return headers[key];
+  }
+  return null;
+}
+function settle(id, patch) {
+  try {
+    networkMonitor.update(id, patch);
+  } catch (e) {
+  }
+}
+var TEXTUAL = /^\s*(?:text\/|application\/(?:json|javascript|ecmascript|xml|x-www-form-urlencoded|graphql|x-ndjson)\b|[^;\s]+\+(?:json|xml)\b)/i;
+var EVENT_STREAM = /^\s*text\/event-stream/i;
+function isTextual(contentType) {
+  return !contentType || TEXTUAL.test(contentType);
+}
+function decodeBody(bytes, contentType) {
+  try {
+    const text = new TextDecoder("utf-8", { fatal: !contentType }).decode(bytes);
+    return serializeBody(text);
+  } catch (e) {
+    return binarySummary(contentType, bytes.byteLength);
+  }
+}
+async function readCapped(body, cap, retain) {
+  const reader = body.getReader();
+  const chunks = [];
+  let length = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.byteLength;
+      if (length > cap) {
+        reader.cancel().catch(noop);
+        return { kind: "over-cap", length };
+      }
+      if (retain) chunks.push(value);
+    }
+  } catch (error) {
+    return { kind: "failed", error };
+  }
+  if (!retain) return { kind: "complete", bytes: null, length };
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { kind: "complete", bytes, length };
+}
+function isRequest(value) {
+  return typeof Request !== "undefined" && value instanceof Request;
+}
+function describe(input, rawInit) {
+  var _a, _b, _c;
+  const request = isRequest(input) ? input : null;
+  const init = rawInit !== null && typeof rawInit === "object" ? rawInit : void 0;
+  const url = request ? request.url : String(input);
+  let resolved = null;
+  try {
+    resolved = new URL(url, typeof location !== "undefined" ? location.href : void 0);
+  } catch (e) {
+    resolved = null;
+  }
+  return {
+    url,
+    resolved,
+    method: String((_b = (_a = init == null ? void 0 : init.method) != null ? _a : request == null ? void 0 : request.method) != null ? _b : "GET").toUpperCase(),
+    headers: flattenHeaders((init == null ? void 0 : init.headers) !== void 0 ? init.headers : request == null ? void 0 : request.headers),
+    signal: (_c = (init == null ? void 0 : init.signal) !== void 0 ? init.signal : request == null ? void 0 : request.signal) != null ? _c : null,
+    request,
+    init
+  };
+}
+function isIgnored(url, rules) {
+  if (!url) return false;
+  const target = url.pathname + url.search;
+  for (const rule of rules) {
+    try {
+      if (typeof rule === "string") {
+        if (target.includes(rule)) return true;
+      } else if (rule instanceof RegExp) {
+        rule.lastIndex = 0;
+        if (rule.test(target)) return true;
+      } else if (typeof rule === "function" && rule(url)) {
+        return true;
+      }
+    } catch (e) {
+    }
+  }
+  return false;
+}
+function describeBodyValue(body) {
+  var _a;
+  const plain = (payload, hadFormData = false) => ({
+    payload,
+    bytes: estimateBytes(body),
+    hadFormData,
+    clone: null
+  });
+  if (typeof FormData !== "undefined" && body instanceof FormData) {
+    return plain(serializeBody(body), true);
+  }
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {
+    return plain(body.toString());
+  }
+  if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+    return {
+      payload: notCaptured("streaming request body \u2014 reading it would consume the upload"),
+      bytes: 0,
+      hadFormData: false,
+      clone: null
+    };
+  }
+  if (typeof File !== "undefined" && body instanceof File) {
+    return plain(`\xABFile: ${body.name} \u2014 ${body.size} bytes\xBB`);
+  }
+  if (typeof Blob !== "undefined" && body instanceof Blob) {
+    return plain(`\xABBlob: ${body.type || "untyped"} \u2014 ${body.size} bytes\xBB`);
+  }
+  if (typeof ArrayBuffer !== "undefined" && (body instanceof ArrayBuffer || ArrayBuffer.isView(body))) {
+    const label = (_a = body.constructor) == null ? void 0 : _a.name;
+    return plain(`\xAB${label || "ArrayBuffer"} \u2014 ${estimateBytes(body)} bytes\xBB`);
+  }
+  return plain(serializeBody(body));
+}
+function planRequestBody(outgoing) {
+  var _a;
+  const none = { payload: void 0, bytes: 0, hadFormData: false, clone: null };
+  const initBody = (_a = outgoing.init) == null ? void 0 : _a.body;
+  if (initBody != null) return describeBodyValue(initBody);
+  const request = outgoing.request;
+  if (!request || request.body === null) return none;
+  if (request.bodyUsed) {
+    return __spreadProps(__spreadValues({}, none), { payload: notCaptured("the request body was already read before fetch was called") });
+  }
+  try {
+    return __spreadProps(__spreadValues({}, none), { clone: request.clone() });
+  } catch (e) {
+    return __spreadProps(__spreadValues({}, none), { payload: notCaptured("the request body is locked and could not be cloned") });
+  }
+}
+function readRequestClone(id, clone, cap, headers) {
+  const body = clone.body;
+  if (!body) return;
+  const contentType = headerValue(headers, "content-type");
+  const retain = isTextual(contentType);
+  void readCapped(body, cap, retain).then((result) => {
+    let requestPayload;
+    if (result.kind === "complete") {
+      requestPayload = result.bytes ? decodeBody(result.bytes, contentType) : binarySummary(contentType, result.length);
+    } else if (result.kind === "over-cap") {
+      requestPayload = notCaptured(
+        `the request body passed the ${describeBytes(cap)} capture limit`
+      );
+    } else {
+      requestPayload = notCaptured(
+        `the request body could not be read (${describeError(result.error)})`
+      );
+    }
+    settle(id, { requestPayload });
+  });
+}
+function begin(outgoing, initiator, cap) {
+  const id = networkMonitor.nextId();
+  const body = planRequestBody(outgoing);
+  const owner = getOwner();
+  networkMonitor.start({
+    id,
+    client: "fetch",
+    method: outgoing.method,
+    url: outgoing.url,
+    at: Date.now(),
+    startTime: now(),
+    requestPayload: body.payload,
+    requestHeaders: serializeHeaders(outgoing.headers),
+    sizeBytes: body.bytes,
+    hadFormData: body.hadFormData,
+    initiator,
+    ownerId: owner == null ? void 0 : owner.id,
+    initiatorKind: owner == null ? void 0 : owner.kind
+  });
+  if (owner) networkMonitor.linkChild(owner.id, id);
+  if (body.clone) readRequestClone(id, body.clone, cap, outgoing.headers);
+  return id;
+}
+function respond(id, response, cap, signal) {
+  const headersAt = now();
+  if (response.type === "opaque" || response.type === "opaqueredirect") {
+    settle(id, {
+      state: "success",
+      status: response.status,
+      endTime: headersAt,
+      responseHeaders: {},
+      responsePayload: notCaptured(
+        response.type === "opaque" ? "opaque response \u2014 a no-cors request hides its status, headers and body from JavaScript" : `opaque redirect \u2014 redirect: "manual" hides the redirect's status, headers and body from JavaScript`
+      )
+    });
+    return;
+  }
+  const ok = response.ok;
+  const finish = (payload, extra = {}, endTime = headersAt) => settle(id, __spreadValues(__spreadValues({
+    state: ok ? "success" : "error",
+    endTime
+  }, ok ? { responsePayload: payload } : { error: payload }), extra));
+  settle(id, {
+    status: response.status,
+    responseHeaders: serializeHeaders(flattenHeaders(response.headers))
+  });
+  if (response.body === null) {
+    finish(void 0, { sizeBytes: 0 });
+    return;
+  }
+  const contentType = response.headers.get("content-type");
+  if (contentType && EVENT_STREAM.test(contentType)) {
+    finish(notCaptured("event stream \u2014 it does not end, so reading it would buffer for the life of the connection"));
+    return;
+  }
+  const declared = Number(response.headers.get("content-length"));
+  const hasDeclared = response.headers.has("content-length") && Number.isFinite(declared);
+  if (hasDeclared && declared > cap) {
+    finish(
+      notCaptured(
+        `Content-Length (${describeBytes(declared)}) is over the ${describeBytes(cap)} capture limit`
+      ),
+      { sizeBytes: declared }
+    );
+    return;
+  }
+  let clone;
+  try {
+    clone = response.clone();
+  } catch (e) {
+    finish(notCaptured("the response body was locked or already read before Blix could clone it"));
+    return;
+  }
+  const body = clone.body;
+  if (!body) {
+    finish(void 0, { sizeBytes: 0 });
+    return;
+  }
+  void readCapped(body, cap, isTextual(contentType)).then((result) => {
+    if (result.kind === "complete") {
+      finish(
+        result.bytes ? decodeBody(result.bytes, contentType) : binarySummary(contentType, result.length),
+        { sizeBytes: result.length },
+        now()
+      );
+    } else if (result.kind === "over-cap") {
+      finish(
+        notCaptured(
+          `the decoded body passed the ${describeBytes(cap)} capture limit while downloading` + (hasDeclared ? ` (Content-Length said ${describeBytes(declared)} \u2014 the compressed size)` : "")
+        ),
+        { sizeBytes: result.length }
+      );
+    } else if (signal == null ? void 0 : signal.aborted) {
+      settle(id, __spreadValues({
+        state: "aborted",
+        endTime: now()
+      }, ok ? { responsePayload: notCaptured("the request was aborted while the body was downloading") } : { error: notCaptured("the request was aborted while the body was downloading") }));
+    } else {
+      finish(notCaptured(`the body stream failed while downloading (${describeError(result.error)})`));
+    }
+  });
+}
+function fail(id, error, signal) {
+  const name = errorName(error);
+  const aborted = name !== "TimeoutError" && ((signal == null ? void 0 : signal.aborted) === true || name === "AbortError");
+  settle(id, {
+    state: aborted ? "aborted" : "error",
+    endTime: now(),
+    error: describeError(error)
+  });
+}
+function isBlixWrapper(fn) {
+  return typeof fn === "function" && fn[WRAPPER_MARK] === true;
+}
+function resolveIgnore(option) {
+  if (option === void 0) return DEFAULT_IGNORE;
+  if (typeof option !== "function") return option;
+  try {
+    const rules = option(DEFAULT_IGNORE);
+    if (Array.isArray(rules)) return rules;
+  } catch (error) {
+    if (process.env.NODE_ENV === "development") {
+      console.warn("[blix] attachFetchMonitor: the ignore function threw; using the defaults.", error);
+    }
+  }
+  return DEFAULT_IGNORE;
+}
+function attachFetchMonitor(options = {}) {
+  if (!MONITOR_ENABLED || typeof window === "undefined") return noop;
+  const original = globalThis.fetch;
+  if (typeof original !== "function") return noop;
+  if (isBlixWrapper(original)) return noop;
+  if (options.dbName) configureDbName(options.dbName);
+  const cap = typeof options.maxBodyBytes === "number" && Number.isFinite(options.maxBodyBytes) && options.maxBodyBytes >= 0 ? options.maxBodyBytes : DEFAULT_MAX_BODY_BYTES;
+  const ignore = resolveIgnore(options.ignore);
+  const wrapper = function blixFetch(...args) {
+    const [input, init] = args;
+    let outgoing = null;
+    try {
+      if (!networkMonitor.isPaused && !isAxiosCapturedFetch(init)) {
+        const described = describe(input, init);
+        if (!isIgnored(described.resolved, ignore)) outgoing = described;
+      }
+    } catch (e) {
+      outgoing = null;
+    }
+    if (!outgoing) return Reflect.apply(original, this, args);
+    const initiator = captureFrames(1);
+    let id = null;
+    try {
+      id = begin(outgoing, initiator, cap);
+    } catch (e) {
+      id = null;
+    }
+    if (id === null) return Reflect.apply(original, this, args);
+    const entryId = id;
+    const signal = outgoing.signal;
+    let pending;
+    try {
+      pending = Promise.resolve(Reflect.apply(original, this, args));
+    } catch (error) {
+      fail(entryId, error, signal);
+      throw error;
+    }
+    return pending.then(
+      (response) => {
+        try {
+          respond(entryId, response, cap, signal);
+        } catch (e) {
+        }
+        return response;
+      },
+      (error) => {
+        try {
+          fail(entryId, error, signal);
+        } catch (e) {
+        }
+        throw error;
+      }
+    );
+  };
+  Object.defineProperty(wrapper, WRAPPER_MARK, {
+    value: true,
+    enumerable: true,
+    writable: false,
+    configurable: false
+  });
+  globalThis.fetch = wrapper;
+  let restored = false;
+  return () => {
+    if (restored) return;
+    if (globalThis.fetch === wrapper) {
+      globalThis.fetch = original;
+      restored = true;
+      return;
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.warn(
+        "[blix] attachFetchMonitor's disposer left globalThis.fetch alone: something else has replaced it since Blix installed its wrapper, and restoring the original now would silently remove that patch too. Blix's wrapper is still underneath it and keeps capturing."
+      );
+    }
+  };
+}
+
+// src/capture/captureEncrypted.ts
+var MAX_ENCRYPTED_BYTES = PERSIST_MAX_ENTRY_BYTES;
+var BINARY_PREVIEW_BYTES = 512;
+var HEX = "0123456789abcdef";
+function toBytes(value) {
+  if (typeof ArrayBuffer === "undefined") return null;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  return null;
+}
+function labelOf(value) {
+  var _a;
+  const name = (_a = value.constructor) == null ? void 0 : _a.name;
+  return typeof name === "string" && name.length > 0 ? name : "BufferSource";
+}
+function binaryPreview(bytes, label) {
+  const limit = Math.min(bytes.length, BINARY_PREVIEW_BYTES);
+  let head = "";
+  for (let i = 0; i < limit; i += 1) {
+    const byte = bytes[i];
+    head += HEX[byte >> 4] + HEX[byte & 15];
+  }
+  return {
+    __blixBinary: label,
+    byteLength: bytes.length,
+    head,
+    truncated: bytes.length > limit
+  };
+}
+function normalize(value) {
+  const bytes = toBytes(value);
+  if (bytes) return binaryPreview(bytes, labelOf(value));
+  return truncateForPersist(serializeBody(value), MAX_ENCRYPTED_BYTES).value;
+}
+function captureEncrypted(config, payload) {
+  if (!MONITOR_ENABLED) return;
+  try {
+    const id = readMonitorId(config);
+    if (!id) return;
+    if (!payload) return;
+    const patch = {};
+    if (payload.request != null) patch.encryptedRequest = normalize(payload.request);
+    if (payload.response != null) patch.encryptedResponse = normalize(payload.response);
+    if (patch.encryptedRequest === void 0 && patch.encryptedResponse === void 0) {
+      return;
+    }
+    networkMonitor.update(id, patch);
+  } catch (e) {
+  }
+}
+
+// src/capture/realtimeCapture.ts
+var frameCounter = 0;
+function makeFrame(direction, event, data) {
+  frameCounter += 1;
+  return {
+    id: `f${frameCounter}`,
+    at: Date.now(),
+    direction,
+    event,
+    data,
+    sizeBytes: estimateBytes(data)
+  };
+}
+function tapRealtimeAdapter(adapter, transport) {
+  if (!MONITOR_ENABLED) return adapter;
+  let connectionId = null;
+  const frame = (direction, event, data) => {
+    if (!connectionId) return;
+    try {
+      networkMonitor.appendFrame(connectionId, makeFrame(direction, event, data));
+    } catch (e) {
+    }
+  };
+  const openConnection = (url) => {
+    try {
+      const id = networkMonitor.nextId();
+      connectionId = id;
+      const startTime = now();
+      networkMonitor.start({
+        id,
+        kind: "ws",
+        transport,
+        method: "WS",
+        // Strip the token from the query string — it is a credential, and the
+        // panel already masks the equivalent HTTP header.
+        url: redactUrl(url),
+        at: Date.now(),
+        startTime,
+        // A connection has no response body; size accrues from its frames.
+        sizeBytes: 0,
+        frames: []
+      });
+      return id;
+    } catch (e) {
+      connectionId = null;
+      return null;
+    }
+  };
+  const closeConnection = (state, reason) => {
+    if (!connectionId) return;
+    try {
+      networkMonitor.update(connectionId, {
+        state,
+        endTime: now(),
+        responsePayload: { closed: reason != null ? reason : "disconnected" }
+      });
+    } catch (e) {
+    }
+    connectionId = null;
+  };
+  return new Proxy(adapter, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      if (prop === "connect") {
+        return (token, url) => {
+          openConnection(url);
+          frame("system", "connect", { url: redactUrl(url), transport });
+          return value.call(target, token, url);
+        };
+      }
+      if (prop === "disconnect") {
+        return () => {
+          frame("system", "disconnect", null);
+          const result = value.call(target);
+          closeConnection("success", "client disconnect");
+          return result;
+        };
+      }
+      if (prop === "subscribe") {
+        return (channelName) => {
+          frame("out", `subscribe:${channelName}`, { channel: channelName });
+          return value.call(target, channelName);
+        };
+      }
+      if (prop === "onMessage") {
+        return (cb) => value.call(target, (payload) => {
+          var _a;
+          frame("in", (_a = payload == null ? void 0 : payload.event) != null ? _a : "message", payload == null ? void 0 : payload.data);
+          cb(payload);
+        });
+      }
+      if (prop === "onPresenceUpdate") {
+        return (cb) => value.call(target, (status) => {
+          frame("system", `presence:${status}`, { status });
+          if (status === "offline") closeConnection("error", "transport offline");
+          cb(status);
+        });
+      }
+      return value.bind(target);
+    }
+  });
+}
+function redactUrl(url) {
+  try {
+    const parsed = new URL(url, "http://local");
+    for (const key of ["token", "access_token", "accessToken", "auth"]) {
+      if (parsed.searchParams.has(key)) parsed.searchParams.set(key, "\u2022\u2022\u2022");
+    }
+    return url.startsWith("/") ? parsed.pathname + parsed.search : parsed.toString();
+  } catch (e) {
+    return url.replace(/([?&](?:token|access_token|accessToken|auth)=)[^&]*/gi, "$1\u2022\u2022\u2022");
+  }
+}
+
+export {
+  attachHttpMonitor,
+  attachFetchMonitor,
+  captureEncrypted,
+  tapRealtimeAdapter
+};