@buoy-gg/network 4.0.2 → 6.0.0

package/lib/module/network/hooks/useNetworkBadgeCounts.js

@@ -0,0 +1,79 @@
+"use strict";
+
+/**
+ * Narrow store subscription for the header's live counters — the ONLY
+ * header data that should update per network event (the success/error/
+ * pending chips and the clear button's has-events state).
+ *
+ * Holds derived COUNTS in state, not the events array, with an equality
+ * guard — so consumers re-render only when a count actually changes
+ * (e.g. an ignored-pattern-matched event arriving doesn't re-render the
+ * chips). rule2: external store, narrowest possible subscription.
+ */
+
+import { useEffect, useState } from "react";
+import { networkEventStore } from "../utils/networkEventStore";
+import { applyIgnoredPatterns } from "../utils/filterNetworkEvents";
+function computeCounts(events, ignoredPatterns) {
+  let successful = 0;
+  let failed = 0;
+  let pending = 0;
+  for (const event of applyIgnoredPatterns(events, ignoredPatterns)) {
+    if (event.status && event.status >= 200 && event.status < 300) {
+      successful++;
+    } else if (event.error || event.status && event.status >= 400) {
+      failed++;
+    } else if (!event.status && !event.error) {
+      pending++;
+    }
+  }
+  return {
+    successful,
+    failed,
+    pending,
+    total: events.length
+  };
+}
+function countsEqual(a, b) {
+  return a.successful === b.successful && a.failed === b.failed && a.pending === b.pending && a.total === b.total;
+}
+export function useNetworkBadgeCounts(options) {
+  const {
+    ignoredPatterns,
+    paused
+  } = options;
+  const [counts, setCounts] = useState(() => computeCounts(networkEventStore.getEvents(), ignoredPatterns));
+  useEffect(() => {
+    if (paused) return undefined;
+    // Frame-coalesced like useNetworkEventList: a request burst updates
+    // the chips once per frame, not once per emission. subscribeToEvents
+    // replays immediately, which also recomputes when ignoredPatterns
+    // change (this effect re-runs).
+    let rafId = null;
+    let pending = null;
+    const unsubscribe = networkEventStore.subscribeToEvents(events => {
+      pending = events;
+      if (rafId != null) return;
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        if (!pending) return;
+        const next = computeCounts(pending, ignoredPatterns);
+        pending = null;
+        setCounts(prev => countsEqual(prev, next) ? prev : next);
+      });
+    });
+    return () => {
+      unsubscribe();
+      if (rafId != null) cancelAnimationFrame(rafId);
+    };
+  }, [paused, ignoredPatterns]);
+  useEffect(() => networkEventStore.onClear(() => {
+    setCounts({
+      successful: 0,
+      failed: 0,
+      pending: 0,
+      total: 0
+    });
+  }), []);
+  return counts;
+}

package/lib/module/network/hooks/useNetworkEventList.js

