@buoy-gg/network 7.0.35 → 7.0.38

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");
@@ -311,13 +312,116 @@ base) {
     headers: rule.headers && typeof rule.headers === "object" ? rule.headers : base?.headers,
     // Objects are accepted and serialized so a caller can send JSON directly
     // instead of pre-stringifying it, which is the mistake everyone makes once.
-    body: typeof rule.body === "string" ? rule.body : rule.body != null ? JSON.stringify(rule.body, null, 2) : base?.body,
+    body: patchedBody(rule, base),
     failKind: rule.failKind === "timeout" ? "timeout" : undefined,
     delayMs: typeof rule.delayMs === "number" ? rule.delayMs : undefined,
     times: typeof rule.times === "number" ? rule.times : null,
     alternate: rule.alternate === true
   };
 }
+const isPlainObject = v => !!v && typeof v === "object" && !Array.isArray(v);
+/**
+ * Objects merge key by key; arrays and primitives are replaced. Collects two
+ * dangers instead of writing them: `shrunk` (a non-empty array shorter than
+ * the one it replaces) and `breaks` (an array/object field overwritten by null
+ * or a primitive — the shape the app renders, changed out from under it). The
+ * handler refuses either unless forced.
+ *
+ * This stays local while the typed-edit RULE is shared: it is the merge itself,
+ * not the check, and it reports network-specific dangers the store surfaces do
+ * not have. `shapeKind` comes from the shared module so both agree on what
+ * counts as an array.
+ */
+function deepMerge(base, patch, path = "", issues = {
+  shrunk: [],
+  breaks: []
+}) {
+  if (Array.isArray(base) && Array.isArray(patch)) {
+    if (patch.length > 0 && patch.length < base.length) {
+      issues.shrunk.push({
+        path: path || "(root)",
+        have: base.length,
+        sent: patch.length
+      });
+    }
+    return patch;
+  }
+  if (!isPlainObject(base) || !isPlainObject(patch)) return patch;
+  const out = {
+    ...base
+  };
+  for (const [k, v] of Object.entries(patch)) {
+    const p = path ? `${path}.${k}` : k;
+    if (k in base) {
+      const from = (0, _sharedUi.shapeKind)(base[k]);
+      const to = (0, _sharedUi.shapeKind)(v);
+      if ((from === "array" || from === "object") && from !== to) {
+        issues.breaks.push({
+          path: p,
+          from,
+          to
+        });
+      }
+      out[k] = deepMerge(base[k], v, p, issues);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+/** Typed-edit violations a bodyPatch would cause against the seed body, or []. */
+function patchViolations(rule, seed) {
+  if (rule.body != null || !isPlainObject(rule.bodyPatch) || typeof seed !== "string") return [];
+  try {
+    return (0, _sharedUi.typedEditViolations)(JSON.parse(seed), rule.bodyPatch, {
+      noun: "response body"
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * The rule's body: explicit `body` wins, else `bodyPatch` deep-merged into the
+ * seeded body (from `fromRequestId`, or the rule being replaced), else the seed.
+ *
+ * `bodyPatch` exists for the same reason `setQueryData` has `merge`: a remote
+ * caller reads the real response through a wire that truncates big payloads,
+ * edits one field, and pastes the torn object back as `body`. The app then
+ * renders a response missing half its fields. With a patch the caller sends
+ * `{ stats: [...] }` and the other 30KB stay exactly as the server sent them.
+ */
+function patchedBody(rule, base) {
+  if (typeof rule.body === "string") return rule.body;
+  if (rule.body != null) return JSON.stringify(rule.body, null, 2);
+  const seed = base?.body ?? (typeof rule.id === "string" ? _overrideRulesStore.overrideRulesStore.getState().rules.find(r => r.id === rule.id)?.body : undefined);
+  if (isPlainObject(rule.bodyPatch) && typeof seed === "string") {
+    try {
+      return JSON.stringify(deepMerge(JSON.parse(seed), rule.bodyPatch), null, 2);
+    } catch {
+      return seed;
+    }
+  }
+  return seed;
+}
+
+/**
+ * Replacing a rule by id inherits every field the caller did not send, so a
+ * remote driver can flip one thing — `{ id, bodyPatch }`, `{ id, status: 500 }`
+ * — without re-sending the urlPattern it never had to know.
+ */
+function existingRule(params) {
+  if (!params || typeof params !== "object") return null;
+  const raw = params.rule ?? params;
+  if (!raw || typeof raw !== "object") return null;
+  const id = raw.id;
+  if (typeof id !== "string") return null;
+  const existing = _overrideRulesStore.overrideRulesStore.getState().rules.find(r => r.id === id);
+  return existing ? {
+    ...existing
+  } : null;
+}
 
 /**
  * The body a remote surface never received, when it says so.
@@ -373,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
@@ -385,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
@@ -405,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();
     },
@@ -511,7 +639,89 @@ const networkSyncAdapter = exports.networkSyncAdapter = {
     },
     /** Create a rule, or replace one by id. */
     upsertOverrideRule: params => {
-      const base = baseFromRequest(params) ?? preservedBody(params);
+      const base = baseFromRequest(params) ?? preservedBody(params) ?? existingRule(params);
+      const rawRule = params?.rule ?? params;
+      // `bodyPath` + `bodyValue` are sugar over `bodyPatch`, resolved against the
+      // real response before anything else looks at the rule — so the keyed
+      // expansion, the typed-edit guard and the merge below all run on an
+      // ordinary patch and gain no special cases. This is the same form the
+      // state tools take; it exists here because a response body is the surface
+      // where the caller is LEAST likely to have seen the shape (it read the
+      // body over a wire that truncates at 24,000 characters), and therefore
+      // most likely to get the nesting wrong.
+      if (rawRule && typeof rawRule.bodyPath === "string" && rawRule.body == null) {
+        const seed = base?.body ?? (typeof rawRule.id === "string" ? _overrideRulesStore.overrideRulesStore.getState().rules.find(r => r.id === rawRule.id)?.body : undefined);
+        if (typeof seed !== "string") {
+          return {
+            ok: false,
+            error: "bodyPath needs something to patch: send fromRequestId (the captured request whose real response it addresses) or the id of an existing rule."
+          };
+        }
+        if (rawRule.bodyValue === undefined) {
+          return {
+            ok: false,
+            error: `Refused: sent \`bodyPath\` without \`bodyValue\`. Say what to set "${rawRule.bodyPath}" to.`
+          };
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(seed);
+        } catch {
+          return {
+            ok: false,
+            error: "The captured response body is not JSON, so it cannot be addressed by path. Send a whole `body` instead."
+          };
+        }
+        const built = (0, _sharedUi.patchFromPath)(parsed, rawRule.bodyPath, rawRule.bodyValue);
+        if (!built.ok) return {
+          ok: false,
+          error: `Refused: ${built.error}`
+        };
+        rawRule.bodyPatch = built.patch;
+        delete rawRule.bodyPath;
+        delete rawRule.bodyValue;
+      }
+      if (rawRule && isPlainObject(rawRule.bodyPatch) && rawRule.body == null) {
+        const seed = base?.body ?? (typeof rawRule.id === "string" ? _overrideRulesStore.overrideRulesStore.getState().rules.find(r => r.id === rawRule.id)?.body : undefined);
+        if (typeof seed !== "string") {
+          return {
+            ok: false,
+            error: "bodyPatch needs something to patch: send fromRequestId (the captured request whose real response the patch is merged into) or the id of an existing rule."
+          };
+        }
+        if (rawRule.force !== true) {
+          // Address list items in the real response by their own id rather than
+          // resending the array: {results:{pikachu:{name:"test123"}}}. Expanded
+          // against the seed BEFORE the guard and before the merge, so the
+          // typed-edit rule still holds over the result. This is the only form
+          // that is correct when the caller read the response through a wire
+          // that truncated it — see packages/shared/src/sync/keyedArrays.ts.
+          let keyedError;
+          try {
+            const expanded = (0, _sharedUi.expandKeyedArrays)(JSON.parse(seed), rawRule.bodyPatch);
+            keyedError = expanded.error;
+            if (expanded.notes.length) rawRule.bodyPatch = expanded.patch;
+          } catch {
+            /* a non-JSON seed has no lists to address; leave the patch alone */
+          }
+          // See keyedArrays.ts: an added item whose id disagrees with the key
+          // it was sent under is ambiguous, and only this layer can say so.
+          if (keyedError) {
+            return {
+              ok: false,
+              error: `Refused: ${keyedError}`
+            };
+          }
+          const violations = patchViolations(rawRule, seed);
+          if (violations.length > 0) {
+            return {
+              ok: false,
+              error: (0, _sharedUi.refusalText)(violations, "response body", (0, _sharedUi.suggestedPatch)(rawRule.bodyPatch, violations)),
+              violations
+            };
+          }
+        }
+      }
       const draft = readRuleDraft(params, base);
       if (!draft) {
         const wanted = params?.fromRequestId;
@@ -541,8 +751,19 @@ const networkSyncAdapter = exports.networkSyncAdapter = {
           enabled: rule.enabled,
           kind: rule.kind,
           status: rule.status,
+          times: rule.times,
           bodySize: rule.body ? rule.body.length : 0
         },
+        // A rule with no budget overrides EVERY matching request until someone
+        // deletes it, and that is rarely what a one-off ask meant. Measured on
+        // `api-sim/next-call-fails-once` ("just the next one, then let it work
+        // again"): ten of fourteen attempts left the budget off and got a rule
+        // that never expires. Saying so is not a nag — it is the difference
+        // between a caller that adds `times` on its next turn and one that walks
+        // away leaving the app permanently broken.
+        ...(rule.times === undefined || rule.times === null ? {
+          lingers: `This rule has no \`times\` budget, so it overrides EVERY matching request until it is disabled or deleted (id \`${rule.id}\`). If you meant only the next one, set times:1.`
+        } : {}),
         ...inactiveStamp()
       };
     },

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`;
     }