@buoy-gg/network 7.0.12 → 7.0.14

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

@@ -5,6 +5,25 @@
  * Simple and reliable network interception for React Native
  */
 
+import { overrideForRequest } from "../overrides/engine";
+import { runOverride } from "../overrides/applyToXhr";
+import { canSynthesizeResponse, sleep, synthesizeFetchError, synthesizeResponse } from "../overrides/applyToFetch";
+import { markForOutcome } from "../overrides/types";
+
+/**
+ * True only while `originalFetch` is being CALLED (not awaited).
+ *
+ * Overrides hook both `fetch` and `XMLHttpRequest`, because Expo's native
+ * `expo/fetch` bypasses XHR while bare RN's whatwg-fetch polyfill runs straight
+ * through it. On bare RN that means one `fetch()` would otherwise be overridden
+ * twice — a doubled delay and a doubled hit count.
+ *
+ * whatwg-fetch creates and sends its XHR synchronously inside the Promise
+ * executor, so a flag raised across the call expression alone is enough to
+ * cover the inner `send()` without leaking across the await.
+ */
+let insideOverriddenFetch = false;
+
 // Extended XMLHttpRequest interface for monkey-patching
 
 // Event types for network operations
@@ -199,7 +218,7 @@ class NetworkListener {
    * Handle XMLHttpRequest response processing
    * This method processes the response and emits appropriate events
    */
-  handleXHRResponse(xhr, requestId, cleanUrl, method, requestHeaders, requestData, params, startTime, isError = false, clientType = "xhr") {
+  handleXHRResponse(xhr, requestId, cleanUrl, method, requestHeaders, requestData, params, startTime, isError = false, clientType = "xhr", override) {
     const duration = startTime ? Date.now() - startTime : 0;
 
     // XHR's duration was ALREADY total (measured at readyState 4 / load), so
@@ -228,7 +247,8 @@ class NetworkListener {
         },
         error: {
           message: isError ? "Request failed" : "Network error or request aborted"
-        }
+        },
+        override
       });
       return;
     }
@@ -367,7 +387,8 @@ class NetworkListener {
           headers: responseHeaders,
           body,
           size: responseSize
-        }
+        },
+        override
       });
     } else {
       this.emit({
@@ -392,7 +413,8 @@ class NetworkListener {
         },
         error: {
           message: `HTTP ${xhr.status}: ${xhr.statusText}`
-        }
+        },
+        override
       });
     }
   }
@@ -463,6 +485,18 @@ class NetworkListener {
       // Determine client type from X-Request-Client header or default to fetch
       const clientType = requestHeaders["X-Request-Client"] || requestHeaders["x-request-client"] || "fetch";
 
+      /**
+       * Response overrides, fetch side.
+       *
+       * Needed even though `send` below also resolves them: Expo installs a
+       * NATIVE `expo/fetch` as `globalThis.fetch`, which never constructs an
+       * XMLHttpRequest, so the XHR hook alone would never see these requests.
+       * Skipped when `canSynthesizeResponse()` is false so a runtime without a
+       * `Response` global degrades to a real request rather than a broken one.
+       */
+      const outcome = canSynthesizeResponse() ? overrideForRequest(url, method) : null;
+      const override = outcome ? markForOutcome(outcome) : undefined;
+
       // Emit request event
       self.emit({
         type: "request",
@@ -475,10 +509,28 @@ class NetworkListener {
           data: requestData,
           params: params || undefined,
           client: clientType
-        }
+        },
+        override
       });
       try {
-        const response = await self.originalFetch(input, init);
+        if (outcome) await sleep(outcome.delayMs);
+        if (outcome?.kind === "fail") throw synthesizeFetchError(outcome);
+        let response;
+        if (outcome?.kind === "respond") {
+          response = synthesizeResponse(url, outcome);
+        } else {
+          // The flag spans the CALL only — see `insideOverriddenFetch`. It has
+          // to be cleared before the await, or it would still be raised for
+          // every unrelated request that starts while this one is in flight.
+          insideOverriddenFetch = outcome != null;
+          let pending;
+          try {
+            pending = self.originalFetch(input, init);
+          } finally {
+            insideOverriddenFetch = false;
+          }
+          response = await pending;
+        }
         // A fetch promise resolves when the HEADERS arrive, not the body — so
         // this is time-to-first-byte, and it is where `duration` used to stop.
         // That silently excluded download time, making an identical request
@@ -547,7 +599,8 @@ class NetworkListener {
             headers: responseHeaders,
             body,
             size: responseSize
-          }
+          },
+          override
         });
         return response;
       } catch (error) {
@@ -570,7 +623,8 @@ class NetworkListener {
           error: {
             message: error instanceof Error ? error.message : "Network error",
             stack: error instanceof Error ? error.stack : undefined
-          }
+          },
+          override
         });
         throw error;
       }