@@ -0,0 +1,89 @@
+"use strict";
+
+/**
+ * Narrow store subscription for components that render the network event
+ * LIST (or need the filtered list). Decomposed from `useNetworkEvents`
+ * per rule2 ("external store + narrow subscriptions") so the subscription
+ * lives in the leaf that consumes it — the modal root no longer
+ * re-renders per network event.
+ *
+ * Profiling evidence (tool-bench, 2026-07-06): with the subscription at
+ * the modal root, 15 network events re-rendered the ENTIRE modal 15× —
+ * JsModalComponent/header buttons ×15, all visible rows ×105.
+ *
+ * `paused` gates the subscription (the power toggle's freeze-stream
+ * semantic, and screens pass `paused || !visible` so hidden screens don't
+ * subscribe at all). Store clears are honored even while paused so a
+ * frozen list can't show deleted events (parity with the old hook's
+ * clearEvents local reset).
+ */
+
+import { useEffect, useMemo, useState } from "react";
+import { networkEventStore } from "../utils/networkEventStore";
+import { applyIgnoredPatterns, filterNetworkEvents } from "../utils/filterNetworkEvents";
+import { FREE_TIER_REQUEST_LIMIT } from "./useNetworkEvents";
+export function useNetworkEventList(options) {
+  const {
+    filter,
+    ignoredPatterns,
+    paused,
+    isPro
+  } = options;
+  const [events, setEvents] = useState(() => networkEventStore.getEvents());
+  useEffect(() => {
+    if (paused) return undefined;
+    // Coalesce store emissions to one commit per frame: a burst of N
+    // concurrent requests emits 2N times (add + response each), and
+    // uncoalesced each emission is its own commit re-rendering the
+    // changed row's whole subtree. Profiling (tool-bench 2026-07-06):
+    // a rapid 25-request session produced 70 commits at ~220 renders
+    // each. subscribeToEvents replays the current array immediately, so
+    // resuming from pause catches up on the next frame.
+    let rafId = null;
+    let pending = null;
+    const unsubscribe = networkEventStore.subscribeToEvents(next => {
+      pending = next;
+      if (rafId != null) return;
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        if (pending) setEvents(pending);
+        pending = null;
+      });
+    });
+    return () => {
+      unsubscribe();
+      if (rafId != null) cancelAnimationFrame(rafId);
+    };
+  }, [paused]);
+  useEffect(() => networkEventStore.onClear(() => {
+    setEvents([]);
+  }), []);
+
+  // Derivations are plain useMemo over the subscribed array — linear
+  // passes over ≤maxEvents items, recomputed only when inputs change.
+  const filteredEvents = useMemo(() => {
+    return filterNetworkEvents(applyIgnoredPatterns(events, ignoredPatterns), filter);
+  }, [events, ignoredPatterns, filter]);
+
+  // Free tier: events beyond the limit in the ORIGINAL order are locked,
+  // so locked events stay locked even when searching (ported verbatim).
+  const lockedEventIds = useMemo(() => {
+    if (isPro) return new Set();
+    const lockedIds = new Set();
+    events.slice(FREE_TIER_REQUEST_LIMIT).forEach(event => {
+      lockedIds.add(event.id);
+    });
+    return lockedIds;
+  }, [events, isPro]);
+  const visibleEvents = useMemo(() => {
+    if (lockedEventIds.size === 0) return filteredEvents;
+    return filteredEvents.filter(event => !lockedEventIds.has(event.id));
+  }, [filteredEvents, lockedEventIds]);
+  const lockedEventCount = filteredEvents.length - visibleEvents.length;
+  return {
+    events: filteredEvents,
+    visibleEvents,
+    hasLockedEvents: lockedEventCount > 0,
+    lockedEventCount
+  };
+}

package/lib/module/network/hooks/useNetworkHasMatches.js

@@ -0,0 +1,52 @@
+"use strict";
+
+/**
+ * Narrowest possible subscription: a BOOLEAN that flips when the store
+ * goes between "has events matching this filter" and "empty". Used by
+ * header buttons (clear/copy) whose only live dependency is their
+ * enabled state — with the full counts hook they re-rendered on every
+ * count change (32× in a 25-request run, tool-bench 2026-07-06); with a
+ * flip-guarded boolean they render ~twice per session.
+ */
+
+import { useEffect, useState } from "react";
+import { networkEventStore } from "../utils/networkEventStore";
+import { applyIgnoredPatterns, filterNetworkEvents } from "../utils/filterNetworkEvents";
+
+/** True while the store has ANY events (clear button's enabled state). */
+export function useNetworkHasEvents(options) {
+  const {
+    paused
+  } = options;
+  const [hasEvents, setHasEvents] = useState(() => networkEventStore.getEvents().length > 0);
+  useEffect(() => {
+    if (paused) return undefined;
+    return networkEventStore.subscribeToEvents(events => {
+      const next = events.length > 0;
+      setHasEvents(prev => prev === next ? prev : next);
+    });
+  }, [paused]);
+  useEffect(() => networkEventStore.onClear(() => setHasEvents(false)), []);
+  return hasEvents;
+}
+
+/** True while the store has events matching the current filter (copy
+ * button's enabled state). The filter pass runs per emission but a
+ * re-render only happens when the boolean flips. */
+export function useNetworkHasMatches(options) {
+  const {
+    filter,
+    ignoredPatterns,
+    paused
+  } = options;
+  const [hasMatches, setHasMatches] = useState(() => filterNetworkEvents(applyIgnoredPatterns(networkEventStore.getEvents(), ignoredPatterns), filter).length > 0);
+  useEffect(() => {
+    if (paused) return undefined;
+    return networkEventStore.subscribeToEvents(events => {
+      const next = filterNetworkEvents(applyIgnoredPatterns(events, ignoredPatterns), filter).length > 0;
+      setHasMatches(prev => prev === next ? prev : next);
+    });
+  }, [paused, filter, ignoredPatterns]);
+  useEffect(() => networkEventStore.onClear(() => setHasMatches(false)), []);
+  return hasMatches;
+}

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

