@buoy-gg/network 7.0.36 → 7.0.39

package/lib/commonjs/network/conditions/store.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.networkConditionsRuntimeId = exports.getNetworkCondition = exports.conditionsCanApply = exports.NETWORK_CONDITIONS = void 0;
+exports.setNetworkCondition = setNetworkCondition;
+exports.snapshotNetworkCondition = snapshotNetworkCondition;
+exports.subscribeNetworkConditions = void 0;
+var _sharedUi = require("@buoy-gg/shared-ui");
+var _networkListener = require("../utils/networkListener");
+const NETWORK_CONDITIONS = exports.NETWORK_CONDITIONS = {
+  normal: {
+    label: "Normal",
+    delayMs: 0
+  },
+  offline: {
+    label: "Offline (requests)",
+    delayMs: 0
+  },
+  slow: {
+    label: "Slow (+500 ms)",
+    delayMs: 500
+  },
+  verySlow: {
+    label: "Very slow (+2000 ms)",
+    delayMs: 2000
+  }
+};
+const networkConditionsRuntimeId = exports.networkConditionsRuntimeId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+let profile = "normal";
+let keepAlive;
+const listeners = new Set();
+const conditionsCanApply = () => typeof __DEV__ !== "undefined" && __DEV__ && (0, _sharedUi.hasAccountAccess)();
+exports.conditionsCanApply = conditionsCanApply;
+const getNetworkCondition = () => profile;
+exports.getNetworkCondition = getNetworkCondition;
+const subscribeNetworkConditions = listener => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+exports.subscribeNetworkConditions = subscribeNetworkConditions;
+function setNetworkCondition(value) {
+  if (typeof value !== "string" || !Object.prototype.hasOwnProperty.call(NETWORK_CONDITIONS, value)) {
+    throw new Error("Choose normal, offline, slow, or verySlow.");
+  }
+  if (value !== "normal" && !conditionsCanApply()) {
+    throw new Error("Network conditions require an admitted account and a development build.");
+  }
+  if (value === profile) return profile;
+  if (value !== "normal" && !keepAlive) {
+    (0, _networkListener.startNetworkListener)();
+    keepAlive = (0, _networkListener.addNetworkListener)(() => {});
+  } else if (value === "normal") {
+    keepAlive?.();
+    keepAlive = undefined;
+    if ((0, _networkListener.getNetworkListenerCount)() === 0) (0, _networkListener.stopNetworkListener)();
+  }
+  profile = value;
+  listeners.forEach(listener => listener());
+  return profile;
+}
+function snapshotNetworkCondition(url) {
+  if (profile === "normal" || !conditionsCanApply() || !/^https?:\/\//i.test(url)) return;
+  return Object.freeze({
+    profile,
+    delayMs: NETWORK_CONDITIONS[profile].delayMs
+  });
+}
+(0, _sharedUi.subscribeAccountAccess)(() => {
+  if (!(0, _sharedUi.hasAccountAccess)()) setNetworkCondition("normal");
+  listeners.forEach(listener => listener());
+});

package/lib/commonjs/network/conditions/wait.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.throwIfAborted = throwIfAborted;
+exports.waitBeforeDispatch = waitBeforeDispatch;
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  if (signal.reason !== undefined) throw signal.reason;
+  const error = new Error("The request was aborted.");
+  error.name = "AbortError";
+  throw error;
+}
+
+/** Wait before dispatch, releasing the timer and listener on cancellation. */
+function waitBeforeDispatch(ms, signal) {
+  return new Promise((resolve, reject) => {
+    try {
+      throwIfAborted(signal);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const cleanup = () => signal?.removeEventListener("abort", abort);
+    const abort = () => {
+      clearTimeout(timer);
+      cleanup();
+      try {
+        throwIfAborted(signal);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", abort, {
+      once: true
+    });
+  });
+}

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

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runConditionXhr = runConditionXhr;
+var _applyToXhr = require("../overrides/applyToXhr");
+/** Active simulation uses a send-to-completion deadline, including the wait. */
+function runConditionXhr(target, url, condition, outcome, dispatch) {
+  if (!(0, _applyToXhr.canSynthesize)(target)) throw new Error("Network conditions require React Native XMLHttpRequest.");
+  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();
+  let timeout = xhr.timeout;
+  let settled = false;
+  let dispatching = false;
+  let deadline;
+  let pending;
+  const originalAbort = xhr.abort;
+  const originalOpen = xhr.open;
+  const abortDescriptor = Object.getOwnPropertyDescriptor(xhr, "abort");
+  const openDescriptor = Object.getOwnPropertyDescriptor(xhr, "open");
+  const timeoutDescriptor = Object.getOwnPropertyDescriptor(xhr, "timeout");
+  const restore = (key, descriptor) => {
+    if (descriptor) Object.defineProperty(xhr, key, descriptor);else delete xhr[key];
+  };
+  const cleanup = () => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(pending);
+    clearTimeout(deadline);
+    xhr.removeEventListener("loadend", cleanup);
+    restore("abort", abortDescriptor);
+    restore("open", openDescriptor);
+    restore("timeout", timeoutDescriptor);
+    xhr.timeout = timeout;
+  };
+  const fail = timedOut => {
+    if (settled) return;
+    // DONE suppresses abort events while the native transport is cancelled.
+    Object.assign(xhr, {
+      readyState: 4
+    });
+    originalAbort.call(xhr);
+    xhr._aborted = false;
+    xhr._hasError = true;
+    xhr._timedOut = timedOut;
+    xhr._response = timedOut ? "Request timed out (Buoy conditions)" : "Network request failed (Buoy Offline)";
+    xhr.setReadyState(4);
+    cleanup();
+  };
+  const expired = () => timeout > 0 && Date.now() - started >= timeout;
+  const scheduleDeadline = () => {
+    clearTimeout(deadline);
+    if (timeout > 0) deadline = setTimeout(() => fail(true), Math.max(0, timeout - (Date.now() - started)));
+  };
+  Object.defineProperty(xhr, "timeout", {
+    configurable: true,
+    get: () => dispatching ? 0 : timeout,
+    set: value => {
+      timeout = Math.max(0, Number(value) || 0);
+      scheduleDeadline();
+    }
+  });
+  Object.defineProperty(xhr, "abort", {
+    configurable: true,
+    value: () => {
+      if (!settled) {
+        originalAbort.call(xhr);
+        cleanup();
+      }
+    }
+  });
+  Object.defineProperty(xhr, "open", {
+    configurable: true,
+    value: (...args) => {
+      const result = Reflect.apply(originalOpen, xhr, args);
+      cleanup();
+      return result;
+    }
+  });
+  xhr._sent = true;
+  xhr._requestId = null;
+  xhr.addEventListener("loadend", cleanup);
+  scheduleDeadline();
+  pending = setTimeout(() => {
+    if (settled) return;
+    if (expired()) {
+      fail(true);
+      return;
+    }
+    if (condition.profile === "offline") {
+      fail(false);
+      return;
+    }
+    if (outcome && outcome.kind !== "delay") {
+      (0, _applyToXhr.completeNativeOverride)(xhr, url, outcome);
+      return;
+    }
+    xhr._sent = false;
+    dispatching = true;
+    try {
+      dispatch();
+    } catch {
+      fail(false);
+    } finally {
+      dispatching = false;
+    }
+  }, condition.delayMs + (outcome?.delayMs ?? 0));
+}

