@buoy-gg/network 7.0.39 → 7.0.41

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nextRequestId = nextRequestId;
+const runtime = globalThis;
+
+// Keep identity across Fast Refresh; distinguish requests from earlier app runs.
+function nextRequestId(client) {
+  const sequence = runtime.__BUOY_NETWORK_REQUEST_SEQUENCE__ ??= {
+    session: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`,
+    next: 0
+  };
+  return `${client}_${sequence.session}_${++sequence.next}`;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveRequestUrl = resolveRequestUrl;
+/** Resolve browser-relative URLs for capture without changing the request arguments. */
+function resolveRequestUrl(url) {
+  if (typeof document === "undefined") return url;
+  try {
+    return new URL(url, document.baseURI).href;
+  } catch {
+    return url;
+  }
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startNetworkCapture = startNetworkCapture;
+var _networkEventStore = require("./networkEventStore");
+var _overrideRulesStore = require("../overrides/overrideRulesStore");
+/**
+ * Keep local capture active while the Network panel is closed.
+ * Call in the app being inspected and dispose during unmount or HMR cleanup.
+ */
+function startNetworkCapture() {
+  const native = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+  if (!native && (typeof window === "undefined" || typeof document === "undefined")) return () => {};
+  void _overrideRulesStore.overrideRulesStore.ensureLoaded();
+  const unsubscribe = _networkEventStore.networkEventStore.subscribeToEvents(() => {});
+  let stopped = false;
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    unsubscribe();
+  };
+}

package/lib/commonjs/preset.js

@@ -27,16 +27,6 @@ var _jsxRuntime = require("react/jsx-runtime");
  * ```
  */
 
-/**
- * Load persisted response-override rules as soon as the tool is registered.
- *
- * Deliberately at import time rather than when the Network modal mounts: an
- * override has to fire from app boot, with the tool closed and nothing
- * capturing — that is the whole point of persisting rules ("force this endpoint
- * to 500, then restart and watch the boot path"). Hydrating also re-installs
- * 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.
  *
@@ -52,8 +42,9 @@ var _jsxRuntime = require("react/jsx-runtime");
  *   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";
+ */const isReactNativeRuntime = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+// Browser capture initializes persisted rules explicitly through startNetworkCapture.
+if (isReactNativeRuntime) void _overrideRulesStore.overrideRulesStore.ensureLoaded();
 if (isReactNativeRuntime && typeof __DEV__ !== "undefined" && __DEV__) {
   _networkEventStore.networkEventStore.startBootCapture();
 }

package/lib/module/index.js

@@ -14,6 +14,7 @@
 // PRESET (Primary entry point for users)
 // =============================================================================
 export { networkToolPreset, createNetworkTool } from "./preset";
+export { startNetworkCapture } from "./network/utils/startNetworkCapture";
 
 // =============================================================================
 // COMPONENTS (For custom UI implementations)

package/lib/module/network/components/NetworkListScreen.js

@@ -20,7 +20,7 @@ import { NetworkUpgradeBanner } from "./NetworkUpgradeBanner";
 import { useNetworkEventList } from "../hooks/useNetworkEventList";
 import { useNetworkSaved } from "../hooks/useNetworkSaved";
 import { useOverrideRules } from "../hooks/useOverrideRules";
-import { ruleMatches } from "../overrides/matchRule";
+import { overriddenEvents } from "../overrides/overriddenRows";
 import { splitPinned } from "../utils/withPinnedFirst";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const keyExtractor = item => item.id;
@@ -192,8 +192,7 @@ export function NetworkListScreen({
   // Paused rules still populate the strip — that's how you find the thing you
   // paused in order to resume it. The header says PAUSED instead.
   const activeRules = rules.filter(rule => rule.enabled && !isRuleSpent(rule));
-  const isOverridden = event => activeRules.some(rule => ruleMatches(rule, event.url, String(event.method || "GET")));
-  const overridden = activeRules.length ? [...pinned, ...rest].filter(isOverridden) : [];
+  const overridden = overriddenEvents([...pinned, ...rest], activeRules);
   const overriddenIds = new Set(overridden.map(event => event.id));
   const pinnedRows = pinned.filter(event => !overriddenIds.has(event.id));
   const restRows = overriddenIds.size ? rest.filter(event => !overriddenIds.has(event.id)) : rest;

package/lib/module/network/components/NetworkListScreen.web.js

@@ -53,7 +53,7 @@ import { NetworkEventItemCompact } from "./NetworkEventItemCompact.web";
 import { useNetworkEventList } from "../hooks/useNetworkEventList";
 import { useNetworkSaved } from "../hooks/useNetworkSaved";
 import { useOverrideRules } from "../hooks/useOverrideRules";
-import { ruleMatches } from "../overrides/matchRule";
+import { overriddenEvents } from "../overrides/overriddenRows";
 import { splitPinned } from "../utils/withPinnedFirst";
 
 // =============================
@@ -385,8 +385,7 @@ export function NetworkListScreen({
   // Hoist anything an active rule covers. Done after `splitPinned` so a request
   // that is both pinned and overridden appears once, in the louder section.
   const activeRules = rules.filter(rule => rule.enabled && !isRuleSpent(rule));
-  const isOverridden = event => activeRules.some(rule => ruleMatches(rule, event.url, String(event.method || "GET")));
-  const overridden = activeRules.length ? [...pinned, ...rest].filter(isOverridden) : [];
+  const overridden = overriddenEvents([...pinned, ...rest], activeRules);
   const overriddenIds = new Set(overridden.map(event => event.id));
   const pinnedRows = pinned.filter(event => !overriddenIds.has(event.id));
   const restRows = overriddenIds.size ? rest.filter(event => !overriddenIds.has(event.id)) : rest;

package/lib/module/network/components/NetworkModal.js

@@ -496,7 +496,7 @@ function NetworkModalInner({
         }) : null, /*#__PURE__*/_jsx(PowerToggleButton, {
           isEnabled: !paused,
           onToggle: () => setPaused(prev => !prev),
-          accessibilityLabel: "Pause network list",
+          accessibilityLabel: paused ? "Resume network capture" : "Pause network capture",
           testID: "buoy-network-power"
         }), /*#__PURE__*/_jsx(NetworkClearButton, {
           paused: paused

package/lib/module/network/conditions/xhr.js

@@ -1,9 +1,34 @@
 "use strict";
 
-import { canSynthesize, completeNativeOverride } from "../overrides/applyToXhr";
+import { canSynthesize, completeNativeOverride, runOverride } from "../overrides/applyToXhr";
 /** Active simulation uses a send-to-completion deadline, including the wait. */
 export function runConditionXhr(target, url, condition, outcome, dispatch) {
-  if (!canSynthesize(target)) throw new Error("Network conditions require React Native XMLHttpRequest.");
+  if (!canSynthesize(target)) {
+    const rule = {
+      id: "condition",
+      enabled: true,
+      urlPattern: url,
+      kind: "delay",
+      hits: 0,
+      seen: 0,
+      createdAt: Date.now()
+    };
+    const simulation = condition.profile === "offline" ? {
+      kind: "fail",
+      rule,
+      failKind: "network",
+      delayMs: 0
+    } : outcome ? {
+      ...outcome,
+      delayMs: condition.delayMs + outcome.delayMs
+    } : {
+      kind: "delay",
+      rule,
+      delayMs: condition.delayMs
+    };
+    if (!runOverride(target, url, simulation, dispatch)) throw new Error("Network conditions are unavailable for this XMLHttpRequest implementation.");
+    return;
+  }
   const xhr = target;
   if (xhr.readyState !== 1 || xhr._sent) throw new Error("Request is not open or has already been sent.");
   const started = Date.now();

package/lib/module/network/overrides/applyToXhr.js

@@ -279,6 +279,7 @@ function respondStandard(xhr, url, outcome, isAborted) {
   setStandardReadyState(xhr, LOADING);
   if (isAborted()) return;
   setStandardReadyState(xhr, DONE);
+  if (isAborted()) return;
   fireEvent(xhr, "load");
   fireEvent(xhr, "loadend");
 }
@@ -307,60 +308,115 @@ function failStandard(xhr, outcome) {
  * `delay` pass-through hands the request to the real network, where the
  * prototype `abort()` must be reachable again.
  */
+const pendingStandardRequests = new WeakMap();
+export function hasPendingStandardRequest(xhr) {
+  return pendingStandardRequests.has(xhr);
+}
 function runStandardOverride(xhr, url, outcome, passThrough) {
-  let timer = null;
-  let aborted = false;
+  const started = Date.now();
+  const generation = {};
+  let timer;
+  let deadline;
   let settled = false;
-  const restoreAbort = () => {
-    try {
-      delete xhr.abort;
-    } catch {
-      // Non-configurable shadow can't happen (we define it configurable), but
-      // never let cleanup throw into app code.
+  let aborted = false;
+  let dispatched = false;
+  let timeout = xhr.timeout;
+  const originalAbort = xhr.abort;
+  const originalOpen = xhr.open;
+  const names = ['abort', 'open', 'timeout', 'readyState', 'status', 'statusText', 'response', 'responseText', 'responseURL', 'getAllResponseHeaders', 'getResponseHeader'];
+  const descriptors = new Map(names.map(name => [name, Object.getOwnPropertyDescriptor(xhr, name)]));
+  let prototype = Object.getPrototypeOf(xhr);
+  let nativeTimeout;
+  while (prototype && !nativeTimeout) {
+    nativeTimeout = Object.getOwnPropertyDescriptor(prototype, 'timeout');
+    prototype = Object.getPrototypeOf(prototype);
+  }
+  const finish = () => {
+    settled = true;
+    if (pendingStandardRequests.get(xhr) === generation) pendingStandardRequests.delete(xhr);
+    clearTimeout(timer);
+    clearTimeout(deadline);
+    xhr.removeEventListener('loadend', finish);
+  };
+  const restore = () => {
+    finish();
+    for (const [name, descriptor] of descriptors) {
+      if (descriptor) Object.defineProperty(xhr, name, descriptor);else delete xhr[name];
     }
+    xhr.timeout = timeout;
   };
-  Object.defineProperty(xhr, "abort", {
+  const scheduleDeadline = () => {
+    clearTimeout(deadline);
+    if (dispatched) {
+      nativeTimeout?.set?.call(xhr, timeout > 0 ? Math.max(1, timeout - (Date.now() - started)) : 0);
+    } else if (timeout > 0) {
+      deadline = setTimeout(() => {
+        if (settled) return;
+        clearTimeout(timer);
+        failStandard(xhr, {
+          ...outcome,
+          kind: 'fail',
+          failKind: 'timeout'
+        });
+        finish();
+      }, Math.max(0, timeout - (Date.now() - started)));
+    }
+  };
+  Object.defineProperty(xhr, 'timeout', {
+    configurable: true,
+    get: () => timeout,
+    set: value => {
+      timeout = Math.max(0, Number(value) || 0);
+      scheduleDeadline();
+    }
+  });
+  Object.defineProperty(xhr, 'open', {
+    configurable: true,
+    value: (...args) => {
+      restore();
+      return Reflect.apply(originalOpen, xhr, args);
+    }
+  });
+  Object.defineProperty(xhr, 'abort', {
     configurable: true,
-    writable: true,
     value: () => {
-      if (settled || aborted) return;
-      aborted = true;
-      settled = true;
-      if (timer !== null) {
-        clearTimeout(timer);
-        timer = null;
+      if (dispatched || settled) {
+        restore();
+        originalAbort.call(xhr);
+        return;
       }
-      restoreAbort();
-      // The in-flight abort sequence: DONE, then 'abort', then 'loadend' —
-      // whatwg's request-error steps, which is also what RN's setReadyState
-      // dispatches off `_aborted`.
+      aborted = true;
+      clearTimeout(timer);
       setStandardReadyState(xhr, DONE);
-      fireEvent(xhr, "abort");
-      fireEvent(xhr, "loadend");
+      fireEvent(xhr, 'abort');
+      fireEvent(xhr, 'loadend');
+      finish();
+      if (!pendingStandardRequests.has(xhr)) defineOwn(xhr, 'readyState', 0);
     }
   });
-  const fire = () => {
-    timer = null;
-    if (aborted) return;
-    if (outcome.kind === "delay") {
-      // The real request is about to be genuinely in flight — put the
-      // prototype `abort()` back FIRST so cancelling reaches the network.
-      restoreAbort();
-      passThrough();
+  pendingStandardRequests.set(xhr, generation);
+  xhr.addEventListener('loadend', finish);
+  scheduleDeadline();
+  timer = setTimeout(() => {
+    if (settled || aborted) return;
+    if (outcome.kind === 'delay') {
+      dispatched = true;
+      scheduleDeadline();
+      try {
+        passThrough();
+      } catch {
+        failStandard(xhr, {
+          ...outcome,
+          kind: 'fail',
+          failKind: 'network'
+        });
+        finish();
+      }
       return;
     }
-    if (outcome.kind === "fail") {
-      failStandard(xhr, outcome);
-    } else {
-      respondStandard(xhr, url, outcome, () => aborted);
-    }
-    settled = true;
-    restoreAbort();
-  };
-
-  // ALWAYS asynchronous, even at 0ms — same contract as the RN path: callers
-  // legitimately attach handlers after `send()` returns (axios does).
-  timer = setTimeout(fire, outcome.delayMs);
+    if (outcome.kind === 'fail') failStandard(xhr, outcome);else respondStandard(xhr, url, outcome, () => aborted || pendingStandardRequests.get(xhr) !== generation);
+    finish();
+  }, outcome.delayMs);
   return true;
 }
 

package/lib/module/network/overrides/matchRule.js

@@ -51,7 +51,13 @@ export function compilePattern(pattern) {
   // Anchored, like Chrome's `^${...}$` — a pattern describes the whole URL, so
   // `pokeapi.co` matches nothing and `*pokeapi.co*` matches everything on that
   // host. Predictable beats clever; the rule editor writes full URLs for you.
-  const regex = new RegExp(`^${escapeRegex(pattern)}$`);
+  //
+  // One exception: a pattern that starts with `/` is a PATH. Anchored to the
+  // full URL it could never match anything (every URL starts with a scheme),
+  // so it means "this path on any origin" — `/api/rewards` matches
+  // `http://localhost:3002/api/rewards`, and `/api/rewards*` also its queries.
+  const source = pattern.startsWith("/") ? `[a-zA-Z][a-zA-Z0-9+.-]*://[^/]*${escapeRegex(pattern)}` : escapeRegex(pattern);
+  const regex = new RegExp(`^${source}$`);
   // Unbounded growth isn't possible in practice (patterns come from a capped
   // rule list), but a user editing a pattern character by character churns
   // entries, so keep the cache from becoming a leak.

package/lib/module/network/overrides/overriddenRows.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import { ruleMatches } from "./matchRule";
+/**
+ * Which captured requests belong in the list's OVERRIDDEN strip.
+ *
+ * A row belongs there when an active rule actually changed it (it carries the
+ * rule's override mark) or matched it after the rule existed (while overrides
+ * are paused those pass through, and the strip is how you find the rule again).
+ * Before a rule existed nothing overrode anything, so older matching requests
+ * are real server responses and stay in the list, with one exception: the
+ * newest of them, which is the request the rule was built from. That one hoists
+ * right away, so creating a rule shows where it points without waiting for the
+ * endpoint to be called again.
+ */
+export function overriddenEvents(events, activeRules) {
+  if (activeRules.length === 0) return [];
+  const activeIds = new Set(activeRules.map(rule => rule.id));
+  const picked = new Set();
+  for (const rule of activeRules) {
+    let source;
+    for (const event of events) {
+      if (event.override && activeIds.has(event.override.ruleId)) {
+        picked.add(event.id);
+        continue;
+      }
+      if (!ruleMatches(rule, event.url, String(event.method || "GET"))) continue;
+      if (event.timestamp >= rule.createdAt) picked.add(event.id);else if (!source || event.timestamp > source.timestamp) source = event;
+    }
+    if (source) picked.add(source.id);
+  }
+  return events.filter(event => picked.has(event.id));
+}

package/lib/module/network/overrides/resolveOverride.js

@@ -23,7 +23,7 @@ import { STATUS_MAX, STATUS_MIN } from "./types";
  * "the dev tools stopped working and I don't know why". Metro/debugger traffic
  * is already excluded upstream by `networkListener.shouldIgnoreUrl`.
  */
-const NEVER_OVERRIDE = [/(^|\.)keygen\.sh/i];
+const NEVER_OVERRIDE = [/(^|\.)keygen\.sh/i, /^https?:\/\/(www\.)?buoy\.gg\/api\/license(\/|$)/i];
 function isProtectedUrl(url) {
   return NEVER_OVERRIDE.some(pattern => pattern.test(url));
 }

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

@@ -24,7 +24,7 @@ import { getAccountAccess } from "@buoy-gg/shared-ui";
 
 import { BaseEventStore } from "@buoy-gg/shared-ui";
 import { extractOperationName } from "./extractOperationName";
-import { networkListener, addNetworkListener } from "./networkListener";
+import { networkListener, addNetworkListener, getNetworkListenerCount, stopNetworkListener } from "./networkListener";
 import { networkSavedStore } from "./networkSavedStore";
 
 /**
@@ -138,9 +138,8 @@ class NetworkEventStore extends BaseEventStore {
     }
 
     // If no other listeners exist, stop the network interceptor
-    const listener = networkListener();
-    if (listener.listenerCount === 0) {
-      listener.stopListening();
+    if (getNetworkListenerCount() === 0) {
+      stopNetworkListener();
     }
   }
 
@@ -153,9 +152,8 @@ class NetworkEventStore extends BaseEventStore {
   disableCapture() {
     this.mirrorMode = true;
     this.takeBootBuffer();
-    const listener = networkListener();
-    if (listener.listenerCount === 0 && listener.isActive) {
-      listener.stopListening();
+    if (getNetworkListenerCount() === 0) {
+      stopNetworkListener();
     }
     super.disableCapture();
   }
@@ -202,6 +200,8 @@ class NetworkEventStore extends BaseEventStore {
       request
     } = event;
     if (event.type === "request") {
+      // Replayed request notifications must not reset a completed row or add a second key.
+      if (this.events.some(item => item.id === request.id)) return;
       // Build full URL with query params if present
       const queryString = request.params ? `?${new URLSearchParams(request.params).toString()}` : "";
       const fullUrl = `${request.url}${queryString}`;
@@ -240,6 +240,24 @@ class NetworkEventStore extends BaseEventStore {
       this.events = [networkEvent, ...this.events].slice(0, this.maxEvents);
       this.notify(networkEvent);
       this.notifyArrayListeners();
+    } else if (event.type === "request-body") {
+      const current = this.events.find(item => item.id === request.id);
+      if (!current) return;
+      const updated = {
+        ...current,
+        requestData: request.data,
+        requestSize: this.getDataSize(request.data)
+      };
+      if (request.client === "graphql") {
+        updated.operationName = extractOperationName(request.data) || undefined;
+        const variables = request.data?.variables;
+        if (variables && typeof variables === "object") updated.graphqlVariables = variables;
+      }
+      this.events = this.events.map(item => item.id === request.id ? updated : item);
+      if (this.pendingRequests.has(request.id)) this.pendingRequests.set(request.id, updated);
+      networkSavedStore.syncFromLive(updated);
+      this.notify(updated);
+      this.notifyArrayListeners();
     } else if (event.type === "response" || event.type === "error") {
       const index = this.events.findIndex(e => e.id === request.id);
       if (index !== -1) {