@buoy-gg/network 7.0.35 → 7.0.38

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

@@ -0,0 +1,106 @@
+"use strict";
+
+import { canSynthesize, completeNativeOverride } 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.");
+  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") {
+      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/module/network/hooks/useNetworkEvents.js

@@ -14,7 +14,7 @@ import { searchGraphQLVariables } from "../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.
  */
 export const FREE_TIER_REQUEST_LIMIT = TIER_LIMITS["network.requests"].free;

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

@@ -400,16 +400,12 @@ export 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;
@@ -442,4 +438,9 @@ export 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. */
+export function completeNativeOverride(xhr, url, outcome) {
+  if (outcome.kind === "fail") fail(xhr, outcome);else if (outcome.kind === "respond") respond(xhr, url, outcome);
 }

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

@@ -1,5 +1,6 @@
 "use strict";
 
+import { hasAccountAccess } from "@buoy-gg/shared-ui";
 /**
  * The seam between the interceptor and the rule store.
  *
@@ -34,7 +35,7 @@ export function setOverrideHooks(next) {
 export 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 hasAccountAccess() && !(typeof __DEV__ !== "undefined" && !__DEV__);
 }
 
 /** Why overrides are inert, for a caller that has to explain it to a person. */

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

@@ -1,5 +1,6 @@
 "use strict";
 
+import { getNetworkCondition, setNetworkCondition, subscribeNetworkConditions, conditionsCanApply, networkConditionsRuntimeId } from "../conditions/store";
 import { networkEventStore } from "../utils/networkEventStore";
 import { flagsForEventId, networkSavedStore } from "../utils/networkSavedStore";
 import { overrideRulesStore } from "../overrides/overrideRulesStore";
@@ -7,6 +8,7 @@ import { draftFromEvent } from "../overrides/presets";
 import { inspectEngine, overridesCanApply, OVERRIDES_INACTIVE_REASON } from "../overrides/engine";
 import { getNetworkListenerCount, isNetworkInterceptionLive, isNetworkListening } from "../utils/networkListener";
 import { approxJsonSize, isOverWireBudget } from "@buoy-gg/shared-ui";
+import { expandKeyedArrays, patchFromPath, refusalText, shapeKind, suggestedPatch, typedEditViolations } from "@buoy-gg/shared-ui";
 
 /**
  * Request/response bodies larger than this are NOT streamed in the list
@@ -308,13 +310,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 = shapeKind(base[k]);
+      const to = 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 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.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.getState().rules.find(r => r.id === id);
+  return existing ? {
+    ...existing
+  } : null;
+}
 
 /**
  * The body a remote surface never received, when it says so.
@@ -370,10 +475,13 @@ function baseFromRequest(params) {
  * `NetworkPanel`/`NetworkInline` accept either shape.
  */
 export const networkSyncAdapter = {
+  dispose: () => {
+    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
@@ -382,6 +490,12 @@ export const networkSyncAdapter = {
     // reads when healthy.
     networkEventStore.ensureInterception();
     return {
+      conditions: {
+        version: 1,
+        runtimeId: networkConditionsRuntimeId,
+        profile: getNetworkCondition(),
+        available: conditionsCanApply()
+      },
       events: fitEventsToBudget(networkEventStore.getEvents()),
       /**
        * Response-override rules live on the DEVICE — that's the only place they
@@ -402,17 +516,32 @@ export const networkSyncAdapter = {
     // Pinning with no traffic in flight still has to reach the dashboard, so
     // both stores drive the snapshot.
     const unsubscribeEvents = networkEventStore.subscribeToEvents(onChange);
+    const unsubscribeConditions = subscribeNetworkConditions(onChange);
     const unsubscribeSaved = 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.subscribe(onChange);
     return () => {
+      unsubscribeConditions();
       unsubscribeEvents();
       unsubscribeSaved();
       unsubscribeOverrides();
     };
   },
   actions: {
+    getNetworkConditions: () => ({
+      runtimeId: networkConditionsRuntimeId,
+      profile: getNetworkCondition(),
+      available: conditionsCanApply()
+    }),
+    setNetworkConditions: params => {
+      const profile = params && typeof params === "object" ? params.profile : undefined;
+      return {
+        runtimeId: networkConditionsRuntimeId,
+        profile: setNetworkCondition(profile),
+        available: conditionsCanApply()
+      };
+    },
     clearEvents: () => {
       networkEventStore.clearEvents();
     },
@@ -508,7 +637,89 @@ export const 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.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 = 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.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 = 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: refusalText(violations, "response body", suggestedPatch(rawRule.bodyPatch, violations)),
+              violations
+            };
+          }
+        }
+      }
       const draft = readRuleDraft(params, base);
       if (!draft) {
         const wanted = params?.fromRequestId;
@@ -538,8 +749,19 @@ export const 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/module/network/utils/generateNetworkCopyText.js

@@ -77,6 +77,7 @@ export 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) {
@@ -115,6 +116,7 @@ export 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/module/network/utils/networkEventStore.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { getAccountAccess } from "@buoy-gg/shared-ui";
 /**
  * Network Event Store
  *
@@ -43,14 +44,6 @@ import { networkSavedStore } from "./networkSavedStore";
 const BOOT_BUFFER_MAX = 200;
 class NetworkEventStore extends 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 = [];
@@ -82,6 +75,7 @@ class NetworkEventStore extends BaseEventStore {
    * state therefore never gains events it didn't ask for).
    */
   startBootCapture() {
+    if (getAccountAccess().status === "locked") return;
     if (this.mirrorMode || this.bootBufferUnsubscribe || this.isCapturing()) {
       return;
     }
@@ -136,6 +130,7 @@ class NetworkEventStore extends BaseEventStore {
    * Stop capturing network events
    */
   stopCapturing() {
+    this.takeBootBuffer();
     // Remove our raw listener
     if (this.rawListenerUnsubscribe) {
       this.rawListenerUnsubscribe();
@@ -202,57 +197,11 @@ class NetworkEventStore extends BaseEventStore {
    * Process a network listener event
    */
   processNetworkEvent(event) {
+    if (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}`;
@@ -284,7 +233,8 @@ class NetworkEventStore extends 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);
@@ -328,26 +278,6 @@ class NetworkEventStore extends 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);
@@ -385,7 +315,6 @@ class NetworkEventStore extends BaseEventStore {
   clearEvents() {
     super.clearEvents();
     this.pendingRequests.clear();
-    this.recentRequests.clear();
   }
 
   /**