package/lib/commonjs/network/hooks/useNetworkEvents.js

@@ -18,7 +18,7 @@ var _formatGraphQLVariables = require("../utils/formatGraphQLVariables");
 
 /**
  * @deprecated Read the live limit with `useLimit("network.requests")` — this
- * only reports the FREE tier's value and is blind to the anonymous tier. Kept
+ * only reports the FREE tier's value and ignores the Weekend Pass. Kept
  * because it is part of the package's public exports.
  */
 const FREE_TIER_REQUEST_LIMIT = exports.FREE_TIER_REQUEST_LIMIT = _sharedUi.TIER_LIMITS["network.requests"].free;

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.canSynthesize = canSynthesize;
 exports.canSynthesizeStandard = canSynthesizeStandard;
+exports.completeNativeOverride = completeNativeOverride;
 exports.runOverride = runOverride;
 /**
  * Perform an override outcome against an XMLHttpRequest — React Native's OR a
@@ -406,16 +407,12 @@ function runOverride(xhr, url, outcome, passThrough) {
   // had already aborted. Claiming it means abort() dispatches DONE + 'abort'
   // and whatwg-fetch rejects with AbortError, as it should.
   internals._sent = true;
-  if (outcome.kind !== "delay") {
-    // Buoy's own `open()` swizzle overwrites RN's private `_requestId` with a
-    // string id. RN normally clobbers it back with the native numeric id inside
-    // `send()` — which we're skipping — so it would survive here, and
-    // `abort()` would hand that string to `RCTNetworking.abortRequest()`.
-    // Nulling it makes abort a clean no-op on the native side.
-    internals._requestId = null;
-  }
+
+  // There is no native request to cancel until a delayed send is dispatched.
+  internals._requestId = null;
   let timer = null;
   const onAbort = () => {
+    xhr.removeEventListener("abort", onAbort);
     if (timer !== null) {
       clearTimeout(timer);
       timer = null;
@@ -448,4 +445,9 @@ function runOverride(xhr, url, outcome, passThrough) {
   // 'load' before they exist.
   timer = setTimeout(fire, outcome.delayMs);
   return true;
+}
+
+/** Complete an already scheduled native outcome without adding another timer. */
+function completeNativeOverride(xhr, url, outcome) {
+  if (outcome.kind === "fail") fail(xhr, outcome);else if (outcome.kind === "respond") respond(xhr, url, outcome);
 }