@@ -637,6 +691,22 @@ class NetworkListener {
       const looksLikeAxios = acceptHeader.includes("application/json") && acceptHeader.includes("text/plain") && acceptHeader.includes("*/*");
       const clientType = explicitClient || (looksLikeAxios ? "axios" : "xhr");
 
+      /**
+       * Response overrides.
+       *
+       * This is the layer that covers `axios` and raw XMLHttpRequest. It also
+       * covers `fetch` on BARE React Native, where the whatwg-fetch polyfill
+       * runs through XHR — which is why the fetch wrapper raises
+       * `insideOverriddenFetch` around its pass-through, so one request can't
+       * be overridden twice.
+       *
+       * Matching uses the raw `url` (query string included), which is what the
+       * developer sees in the list and writes into a rule. No-ops in production
+       * builds; see `overrideForRequest`.
+       */
+      const outcome = insideOverriddenFetch ? null : overrideForRequest(url, method);
+      const override = outcome ? markForOutcome(outcome) : undefined;
+
       // Emit request event
       self.emit({
         type: "request",
@@ -649,7 +719,8 @@ class NetworkListener {
           data: requestData,
           params: params || undefined,
           client: clientType
-        }
+        },
+        override
       });
 
       // Track if we've already processed this request to avoid duplicate events