@@ -0,0 +1,92 @@
+"use strict";
+
+/**
+ * Pure network-event filtering shared by the list/copy/filter-screen hooks
+ * (rule3: reusable logic extracted to a pure function). Ported verbatim
+ * from the filtering previously inlined in `useNetworkEvents` so every
+ * subscriber applies identical semantics.
+ */
+
+import { urlMatchesIgnoredPattern } from "@buoy-gg/shared-ui";
+import { searchGraphQLVariables } from "./formatGraphQLVariables";
+
+/** Apply the user's search/method/status/host/content-type filter. */
+export function filterNetworkEvents(events, filter) {
+  const searchLower = filter.searchText ? filter.searchText.toLowerCase() : null;
+  const methodSet = filter.method && filter.method.length > 0 ? new Set(filter.method) : null;
+  const contentTypeSet = filter.contentType && filter.contentType.length > 0 ? new Set(filter.contentType) : null;
+  let filtered = [...events];
+  if (methodSet) {
+    filtered = filtered.filter(e => methodSet.has(e.method));
+  }
+  if (filter.status && filter.status !== "all") {
+    switch (filter.status) {
+      case "success":
+        filtered = filtered.filter(e => e.status && e.status >= 200 && e.status < 300);
+        break;
+      case "error":
+        filtered = filtered.filter(e => e.error || e.status && e.status >= 400);
+        break;
+      case "pending":
+        filtered = filtered.filter(e => !e.status && !e.error);
+        break;
+    }
+  }
+  if (searchLower) {
+    filtered = filtered.filter(e => e.url.toLowerCase().includes(searchLower) || e.method.toLowerCase().includes(searchLower) || e.path?.toLowerCase().includes(searchLower) || e.host?.toLowerCase().includes(searchLower) || e.error && e.error.toLowerCase().includes(searchLower) ||
+    // Search by GraphQL operation name (e.g., "GetUser", "CreatePost")
+    e.operationName && e.operationName.toLowerCase().includes(searchLower) ||
+    // Search by GraphQL variable values (e.g., "Sandshrew", "123")
+    searchGraphQLVariables(e.graphqlVariables, searchLower));
+  }
+  if (filter.host) {
+    filtered = filtered.filter(e => e.host === filter.host);
+  }
+  if (contentTypeSet) {
+    filtered = filtered.filter(e => {
+      const headers = e.responseHeaders || e.requestHeaders;
+      const contentType = headers?.["content-type"] || headers?.["Content-Type"] || "";
+      for (const type of contentTypeSet) {
+        switch (type) {
+          case "JSON":
+            if (contentType.includes("json")) return true;
+            break;
+          case "XML":
+            if (contentType.includes("xml")) return true;
+            break;
+          case "HTML":
+            if (contentType.includes("html")) return true;
+            break;
+          case "TEXT":
+            if (contentType.includes("text")) return true;
+            break;
+          case "IMAGE":
+            if (contentType.includes("image")) return true;
+            break;
+          case "VIDEO":
+            if (contentType.includes("video")) return true;
+            break;
+          case "AUDIO":
+            if (contentType.includes("audio")) return true;
+            break;
+          case "FORM":
+            if (contentType.includes("form")) return true;
+            break;
+          case "OTHER":
+            if (!contentType || !contentType.includes("json") && !contentType.includes("xml") && !contentType.includes("html") && !contentType.includes("text") && !contentType.includes("image") && !contentType.includes("video") && !contentType.includes("audio") && !contentType.includes("form")) {
+              return true;
+            }
+            break;
+        }
+      }
+      return false;
+    });
+  }
+  return filtered;
+}
+
+/** Drop events matching the shared ignored-domain/URL patterns. */
+export function applyIgnoredPatterns(events, ignoredPatterns) {
+  if (ignoredPatterns.length === 0) return events;
+  return events.filter(event => !ignoredPatterns.some(pattern => urlMatchesIgnoredPattern(event.url, pattern)));
+}

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