package/lib/commonjs/network/overrides/engine.js

@@ -8,6 +8,7 @@ exports.inspectEngine = inspectEngine;
 exports.overrideForRequest = overrideForRequest;
 exports.overridesCanApply = overridesCanApply;
 exports.setOverrideHooks = setOverrideHooks;
+var _sharedUi = require("@buoy-gg/shared-ui");
 var _resolveOverride = require("./resolveOverride");
 /**
  * The seam between the interceptor and the rule store.
@@ -42,7 +43,7 @@ function setOverrideHooks(next) {
 function overridesCanApply() {
   // `__DEV__` is undefined outside React Native (unit tests, the desktop
   // bundle); only an explicit `false` — a real release build — disables it.
-  return !(typeof __DEV__ !== "undefined" && !__DEV__);
+  return (0, _sharedUi.hasAccountAccess)() && !(typeof __DEV__ !== "undefined" && !__DEV__);
 }
 
 /** Why overrides are inert, for a caller that has to explain it to a person. */

package/lib/commonjs/network/sync/networkSyncAdapter.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.networkSyncAdapter = exports.SNAPSHOT_HEADER_VALUE_LIMIT = exports.SNAPSHOT_EVENTS_BUDGET = exports.SNAPSHOT_BODY_INLINE_LIMIT = void 0;
+var _store = require("../conditions/store");
 var _networkEventStore = require("../utils/networkEventStore");
 var _networkSavedStore = require("../utils/networkSavedStore");
 var _overrideRulesStore = require("../overrides/overrideRulesStore");