@@ -657,7 +728,7 @@ class NetworkListener {
       const processResponse = (isError = false) => {
         if (processed) return;
         processed = true;
-        self.handleXHRResponse(this, requestId || "unknown", cleanUrl, method, requestHeaders, requestData, params, startTime || 0, isError, clientType);
+        self.handleXHRResponse(this, requestId || "unknown", cleanUrl, method, requestHeaders, requestData, params, startTime || 0, isError, clientType, override);
         // Clean up event listeners after processing to prevent memory leaks
         cleanup();
       };
@@ -704,6 +775,16 @@ class NetworkListener {
       this.addEventListener("error", errorListener);
       this.addEventListener("abort", abortListener);
       this.addEventListener("readystatechange", readyStateListener);
+      if (outcome) {
+        // Listeners are attached above FIRST: `runOverride` drives the same
+        // readyState transitions a real response would, and the interceptor has
+        // to see them (readyState 2 is where TTFB is stamped).
+        const handled = runOverride(this, url, outcome, () => self.originalXHRSend.call(this, data));
+        // `handled` is false only where this isn't React Native's own
+        // XMLHttpRequest and can't be driven by hand. Fall through and send for
+        // real rather than dropping the request on the floor.
+        if (handled) return;
+      }
       return self.originalXHRSend.call(this, data);
     };
     this.isListening = true;

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

@@ -0,0 +1,188 @@
+"use strict";
+
+/**
+ * Which request the detail view is showing, and where it sits in the list —
+ * the prev/next CURSOR.
+ *
+ * ## Why this is a store and not `useState` in the modal
+ *
+ * It used to be `useState` in `NetworkModalInner`. Every tap on Previous/Next
+ * therefore dirtied the modal ROOT, which re-rendered `JsModal` (1833 lines,
+ * nine useStates, animations/gestures/persistence — and it can never bail out,
+ * because its `header` prop is a fresh object literal every render), the whole
+ * header, and all five screens. None of them care which request is selected;
+ * they only care THAT one is.
+ *
+ * This is the same argument `NetworkModal`'s own header comment already makes
+ * about network events ("with the subscription here, 15 events re-rendered
+ * JsModal + every header button 15×"). Stepping is that same class of
+ * high-frequency churn, and it was sitting in the same wrong place. Now the
+ * root subscribes to `hasSelection` — a boolean that flips twice a session —
+ * while the footer, the body and the header's pin actions subscribe to the
+ * parts they actually render.
+ *
+ * ## The three cursors
+ *
+ * `selectedId` is where the USER is. It moves on the tap, synchronously.
+ *
+ * `bodyId` is what the detail body is allowed to render, and it deliberately
+ * LAGS: drawing a request means handing its payload to the virtualized data
+ * viewer to flatten, and that has no business blocking the next tap. It
+ * catches up only once the selection has held still for `settleMs`, so a
+ * burst of taps renders the request you land on and none of the ones you flew
+ * past. (`useDeferredValue` was tried here first and is the wrong tool — it
+ * lowers the priority of that work without preventing it, so every settled
+ * step still queued a flatten and each one delayed the touch behind it.)
+ *
+ * `renderedId` is what actually made it to the screen, reported by the detail
+ * screen after commit. Nothing in the product reads it; it exists so the
+ * benchmark harness can measure "time until request N was really painted"
+ * separately from "time until the cursor reached N".
+ */
+
+/**
+ * How long the selection must hold still before the body renders it. Short
+ * enough that a single step reads as immediate (the footer and header have
+ * already moved), long enough that a burst collapses to one render.
+ */
+export const DEFAULT_SETTLE_MS = 120;
+class NetworkSelectionStore {
+  ids = [];
+  index = -1;
+  selectedId = null;
+  bodyId = null;
+  renderedId = null;
+  settleMs = DEFAULT_SETTLE_MS;
+  settleTimer = null;
+  subscribers = new Set();
+  snapshot = this.buildSnapshot();
+  buildSnapshot() {
+    return {
+      ids: this.ids,
+      index: this.index,
+      selectedId: this.selectedId,
+      bodyId: this.bodyId,
+      renderedId: this.renderedId
+    };
+  }
+
+  /**
+   * One immutable snapshot per mutation, so subscribers can identity-compare
+   * and `useSyncExternalStore` stays happy.
+   */
+  emit() {
+    this.snapshot = this.buildSnapshot();
+    for (const subscriber of this.subscribers) subscriber(this.snapshot);
+  }
+  getState() {
+    return this.snapshot;
+  }
+  subscribe(subscriber) {
+    this.subscribers.add(subscriber);
+    return () => {
+      this.subscribers.delete(subscriber);
+    };
+  }
+
+  /**
+   * Publish the navigable order. Called by the stepper whenever its derived
+   * list changes (filter, search, pins, new requests arriving).
+   *
+   * The cursor is re-anchored BY ID, not by position: the live list is
+   * newest-first and new requests are prepended, so holding an index would
+   * silently slide the selection onto a different request every time one
+   * landed.
+   */
+  setIds(ids) {
+    const sameIds = ids.length === this.ids.length && ids.every((id, i) => id === this.ids[i]);
+    if (sameIds) return;
+    this.ids = ids;
+    this.index = this.selectedId == null ? -1 : ids.indexOf(this.selectedId);
+    this.emit();
+  }
+  select(id) {
+    if (id === this.selectedId) return;
+    this.selectedId = id;
+    this.index = id == null ? -1 : this.ids.indexOf(id);
+    this.scheduleBody(id);
+    this.emit();
+  }
+  clear() {
+    this.select(null);
+  }
+
+  /**
+   * Move the cursor. O(1) — the whole reason `index` is stored rather than
+   * re-derived with a `findIndex` on every render.
+   *
+   * Returns the id it landed on, or null if the move was out of bounds (the
+   * footer disables its arrows at the ends, but the benchmark driver calls
+   * this directly and needs to know when it has run off the end).
+   */
+  step(delta) {
+    if (this.index < 0) return null;
+    const next = this.index + delta;
+    if (next < 0 || next >= this.ids.length) return null;
+    const id = this.ids[next];
+    this.selectedId = id;
+    this.index = next;
+    this.scheduleBody(id);
+    this.emit();
+    return id;
+  }
+
+  /**
+   * Opening and closing skip the settle delay: there is no in-flight render to
+   * protect on a null↔id transition, and waiting there just reads as a hang.
+   * Only id → id steps debounce.
+   */
+  scheduleBody(id) {
+    if (this.settleTimer != null) {
+      clearTimeout(this.settleTimer);
+      this.settleTimer = null;
+    }
+    if (id == null || this.bodyId == null || this.settleMs <= 0) {
+      this.bodyId = id;
+      return;
+    }
+    this.settleTimer = setTimeout(() => {
+      this.settleTimer = null;
+      if (this.bodyId === this.selectedId) return;
+      this.bodyId = this.selectedId;
+      this.emit();
+    }, this.settleMs);
+  }
+
+  /** Benchmark toggle — `?settle=0` measures the gate's contribution. */
+  setSettleMs(ms) {
+    this.settleMs = Math.max(0, ms);
+  }
+  getSettleMs() {
+    return this.settleMs;
+  }
+
+  /** Reported by the detail screen after commit. Instrumentation only. */
+  reportRendered(id) {
+    if (id === this.renderedId) return;
+    this.renderedId = id;
+    this.emit();
+  }
+
+  /** Test/bench helper — drop all cursor state without touching the events. */
+  reset() {
+    if (this.settleTimer != null) clearTimeout(this.settleTimer);
+    this.settleTimer = null;
+    this.ids = [];
+    this.index = -1;
+    this.selectedId = null;
+    this.bodyId = null;
+    this.renderedId = null;
+    this.emit();
+  }
+}
+export const networkSelectionStore = new NetworkSelectionStore();
+
+/** Convenience for publishing an event list as the navigable order. */
+export function toSelectionIds(events) {
+  return events.map(event => event.id);
+}

package/lib/module/preset.js

@@ -19,6 +19,19 @@
 
 import { NetworkIcon } from "@buoy-gg/shared-ui";
 import { NetworkModal } from "./network/components/NetworkModal";
+import { overrideRulesStore } from "./network/overrides/overrideRulesStore";
+
+/**
+ * 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.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+void overrideRulesStore.ensureLoaded();
 
 /**
  * Pre-configured network monitoring tool for FloatingDevTools.
@@ -28,7 +41,6 @@ import { NetworkModal } from "./network/components/NetworkModal";
  * - Filter by status, method, URL
  * - Timing information
  */
-import { jsx as _jsx } from "react/jsx-runtime";
 export const networkToolPreset = {
   id: "network",
   name: "NET",

package/lib/typescript/index.d.ts

@@ -20,9 +20,18 @@ export { useLiveNetworkEvent } from "./network/hooks/useLiveNetworkEvent";
 export { useNetworkBadgeCounts } from "./network/hooks/useNetworkBadgeCounts";
 export { useNetworkSaved, type UseNetworkSavedResult, } from "./network/hooks/useNetworkSaved";
 export { splitPinned, type PinnedSplit } from "./network/utils/withPinnedFirst";
+export { networkSelectionStore, DEFAULT_SETTLE_MS, type NetworkSelectionState, } from "./network/utils/networkSelectionStore";
 export { TickProvider, useTickEveryMinute } from "./network/hooks/useTickEveryMinute";
 export { formatBytes, formatDuration, formatHttpStatus, } from "./network/utils/formatting";
 export type { NetworkEvent, NetworkStats, NetworkFilter, NetworkEventStatus, NetworkInsight, IgnoredPattern, IgnoredPatternMatchMode, } from "./network/types";
+export { overrideRulesStore, type OverrideRulesState, type OverrideRuleDraft, 
+/**
+ * @internal — the desktop dashboard puts the rule store in remote-mirror mode
+ * so edits made there are forwarded to the device instead of stored locally.
+ */
+type OverrideRulesRemote, } from "./network/overrides/overrideRulesStore";
+export { draftFromEvent } from "./network/overrides/presets";
+export { MAX_RULES as MAX_OVERRIDE_RULES, FREE_TIER_RULE_LIMIT as FREE_TIER_OVERRIDE_LIMIT, STATUS_MIN as OVERRIDE_STATUS_MIN, STATUS_MAX as OVERRIDE_STATUS_MAX, type OverrideRule, type OverrideRuleKind, type OverrideFailKind, type NetworkOverrideMark, } from "./network/overrides/types";
 export { useIgnoredPatterns, ignoredPatternsStore, urlMatchesIgnoredPattern, isUrlIgnored, } from "@buoy-gg/shared-ui";
 export { networkSyncAdapter } from "./network/sync/networkSyncAdapter";
 export { NetworkBodyResolverProvider, type NetworkBodyResolver, type ResolvedNetworkBody, } from "./network/sync/networkBodyResolver";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAOhE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAClF,YAAY,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AACvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EACL,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,wCAAwC,CAAC;AAKhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAIpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAI9E,OAAO,EACL,eAAe,EACf,KAAK,qBAAqB,GAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAKtF,OAAO,EACL,WAAW,EACX,cAAc,EACd,gBAAgB,GACjB,MAAM,4BAA4B,CAAC;AAKpC,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AAQzB,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EACL,2BAA2B,EAC3B,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,oCAAoC,CAAC;AAO5C,gBAAgB;AAChB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE;;;GAGG;AACH,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,UAAU,EACV,SAAS,EACT,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,gBAAgB;AAChB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAOhE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAClF,YAAY,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AACvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EACL,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,wCAAwC,CAAC;AAKhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAIpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAI9E,OAAO,EACL,eAAe,EACf,KAAK,qBAAqB,GAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAIhF,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,qBAAqB,GAC3B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAKtF,OAAO,EACL,WAAW,EACX,cAAc,EACd,gBAAgB,GACjB,MAAM,4BAA4B,CAAC;AAKpC,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AAQzB,OAAO,EACL,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB;AACtB;;;GAGG;AACH,KAAK,mBAAmB,GACzB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EACL,SAAS,IAAI,kBAAkB,EAC/B,oBAAoB,IAAI,wBAAwB,EAChD,UAAU,IAAI,mBAAmB,EACjC,UAAU,IAAI,mBAAmB,EACjC,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,2BAA2B,CAAC;AAQnC,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EACL,2BAA2B,EAC3B,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,oCAAoC,CAAC;AAO5C,gBAAgB;AAChB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE;;;GAGG;AACH,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,UAAU,EACV,SAAS,EACT,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,gBAAgB;AAChB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,iCAAiC,CAAC"}

package/lib/typescript/network/components/NetworkDetailStepper.d.ts

@@ -5,8 +5,8 @@
  * It is its OWN leaf (rule3) because it is the only part of the detail screen
  * that needs the event LIST. Subscribing here keeps the request stream out of
  * the detail body's render path, which is the expensive subtree (headers,
- * bodies, JSON viewers, diff views): a request arriving re-renders this
- * ~30-node footer and nothing else.
+ * bodies, JSON viewers): a request arriving re-renders this ~30-node footer
+ * and nothing else.
  *
  * The order it steps through is EXACTLY what the list screen renders —
  * `[...pinned, ...rest]` off the same `useNetworkEventList` + `splitPinned`