@@ -0,0 +1,135 @@
+"use strict";
+
+/**
+ * Pure copy-text generation for the network tool (rule3: reusable logic
+ * extracted from the modal). Ported verbatim from the `generateCopyText`
+ * callback previously inlined in NetworkModal — kept pure so the header
+ * CopyButton can resolve it LAZILY at copy time (CopyButton accepts a
+ * function value) instead of rebuilding the string on every event.
+ */
+
+import { formatBytes } from "./formatting";
+function shouldIncludePayload(data, bodySizeThresholdKb) {
+  if (bodySizeThresholdKb === -1) return true;
+  if (!data) return true;
+  try {
+    const size = JSON.stringify(data).length;
+    return size < bodySizeThresholdKb * 1024;
+  } catch {
+    return false;
+  }
+}
+export function generateNetworkCopyText(events, copySettings) {
+  let eventsToUse = events;
+
+  // Apply filter mode
+  if (copySettings.filterMode === "failed") {
+    eventsToUse = eventsToUse.filter(e => e.error || e.status && e.status >= 400);
+  } else if (copySettings.filterMode === "success") {
+    eventsToUse = eventsToUse.filter(e => e.status && e.status >= 200 && e.status < 300);
+  }
+  if (eventsToUse.length === 0) {
+    return "No requests to copy";
+  }
+
+  // Plain text format (URLs only)
+  if (copySettings.format === "plaintext") {
+    return eventsToUse.map(event => `${event.method} ${event.url}`).join("\n");
+  }
+
+  // JSON format
+  if (copySettings.format === "json") {
+    const requests = eventsToUse.map(event => {
+      const obj = {};
+      if (copySettings.includeMethod) {
+        obj.method = event.method;
+        obj.url = event.url;
+      }
+      if (copySettings.includeStatus) {
+        obj.status = event.status;
+        obj.statusText = event.statusText;
+      }
+      if (copySettings.includeDuration) obj.duration = event.duration;
+      if (copySettings.includeTimestamp) obj.timestamp = event.timestamp;
+      if (copySettings.includeClient) obj.requestClient = event.requestClient;
+      if (copySettings.includeSizes) {
+        obj.requestSize = event.requestSize;
+        obj.responseSize = event.responseSize;
+      }
+      if (copySettings.includeErrors && event.error) obj.error = event.error;
+      if (copySettings.includeRequestHeaders) {
+        obj.requestHeaders = event.requestHeaders;
+      }
+      if (copySettings.includeResponseHeaders) {
+        obj.responseHeaders = event.responseHeaders;
+      }
+      if (copySettings.includeRequestBody && shouldIncludePayload(event.requestData, copySettings.bodySizeThreshold)) {
+        obj.requestData = event.requestData;
+      }
+      if (copySettings.includeResponseBody && shouldIncludePayload(event.responseData, copySettings.bodySizeThreshold)) {
+        obj.responseData = event.responseData;
+      }
+      return obj;
+    });
+    return JSON.stringify(requests, null, 2);
+  }
+
+  // Markdown format
+  const requests = eventsToUse.map((event, index) => {
+    let md = `# Request ${index + 1}\n\n`;
+    if (copySettings.includeMethod) {
+      md += `**Method:** ${event.method}\n`;
+      md += `**URL:** ${event.url}\n`;
+    }
+    if (copySettings.includeStatus) {
+      const status = event.status || "Pending";
+      md += `**Status:** ${status}${event.statusText ? ` (${event.statusText})` : ""}\n`;
+    }
+    if (copySettings.includeClient && event.requestClient) {
+      md += `**Client:** ${event.requestClient}\n`;
+    }
+    if (copySettings.includeDuration && event.duration) {
+      md += `**Duration:** ${event.duration}ms\n`;
+    }
+    if (copySettings.includeTimestamp) {
+      md += `**Timestamp:** ${new Date(event.timestamp).toISOString()}\n`;
+    }
+    if (copySettings.includeSizes) {
+      const reqSize = event.requestSize ? formatBytes(event.requestSize) : "N/A";
+      const resSize = event.responseSize ? formatBytes(event.responseSize) : "N/A";
+      md += `**Request Size:** ${reqSize}\n`;
+      md += `**Response Size:** ${resSize}\n`;
+    }
+    if (copySettings.includeErrors && event.error) {
+      md += `**Error:** ${event.error}\n`;
+    }
+    if (copySettings.includeRequestHeaders && Object.keys(event.requestHeaders).length > 0) {
+      md += `\n## Request Headers\n\`\`\`json\n${JSON.stringify(event.requestHeaders, null, 2)}\n\`\`\`\n`;
+    }
+    if (copySettings.includeRequestBody) {
+      md += `\n## Request Data\n`;
+      if (shouldIncludePayload(event.requestData, copySettings.bodySizeThreshold)) {
+        md += `\`\`\`json\n${JSON.stringify(event.requestData, null, 2)}\n\`\`\`\n`;
+      } else {
+        const size = event.requestSize ? formatBytes(event.requestSize) : "Unknown size";
+        md += `_Payload omitted (${size}). Exceeds ${copySettings.bodySizeThreshold}KB threshold._\n`;
+      }
+    }
+    if (copySettings.includeResponseHeaders && Object.keys(event.responseHeaders).length > 0) {
+      md += `\n## Response Headers\n\`\`\`json\n${JSON.stringify(event.responseHeaders, null, 2)}\n\`\`\`\n`;
+    }
+    if (copySettings.includeResponseBody) {
+      md += `\n## Response Data\n`;
+      if (shouldIncludePayload(event.responseData, copySettings.bodySizeThreshold)) {
+        md += `\`\`\`json\n${JSON.stringify(event.responseData, null, 2)}\n\`\`\`\n`;
+      } else {
+        const size = event.responseSize ? formatBytes(event.responseSize) : "Unknown size";
+        md += `_Payload omitted (${size}). Exceeds ${copySettings.bodySizeThreshold}KB threshold._\n`;
+      }
+    }
+    md += `\n---\n`;
+    return md;
+  }).join("\n");
+  const header = `# Network Requests (${eventsToUse.length} total)\n\n`;
+  return header + requests;
+}

