@buoy-gg/network 7.0.20 → 7.0.21

package/README.md

@@ -36,6 +36,7 @@ Want a different label or color? Build the tool with `createNetworkTool({ name,
 ## What you get
 
 - **Every request, zero config** — intercepts `fetch` and `XMLHttpRequest`, so fetch, axios, GraphQL clients, and gRPC-web all show up automatically.
+- **Boot requests included** — interception installs at app launch (dev builds), so module-scope fetches, session bootstrap, and your first queries are captured even though they fired before any tool or dashboard was open.
 - **GraphQL gets special treatment** — operation names are extracted from queries, mutations, and subscriptions and shown with variables in arrow notation: `GetUser › 123`. No more guessing which `/graphql` request is which.
 - **Full request detail** — request/response headers, payloads, HTTP status, and duration for every call, with status-colored rows.
 - **Filter and search** — narrow by status code, HTTP method, or URL pattern; search captured events; pause/resume capture; clear history.

package/lib/commonjs/network/utils/networkEventStore.js

@@ -37,6 +37,13 @@ var _networkSavedStore = require("./networkSavedStore");
  * Callback type for full events array notifications
  */
 
+/**
+ * Cap on raw events held in the boot buffer before the first consumer
+ * subscribes (request + response are separate raw events, so this is ~100
+ * requests). Old events are dropped first; a response whose request was
+ * evicted is simply ignored at flush (processNetworkEvent finds no match).
+ */
+const BOOT_BUFFER_MAX = 200;
 class NetworkEventStore extends _sharedUi.BaseEventStore {
   pendingRequests = new Map();
   /**
@@ -48,6 +55,11 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
    */
   recentRequests = new Map();
   rawListenerUnsubscribe = null;
+  /** Raw events captured before the first consumer subscribed — see startBootCapture. */
+  bootBuffer = [];
+  bootBufferUnsubscribe = null;
+  /** Set by disableCapture (remote-mirror mode) — boot capture must never (re)start. */
+  mirrorMode = false;
   constructor() {
     super({
       storeName: "network",
@@ -55,6 +67,48 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
     });
   }
 
+  /**
+   * Install the interceptor NOW and buffer raw events until the first real
+   * consumer subscribes.
+   *
+   * Why: capture normally starts with the first subscriber — the Network modal
+   * opening, a dashboard watch, an MCP watch — which is long after the app's
+   * startup requests (module-scope fetches, session bootstrap, the first
+   * query) have already fired. Those were unrecoverable: by the time anything
+   * subscribed, boot traffic was gone. Called as a dev-only import-time side
+   * effect from the preset, this hooks fetch/XHR at bundle-eval and parks the
+   * raw events in a bounded buffer; `startCapturing` flushes them into the
+   * store in order, so every consumer sees boot requests too.
+   *
+   * If no consumer EVER subscribes, nothing is flushed — the buffer just sits
+   * bounded at BOOT_BUFFER_MAX raw events (an explicit user "capture off"
+   * state therefore never gains events it didn't ask for).
+   */
+  startBootCapture() {
+    if (this.mirrorMode || this.bootBufferUnsubscribe || this.isCapturing()) {
+      return;
+    }
+    const listener = (0, _networkListener.networkListener)();
+    if (!listener.isActive) {
+      listener.startListening();
+    }
+    this.bootBufferUnsubscribe = (0, _networkListener.addNetworkListener)(event => {
+      this.bootBuffer.push(event);
+      if (this.bootBuffer.length > BOOT_BUFFER_MAX) this.bootBuffer.shift();
+    });
+  }
+
+  /** Detach the boot-buffer listener; optionally hand back what it caught. */
+  takeBootBuffer() {
+    if (this.bootBufferUnsubscribe) {
+      this.bootBufferUnsubscribe();
+      this.bootBufferUnsubscribe = null;
+    }
+    const buffered = this.bootBuffer;
+    this.bootBuffer = [];
+    return buffered;
+  }
+
   /**
    * Start capturing network events
    */
@@ -66,6 +120,13 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
       listener.startListening();
     }
 
+    // Flush boot-buffered events (in capture order) BEFORE attaching the live
+    // listener: the boot listener is detached first, so no event can be seen
+    // by both. All synchronous — nothing interleaves.
+    for (const event of this.takeBootBuffer()) {
+      this.processNetworkEvent(event);
+    }
+
     // Add our listener to push raw events into the store
     if (!this.rawListenerUnsubscribe) {
       this.rawListenerUnsubscribe = (0, _networkListener.addNetworkListener)(event => {
@@ -91,6 +152,22 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
     }
   }
 
+  /**
+   * Remote-mirror mode (desktop dashboard): on top of the base behavior, tear
+   * down boot capture and drop its buffer — a mirror must never intercept its
+   * OWN process's traffic, and must never flush host requests into the
+   * device-event list it mirrors.
+   */
+  disableCapture() {
+    this.mirrorMode = true;
+    this.takeBootBuffer();
+    const listener = (0, _networkListener.networkListener)();
+    if (listener.listenerCount === 0 && listener.isActive) {
+      listener.stopListening();
+    }
+    super.disableCapture();
+  }
+
   /**
    * Check if the store is actively capturing network events
    */
@@ -106,9 +183,15 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
       request
     } = event;
     if (event.type === "request") {
-      // Check for duplicate request based on URL, method, and timing
+      // Check for duplicate request based on URL, method, and timing.
+      // The clock is the event's CAPTURE time, not Date.now(): boot-buffered
+      // events are flushed in one synchronous burst, and wall-clock "now"
+      // would put two genuinely separate boot requests to the same endpoint
+      // inside the 50ms dual-interception window, silently dropping one. For
+      // live events the two clocks are the same (the raw event is emitted
+      // synchronously at capture).
       const requestKey = `${request.method}:${request.url}`;
-      const now = Date.now();
+      const now = event.timestamp instanceof Date ? event.timestamp.getTime() : Date.now();
       const recent = this.recentRequests.get(requestKey);
 
       // If same request within 50ms, likely a duplicate from XHR/fetch dual

package/lib/commonjs/preset.js

@@ -8,6 +8,7 @@ exports.networkToolPreset = void 0;
 var _sharedUi = require("@buoy-gg/shared-ui");
 var _NetworkModal = require("./network/components/NetworkModal");
 var _overrideRulesStore = require("./network/overrides/overrideRulesStore");
+var _networkEventStore = require("./network/utils/networkEventStore");
 var _jsxRuntime = require("react/jsx-runtime");
 /**
  * Pre-configured network monitoring tool for FloatingDevTools
@@ -36,6 +37,27 @@ var _jsxRuntime = require("react/jsx-runtime");
  * the interceptor if any rule is still active. One storage read, dev-only.
  */void _overrideRulesStore.overrideRulesStore.ensureLoaded();
 
+/**
+ * Install interception at IMPORT time and buffer boot traffic.
+ *
+ * Capture used to start with the first subscriber (Network modal open,
+ * dashboard/MCP watch) — long after the app's startup requests (module-scope
+ * fetches, session bootstrap, the first query) had fired, so boot traffic was
+ * permanently invisible. The boot buffer holds those raw events until the
+ * first consumer subscribes, then flushes them into the store; if nothing
+ * ever subscribes, nothing is flushed (see startBootCapture).
+ *
+ * Guards:
+ * - `navigator.product === "ReactNative"` — a real RN runtime only. The
+ *   desktop dashboard and web mirrors also evaluate this module and must
+ *   never intercept their OWN process's traffic.
+ * - Dev-only, like the rest of the automatic capture behavior.
+ */
+const isReactNativeRuntime = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+if (isReactNativeRuntime && typeof __DEV__ !== "undefined" && __DEV__) {
+  _networkEventStore.networkEventStore.startBootCapture();
+}
+
 /**
  * Pre-configured network monitoring tool for FloatingDevTools.
  * Includes:

package/lib/module/network/utils/networkEventStore.js

@@ -34,6 +34,13 @@ import { networkSavedStore } from "./networkSavedStore";
  * Callback type for full events array notifications
  */
 
+/**
+ * Cap on raw events held in the boot buffer before the first consumer
+ * subscribes (request + response are separate raw events, so this is ~100
+ * requests). Old events are dropped first; a response whose request was
+ * evicted is simply ignored at flush (processNetworkEvent finds no match).
+ */
+const BOOT_BUFFER_MAX = 200;
 class NetworkEventStore extends BaseEventStore {
   pendingRequests = new Map();
   /**
@@ -45,6 +52,11 @@ class NetworkEventStore extends BaseEventStore {
    */
   recentRequests = new Map();
   rawListenerUnsubscribe = null;
+  /** Raw events captured before the first consumer subscribed — see startBootCapture. */
+  bootBuffer = [];
+  bootBufferUnsubscribe = null;
+  /** Set by disableCapture (remote-mirror mode) — boot capture must never (re)start. */
+  mirrorMode = false;
   constructor() {
     super({
       storeName: "network",
@@ -52,6 +64,48 @@ class NetworkEventStore extends BaseEventStore {
     });
   }
 
+  /**
+   * Install the interceptor NOW and buffer raw events until the first real
+   * consumer subscribes.
+   *
+   * Why: capture normally starts with the first subscriber — the Network modal
+   * opening, a dashboard watch, an MCP watch — which is long after the app's
+   * startup requests (module-scope fetches, session bootstrap, the first
+   * query) have already fired. Those were unrecoverable: by the time anything
+   * subscribed, boot traffic was gone. Called as a dev-only import-time side
+   * effect from the preset, this hooks fetch/XHR at bundle-eval and parks the
+   * raw events in a bounded buffer; `startCapturing` flushes them into the
+   * store in order, so every consumer sees boot requests too.
+   *
+   * If no consumer EVER subscribes, nothing is flushed — the buffer just sits
+   * bounded at BOOT_BUFFER_MAX raw events (an explicit user "capture off"
+   * state therefore never gains events it didn't ask for).
+   */
+  startBootCapture() {
+    if (this.mirrorMode || this.bootBufferUnsubscribe || this.isCapturing()) {
+      return;
+    }
+    const listener = networkListener();
+    if (!listener.isActive) {
+      listener.startListening();
+    }
+    this.bootBufferUnsubscribe = addNetworkListener(event => {
+      this.bootBuffer.push(event);
+      if (this.bootBuffer.length > BOOT_BUFFER_MAX) this.bootBuffer.shift();
+    });
+  }
+
+  /** Detach the boot-buffer listener; optionally hand back what it caught. */
+  takeBootBuffer() {
+    if (this.bootBufferUnsubscribe) {
+      this.bootBufferUnsubscribe();
+      this.bootBufferUnsubscribe = null;
+    }
+    const buffered = this.bootBuffer;
+    this.bootBuffer = [];
+    return buffered;
+  }
+
   /**
    * Start capturing network events
    */
@@ -63,6 +117,13 @@ class NetworkEventStore extends BaseEventStore {
       listener.startListening();
     }
 
+    // Flush boot-buffered events (in capture order) BEFORE attaching the live
+    // listener: the boot listener is detached first, so no event can be seen
+    // by both. All synchronous — nothing interleaves.
+    for (const event of this.takeBootBuffer()) {
+      this.processNetworkEvent(event);
+    }
+
     // Add our listener to push raw events into the store
     if (!this.rawListenerUnsubscribe) {
       this.rawListenerUnsubscribe = addNetworkListener(event => {
@@ -88,6 +149,22 @@ class NetworkEventStore extends BaseEventStore {
     }
   }
 
+  /**
+   * Remote-mirror mode (desktop dashboard): on top of the base behavior, tear
+   * down boot capture and drop its buffer — a mirror must never intercept its
+   * OWN process's traffic, and must never flush host requests into the
+   * device-event list it mirrors.
+   */
+  disableCapture() {
+    this.mirrorMode = true;
+    this.takeBootBuffer();
+    const listener = networkListener();
+    if (listener.listenerCount === 0 && listener.isActive) {
+      listener.stopListening();
+    }
+    super.disableCapture();
+  }
+
   /**
    * Check if the store is actively capturing network events
    */
@@ -103,9 +180,15 @@ class NetworkEventStore extends BaseEventStore {
       request
     } = event;
     if (event.type === "request") {
-      // Check for duplicate request based on URL, method, and timing
+      // Check for duplicate request based on URL, method, and timing.
+      // The clock is the event's CAPTURE time, not Date.now(): boot-buffered
+      // events are flushed in one synchronous burst, and wall-clock "now"
+      // would put two genuinely separate boot requests to the same endpoint
+      // inside the 50ms dual-interception window, silently dropping one. For
+      // live events the two clocks are the same (the raw event is emitted
+      // synchronously at capture).
       const requestKey = `${request.method}:${request.url}`;
-      const now = Date.now();
+      const now = event.timestamp instanceof Date ? event.timestamp.getTime() : Date.now();
       const recent = this.recentRequests.get(requestKey);
 
       // If same request within 50ms, likely a duplicate from XHR/fetch dual

package/lib/module/preset.js

@@ -20,6 +20,7 @@
 import { NetworkIcon } from "@buoy-gg/shared-ui";
 import { NetworkModal } from "./network/components/NetworkModal";
 import { overrideRulesStore } from "./network/overrides/overrideRulesStore";
+import { networkEventStore } from "./network/utils/networkEventStore";
 
 /**
  * Load persisted response-override rules as soon as the tool is registered.
@@ -33,6 +34,27 @@ import { overrideRulesStore } from "./network/overrides/overrideRulesStore";
 import { jsx as _jsx } from "react/jsx-runtime";
 void overrideRulesStore.ensureLoaded();
 
+/**
+ * Install interception at IMPORT time and buffer boot traffic.
+ *
+ * Capture used to start with the first subscriber (Network modal open,
+ * dashboard/MCP watch) — long after the app's startup requests (module-scope
+ * fetches, session bootstrap, the first query) had fired, so boot traffic was
+ * permanently invisible. The boot buffer holds those raw events until the
+ * first consumer subscribes, then flushes them into the store; if nothing
+ * ever subscribes, nothing is flushed (see startBootCapture).
+ *
+ * Guards:
+ * - `navigator.product === "ReactNative"` — a real RN runtime only. The
+ *   desktop dashboard and web mirrors also evaluate this module and must
+ *   never intercept their OWN process's traffic.
+ * - Dev-only, like the rest of the automatic capture behavior.
+ */
+const isReactNativeRuntime = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+if (isReactNativeRuntime && typeof __DEV__ !== "undefined" && __DEV__) {
+  networkEventStore.startBootCapture();
+}
+
 /**
  * Pre-configured network monitoring tool for FloatingDevTools.
  * Includes:

package/lib/typescript/network/utils/networkEventStore.d.ts

@@ -40,7 +40,32 @@ declare class NetworkEventStore extends BaseEventStore<NetworkEvent> {
      */
     private recentRequests;
     private rawListenerUnsubscribe;
+    /** Raw events captured before the first consumer subscribed — see startBootCapture. */
+    private bootBuffer;
+    private bootBufferUnsubscribe;
+    /** Set by disableCapture (remote-mirror mode) — boot capture must never (re)start. */
+    private mirrorMode;
     constructor();
+    /**
+     * Install the interceptor NOW and buffer raw events until the first real
+     * consumer subscribes.
+     *
+     * Why: capture normally starts with the first subscriber — the Network modal
+     * opening, a dashboard watch, an MCP watch — which is long after the app's
+     * startup requests (module-scope fetches, session bootstrap, the first
+     * query) have already fired. Those were unrecoverable: by the time anything
+     * subscribed, boot traffic was gone. Called as a dev-only import-time side
+     * effect from the preset, this hooks fetch/XHR at bundle-eval and parks the
+     * raw events in a bounded buffer; `startCapturing` flushes them into the
+     * store in order, so every consumer sees boot requests too.
+     *
+     * If no consumer EVER subscribes, nothing is flushed — the buffer just sits
+     * bounded at BOOT_BUFFER_MAX raw events (an explicit user "capture off"
+     * state therefore never gains events it didn't ask for).
+     */
+    startBootCapture(): void;
+    /** Detach the boot-buffer listener; optionally hand back what it caught. */
+    private takeBootBuffer;
     /**
      * Start capturing network events
      */
@@ -49,6 +74,13 @@ declare class NetworkEventStore extends BaseEventStore<NetworkEvent> {
      * Stop capturing network events
      */
     protected stopCapturing(): void;
+    /**
+     * Remote-mirror mode (desktop dashboard): on top of the base behavior, tear
+     * down boot capture and drop its buffer — a mirror must never intercept its
+     * OWN process's traffic, and must never flush host requests into the
+     * device-event list it mirrors.
+     */
+    disableCapture(): void;
     /**
      * Check if the store is actively capturing network events
      */

package/lib/typescript/network/utils/networkEventStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"networkEventStore.d.ts","sourceRoot":"","sources":["../../../../src/network/utils/networkEventStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAQzD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,IAAI,CAAC;AAE1E,cAAM,iBAAkB,SAAQ,cAAc,CAAC,YAAY,CAAC;IAC1D,OAAO,CAAC,eAAe,CAAwC;IAC/D;;;;;;OAMG;IACH,OAAO,CAAC,cAAc,CAAsD;IAC5E,OAAO,CAAC,sBAAsB,CAA6B;;IAS3D;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAgBhC;;OAEG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAc/B;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAwIjD;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,WAAW;IAUnB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIlD;;OAEG;IACH,WAAW,IAAI,IAAI;IAMnB;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,oBAAoB,EAAE,cAAc,UAAO,GAAG,MAAM,IAAI;IAkB1E,QAAQ;;;;;;;;;IAuCR,YAAY,CAAC,MAAM,EAAE;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;QACzC,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,GAAG,YAAY,EAAE;CAyCnB;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}
+{"version":3,"file":"networkEventStore.d.ts","sourceRoot":"","sources":["../../../../src/network/utils/networkEventStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAQzD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,IAAI,CAAC;AAU1E,cAAM,iBAAkB,SAAQ,cAAc,CAAC,YAAY,CAAC;IAC1D,OAAO,CAAC,eAAe,CAAwC;IAC/D;;;;;;OAMG;IACH,OAAO,CAAC,cAAc,CAAsD;IAC5E,OAAO,CAAC,sBAAsB,CAA6B;IAC3D,uFAAuF;IACvF,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,qBAAqB,CAA6B;IAC1D,sFAAsF;IACtF,OAAO,CAAC,UAAU,CAAS;;IAS3B;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,IAAI,IAAI;IAcxB,4EAA4E;IAC5E,OAAO,CAAC,cAAc;IAUtB;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAuBhC;;OAEG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAc/B;;;;;OAKG;IACH,cAAc,IAAI,IAAI;IAUtB;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IA+IjD;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,WAAW;IAUnB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIlD;;OAEG;IACH,WAAW,IAAI,IAAI;IAMnB;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,oBAAoB,EAAE,cAAc,UAAO,GAAG,MAAM,IAAI;IAkB1E,QAAQ;;;;;;;;;IAuCR,YAAY,CAAC,MAAM,EAAE;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;QACzC,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,GAAG,YAAY,EAAE;CAyCnB;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}

package/lib/typescript/preset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preset.d.ts","sourceRoot":"","sources":["../../src/preset.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAcjE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;qBAKX;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;;;;;CAKlC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAC1C,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,qCAAqC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;;;;;qBAMoB;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;;;;;EASpC"}
+{"version":3,"file":"preset.d.ts","sourceRoot":"","sources":["../../src/preset.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAqCjE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;qBAKX;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;;;;;CAKlC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAC1C,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,qCAAqC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;;;;;qBAMoB;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;;;;;EASpC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buoy-gg/network",
-  "version": "7.0.20",
+  "version": "7.0.21",
   "description": "In-app network inspector for React Native — requests, responses, timing & errors live, with GraphQL operation parsing. Part of Buoy devtools.",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -26,7 +26,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@buoy-gg/shared-ui": "^7.0.20"
+    "@buoy-gg/shared-ui": "^7.0.21"
   },
   "peerDependencies": {
     "react": "*",