@@ -16,12 +16,16 @@
  * "request N of <what the list is showing>", never "N of everything ever
  * captured". Detail opened from the Saved screen steps through the SAVED
  * list instead (with its own search applied), for the same reason.
+ *
+ * This component OWNS the navigable order but not the cursor: it publishes
+ * the ordered ids into `networkSelectionStore` and reads the cursor back.
+ * That split is what makes stepping O(1) (the store keeps the index, so
+ * there is no `findIndex` per render) and what lets the benchmark harness
+ * drive `step(+1)` directly without going through the UI.
  */
 import { type IgnoredPattern } from "@buoy-gg/shared-ui";
 import type { NetworkFilter } from "../types";
 interface NetworkDetailStepperProps {
-    /** The request currently on screen. */
-    eventId: string;
     paused: boolean;
     filter: NetworkFilter;
     ignoredPatterns: readonly IgnoredPattern[];
@@ -30,7 +34,6 @@ interface NetworkDetailStepperProps {
     fromSaved: boolean;
     /** The Saved screen's search box (lifted to the modal root so both agree). */
     savedSearch: string;
-    onSelect: (eventId: string) => void;
     /** Only a bottom sheet sits on the home indicator — see NetworkModal. */
     applySafeAreaInset: boolean;
 }

package/lib/typescript/network/components/NetworkDetailStepper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkDetailStepper.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkDetailStepper.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,UAAU,CAAC;AAM5D,UAAU,yBAAyB;IACjC,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,aAAa,CAAC;IACtB,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,KAAK,EAAE,OAAO,CAAC;IACf,wEAAwE;IACxE,SAAS,EAAE,OAAO,CAAC;IACnB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,yEAAyE;IACzE,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED,eAAO,MAAM,oBAAoB,iEAmE/B,CAAC"}
+{"version":3,"file":"NetworkDetailStepper.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkDetailStepper.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,UAAU,CAAC;AAW5D,UAAU,yBAAyB;IACjC,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,aAAa,CAAC;IACtB,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,KAAK,EAAE,OAAO,CAAC;IACf,wEAAwE;IACxE,SAAS,EAAE,OAAO,CAAC;IACnB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAMD,eAAO,MAAM,oBAAoB,iEAiE/B,CAAC"}

package/lib/typescript/network/components/NetworkEventDetailView.d.ts

@@ -3,11 +3,46 @@ interface NetworkEventDetailViewProps {
     event: NetworkEvent;
     ignoredPatterns?: Set<string>;
     onTogglePattern?: (pattern: string) => void;
+    /**
+     * Mount the request/response BODY trees.
+     *
+     * False while the prev/next cursor is still moving. The body trees are ~93%
+     * of a step's cost (measured: 647ms/step with them, 43ms without, at a 150ms
+     * tap interval over 64KB payloads), and they are the only part of this view
+     * that can't keep up with a thumb. Everything else renders on every step.
+     *
+     * Note the mechanism: this doesn't skip the tree so much as ensure it gets
+     * unmounted by the next tap before its chunked flatten completes. Stepping
+     * therefore costs ~14ms/step instead of ~500ms, and exactly one tree
+     * flattens for real — the one you stop on.
+     *
+     * Defaults true so the Events tool — which renders this same view without a
+     * cursor — is unaffected.
+     */
+    showBodies?: boolean;
 }
 /**
  * Detailed inspector rendering request/response metadata for a single network event. Designed to
  * mimic Sentry’s layout with collapsible sections, diff views, and quick copy affordances.
+ *
+ * MEMOIZED with profiling evidence, not by reflex. Two render paths hit this
+ * subtree with unchanged props:
+ *
+ *  1. `useLiveNetworkEvent` re-subscribes when the selected ID changes, and
+ *     `subscribeToEvents` replays immediately — so every step through the
+ *     prev/next footer committed the SAME event object twice, rendering this
+ *     whole tree (expanded DataViewer included) a second time for nothing.
+ *  2. Any modal-root state change (header search, mode toggle) re-renders the
+ *     shell, and the detail body has nothing to do with it.
+ *
+ * Both props besides `event` are stable by construction — `values` is memoized
+ * in `useIgnoredPatterns` and `toggle` is module-scope there — so the bail-out
+ * actually fires.
+ *
+ * Measured baseline (js-top, example-dev-build, 5 steps over 109–324KB
+ * pokeapi responses): 307ms of React work across 5 steps ≈ 61ms of JS per
+ * step. Case 1 alone is half of that, since it re-ran the whole body render.
  */
-export declare function NetworkEventDetailView({ event, ignoredPatterns, onTogglePattern, }: NetworkEventDetailViewProps): import("react").JSX.Element;
+export declare const NetworkEventDetailView: import("react").NamedExoticComponent<NetworkEventDetailViewProps>;
 export {};
 //# sourceMappingURL=NetworkEventDetailView.d.ts.map

package/lib/typescript/network/components/NetworkEventDetailView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkEventDetailView.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkEventDetailView.tsx"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,UAAU,CAAC;AAqB7D,UAAU,2BAA2B;IACnC,KAAK,EAAE,YAAY,CAAC;IACpB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7C;AAmQD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,KAAK,EACL,eAA2B,EAC3B,eAA0B,GAC3B,EAAE,2BAA2B,+BAse7B"}
+{"version":3,"file":"NetworkEventDetailView.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkEventDetailView.tsx"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,UAAU,CAAC;AA0B7D,UAAU,2BAA2B;IACnC,KAAK,EAAE,YAAY,CAAC;IACpB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C;;;;;;;;;;;;;;;OAeG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AA+QD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sBAAsB,mEA6gBjC,CAAC"}

package/lib/typescript/network/components/NetworkEventItemCompact.d.ts

@@ -14,6 +14,12 @@ interface NetworkEventItemCompactProps {
     pinned?: boolean;
     saved?: boolean;
     onLongPress?: (event: NetworkEvent) => void;
+    /**
+     * Rendered in the OVERRIDDEN strip. Distinct from `event.override`, which
+     * records that a PAST request was overridden — this says a rule covers the
+     * row right now, which is true even for a request captured before the rule.
+     */
+    overridden?: boolean;
 }
 export declare const NetworkEventItemCompact: import("react").NamedExoticComponent<NetworkEventItemCompactProps>;
 export {};

package/lib/typescript/network/components/NetworkEventItemCompact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkEventItemCompact.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkEventItemCompact.tsx"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAM7C,UAAU,4BAA4B;IACpC,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;CAC7C;AAkJD,eAAO,MAAM,uBAAuB,oEAsHnC,CAAC"}
+{"version":3,"file":"NetworkEventItemCompact.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkEventItemCompact.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAM7C,UAAU,4BAA4B;IACpC,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC5C;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAkJD,eAAO,MAAM,uBAAuB,oEA4HnC,CAAC"}