package/lib/typescript/index.d.ts

@@ -12,6 +12,8 @@ export { NetworkModal } from "./network/components/NetworkModal";
 export { NetworkEventDetailView } from "./network/components/NetworkEventDetailView";
 export { NetworkEventItemCompact } from "./network/components/NetworkEventItemCompact";
 export { useNetworkEvents } from "./network/hooks/useNetworkEvents";
+export { useNetworkEventList } from "./network/hooks/useNetworkEventList";
+export { useNetworkBadgeCounts } from "./network/hooks/useNetworkBadgeCounts";
 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";

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;AAKhE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AAKvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,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,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;AAKhE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AAKvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAIpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,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,gBAAgB;AAChB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,iCAAiC,CAAC"}

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

@@ -3,10 +3,6 @@ interface NetworkEventItemCompactProps {
     event: NetworkEvent;
     onPress: (event: NetworkEvent) => void;
 }
-/**
- * Compact list-row representation of a network event. Optimized for large lists with memoization
- * and periodic refresh via `useTickEveryMinute` to keep relative timestamps accurate.
- */
 export declare const NetworkEventItemCompact: import("react").NamedExoticComponent<NetworkEventItemCompactProps>;
 export {};
 //# sourceMappingURL=NetworkEventItemCompact.d.ts.map

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":"AAaA,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;CACxC;AA8FD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,oEAuInC,CAAC"}
+{"version":3,"file":"NetworkEventItemCompact.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkEventItemCompact.tsx"],"names":[],"mappings":"AAaA,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;CACxC;AA0HD,eAAO,MAAM,uBAAuB,oEA4HnC,CAAC"}

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

