@hakam-aldeen-kh/blix 0.3.2

package/dist/chunk-MRTSIXR7.js

@@ -0,0 +1,1076 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/capture/monitorConfig.ts
+var MONITOR_ENABLED = process.env.NODE_ENV === "development" && typeof window !== "undefined";
+var NM_SCHEMA_VERSION = 1;
+var NM_DB_NAME = "nm-devtools";
+var NM_DB_VERSION = 1;
+var _activeDbName = NM_DB_NAME;
+function configureDbName(name) {
+  _activeDbName = name;
+}
+function getActiveDbName() {
+  return _activeDbName;
+}
+var POOL_OF = {
+  http: "net",
+  ws: "net",
+  redux: "redux",
+  query: "query"
+};
+var POOL_QUOTA = {
+  // Raised from the original 100 because the list is virtualized.
+  net: 200,
+  redux: 300,
+  query: 150
+};
+var MAX_ENTRIES = POOL_QUOTA.net;
+var MAX_REDUX_PAYLOAD_BYTES = 4 * 1024;
+var MAX_REDUX_DIFF_VALUE_BYTES = 2 * 1024;
+var MAX_REDUX_ACTIONS_PER_SEC = 300;
+var REDUX_COALESCE_MS = 120;
+var MAX_QUERY_DATA_BYTES = 32 * 1024;
+var PERSIST_MAX_ENTRIES = 200;
+var PERSIST_MAX_BYTES = 24 * 1024 * 1024;
+var PERSIST_MAX_ENTRY_BYTES = 512 * 1024;
+var STRING_CAP = 32 * 1024;
+var ARRAY_CAP = 200;
+var SEARCH_INDEX_CAP = 64 * 1024;
+var PENDING_WINDOW_CAP_MS = 3e4;
+var TIME_ORIGIN = typeof performance !== "undefined" && typeof performance.timeOrigin === "number" ? performance.timeOrigin : Date.now();
+var PAGE_LOAD_AT = Date.now();
+function makeLoadId() {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+  } catch (e) {
+  }
+  return `${PAGE_LOAD_AT}-${Math.random().toString(36).slice(2, 10)}`;
+}
+var LOAD_ID = makeLoadId();
+var now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+
+// src/capture/monitorSerialize.ts
+function serializeBody(data) {
+  if (data == null) return data;
+  if (typeof FormData !== "undefined" && data instanceof FormData) {
+    const obj = {};
+    data.forEach((value, key) => {
+      if (typeof File !== "undefined" && value instanceof File) {
+        obj[key] = `\xABFile: ${value.name} \u2014 ${value.size} bytes\xBB`;
+      } else {
+        obj[key] = value;
+      }
+    });
+    return obj;
+  }
+  if (typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch (e) {
+      return data;
+    }
+  }
+  return data;
+}
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key"
+]);
+function maskHeaderValue(key, value) {
+  if (!SENSITIVE_HEADERS.has(key.toLowerCase())) return value;
+  if (value.length <= 12) return "\u2022\u2022\u2022\u2022";
+  return `${value.slice(0, 8)}\u2026${value.slice(-4)} (masked)`;
+}
+function serializeHeaders(headers) {
+  const out = {};
+  if (!headers || typeof headers !== "object") return out;
+  const source = typeof headers.toJSON === "function" ? headers.toJSON() : headers;
+  if (!source || typeof source !== "object") return out;
+  for (const [key, value] of Object.entries(source)) {
+    if (value == null) continue;
+    if (typeof value === "object" && !Array.isArray(value)) continue;
+    const str = Array.isArray(value) ? value.join(", ") : String(value);
+    out[key] = maskHeaderValue(key, str);
+  }
+  return out;
+}
+var ESTIMATE_CEILING = 8 * 1024 * 1024;
+function estimateBytes(value) {
+  let total = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node) => {
+    if (total >= ESTIMATE_CEILING) return;
+    if (node === null || node === void 0) {
+      total += 4;
+      return;
+    }
+    switch (typeof node) {
+      case "string":
+        total += node.length + 2;
+        return;
+      case "number":
+      case "boolean":
+        total += 8;
+        return;
+      case "bigint":
+      case "symbol":
+      case "function":
+        total += 8;
+        return;
+    }
+    if (typeof node !== "object") return;
+    if (seen.has(node)) {
+      total += 8;
+      return;
+    }
+    seen.add(node);
+    if (Array.isArray(node)) {
+      total += 2 + node.length;
+      for (const item of node) {
+        if (total >= ESTIMATE_CEILING) return;
+        walk(item);
+      }
+      return;
+    }
+    const entries = Object.entries(node);
+    total += 2 + entries.length * 2;
+    for (const [key, val] of entries) {
+      if (total >= ESTIMATE_CEILING) return;
+      total += key.length + 2;
+      walk(val);
+    }
+  };
+  try {
+    walk(value);
+  } catch (e) {
+  }
+  return Math.min(total, ESTIMATE_CEILING);
+}
+
+// src/capture/networkMonitor.ts
+var MAX_FRAMES_PER_CONNECTION = 500;
+function evictOldest(entries) {
+  var _a;
+  const totalQuota = POOL_QUOTA.net + POOL_QUOTA.redux + POOL_QUOTA.query;
+  if (entries.length <= totalQuota) return { kept: entries, evicted: [] };
+  const kept = [];
+  const evicted = [];
+  const budget = __spreadValues({}, POOL_QUOTA);
+  for (const entry of entries) {
+    const pool = POOL_OF[(_a = entry.kind) != null ? _a : "http"];
+    const protectedEntry = entry.pinned || entry.kind === "ws" && entry.state === "pending";
+    if (budget[pool] > 0 || protectedEntry) {
+      kept.push(entry);
+      if (!protectedEntry) budget[pool] -= 1;
+    } else {
+      evicted.push(entry.id);
+    }
+  }
+  return { kept, evicted };
+}
+var EMPTY = [];
+var NetworkMonitor = class {
+  constructor() {
+    this.entries = [];
+    /** id → index into `entries`. Avoids an O(n) `map()` with a closure per
+     * element on every patch; each request produces 2–4 patches. */
+    this.index = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.counter = 0;
+    this.paused = false;
+    this.sink = null;
+    /** Set while an emit is already queued, so a burst of parallel requests
+     * produces one re-render rather than one per request. */
+    this.emitQueued = false;
+    /** Stable reference between mutations so useSyncExternalStore is happy. */
+    this.getSnapshot = () => this.entries;
+    this.getServerSnapshot = () => EMPTY;
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => {
+        this.listeners.delete(listener);
+      };
+    };
+  }
+  /** Whether capturing + the panel are active. Development only. */
+  get enabled() {
+    return MONITOR_ENABLED;
+  }
+  /** When paused, new requests are dropped (existing entries still update). */
+  get isPaused() {
+    return this.paused;
+  }
+  setPaused(value) {
+    if (this.paused === value) return;
+    this.paused = value;
+    this.emit();
+  }
+  setSink(sink) {
+    this.sink = sink;
+  }
+  nextId() {
+    this.counter += 1;
+    return `${Date.now()}-${this.counter}`;
+  }
+  start(input) {
+    var _a, _b, _c;
+    if (!this.enabled || this.paused) return;
+    const next = __spreadProps(__spreadValues({}, input), {
+      state: (_a = input.state) != null ? _a : "pending",
+      seq: this.counter,
+      rev: 0,
+      timeOrigin: TIME_ORIGIN,
+      startAbs: TIME_ORIGIN + input.startTime,
+      loadId: LOAD_ID
+    });
+    const combined = [next, ...this.entries];
+    const { kept, evicted } = evictOldest(combined);
+    this.entries = kept;
+    this.reindex();
+    if (next.replayOf) this.bumpReplayCount(next.replayOf);
+    (_b = this.sink) == null ? void 0 : _b.onDirty(next.id);
+    if (evicted.length) (_c = this.sink) == null ? void 0 : _c.onEvict(evicted);
+    this.emit();
+  }
+  update(id, patch) {
+    var _a;
+    if (!this.enabled) return;
+    const at = this.index.get(id);
+    if (at === void 0) return;
+    const prev = this.entries[at];
+    const merged = __spreadProps(__spreadValues(__spreadValues({}, prev), patch), { rev: prev.rev + 1 });
+    if (patch.marks) merged.marks = __spreadValues(__spreadValues({}, prev.marks), patch.marks);
+    if (patch.endTime != null && merged.startTime != null) {
+      merged.durationMs = Math.round(patch.endTime - merged.startTime);
+      merged.endAbs = merged.timeOrigin + patch.endTime;
+    }
+    const next = this.entries.slice();
+    next[at] = merged;
+    this.entries = next;
+    (_a = this.sink) == null ? void 0 : _a.onDirty(id);
+    this.emit();
+  }
+  /** Increments the parent's replay counter, in the same mutation as the child
+   * being added. Silently ignores an unknown parent (it may have been evicted). */
+  bumpReplayCount(parentId) {
+    var _a, _b;
+    const at = this.index.get(parentId);
+    if (at === void 0) return;
+    const prev = this.entries[at];
+    const next = this.entries.slice();
+    next[at] = __spreadProps(__spreadValues({}, prev), {
+      rev: prev.rev + 1,
+      replayCount: ((_a = prev.replayCount) != null ? _a : 0) + 1
+    });
+    this.entries = next;
+    (_b = this.sink) == null ? void 0 : _b.onDirty(parentId);
+  }
+  /** Clears the log, keeping pinned entries — that is what pinning is for. */
+  clear() {
+    var _a, _b;
+    const survivors = this.entries.filter((e) => e.pinned);
+    const removed = this.entries.filter((e) => !e.pinned).map((e) => e.id);
+    this.entries = survivors;
+    this.reindex();
+    if (survivors.length === 0) {
+      (_a = this.sink) == null ? void 0 : _a.onClear();
+    } else if (removed.length) {
+      (_b = this.sink) == null ? void 0 : _b.onEvict(removed);
+    }
+    this.emit();
+  }
+  togglePin(id) {
+    var _a;
+    const at = this.index.get(id);
+    if (at === void 0) return;
+    const prev = this.entries[at];
+    const next = this.entries.slice();
+    next[at] = __spreadProps(__spreadValues({}, prev), { rev: prev.rev + 1, pinned: !prev.pinned });
+    this.entries = next;
+    (_a = this.sink) == null ? void 0 : _a.onDirty(id);
+    this.emit();
+  }
+  /** O(1) lookup by id. Used by capture sources (Redux/Query) that need to
+   * read an entry's current fields before patching it — e.g. to fold a
+   * repeated action into its existing row's `batchCount`. */
+  getById(id) {
+    const at = this.index.get(id);
+    return at === void 0 ? void 0 : this.entries[at];
+  }
+  /**
+   * Records that `childId` (an HTTP entry) was caused by the query/mutation
+   * entry `ownerId`. A no-op if the owner isn't a query/mutation row, or has
+   * been evicted — this is a best-effort correlation, never load-bearing.
+   */
+  linkChild(ownerId, childId) {
+    var _a, _b;
+    const at = this.index.get(ownerId);
+    if (at === void 0) return;
+    const prev = this.entries[at];
+    if (!prev.query) return;
+    const causedIds = [...(_a = prev.query.causedIds) != null ? _a : [], childId].slice(-20);
+    const next = this.entries.slice();
+    next[at] = __spreadProps(__spreadValues({}, prev), { rev: prev.rev + 1, query: __spreadProps(__spreadValues({}, prev.query), { causedIds }) });
+    this.entries = next;
+    (_b = this.sink) == null ? void 0 : _b.onDirty(ownerId);
+    this.emit();
+  }
+  /**
+   * Appends a frame to a realtime connection.
+   *
+   * Frames mutate a long-lived entry rather than creating rows of their own, so
+   * the buffer stays dominated by HTTP requests. The per-connection cap keeps a
+   * chatty channel from growing without bound.
+   */
+  appendFrame(id, frame2) {
+    var _a, _b, _c;
+    if (!this.enabled || this.paused) return;
+    const at = this.index.get(id);
+    if (at === void 0) return;
+    const prev = this.entries[at];
+    const frames = [...(_a = prev.frames) != null ? _a : [], frame2].slice(
+      -MAX_FRAMES_PER_CONNECTION
+    );
+    const next = this.entries.slice();
+    next[at] = __spreadProps(__spreadValues({}, prev), {
+      rev: prev.rev + 1,
+      frames,
+      sizeBytes: ((_b = prev.sizeBytes) != null ? _b : 0) + frame2.sizeBytes
+    });
+    this.entries = next;
+    (_c = this.sink) == null ? void 0 : _c.onDirty(id);
+    this.emit();
+  }
+  /**
+   * Folds entries restored from IndexedDB into the live buffer. Called once,
+   * from the panel's boot sequence, after any requests that fired while the DB
+   * was opening — hence the merge rather than a plain assignment.
+   */
+  mergeHydrated(records) {
+    if (!this.enabled || records.length === 0) return;
+    const live = new Set(this.entries.map((e) => e.id));
+    const restored = records.filter((r) => !live.has(r.id)).map(
+      (r) => (
+        // A request left pending by a previous page load can never complete.
+        // Leaving it `pending` would spin a forever-spinner, inflate the
+        // pending count, and keep the waterfall ticker running indefinitely.
+        r.state === "pending" && r.loadId !== LOAD_ID ? __spreadProps(__spreadValues({}, r), { state: "aborted" }) : r
+      )
+    );
+    const combined = [...this.entries, ...restored].sort((a, b) => {
+      if (b.startAbs !== a.startAbs) return b.startAbs - a.startAbs;
+      return b.seq - a.seq;
+    });
+    this.entries = combined.slice(0, MAX_ENTRIES);
+    this.reindex();
+    const maxSeq = this.entries.reduce((m, e) => Math.max(m, e.seq), 0);
+    this.counter = Math.max(this.counter, maxSeq + 1);
+    this.emit();
+  }
+  reindex() {
+    this.index.clear();
+    for (let i = 0; i < this.entries.length; i += 1) {
+      this.index.set(this.entries[i].id, i);
+    }
+  }
+  /**
+   * Coalesced notification. Twenty parallel requests would otherwise fire
+   * twenty synchronous emits, each forcing `useSyncExternalStore` into a
+   * separate re-render; batching to a microtask makes that one render.
+   */
+  emit() {
+    if (this.emitQueued) return;
+    this.emitQueued = true;
+    queueMicrotask(() => {
+      this.emitQueued = false;
+      this.listeners.forEach((listener) => listener());
+    });
+  }
+};
+var networkMonitor = new NetworkMonitor();
+
+// src/capture/monitorTruncate.ts
+function truncateForPersist(value, maxBytes) {
+  let used = 0;
+  let truncated = false;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node) => {
+    if (node === null || node === void 0) {
+      used += 4;
+      return node;
+    }
+    if (typeof node === "string") {
+      if (node.length > STRING_CAP) {
+        truncated = true;
+        used += STRING_CAP + 64;
+        const marker = {
+          __nmTruncated: "string",
+          bytes: node.length,
+          head: node.slice(0, STRING_CAP)
+        };
+        return marker;
+      }
+      used += node.length + 2;
+      return node;
+    }
+    if (typeof node === "number" || typeof node === "boolean") {
+      used += 8;
+      return node;
+    }
+    if (typeof node !== "object") {
+      used += 8;
+      return String(node);
+    }
+    if (seen.has(node)) {
+      truncated = true;
+      return { __nmTruncated: "object", omitted: 0 };
+    }
+    seen.add(node);
+    if (Array.isArray(node)) {
+      const limit = Math.min(node.length, ARRAY_CAP);
+      const out3 = [];
+      used += 2;
+      for (let i = 0; i < limit; i += 1) {
+        if (used >= maxBytes) {
+          truncated = true;
+          out3.push({
+            __nmTruncated: "array",
+            total: node.length,
+            omitted: node.length - i
+          });
+          return out3;
+        }
+        out3.push(walk(node[i]));
+        used += 1;
+      }
+      if (node.length > limit) {
+        truncated = true;
+        out3.push({
+          __nmTruncated: "array",
+          total: node.length,
+          omitted: node.length - limit
+        });
+      }
+      return out3;
+    }
+    const entries = Object.entries(node);
+    const out2 = {};
+    used += 2;
+    for (let i = 0; i < entries.length; i += 1) {
+      if (used >= maxBytes) {
+        truncated = true;
+        out2.__nmTruncated = "object";
+        out2.omitted = entries.length - i;
+        return out2;
+      }
+      const [key, val] = entries[i];
+      used += key.length + 3;
+      out2[key] = walk(val);
+    }
+    return out2;
+  };
+  let out;
+  try {
+    out = walk(value);
+  } catch (e) {
+    return {
+      value: { __nmTruncated: "object", omitted: 0 },
+      bytes: 32,
+      truncated: true
+    };
+  }
+  return { value: out, bytes: used, truncated };
+}
+function isTruncationMarker(value) {
+  return typeof value === "object" && value !== null && "__nmTruncated" in value;
+}
+
+// src/capture/stateDiff.ts
+var DEFAULTS = {
+  maxDepth: 6,
+  maxNodes: 2e3,
+  maxChanges: 100,
+  maxValueBytes: MAX_REDUX_DIFF_VALUE_BYTES,
+  arrayScanCap: 64
+};
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function capture(value, maxBytes) {
+  return truncateForPersist(value, maxBytes).value;
+}
+function diffState(prev, next, options) {
+  const o = __spreadValues(__spreadValues({}, DEFAULTS), options);
+  const changes = [];
+  const slices = /* @__PURE__ */ new Set();
+  let truncated = false;
+  let nodesVisited = 0;
+  const record = (path, op, before, after) => {
+    if (changes.length >= o.maxChanges) {
+      truncated = true;
+      return;
+    }
+    const entry = { path, op };
+    if (before !== void 0) entry.before = capture(before, o.maxValueBytes);
+    if (after !== void 0) entry.after = capture(after, o.maxValueBytes);
+    changes.push(entry);
+    const top = path.split(/[.[]/)[0];
+    if (top) slices.add(top);
+  };
+  const walk = (a, b, path, depth) => {
+    if (Object.is(a, b)) return;
+    if (changes.length >= o.maxChanges) {
+      truncated = true;
+      return;
+    }
+    nodesVisited += 1;
+    if (nodesVisited > o.maxNodes || depth > o.maxDepth) {
+      truncated = true;
+      record(path || "(root)", "change", a, b);
+      return;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) {
+        record(path || "(root)", "change", `length ${a.length}`, `length ${b.length}`);
+        return;
+      }
+      let refDifferent = 0;
+      for (let i = 0; i < a.length; i += 1) {
+        if (!Object.is(a[i], b[i])) refDifferent += 1;
+      }
+      if (refDifferent > o.arrayScanCap) {
+        truncated = true;
+        record(
+          path || "(root)",
+          "change",
+          void 0,
+          `${refDifferent} of ${a.length} elements changed`
+        );
+        return;
+      }
+      for (let i = 0; i < a.length; i += 1) {
+        if (!Object.is(a[i], b[i])) walk(a[i], b[i], `${path}[${i}]`, depth + 1);
+      }
+      return;
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+      const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+      for (const key of keys) {
+        const childPath = path ? `${path}.${key}` : key;
+        const av = a[key];
+        const bv = b[key];
+        if (Object.is(av, bv)) continue;
+        if (!(key in a)) record(childPath, "add", void 0, bv);
+        else if (!(key in b)) record(childPath, "remove", av, void 0);
+        else walk(av, bv, childPath, depth + 1);
+      }
+      return;
+    }
+    record(path || "(root)", "change", a, b);
+  };
+  try {
+    walk(prev, next, "", 0);
+  } catch (e) {
+    truncated = true;
+  }
+  return { changes, truncated, slices: Array.from(slices) };
+}
+
+// src/capture/reduxCapture.ts
+var DEFAULT_IGNORE = ["@@redux/INIT", "@@INIT"];
+var ignoreExact = new Set(DEFAULT_IGNORE);
+var ignorePrefixes = [];
+function setIgnoreList(types) {
+  ignoreExact = new Set(types.filter((t) => !t.endsWith("/*")));
+  ignorePrefixes = types.filter((t) => t.endsWith("/*")).map((t) => t.slice(0, -2));
+}
+setIgnoreList(DEFAULT_IGNORE);
+function setReduxIgnoreList(types) {
+  setIgnoreList([...DEFAULT_IGNORE, ...types]);
+}
+function getReduxIgnoreList() {
+  return [...ignoreExact].filter((t) => !DEFAULT_IGNORE.includes(t));
+}
+function isIgnored(type) {
+  if (ignoreExact.has(type)) return true;
+  return ignorePrefixes.some((p) => type.startsWith(p));
+}
+var windowStartedAt = 0;
+var windowCount = 0;
+function isFlooding(maxPerSecond) {
+  const t = Date.now();
+  if (t - windowStartedAt > 1e3) {
+    windowStartedAt = t;
+    windowCount = 0;
+  }
+  windowCount += 1;
+  return windowCount > maxPerSecond;
+}
+function toEntryState(isError) {
+  return isError ? "error" : "success";
+}
+var replayOfId = null;
+function markReplaying(entryId, fn) {
+  const prev = replayOfId;
+  replayOfId = entryId;
+  try {
+    return fn();
+  } finally {
+    replayOfId = prev;
+  }
+}
+function createReduxMonitorMiddleware(options = {}) {
+  var _a, _b;
+  if (options.ignore) setReduxIgnoreList(options.ignore);
+  const coalesceMs = (_a = options.coalesceMs) != null ? _a : REDUX_COALESCE_MS;
+  const maxPerSecond = (_b = options.maxActionsPerSecond) != null ? _b : MAX_REDUX_ACTIONS_PER_SEC;
+  if (!MONITOR_ENABLED) {
+    return () => (next) => (action) => next(action);
+  }
+  let lastEntryId = null;
+  let lastType = null;
+  let lastAt = 0;
+  return (api) => (next) => (action) => {
+    var _a2, _b2;
+    const type = action == null ? void 0 : action.type;
+    if (typeof type !== "string" || networkMonitor.isPaused || isIgnored(type)) {
+      return next(action);
+    }
+    const prevState = api.getState();
+    const t0 = now();
+    const result = next(action);
+    const reducerMs = now() - t0;
+    try {
+      const nextState = api.getState();
+      const changed = prevState !== nextState;
+      const flooding = isFlooding(maxPerSecond);
+      const isError = action.error === true;
+      const at = Date.now();
+      const truncatedPayload = truncateForPersist(
+        {
+          payload: action.payload,
+          meta: action.meta
+        },
+        MAX_REDUX_PAYLOAD_BYTES
+      );
+      const payload = truncatedPayload.value;
+      const replayable = !truncatedPayload.truncated;
+      const diff = changed && !flooding ? diffState(prevState, nextState) : void 0;
+      const slice = type.includes("/") ? type.slice(0, type.indexOf("/")) : type;
+      const canCoalesce = !replayOfId && lastEntryId != null && lastType === type && at - lastAt < coalesceMs;
+      if (canCoalesce && lastEntryId) {
+        const prevEntry = networkMonitor.getById(lastEntryId);
+        if (prevEntry) {
+          networkMonitor.update(lastEntryId, {
+            state: toEntryState(isError),
+            endTime: t0 + reducerMs,
+            sizeBytes: estimateBytes(payload),
+            // Reused generically by the detail pane's "Action" tab (same
+            // field HTTP entries use for their request body).
+            requestPayload: payload,
+            redux: {
+              type,
+              payload,
+              isError,
+              diff,
+              reducerMs,
+              replayable,
+              batchCount: ((_b2 = (_a2 = prevEntry.redux) == null ? void 0 : _a2.batchCount) != null ? _b2 : 1) + 1
+            }
+          });
+          lastAt = at;
+          return result;
+        }
+      }
+      const id = networkMonitor.nextId();
+      networkMonitor.start({
+        id,
+        kind: "redux",
+        method: slice,
+        url: type,
+        at,
+        startTime: t0,
+        state: toEntryState(isError),
+        sizeBytes: estimateBytes(payload),
+        requestPayload: payload,
+        replayOf: replayOfId != null ? replayOfId : void 0,
+        redux: { type, payload, isError, diff, reducerMs, replayable }
+      });
+      networkMonitor.update(id, { endTime: t0 + reducerMs });
+      lastEntryId = id;
+      lastType = type;
+      lastAt = at;
+    } catch (e) {
+    }
+    return result;
+  };
+}
+
+// src/capture/monitorContext.ts
+var owner = null;
+function openOwnerWindow(next) {
+  owner = next;
+  queueMicrotask(() => {
+    if (owner === next) owner = null;
+  });
+}
+function getOwner() {
+  return owner;
+}
+
+// src/capture/queryCapture.ts
+var tapped = /* @__PURE__ */ new WeakSet();
+var activeClient = null;
+function getTappedQueryClient() {
+  return activeClient;
+}
+var queryEntryIds = /* @__PURE__ */ new Map();
+var mutationEntryIds = /* @__PURE__ */ new Map();
+var fetchCounts = /* @__PURE__ */ new Map();
+var frameCounter = 0;
+function frame(direction, event) {
+  frameCounter += 1;
+  return { id: `qf${frameCounter}`, at: Date.now(), direction, event, data: void 0, sizeBytes: 0 };
+}
+function keyLabel(key) {
+  try {
+    return JSON.stringify(key);
+  } catch (e) {
+    return String(key);
+  }
+}
+function toEntryState2(status) {
+  if (status === "error") return "error";
+  if (status === "success") return "success";
+  return "pending";
+}
+function toQueryMeta(q) {
+  var _a, _b, _c;
+  return {
+    sub: "query",
+    hash: q.queryHash,
+    key: [...q.queryKey],
+    status: toEntryState2(q.state.status),
+    fetchStatus: q.state.fetchStatus,
+    observers: (_b = (_a = q.getObserversCount) == null ? void 0 : _a.call(q)) != null ? _b : 0,
+    isInvalidated: q.state.isInvalidated,
+    dataUpdatedAt: q.state.dataUpdatedAt,
+    errorUpdatedAt: q.state.errorUpdatedAt,
+    failureCount: q.state.fetchFailureCount,
+    fetchCount: (_c = fetchCounts.get(q.queryHash)) != null ? _c : 0
+  };
+}
+function handleQueryEvent(event) {
+  var _a, _b;
+  const q = event.query;
+  if (!q) return;
+  if (event.type === "observerResultsUpdated" || event.type === "observerOptionsUpdated") {
+    return;
+  }
+  if (event.type === "observerAdded" || event.type === "observerRemoved") {
+    const id2 = queryEntryIds.get(q.queryHash);
+    if (id2 && networkMonitor.getById(id2)) {
+      networkMonitor.update(id2, { query: toQueryMeta(q) });
+    }
+    return;
+  }
+  if (event.type === "removed") {
+    const id2 = queryEntryIds.get(q.queryHash);
+    if (id2 && networkMonitor.getById(id2)) {
+      networkMonitor.appendFrame(id2, frame("system", "removed"));
+      networkMonitor.update(id2, { query: __spreadProps(__spreadValues({}, toQueryMeta(q)), { gcRemoved: true }) });
+    }
+    return;
+  }
+  if (event.type !== "added" && event.type !== "updated") return;
+  const existingId = queryEntryIds.get(q.queryHash);
+  const isNew = !existingId || !networkMonitor.getById(existingId);
+  const id = isNew ? networkMonitor.nextId() : existingId;
+  if (isNew) {
+    queryEntryIds.set(q.queryHash, id);
+    networkMonitor.start({
+      id,
+      kind: "query",
+      method: "QUERY",
+      url: keyLabel(q.queryKey),
+      at: Date.now(),
+      startTime: now(),
+      state: toEntryState2(q.state.status),
+      sizeBytes: 0,
+      frames: [],
+      requestPayload: { key: [...q.queryKey] },
+      query: toQueryMeta(q)
+    });
+  }
+  const actionType = (_a = event.action) == null ? void 0 : _a.type;
+  switch (actionType) {
+    case "fetch":
+      fetchCounts.set(q.queryHash, ((_b = fetchCounts.get(q.queryHash)) != null ? _b : 0) + 1);
+      networkMonitor.appendFrame(id, frame("out", "fetch"));
+      openOwnerWindow({ id, kind: "query", label: keyLabel(q.queryKey) });
+      networkMonitor.update(id, { state: "pending", query: toQueryMeta(q) });
+      break;
+    case "success":
+      networkMonitor.appendFrame(id, frame("in", "success"));
+      networkMonitor.update(id, {
+        state: "success",
+        endTime: now(),
+        responsePayload: truncateForPersist(q.state.data, MAX_QUERY_DATA_BYTES).value,
+        query: toQueryMeta(q)
+      });
+      break;
+    case "error":
+    case "failed":
+      networkMonitor.appendFrame(id, frame("in", "error"));
+      networkMonitor.update(id, {
+        state: "error",
+        endTime: now(),
+        error: truncateForPersist(q.state.error, MAX_QUERY_DATA_BYTES).value,
+        query: toQueryMeta(q)
+      });
+      break;
+    case "invalidate":
+      networkMonitor.appendFrame(id, frame("system", "invalidate"));
+      networkMonitor.update(id, { query: toQueryMeta(q) });
+      break;
+    default:
+      if (!isNew) networkMonitor.update(id, { query: toQueryMeta(q) });
+  }
+}
+function handleMutationEvent(event) {
+  const m = event.mutation;
+  if (!m) return;
+  if (event.type === "observerResultsUpdated" || event.type === "observerOptionsUpdated") return;
+  const existingId = mutationEntryIds.get(m.mutationId);
+  const isNew = !existingId;
+  const id = isNew ? networkMonitor.nextId() : existingId;
+  if (isNew) {
+    mutationEntryIds.set(m.mutationId, id);
+    networkMonitor.start({
+      id,
+      kind: "query",
+      method: "MUTATE",
+      url: "mutation",
+      at: Date.now(),
+      startTime: now(),
+      state: toEntryState2(m.state.status),
+      sizeBytes: 0,
+      requestPayload: truncateForPersist(m.state.variables, MAX_QUERY_DATA_BYTES).value,
+      query: {
+        sub: "mutation",
+        hash: String(m.mutationId),
+        key: [],
+        status: toEntryState2(m.state.status),
+        observers: 0
+      }
+    });
+    if (m.state.status === "pending") {
+      openOwnerWindow({ id, kind: "mutation", label: `mutation #${m.mutationId}` });
+    }
+    return;
+  }
+  if (m.state.status === "success") {
+    networkMonitor.update(id, {
+      state: "success",
+      endTime: now(),
+      responsePayload: truncateForPersist(m.state.data, MAX_QUERY_DATA_BYTES).value,
+      query: { sub: "mutation", hash: String(m.mutationId), key: [], status: "success", observers: 0 }
+    });
+  } else if (m.state.status === "error") {
+    networkMonitor.update(id, {
+      state: "error",
+      endTime: now(),
+      error: truncateForPersist(m.state.error, MAX_QUERY_DATA_BYTES).value,
+      query: { sub: "mutation", hash: String(m.mutationId), key: [], status: "error", observers: 0 }
+    });
+  }
+}
+function tapQueryClient(client) {
+  if (!MONITOR_ENABLED) return () => {
+  };
+  if (tapped.has(client)) return () => {
+  };
+  tapped.add(client);
+  activeClient = client;
+  try {
+    for (const q of client.getQueryCache().getAll()) {
+      handleQueryEvent({ type: "added", query: q });
+    }
+  } catch (e) {
+  }
+  const unsubQuery = client.getQueryCache().subscribe((event) => {
+    try {
+      handleQueryEvent(event);
+    } catch (e) {
+    }
+  });
+  const unsubMutation = client.getMutationCache().subscribe((event) => {
+    try {
+      handleMutationEvent(event);
+    } catch (e) {
+    }
+  });
+  return () => {
+    unsubQuery();
+    unsubMutation();
+    tapped.delete(client);
+    if (activeClient === client) activeClient = null;
+  };
+}
+
+// src/capture/monitorInitiator.ts
+var NOISE = [
+  /[\\/]node_modules[\\/]axios[\\/]/,
+  /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/,
+  /[\\/]node_modules[\\/]@tanstack[\\/]/,
+  /monitorInitiator|networkMonitor|monitorPersistence/,
+  /[\\/]core[\\/]network[\\/]axios\.ts/,
+  /node:internal|next[\\/]dist/,
+  /^\s*at (?:Object\.)?(?:Promise|process|async)\b/
+];
+var FRAME_RE = /^\s*at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?$/;
+function tidyPath(file) {
+  const cleaned = file.replace(/^webpack-internal:\/{3}\(.*?\)\/\.?/, "").replace(/^rsc:\/{3}/, "").replace(/\?.*$/, "");
+  const at = cleaned.lastIndexOf("/src/");
+  if (at >= 0) return cleaned.slice(at + 1);
+  const backslash = cleaned.lastIndexOf("\\src\\");
+  if (backslash >= 0) return cleaned.slice(backslash + 1).replace(/\\/g, "/");
+  return cleaned;
+}
+var MAX_FRAMES = 8;
+function parseStack(stack) {
+  if (!stack) return [];
+  const out = [];
+  for (const line of stack.split("\n").slice(1)) {
+    if (NOISE.some((re) => re.test(line))) continue;
+    const match = FRAME_RE.exec(line);
+    if (!match) continue;
+    const [, fn, file, lineNo, col] = match;
+    out.push({
+      fn: (fn == null ? void 0 : fn.trim()) || void 0,
+      file: tidyPath(file),
+      line: Number(lineNo),
+      col: Number(col)
+    });
+    if (out.length >= MAX_FRAMES) break;
+  }
+  return out;
+}
+function summarizeInitiator(frames) {
+  var _a, _b;
+  if (frames.length === 0) return "";
+  const own = (_a = frames.find((f) => /^src\/(features|shared|app)\//.test(f.file))) != null ? _a : frames[0];
+  const name = own.fn ? `${own.fn} \xB7 ` : "";
+  const file = (_b = own.file.split("/").pop()) != null ? _b : own.file;
+  return `${name}${file}${own.line ? `:${own.line}` : ""}`;
+}
+var captureEnabled = true;
+function setInitiatorCapture(on) {
+  captureEnabled = on;
+}
+function captureFrames() {
+  if (!captureEnabled) return void 0;
+  const previousLimit = Error.stackTraceLimit;
+  try {
+    Error.stackTraceLimit = 24;
+    const stack = new Error().stack;
+    return parseStack(stack);
+  } catch (e) {
+    return void 0;
+  } finally {
+    Error.stackTraceLimit = previousLimit;
+  }
+}
+function withInitiatorCapture(instance) {
+  if (!MONITOR_ENABLED) return instance;
+  const attach = (config) => {
+    if (!config) return config;
+    if (!config.__monitorInitiator) config.__monitorInitiator = captureFrames();
+    return config;
+  };
+  const proxy = new Proxy(instance, {
+    apply(target, thisArg, args) {
+      const [config] = args;
+      return Reflect.apply(
+        target,
+        thisArg,
+        [attach(config)]
+      );
+    },
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      if (prop === "request") {
+        return (config) => value.call(target, attach(config));
+      }
+      if (prop === "post" || prop === "put" || prop === "patch") {
+        return (url, data, config) => value.call(
+          target,
+          url,
+          data,
+          attach(config != null ? config : {})
+        );
+      }
+      if (prop === "get" || prop === "delete" || prop === "head") {
+        return (url, config) => value.call(target, url, attach(config != null ? config : {}));
+      }
+      return value.bind(target);
+    }
+  });
+  return proxy;
+}
+
+export {
+  __spreadValues,
+  __spreadProps,
+  MONITOR_ENABLED,
+  NM_SCHEMA_VERSION,
+  NM_DB_VERSION,
+  configureDbName,
+  getActiveDbName,
+  MAX_ENTRIES,
+  PERSIST_MAX_ENTRIES,
+  PERSIST_MAX_BYTES,
+  PERSIST_MAX_ENTRY_BYTES,
+  SEARCH_INDEX_CAP,
+  PENDING_WINDOW_CAP_MS,
+  now,
+  getOwner,
+  serializeBody,
+  serializeHeaders,
+  estimateBytes,
+  networkMonitor,
+  truncateForPersist,
+  isTruncationMarker,
+  setReduxIgnoreList,
+  getReduxIgnoreList,
+  markReplaying,
+  createReduxMonitorMiddleware,
+  getTappedQueryClient,
+  tapQueryClient,
+  summarizeInitiator,
+  setInitiatorCapture,
+  withInitiatorCapture
+};