@buoy-gg/events 3.0.1 → 4.0.1

package/src/components/UnifiedEventDetail.tsx

@@ -7,12 +7,13 @@
  */
 
 import { View, Text, StyleSheet, ScrollView } from "react-native";
-import { memo, useMemo, type ComponentType } from "react";
+import { memo, useMemo, type ComponentType, type ReactNode } from "react";
 import {
   buoyColors,
   formatRelativeTime,
   copyToClipboard,
   parseValue,
+  useIgnoredPatterns,
 } from "@buoy-gg/shared-ui";
 import { DataViewer } from "@buoy-gg/shared-ui/dataViewer";
 import { ReactQueryEventDetail } from "./ReactQueryEventDetail";
@@ -44,6 +45,8 @@ interface OptionalDetailComponents {
   }> | null;
   NetworkEventDetailView: ComponentType<{
     event: unknown;
+    ignoredPatterns?: Set<string>;
+    onTogglePattern?: (value: string) => void;
   }> | null;
   RenderDetailView: ComponentType<{
     render: unknown;
@@ -183,17 +186,46 @@ function getValueType(
 // Component
 // ============================================================================
 
+/** Passthrough used when no network detail wrapper is injected. */
+function PassThrough({ children }: { children: ReactNode }) {
+  return <>{children}</>;
+}
+
 interface UnifiedEventDetailProps {
   event: UnifiedEvent;
   onBack?: () => void;
+  /**
+   * Optional override for the network detail component. The desktop dashboard
+   * injects the real `@buoy-gg/network` export here because the runtime
+   * `require("@buoy-gg/network")` fallback is unreliable in its Vite/ESM build.
+   * When omitted, the dynamically-required component is used (works on mobile).
+   */
+  NetworkEventDetailViewComponent?: ComponentType<{
+    event: unknown;
+    ignoredPatterns?: Set<string>;
+    onTogglePattern?: (value: string) => void;
+  }>;
+  /**
+   * Optional wrapper rendered around the network detail view — e.g. the desktop
+   * passes `NetworkBodyResolverProvider` so large request/response bodies that
+   * were stripped from the sync snapshot can be fetched from the device on demand.
+   */
+  networkDetailWrapper?: ComponentType<{ children: ReactNode }>;
 }
 
 export const UnifiedEventDetail = memo(function UnifiedEventDetail({
   event,
   onBack,
+  NetworkEventDetailViewComponent,
+  networkDetailWrapper,
 }: UnifiedEventDetailProps) {
   const sourceConfig = SOURCE_CONFIG[event.source];
   const timestamp = new Date(event.timestamp);
+  // Shared ignored-domain/URL patterns — drives the "Ignore Domain / Ignore URL
+  // Pattern" toggles at the bottom of the network detail page so they actually
+  // work here and stay in sync with the Network tool.
+  const { values: ignoredPatternValues, toggle: toggleIgnoredPattern } =
+    useIgnoredPatterns();
 
   // For storage events, create a conversation object to use with StorageEventDetailContent
   const storageConversation = useMemo(() => {
@@ -249,16 +281,28 @@ export const UnifiedEventDetail = memo(function UnifiedEventDetail({
     );
   }
 
-  // For network events, use the shared NetworkEventDetailView if available
-  if (event.source === "network" && optionalComponents.NetworkEventDetailView) {
-    const { NetworkEventDetailView } = optionalComponents;
+  // For network events, render the SAME NetworkEventDetailView the Network tool
+  // uses. Prefer an injected component (desktop), fall back to the dynamically
+  // required one (mobile). Wire the shared ignored-patterns so the bottom
+  // "Ignore Domain / Ignore URL Pattern" toggles work, and wrap in the optional
+  // body-resolver provider so large bodies can be fetched on demand.
+  const NetworkDetailView =
+    NetworkEventDetailViewComponent ?? optionalComponents.NetworkEventDetailView;
+  if (event.source === "network" && NetworkDetailView) {
     const networkEvent = event.originalEvent as NetworkEvent;
+    const NetworkWrapper = networkDetailWrapper ?? PassThrough;
 
     return (
       <View style={styles.container}>
-        <ScrollView style={styles.content}>
-          <NetworkEventDetailView event={networkEvent} />
-        </ScrollView>
+        <NetworkWrapper>
+          <ScrollView style={styles.content}>
+            <NetworkDetailView
+              event={networkEvent}
+              ignoredPatterns={ignoredPatternValues}
+              onTogglePattern={toggleIgnoredPattern}
+            />
+          </ScrollView>
+        </NetworkWrapper>
       </View>
     );
   }

package/src/hooks/useUnifiedEvents.ts

@@ -6,7 +6,14 @@
  */
 
 import { useState, useEffect, useCallback, useMemo, useRef } from "react";
-import { useFeatureGate, subscribeToSubscriberCountChanges, isDevToolsStorageKey } from "@buoy-gg/shared-ui";
+import {
+  useFeatureGate,
+  subscribeToSubscriberCountChanges,
+  isDevToolsStorageKey,
+  useIgnoredPatterns,
+  isUrlIgnored,
+  type IgnoredPattern,
+} from "@buoy-gg/shared-ui";
 import type { UnifiedEvent, EventSource, SourceInfo } from "../types";
 import {
   subscribe,
@@ -26,7 +33,6 @@ import {
   unsubscribeFromZustand,
   unsubscribeFromJotai,
   unsubscribeFromRender,
-  unsubscribeAll,
   getSourceCounts,
   clearEvents as clearStoreEvents,
   getAvailableEventSources,
@@ -76,6 +82,20 @@ function isBuoyInternalEvent(event: UnifiedEvent): boolean {
   return false;
 }
 
+/**
+ * Check whether a network event should be hidden because its URL matches one of
+ * the user's shared ignored-domain/URL patterns (the same store the Network tool
+ * writes to). Non-network events are never affected.
+ */
+function isNetworkEventIgnored(
+  event: UnifiedEvent,
+  ignoredPatterns: IgnoredPattern[]
+): boolean {
+  if (event.source !== "network" || ignoredPatterns.length === 0) return false;
+  const url = (event.originalEvent as { url?: string } | undefined)?.url ?? "";
+  return isUrlIgnored(url, ignoredPatterns);
+}
+
 /**
  * All possible sources for display
  */
@@ -117,22 +137,6 @@ const SOURCE_TO_EVENT_SOURCES: Record<EventSource, EventSource[]> = {
   render: ["render"],
 };
 
-/**
- * Map event sources to their parent discovery ID
- */
-const EVENT_SOURCE_TO_DISCOVERY_ID: Record<EventSource, string> = {
-  "storage-async": "storage",
-  "storage-mmkv": "storage",
-  redux: "redux",
-  network: "network",
-  "react-query": "react-query",
-  "react-query-query": "react-query",
-  "react-query-mutation": "react-query",
-  route: "route-events",
-  zustand: "zustand",
-  jotai: "jotai",
-  render: "render",
-};
 
 export interface UseUnifiedEventsResult {
   events: UnifiedEvent[];
@@ -160,6 +164,10 @@ export interface UseUnifiedEventsResult {
 
 export function useUnifiedEvents(): UseUnifiedEventsResult {
   const { isPro } = useFeatureGate();
+  // Shared ignored-domain/URL patterns (same store as the Network tool). Network
+  // events matching these are hidden from the events list too, keeping both
+  // tools' filtering perfectly in sync.
+  const { patterns: ignoredPatterns } = useIgnoredPatterns();
   const [events, setEvents] = useState<UnifiedEvent[]>([]);
   const [enabledSources, setEnabledSources] = useState<Set<EventSource>>(
     () => new Set(DEFAULT_ENABLED_SOURCES)
@@ -167,10 +175,16 @@ export function useUnifiedEvents(): UseUnifiedEventsResult {
   const [isCapturing, setIsCapturing] = useState(true);
   const isStateRestoredRef = useRef(false);
 
-  // Get discovered sources (which packages are installed)
-  const discoveredSources = useMemo(() => {
-    return getAvailableEventSources();
-  }, []);
+  // Get discovered sources (which packages are installed).
+  // Held in state, not a mount-only memo, because in remote mirror mode
+  // (desktop dashboard) the device's available sources arrive asynchronously
+  // via setRemoteAvailableSources() — after first paint. We refresh this from
+  // the store's notify path below so the filter badge bar appears once the
+  // first device snapshot lands. The reference is kept stable while the set is
+  // unchanged so dependent memos/effects don't re-run on every event.
+  const [discoveredSources, setDiscoveredSources] = useState<Set<EventSource>>(
+    () => getAvailableEventSources()
+  );
 
   // Subscribe to subscriber count changes for instant UI updates (TanStack Query pattern)
   const [subscriberCountVersion, setSubscriberCountVersion] = useState(0);
@@ -189,10 +203,22 @@ export function useUnifiedEvents(): UseUnifiedEventsResult {
     });
   }, [discoveredSources]);
 
-  // Subscribe to store changes (always subscribe to get events when they come)
+  // Subscribe to store changes (always subscribe to get events when they come).
+  // Also refresh discoveredSources here: in remote mirror mode the device's
+  // availability is set right before replaceEvents() fires this listener, so
+  // this is where the badge bar first learns which sources exist. Keep the
+  // Set reference stable when membership is unchanged to avoid re-running the
+  // availableDisplaySources memo / restore-state effect on every event.
   useEffect(() => {
     const unsubscribe = subscribe((newEvents) => {
       setEvents(newEvents);
+      setDiscoveredSources((prev) => {
+        const next = getAvailableEventSources();
+        if (prev.size === next.size && [...next].every((s) => prev.has(s))) {
+          return prev;
+        }
+        return new Set(next);
+      });
     });
     return unsubscribe;
   }, []);
@@ -279,15 +305,19 @@ export function useUnifiedEvents(): UseUnifiedEventsResult {
     return allowed;
   }, [enabledSources]);
 
-  // Filter events by enabled sources and exclude Buoy internal events
+  // Filter events by enabled sources, exclude Buoy internal events, and hide
+  // network events matching the shared ignored-domain/URL patterns.
   const allFilteredEvents = useMemo(() => {
     if (allowedEventSources.size === 0) {
       return [];
     }
     return events.filter(
-      (event) => allowedEventSources.has(event.source) && !isBuoyInternalEvent(event)
+      (event) =>
+        allowedEventSources.has(event.source) &&
+        !isBuoyInternalEvent(event) &&
+        !isNetworkEventIgnored(event, ignoredPatterns)
     );
-  }, [events, allowedEventSources]);
+  }, [events, allowedEventSources, ignoredPatterns]);
 
   // Apply free tier limit if not Pro
   const filteredEvents = useMemo(() => {
@@ -456,9 +486,25 @@ export function useUnifiedEvents(): UseUnifiedEventsResult {
   }, [enabledSources]);
 
   const stopCapturing = useCallback(() => {
-    unsubscribeAll();
+    // Release only THIS hook's enabled sources (mirrors startCapturing). Source
+    // subscriptions are ref-counted in the store, so this won't yank sources a
+    // remote dashboard consumer is still watching (vs the old unsubscribeAll
+    // hard reset, which tore down everyone's).
+    if (enabledSources.has("storage-async")) unsubscribeFromStorage();
+    if (enabledSources.has("redux")) unsubscribeFromRedux();
+    if (enabledSources.has("network")) unsubscribeFromNetwork();
+    if (
+      enabledSources.has("react-query-query") ||
+      enabledSources.has("react-query-mutation")
+    ) {
+      unsubscribeFromReactQuery();
+    }
+    if (enabledSources.has("route")) unsubscribeFromRoutes();
+    if (enabledSources.has("zustand")) unsubscribeFromZustand();
+    if (enabledSources.has("jotai")) unsubscribeFromJotai();
+    if (enabledSources.has("render")) unsubscribeFromRender();
     setIsCapturing(false);
-  }, []);
+  }, [enabledSources]);
 
   const toggleCapturing = useCallback(() => {
     if (isCapturing) {

package/src/index.tsx

@@ -19,6 +19,12 @@ export { eventsToolPreset, createEventsTool } from "./preset";
 // MAIN COMPONENT
 // =============================================================================
 export { UnifiedEventViewer } from "./components/UnifiedEventViewer";
+export { EventsModal } from "./components/EventsModal";
+
+// =============================================================================
+// EXTERNAL SYNC (Adapter for @buoy-gg/external-sync's useExternalSync)
+// =============================================================================
+export { eventsSyncAdapter } from "./sync/eventsSyncAdapter";
 
 // =============================================================================
 // HOOKS (For consuming event data)
@@ -102,8 +108,10 @@ export {
 // These are NOT exported to prevent users from bypassing the unified event
 // system. Event subscription should go through the proper tool integration.
 // =============================================================================
+/** @internal - Remote mirror mode only (desktop dashboard): replaceEvents /
+ * onClear / setRemoteAvailableSources. Do not use for event subscription. */
+export { unifiedEventStore } from "./stores/unifiedEventStore";
 // NOTE: The following are intentionally NOT exported:
-// - unifiedEventStore (internal store)
 // - subscribeToStorage, unsubscribeFromStorage (internal subscription)
 // - subscribeToRedux, unsubscribeFromRedux (internal subscription)
 // - subscribeToNetwork, unsubscribeFromNetwork (internal subscription)

package/src/sources/sourceIds.ts

@@ -0,0 +1,25 @@
+import type { EventSource } from "../types";
+
+/**
+ * Map an event source (the granular UI badge identity) to its parent discovery
+ * ID (the key used by unifiedEventStore's source subscriptions). Several event
+ * sources can share one discovery source — e.g. storage-async + storage-mmkv
+ * both come from the "storage" discovery source, and the react-query family all
+ * map to "react-query".
+ *
+ * Shared by useUnifiedEvents (the on-device consumer) and unifiedEventStore's
+ * remote-consumer channel so the mapping lives in exactly one place.
+ */
+export const EVENT_SOURCE_TO_DISCOVERY_ID: Record<EventSource, string> = {
+  "storage-async": "storage",
+  "storage-mmkv": "storage",
+  redux: "redux",
+  network: "network",
+  "react-query": "react-query",
+  "react-query-query": "react-query",
+  "react-query-mutation": "react-query",
+  route: "route-events",
+  zustand: "zustand",
+  jotai: "jotai",
+  render: "render",
+};

package/src/stores/unifiedEventStore.ts

@@ -18,16 +18,42 @@ import {
   type DiscoveredEventSource,
   type AggregatedSubscriberCounts,
 } from "../utils/autoDiscoverEventSources";
+import { EVENT_SOURCE_TO_DISCOVERY_ID } from "../sources/sourceIds";
 
 const MAX_EVENTS = 200;
 
+/**
+ * Source IDs that subscribeToAll() must NOT auto-subscribe to.
+ *
+ * These are high-frequency sources the UI excludes from DEFAULT_ENABLED_SOURCES
+ * (see useUnifiedEvents.ts). "render" (highlight-updates) fires on every
+ * component render — tens of events per second — which floods the shared store
+ * (capped at MAX_EVENTS), shoves real events out, and shows up as hidden noise
+ * ("1 of 100"). subscribeToAll() is the dashboard-watch path; it must mirror
+ * the on-device default of leaving render OFF unless the user opts in.
+ */
+const SUBSCRIBE_ALL_EXCLUDED_SOURCE_IDS = new Set<string>(["render"]);
+
 class UnifiedEventStore {
   private events: UnifiedEvent[] = [];
   private listeners: Set<UnifiedEventListener> = new Set();
   private activeSources: Set<EventSource> = new Set();
-
-  // Track which sources are currently subscribed
-  private sourceUnsubscribers: Map<string, () => void> = new Map();
+  private clearListeners: Set<() => void> = new Set();
+  private remoteAvailableSources: Set<EventSource> | null = null;
+
+  // Track which sources are currently subscribed, ref-counted so independent
+  // consumers (the on-device EventsModal and the remote dashboard) can each
+  // request a source and the underlying capture only stops when the LAST one
+  // drops it. Presence of a key still means "subscribed".
+  private sourceUnsubscribers: Map<
+    string,
+    { unsubscribe: () => void; refCount: number }
+  > = new Map();
+
+  // Discovery IDs the remote dashboard (sync adapter) currently wants. Tracked
+  // separately so the remote consumer can be diffed/cleared independently of
+  // the on-device consumer's subscriptions.
+  private remoteDiscoveryIds: Set<string> = new Set();
 
   // Map network event IDs to unified event IDs for updates
   private networkEventIdMap: Map<string, string> = new Map();
@@ -40,12 +66,66 @@ class UnifiedEventStore {
   }
 
   /**
-   * Get which event source types are available
+   * Get which event source types are available. In remote mirror mode this
+   * reflects the synced device's availability instead of local discovery.
    */
   getAvailableEventSources(): Set<EventSource> {
+    if (this.remoteAvailableSources) {
+      return this.remoteAvailableSources;
+    }
     return getCachedDiscovery().availableEventSources;
   }
 
+  // ===========================================================================
+  // REMOTE MIRROR MODE
+  // ===========================================================================
+
+  /**
+   * Override source availability with the synced device's (auto-discovery
+   * finds nothing on the dashboard — the tool packages live on the device).
+   * Pass null to restore local discovery.
+   *
+   * Notifies listeners when the set actually changes so consumers
+   * (useUnifiedEvents) can refresh their available-source list — this is the
+   * only signal the dashboard's filter badge bar gets when capture is OFF and
+   * no events are flowing to trigger replaceEvents().
+   */
+  setRemoteAvailableSources(sources: EventSource[] | null): void {
+    const next = sources ? new Set(sources) : null;
+    const prev = this.remoteAvailableSources;
+    const unchanged =
+      (prev === null && next === null) ||
+      (!!prev &&
+        !!next &&
+        prev.size === next.size &&
+        [...next].every((s) => prev.has(s)));
+    this.remoteAvailableSources = next;
+    if (!unchanged) {
+      this.notifyListeners();
+    }
+  }
+
+  /**
+   * Replace the entire event list and notify listeners. Used in remote
+   * mirror mode where full snapshots arrive from a synced device.
+   */
+  replaceEvents(events: UnifiedEvent[]): void {
+    this.events = events.slice(0, MAX_EVENTS);
+    this.activeSources = new Set(events.map((event) => event.source));
+    this.notifyListeners();
+  }
+
+  /**
+   * Listen for clearEvents() calls. Used in remote mirror mode to forward a
+   * clear performed in the dashboard UI to the synced device.
+   */
+  onClear(listener: () => void): () => void {
+    this.clearListeners.add(listener);
+    return () => {
+      this.clearListeners.delete(listener);
+    };
+  }
+
   /**
    * Subscribe to all available event sources
    */
@@ -53,6 +133,12 @@ class UnifiedEventStore {
     const { sources } = getCachedDiscovery();
 
     for (const source of sources) {
+      // Skip high-frequency sources the UI leaves off by default (e.g. render).
+      // Subscribing to them here would flood the timeline with events that are
+      // then filtered out of the display — see SUBSCRIBE_ALL_EXCLUDED_SOURCE_IDS.
+      if (SUBSCRIBE_ALL_EXCLUDED_SOURCE_IDS.has(source.id)) {
+        continue;
+      }
       await this.subscribeToSource(source);
     }
   }
@@ -61,10 +147,18 @@ class UnifiedEventStore {
    * Subscribe to a specific event source by ID
    */
   async subscribeToSource(source: DiscoveredEventSource): Promise<void> {
-    if (this.sourceUnsubscribers.has(source.id)) {
-      return; // Already subscribed
+    const existing = this.sourceUnsubscribers.get(source.id);
+    if (existing) {
+      existing.refCount++; // Another consumer wants it — just count.
+      return;
     }
 
+    // Reserve the slot synchronously (refCount 1) so concurrent subscribe calls
+    // for the same source ref-count instead of double-subscribing during the
+    // awaits below.
+    const entry = { unsubscribe: () => {}, refCount: 1 };
+    this.sourceUnsubscribers.set(source.id, entry);
+
     try {
       // Run setup if needed
       if (source.setup) {
@@ -77,20 +171,27 @@ class UnifiedEventStore {
       });
 
       if (unsubscribe) {
-        this.sourceUnsubscribers.set(source.id, unsubscribe);
+        entry.unsubscribe = unsubscribe;
       }
     } catch {
-      // Silently fail - source may not be available
+      // Failed - source may not be available. Drop the reservation unless other
+      // consumers incremented it while we were awaiting.
+      if (this.sourceUnsubscribers.get(source.id) === entry && entry.refCount <= 1) {
+        this.sourceUnsubscribers.delete(source.id);
+      }
     }
   }
 
   /**
-   * Unsubscribe from a specific source by ID
+   * Unsubscribe from a specific source by ID. Ref-counted: the real teardown
+   * only runs when the last consumer drops it.
    */
   unsubscribeFromSource(sourceId: string): void {
-    const unsubscribe = this.sourceUnsubscribers.get(sourceId);
-    if (unsubscribe) {
-      unsubscribe();
+    const entry = this.sourceUnsubscribers.get(sourceId);
+    if (!entry) return;
+    entry.refCount--;
+    if (entry.refCount <= 0) {
+      entry.unsubscribe();
       this.sourceUnsubscribers.delete(sourceId);
     }
   }
@@ -341,6 +442,13 @@ class UnifiedEventStore {
     this.activeSources.clear();
     this.networkEventIdMap.clear();
     this.notifyListeners();
+    this.clearListeners.forEach((listener) => {
+      try {
+        listener();
+      } catch {
+        // Ignore listener errors
+      }
+    });
   }
 
   /**
@@ -377,14 +485,87 @@ class UnifiedEventStore {
    * Unsubscribe from all sources
    */
   unsubscribeAll(): void {
-    // Unsubscribe from all tracked sources
-    for (const [, unsubscribe] of this.sourceUnsubscribers) {
-      unsubscribe();
+    // Hard reset: tear down every tracked source regardless of ref-count.
+    for (const [, entry] of this.sourceUnsubscribers) {
+      entry.unsubscribe();
     }
     this.sourceUnsubscribers.clear();
 
-    // Clear active sources
+    // Clear active + remote source bookkeeping (all subscriptions are gone).
     this.activeSources.clear();
+    this.remoteDiscoveryIds.clear();
+  }
+
+  /**
+   * Remote-consumer channel: the dashboard sync adapter declares which event
+   * sources it wants the device to capture. Diffed against the previous remote
+   * set so only changed sources are (un)subscribed; ref-counting keeps the
+   * on-device EventsModal's own subscriptions intact. Pass "all" to capture
+   * every discovered source except the high-frequency excluded ones.
+   */
+  async setRemoteEnabledSources(
+    sources: EventSource[] | "all"
+  ): Promise<void> {
+    const { sources: discovered } = getCachedDiscovery();
+
+    let nextIds: Set<string>;
+    if (sources === "all") {
+      nextIds = new Set(
+        discovered
+          .map((s) => s.id)
+          .filter((id) => !SUBSCRIBE_ALL_EXCLUDED_SOURCE_IDS.has(id))
+      );
+    } else {
+      nextIds = new Set<string>();
+      for (const src of sources) {
+        const id = EVENT_SOURCE_TO_DISCOVERY_ID[src];
+        if (id) nextIds.add(id);
+      }
+    }
+
+    // Swap the tracked set SYNCHRONOUSLY (before the awaits) so a watch's
+    // ensureRemoteSourcesDefault() that runs in between sees the new selection
+    // and won't re-broaden to "all".
+    const prevIds = this.remoteDiscoveryIds;
+    this.remoteDiscoveryIds = nextIds;
+
+    // Subscribe newly-requested sources.
+    for (const id of nextIds) {
+      if (!prevIds.has(id)) {
+        const source = discovered.find((s) => s.id === id);
+        if (source) await this.subscribeToSource(source);
+      }
+    }
+    // Release sources the remote no longer wants.
+    for (const id of prevIds) {
+      if (!nextIds.has(id)) {
+        this.unsubscribeFromSource(id);
+      }
+    }
+  }
+
+  /**
+   * Called by the sync adapter when a dashboard starts watching: default to all
+   * sources, but ONLY if the dashboard hasn't already declared a selection for
+   * this watch session (the setEnabledSources action can arrive before the
+   * watch). Keeps backward compatibility with dashboards that never narrow.
+   */
+  ensureRemoteSourcesDefault(): void {
+    if (this.remoteDiscoveryIds.size === 0) {
+      void this.setRemoteEnabledSources("all");
+    }
+  }
+
+  /**
+   * Release all of the remote consumer's source subscriptions (e.g. when the
+   * dashboard stops watching the events tool). Ref-counting means sources the
+   * on-device EventsModal also wants stay subscribed.
+   */
+  clearRemoteSources(): void {
+    for (const id of this.remoteDiscoveryIds) {
+      this.unsubscribeFromSource(id);
+    }
+    this.remoteDiscoveryIds.clear();
   }
 
   /**

package/src/sync/eventsSyncAdapter.ts

@@ -0,0 +1,56 @@
+import { unifiedEventStore } from "../stores/unifiedEventStore";
+import type { EventSource } from "../types";
+
+/**
+ * Sync adapter for the events tool, consumed by @buoy-gg/external-sync's
+ * `useExternalSync` (structurally matches its ToolSyncAdapter interface so
+ * this package doesn't need a dependency on it).
+ *
+ * This adapter is the "remote consumer" of the unified event store. While a
+ * dashboard is watching, it requests a SET of event sources (defaulting to all,
+ * narrowed by the dashboard via `setEnabledSources`). On unwatch it releases
+ * those requests, so — unlike before — the device stops capturing sources that
+ * nothing else is watching. Source requests are ref-counted in the store, so
+ * the on-device EventsModal keeps working when open at the same time.
+ *
+ * The snapshot carries the device's available sources so the dashboard can
+ * render the source filter chips (its own auto-discovery finds nothing — the
+ * tool packages live on the device).
+ */
+export const eventsSyncAdapter = {
+  version: 2,
+  getSnapshot: () => ({
+    events: unifiedEventStore.getEvents(),
+    availableSources: Array.from(unifiedEventStore.getAvailableEventSources()),
+  }),
+  subscribe: (onChange: () => void) => {
+    // Default to all sources until the dashboard narrows the set via
+    // setEnabledSources — backward compatible with dashboards that don't send
+    // it. Uses ensureRemoteSourcesDefault so a setEnabledSources that raced
+    // ahead of this watch isn't clobbered back to "all".
+    unifiedEventStore.ensureRemoteSourcesDefault();
+    const unsubscribe = unifiedEventStore.subscribe(() => onChange());
+    return () => {
+      unsubscribe();
+      // Release this consumer's source subscriptions so the device stops
+      // capturing sources nothing else is watching (fixes the old leak).
+      unifiedEventStore.clearRemoteSources();
+    };
+  },
+  actions: {
+    clearEvents: () => {
+      unifiedEventStore.clearEvents();
+    },
+    /**
+     * Narrow which sources the device captures for this dashboard, driven by
+     * the dashboard's source badges. Ref-counted in the store, so disabling a
+     * source here only stops its capture if no other consumer wants it.
+     */
+    setEnabledSources: (params: unknown) => {
+      const sources =
+        (params as { sources?: EventSource[] } | undefined)?.sources ?? [];
+      unifiedEventStore.setRemoteEnabledSources(sources);
+      return { enabledSources: sources };
+    },
+  },
+};