@@ -0,0 +1,52 @@
+/**
+ * The header pieces that consume LIVE event data, decomposed out of
+ * NetworkModal per rule3 (decompose by responsibility) so each one is its
+ * own narrow store subscriber and the modal root/header never re-render
+ * per network event:
+ *
+ *  - `NetworkHeaderBadges` — success/error/pending count chips
+ *  - `NetworkClearButton`  — trash button (enabled = store has events;
+ *    clear handler co-located here per rule2)
+ *  - `NetworkHeaderCopyButton` — copy-all button; the copy TEXT is
+ *    resolved lazily at press time (CopyButton accepts a function value —
+ *    rule2's latest-ref pattern), so no string is built per event
+ *
+ * Profiling evidence for this decomposition: tool-bench 2026-07-06 —
+ * Trash2/CopyButton re-rendered 15× for 15 network events when the
+ * subscription lived at the modal root.
+ */
+import { type IgnoredPattern } from "@buoy-gg/shared-ui";
+import type { NetworkFilter } from "../types";
+import type { CopySettings } from "./NetworkCopySettingsView";
+type StatusFilter = "success" | "error" | "pending";
+interface NetworkHeaderBadgesProps {
+    activeStatus: NetworkFilter["status"];
+    onToggleStatus: (status: StatusFilter) => void;
+    ignoredPatterns: readonly IgnoredPattern[];
+    paused: boolean;
+}
+/** Success / error / pending chips — tap to toggle the status filter. */
+export declare function NetworkHeaderBadges({ activeStatus, onToggleStatus, ignoredPatterns, paused, }: NetworkHeaderBadgesProps): import("react").JSX.Element;
+interface NetworkClearButtonProps {
+    paused: boolean;
+}
+/** Trash button — handler co-located; enabled while the store has events.
+ * Subscribes to a flip-guarded boolean, so it renders when the store goes
+ * empty↔non-empty, not on every count change. */
+export declare function NetworkClearButton({ paused }: NetworkClearButtonProps): import("react").JSX.Element;
+interface NetworkHeaderCopyButtonProps {
+    isPro: boolean;
+    filter: NetworkFilter;
+    ignoredPatterns: readonly IgnoredPattern[];
+    copySettings: CopySettings;
+    paused: boolean;
+    onUpgradePress: () => void;
+}
+/**
+ * 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 {};
+//# sourceMappingURL=NetworkHeaderLive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkHeaderLive.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkHeaderLive.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAQL,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAa9D,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,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"}

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

@@ -0,0 +1,27 @@
+/**
+ * The network tool's LIST screen — owns the event-store subscription, the
+ * FlatList, empty state, disabled banner, and the free-tier locked-history
+ * footer. Decomposed from NetworkModal per rule3 so per-event re-renders
+ * are confined to this subtree (plus the header's live leaves) instead of
+ * the whole modal.
+ *
+ * Stable-tree contract (rule4): hooks run unconditionally, then the
+ * component returns null when not visible. The subscription is gated with
+ * `paused || !visible` so a hidden list doesn't subscribe at all.
+ */
+import { type IgnoredPattern } from "@buoy-gg/shared-ui";
+import type { NetworkEvent, NetworkFilter } from "../types";
+interface NetworkListScreenProps {
+    visible: boolean;
+    paused: boolean;
+    filter: NetworkFilter;
+    ignoredPatterns: readonly IgnoredPattern[];
+    isPro: boolean;
+    searchText: string;
+    /** Row tap — the root's setSelectedEvent (inherently stable setter). */
+    onEventPress: (event: NetworkEvent) => void;
+    onUpgradePress: () => void;
+}
+export declare function NetworkListScreen({ visible, paused, filter, ignoredPatterns, isPro, searchText, onEventPress, onUpgradePress, }: NetworkListScreenProps): import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=NetworkListScreen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkListScreen.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkListScreen.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAoB5D,UAAU,sBAAsB;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,aAAa,CAAC;IACtB,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,YAAY,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC5C,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED,wBAAgB,iBAAiB,CAAC,EAChC,OAAO,EACP,MAAM,EACN,MAAM,EACN,eAAe,EACf,KAAK,EACL,UAAU,EACV,YAAY,EACZ,cAAc,GACf,EAAE,sBAAsB,sCAuFxB"}

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