package/lib/typescript/network/components/NetworkHeaderLive.d.ts

@@ -43,7 +43,6 @@ interface NetworkSavedButtonProps {
  */
 export declare function NetworkSavedButton({ onPress }: NetworkSavedButtonProps): import("react").JSX.Element;
 interface NetworkDetailPinActionsProps {
-    eventId: string | null;
     isPro: boolean;
     onUpgradePress: () => void;
 }
@@ -60,8 +59,12 @@ interface NetworkDetailPinActionsProps {
  * The event object is resolved at PRESS time rather than held as a prop: the
  * live store has the fresh copy while the request is in flight, and the saved
  * store is the only copy once it has been cleared or aged out.
+ *
+ * The selected id is SUBSCRIBED here rather than passed down, so stepping
+ * through requests doesn't have to re-render the modal root just to rebuild
+ * the header around a new prop.
  */
-export declare function NetworkDetailPinActions({ eventId, isPro, onUpgradePress, }: NetworkDetailPinActionsProps): import("react").JSX.Element;
+export declare function NetworkDetailPinActions({ isPro, onUpgradePress, }: NetworkDetailPinActionsProps): import("react").JSX.Element;
 interface NetworkHeaderCopyButtonProps {
     isPro: boolean;
     filter: NetworkFilter;
@@ -69,12 +72,19 @@ interface NetworkHeaderCopyButtonProps {
     copySettings: CopySettings;
     paused: boolean;
     onUpgradePress: () => void;
+    /**
+     * Render as a labelled row instead of a bare glyph, for the header's
+     * overflow menu. The behaviour is identical — this button owns the lazy copy
+     * value, the Pro gate and the copied/failed feedback, and a menu row that
+     * reimplemented them would be a second copy path to keep in step.
+     */
+    label?: string;
 }
 /**
  * Copy-all-requests button. Subscribes to a flip-guarded boolean (its
  * enabled state); the copy text is generated at PRESS time from a live
  * store read, so there's no per-event work and no stale closure.
  */
-export declare function NetworkHeaderCopyButton({ isPro, filter, ignoredPatterns, copySettings, paused, onUpgradePress, }: NetworkHeaderCopyButtonProps): import("react").JSX.Element;
+export declare function NetworkHeaderCopyButton({ isPro, filter, ignoredPatterns, copySettings, paused, onUpgradePress, label, }: NetworkHeaderCopyButtonProps): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=NetworkHeaderLive.d.ts.map

package/lib/typescript/network/components/NetworkHeaderLive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkHeaderLive.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkHeaderLive.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAUL,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAqB9D,KAAK,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAEpD,UAAU,wBAAwB;IAChC,YAAY,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IACtC,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAC/C,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,EAClC,YAAY,EACZ,cAAc,EACd,eAAe,EACf,MAAM,GACP,EAAE,wBAAwB,+BA4D1B;AAED,UAAU,uBAAuB;IAC/B,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;iDAEiD;AACjD,wBAAgB,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAAE,uBAAuB,+BAqBrE;AAED,UAAU,uBAAuB;IAC/B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,OAAO,EAAE,EAAE,uBAAuB,+BAwBtE;AAED,UAAU,4BAA4B;IACpC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,OAAO,EACP,KAAK,EACL,cAAc,GACf,EAAE,4BAA4B,+BAsF9B;AAED,UAAU,4BAA4B;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,aAAa,CAAC;IACtB,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,MAAM,EACN,eAAe,EACf,YAAY,EACZ,MAAM,EACN,cAAc,GACf,EAAE,4BAA4B,+BAiD9B"}
+{"version":3,"file":"NetworkHeaderLive.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkHeaderLive.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAUL,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAsB9D,KAAK,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAEpD,UAAU,wBAAwB;IAChC,YAAY,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IACtC,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAC/C,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,EAClC,YAAY,EACZ,cAAc,EACd,eAAe,EACf,MAAM,GACP,EAAE,wBAAwB,+BA4D1B;AAED,UAAU,uBAAuB;IAC/B,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;iDAEiD;AACjD,wBAAgB,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAAE,uBAAuB,+BAqBrE;AAED,UAAU,uBAAuB;IAC/B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,OAAO,EAAE,EAAE,uBAAuB,+BAwBtE;AAED,UAAU,4BAA4B;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,cAAc,GACf,EAAE,4BAA4B,+BAuF9B;AAED,UAAU,4BAA4B;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,aAAa,CAAC;IACtB,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,MAAM,EACN,eAAe,EACf,YAAY,EACZ,MAAM,EACN,cAAc,EACd,KAAK,GACN,EAAE,4BAA4B,+BAsD9B"}

package/lib/typescript/network/components/NetworkHeaderMenu.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode } from "react";
+/**
+ * The header's overflow menu.
+ *
+ * The toolbar had grown to three status badges and six icon buttons, which on a
+ * 402pt screen meant the pending badge was being overlapped by the search
+ * button. Something had to leave, and the rule for deciding what is:
+ *
+ *   **A control that COMMUNICATES STATE stays visible. A destination or a rare
+ *   action goes in the menu.**
+ *
+ * That keeps the power toggle (are we capturing?), the overrides flask (is the
+ * app being lied to, and how many rules?), the status badges (what happened)
+ * and Clear (the reproduce loop is clear → repro → read, and burying the first
+ * step doubles it). Search stays because it's the only way through 500 rows.
+ *
+ * Filters, Saved and Copy leave. Filters is the interesting one — it does show
+ * state, so the ⋯ carries a dot when a filter is applied rather than hiding
+ * that fact.
+ */
+export declare function NetworkHeaderMenuButton({ onPress, isOpen, hasIndicator, }: {
+    onPress: () => void;
+    /** The menu is showing — the button holds a lit state and closes on tap. */
+    isOpen?: boolean;
+    /** Something behind the menu is active — currently a filter. */
+    hasIndicator?: boolean;
+}): import("react").JSX.Element;
+export interface NetworkHeaderMenuProps {
+    onClose: () => void;
+    children: ReactNode;
+}
+/**
+ * The dropdown itself, rendered in the modal BODY rather than the header —
+ * the header is a fixed-height row and anything overflowing it is clipped, so
+ * a panel anchored to the top-right of the body lands exactly where a dropdown
+ * from the ⋯ should appear.
+ */
+export declare function NetworkHeaderMenu({ onClose, children }: NetworkHeaderMenuProps): import("react").JSX.Element;
+export declare function NetworkHeaderMenuItem({ icon, label, detail, onPress, }: {
+    icon: ReactNode;
+    label: string;
+    /** Right-aligned state, e.g. the active filter count. */
+    detail?: string;
+    onPress: () => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=NetworkHeaderMenu.d.ts.map

package/lib/typescript/network/components/NetworkHeaderMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkHeaderMenu.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkHeaderMenu.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAgB,uBAAuB,CAAC,EACtC,OAAO,EACP,MAAM,EACN,YAAY,GACb,EAAE;IACD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,gEAAgE;IAChE,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,+BAkBA;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,sBAAsB,+BAY9E;AAED,wBAAgB,qBAAqB,CAAC,EACpC,IAAI,EACJ,KAAK,EACL,MAAM,EACN,OAAO,GACR,EAAE;IACD,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,+BAYA"}