@@ -476,10 +477,13 @@ function baseFromRequest(params) {
  * `NetworkPanel`/`NetworkInline` accept either shape.
  */
 const networkSyncAdapter = exports.networkSyncAdapter = {
+  dispose: () => {
+    _overrideRulesStore.overrideRulesStore.setEnabled(false);
+  },
   // v5: honest request/responseSize + explicit request/responseBodyOmitted
   // flags, and a total snapshot budget so the list degrades instead of the
   // whole panel being dropped at the emit layer.
-  version: 5,
+  version: 6,
   getSnapshot: () => {
     // Piggyback the interception health check on the watch loop: while a
     // dashboard/MCP watch is open this runs continuously, so a clobbered
@@ -488,6 +492,12 @@ const networkSyncAdapter = exports.networkSyncAdapter = {
     // reads when healthy.
     _networkEventStore.networkEventStore.ensureInterception();
     return {
+      conditions: {
+        version: 1,
+        runtimeId: _store.networkConditionsRuntimeId,
+        profile: (0, _store.getNetworkCondition)(),
+        available: (0, _store.conditionsCanApply)()
+      },
       events: fitEventsToBudget(_networkEventStore.networkEventStore.getEvents()),
       /**
        * Response-override rules live on the DEVICE — that's the only place they
@@ -508,17 +518,32 @@ const networkSyncAdapter = exports.networkSyncAdapter = {
     // Pinning with no traffic in flight still has to reach the dashboard, so
     // both stores drive the snapshot.
     const unsubscribeEvents = _networkEventStore.networkEventStore.subscribeToEvents(onChange);
+    const unsubscribeConditions = (0, _store.subscribeNetworkConditions)(onChange);
     const unsubscribeSaved = _networkSavedStore.networkSavedStore.subscribe(onChange);
     // Same reasoning for rules: editing one with no traffic in flight must
     // still reach the dashboard. Subscribing also hydrates the rule list.
     const unsubscribeOverrides = _overrideRulesStore.overrideRulesStore.subscribe(onChange);
     return () => {
+      unsubscribeConditions();
       unsubscribeEvents();
       unsubscribeSaved();
       unsubscribeOverrides();
     };
   },
   actions: {
+    getNetworkConditions: () => ({
+      runtimeId: _store.networkConditionsRuntimeId,
+      profile: (0, _store.getNetworkCondition)(),
+      available: (0, _store.conditionsCanApply)()
+    }),
+    setNetworkConditions: params => {
+      const profile = params && typeof params === "object" ? params.profile : undefined;
+      return {
+        runtimeId: _store.networkConditionsRuntimeId,
+        profile: (0, _store.setNetworkCondition)(profile),
+        available: (0, _store.conditionsCanApply)()
+      };
+    },
     clearEvents: () => {
       _networkEventStore.networkEventStore.clearEvents();
     },

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

@@ -81,6 +81,7 @@ function generateNetworkCopyText(events, copySettings) {
         obj.statusText = event.statusText;
       }
       if (copySettings.includeDuration) obj.duration = event.duration;
+      if (event.condition) obj.condition = event.condition;
       if (copySettings.includeTimestamp) obj.timestamp = event.timestamp;
       if (copySettings.includeClient) obj.requestClient = event.requestClient;
       if (copySettings.includeSizes) {
@@ -119,6 +120,7 @@ function generateNetworkCopyText(events, copySettings) {
     if (copySettings.includeClient && event.requestClient) {
       md += `**Client:** ${event.requestClient}\n`;
     }
+    if (event.condition) md += `Conditions: ${event.condition.profile} (+${event.condition.delayMs} ms)\n`;
     if (copySettings.includeDuration && event.duration) {
       md += `**Duration:** ${event.duration}ms\n`;
     }

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

@@ -46,14 +46,6 @@ var _networkSavedStore = require("./networkSavedStore");
 const BOOT_BUFFER_MAX = 200;
 class NetworkEventStore extends _sharedUi.BaseEventStore {
   pendingRequests = new Map();
-  /**
-   * Recently seen `METHOD:url` keys → when, and which event id we kept.
-   *
-   * The timestamp powers the dual-interception dedup below. The id is what lets
-   * a DROPPED duplicate still contribute something the kept event doesn't know
-   * — see `applyOverrideMark`.
-   */
-  recentRequests = new Map();
   rawListenerUnsubscribe = null;
   /** Raw events captured before the first consumer subscribed — see startBootCapture. */
   bootBuffer = [];
@@ -85,6 +77,7 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
    * state therefore never gains events it didn't ask for).
    */
   startBootCapture() {
+    if ((0, _sharedUi.getAccountAccess)().status === "locked") return;
     if (this.mirrorMode || this.bootBufferUnsubscribe || this.isCapturing()) {
       return;
     }
@@ -139,6 +132,7 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
    * Stop capturing network events
    */
   stopCapturing() {
+    this.takeBootBuffer();
     // Remove our raw listener
     if (this.rawListenerUnsubscribe) {
       this.rawListenerUnsubscribe();
@@ -205,57 +199,11 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
    * Process a network listener event
    */
   processNetworkEvent(event) {
+    if ((0, _sharedUi.getAccountAccess)().status === "locked") return;
     const {
       request
     } = event;
     if (event.type === "request") {
-      // 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 = 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
-      // interception. The age must be non-negative: Date.now() is not
-      // monotonic, and after a backwards clock adjustment (iOS time sync) a
-      // future-dated entry would satisfy `< 50` for EVERY request to this
-      // endpoint until the clock caught up — capture going silent for minutes
-      // to hours, "fixed" only by Clear wiping this map (field-reported). A
-      // negative age falls through and re-stamps the entry with the new clock.
-      if (recent && now - recent.at >= 0 && now - recent.at < 50) {
-        // …but the duplicate is not always redundant. On React Native a
-        // `fetch()` is seen twice: once by the fetch wrapper, which is what
-        // creates this event, and again by the XHR wrapper underneath it —
-        // and ONLY the XHR layer resolves overrides, because that's where the
-        // request can actually be intercepted. So the mark arrives on the copy
-        // we're about to throw away. Move it across before dropping.
-        if (event.override) {
-          this.applyOverrideMark(recent.id, event.override);
-        }
-        return;
-      }
-      this.recentRequests.set(requestKey, {
-        at: now,
-        id: request.id
-      });
-
-      // Clean up old entries to prevent memory leak. Future-dated entries are
-      // stale by definition (clock moved backwards) — drop those too, or they
-      // survive every sweep until the clock overtakes them.
-      if (this.recentRequests.size > 100) {
-        const cutoff = now - 5000;
-        for (const [key, entry] of this.recentRequests.entries()) {
-          if (entry.at < cutoff || entry.at > now) {
-            this.recentRequests.delete(key);
-          }
-        }
-      }
-
       // Build full URL with query params if present
       const queryString = request.params ? `?${new URLSearchParams(request.params).toString()}` : "";
       const fullUrl = `${request.url}${queryString}`;
@@ -287,7 +235,8 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
         graphqlVariables,
         // Present when this request came straight through the XHR wrapper
         // (axios, raw XHR). For `fetch` it arrives later — see the dedup branch.
-        override: event.override
+        override: event.override,
+        condition: event.condition
       };
       this.pendingRequests.set(request.id, networkEvent);
       this.events = [networkEvent, ...this.events].slice(0, this.maxEvents);
@@ -331,26 +280,6 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
       }
     }
   }
-
-  /**
-   * Stamp an override mark onto an already-recorded event.
-   *
-   * Only ever moves a mark from a dropped duplicate onto the event that was
-   * kept, so it never overwrites one that is already there.
-   */
-  applyOverrideMark(id, override) {
-    const index = this.events.findIndex(e => e.id === id);
-    if (index === -1 || this.events[index].override) return;
-    const updatedEvent = {
-      ...this.events[index],
-      override
-    };
-    this.events = this.events.map((e, i) => i === index ? updatedEvent : e);
-    const pending = this.pendingRequests.get(id);
-    if (pending) this.pendingRequests.set(id, updatedEvent);
-    this.notify(updatedEvent);
-    this.notifyArrayListeners();
-  }
   extractHost(url) {
     try {
       const urlObj = new URL(url);
@@ -388,7 +317,6 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
   clearEvents() {
     super.clearEvents();
     this.pendingRequests.clear();
-    this.recentRequests.clear();
   }
 
   /**