@@ -1 +1 @@
-{"version":3,"file":"NetworkModal.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkModal.tsx"],"names":[],"mappings":"AA8CA,UAAU,iBAAiB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,KAAK,IAAI,CAAC;IACvC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAu/BD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,+BAMpD"}
+{"version":3,"file":"NetworkModal.d.ts","sourceRoot":"","sources":["../../../../src/network/components/NetworkModal.tsx"],"names":[],"mappings":"AAyCA,UAAU,iBAAiB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,KAAK,IAAI,CAAC;IACvC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAoeD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,+BAMpD"}

package/lib/typescript/network/hooks/useNetworkBadgeCounts.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Narrow store subscription for the header's live counters — the ONLY
+ * header data that should update per network event (the success/error/
+ * pending chips and the clear button's has-events state).
+ *
+ * Holds derived COUNTS in state, not the events array, with an equality
+ * guard — so consumers re-render only when a count actually changes
+ * (e.g. an ignored-pattern-matched event arriving doesn't re-render the
+ * chips). rule2: external store, narrowest possible subscription.
+ */
+import type { IgnoredPattern } from "@buoy-gg/shared-ui";
+export interface NetworkBadgeCounts {
+    /** Ignored-patterns applied — what the chips display. */
+    successful: number;
+    failed: number;
+    pending: number;
+    /** Raw store count (pre-ignore) — drives clear-button enablement. */
+    total: number;
+}
+export declare function useNetworkBadgeCounts(options: {
+    ignoredPatterns: readonly IgnoredPattern[];
+    paused: boolean;
+}): NetworkBadgeCounts;
+//# sourceMappingURL=useNetworkBadgeCounts.d.ts.map

package/lib/typescript/network/hooks/useNetworkBadgeCounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNetworkBadgeCounts.d.ts","sourceRoot":"","sources":["../../../../src/network/hooks/useNetworkBadgeCounts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAKzD,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;CACf;AA8BD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,MAAM,EAAE,OAAO,CAAC;CACjB,GAAG,kBAAkB,CAwCrB"}

package/lib/typescript/network/hooks/useNetworkEventList.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Narrow store subscription for components that render the network event
+ * LIST (or need the filtered list). Decomposed from `useNetworkEvents`
+ * per rule2 ("external store + narrow subscriptions") so the subscription
+ * lives in the leaf that consumes it — the modal root no longer
+ * re-renders per network event.
+ *
+ * Profiling evidence (tool-bench, 2026-07-06): with the subscription at
+ * the modal root, 15 network events re-rendered the ENTIRE modal 15× —
+ * JsModalComponent/header buttons ×15, all visible rows ×105.
+ *
+ * `paused` gates the subscription (the power toggle's freeze-stream
+ * semantic, and screens pass `paused || !visible` so hidden screens don't
+ * subscribe at all). Store clears are honored even while paused so a
+ * frozen list can't show deleted events (parity with the old hook's
+ * clearEvents local reset).
+ */
+import type { IgnoredPattern } from "@buoy-gg/shared-ui";
+import type { NetworkEvent, NetworkFilter } from "../types";
+export interface NetworkEventListResult {
+    /** Filtered events (may include free-tier locked events). */
+    events: NetworkEvent[];
+    /** Filtered events minus locked ones — what the list renders. */
+    visibleEvents: NetworkEvent[];
+    hasLockedEvents: boolean;
+    lockedEventCount: number;
+}
+export declare function useNetworkEventList(options: {
+    filter: NetworkFilter;
+    ignoredPatterns: readonly IgnoredPattern[];
+    paused: boolean;
+    isPro: boolean;
+}): NetworkEventListResult;
+//# sourceMappingURL=useNetworkEventList.d.ts.map

package/lib/typescript/network/hooks/useNetworkEventList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNetworkEventList.d.ts","sourceRoot":"","sources":["../../../../src/network/hooks/useNetworkEventList.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAO5D,MAAM,WAAW,sBAAsB;IACrC,6DAA6D;IAC7D,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,iEAAiE;IACjE,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC3C,MAAM,EAAE,aAAa,CAAC;IACtB,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,sBAAsB,CAyEzB"}