@agent-native/core 0.85.6 → 0.86.0

package/corpus/core/src/client/use-db-sync.ts

@@ -32,7 +32,7 @@ class HttpStatusError extends Error {
   }
 }
 
-type SyncEvent = {
+export type SyncEvent = {
   version?: number;
   source?: string;
   type?: string;
@@ -147,6 +147,13 @@ interface TransportSubscription {
   interval: number;
   /** Requested fallback interval while SSE is connected. */
   fallbackInterval: number;
+  /**
+   * Optional: notified when the shared SSE connection opens or closes (also
+   * fired once with the current state when the subscriber joins). Lets
+   * subscribers with their own fallback loops (e.g. the collab doc poll)
+   * relax their cadence while the push path is healthy.
+   */
+  onSseStateChange?: (connected: boolean) => void;
 }
 
 class SyncTransport {
@@ -158,6 +165,7 @@ class SyncTransport {
   private eventSource: EventSource | null = null;
   private sseConnected = false;
   private authFailureUntil = 0;
+  private consecutiveFailures = 0;
 
   constructor(
     private readonly pollUrl: string,
@@ -175,6 +183,7 @@ class SyncTransport {
       this.stopped = false;
       this.start();
     }
+    sub.onSseStateChange?.(this.sseConnected);
   }
 
   remove(id: symbol): void {
@@ -226,6 +235,14 @@ class SyncTransport {
     }
   }
 
+  private setSseConnected(connected: boolean): void {
+    if (this.sseConnected === connected) return;
+    this.sseConnected = connected;
+    for (const sub of this.subscribers.values()) {
+      sub.onSseStateChange?.(connected);
+    }
+  }
+
   // -------------------------------------------------------------------------
   // SSE + poll loop (mirrors the original per-hook logic exactly)
   // -------------------------------------------------------------------------
@@ -246,15 +263,21 @@ class SyncTransport {
       }, authDelay);
       return;
     }
-    this.timer = setTimeout(
-      () => {
-        this.timer = null;
-        void this.poll();
-      },
-      this.sseConnected
-        ? this.effectiveFallbackInterval
-        : this.effectiveInterval,
-    );
+    const base = this.sseConnected
+      ? this.effectiveFallbackInterval
+      : this.effectiveInterval;
+    // Exponential backoff while polls keep failing (500s during a deploy,
+    // DNS blips, a struggling DB). Auth failures have their own cooldown
+    // above; this covers everything else so a down server isn't hammered at
+    // full cadence. Resets on the first successful poll.
+    const delay =
+      this.consecutiveFailures > 0
+        ? Math.min(base * 2 ** Math.min(this.consecutiveFailures, 5), 30_000)
+        : base;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.poll();
+    }, delay);
   }
 
   private reschedule(): void {
@@ -271,7 +294,7 @@ class SyncTransport {
     if (!this.eventSource) return;
     this.eventSource.close();
     this.eventSource = null;
-    this.sseConnected = false;
+    this.setSseConnected(false);
   }
 
   private connectEvents(): void {
@@ -288,11 +311,11 @@ class SyncTransport {
     const source = new EventSource(this.sseUrl);
     this.eventSource = source;
     source.onopen = () => {
-      this.sseConnected = true;
+      this.setSseConnected(true);
       this.schedulePoll();
     };
     source.onerror = () => {
-      this.sseConnected = false;
+      this.setSseConnected(false);
       // When the browser gives up permanently (HTTP error → readyState
       // CLOSED), it won't auto-reconnect. Drop the ref so a later
       // connectEvents() (on focus/visibility) can establish a fresh stream;
@@ -342,16 +365,18 @@ class SyncTransport {
         this.effectiveInterval,
       );
       if (this.stopped) return;
+      this.consecutiveFailures = 0;
       const events = data.events ?? [];
       this.applyVersion(events, data.version);
       this.fan(events, data.version);
     } catch (err) {
       if (this.stopped) return;
+      this.consecutiveFailures++;
       if (isAuthFailure(err)) {
         this.authFailureUntil = Date.now() + POLL_AUTH_FAILURE_COOLDOWN_MS;
         this.closeEvents();
       }
-      // Network error — will retry on next interval.
+      // Network error — retried on the next (backed-off) interval.
     } finally {
       this.inFlight = false;
       this.schedulePoll();
@@ -456,6 +481,56 @@ export function _resetSyncTransportRegistryForTests(): void {
   transportRegistry.clear();
 }
 
+export interface SubscribeSyncEventsOptions {
+  /** Receives every batch of change events (SSE push or poll). */
+  onEvents: (events: SyncEvent[], version: number | undefined) => void;
+  /** Notified when the shared SSE connection opens/closes (and once on join). */
+  onSseStateChange?: (connected: boolean) => void;
+  pollUrl?: string;
+  sseUrl?: string | false;
+  pauseWhenHidden?: boolean;
+  /**
+   * Poll cadence this subscriber requests from the SHARED poll loop. The
+   * transport uses the minimum across subscribers, so the defaults here are
+   * deliberately high: subscribing must not speed up the shared poll —
+   * useDbSync (mounted by every template root) already sets the pace.
+   */
+  interval?: number;
+  fallbackInterval?: number;
+}
+
+/**
+ * Subscribe to the shared SSE + poll transport without the React Query
+ * invalidation behavior of `useDbSync`. Use this instead of opening another
+ * `EventSource` to `/_agent-native/events` — a browser tab should hold ONE
+ * SSE connection no matter how many features listen to it (extra streams eat
+ * the per-origin connection budget and starve data fetches, especially on
+ * HTTP/1.1 dev servers).
+ *
+ * Returns an unsubscribe function. Safe to call only in browser contexts.
+ */
+export function subscribeSyncEvents(
+  options: SubscribeSyncEventsOptions,
+): () => void {
+  const pollUrl = agentNativePath(options.pollUrl ?? "/_agent-native/poll");
+  const sseUrl = resolveSseUrl(options.sseUrl);
+  const transport = getOrCreateTransport(pollUrl, sseUrl);
+  const id = Symbol("subscribeSyncEvents");
+  transport.add(id, {
+    onEvents: options.onEvents,
+    onSseStateChange: options.onSseStateChange,
+    pauseWhenHidden: options.pauseWhenHidden ?? true,
+    interval: options.interval ?? 60_000,
+    fallbackInterval: options.fallbackInterval ?? 60_000,
+  });
+  return () => {
+    transport.remove(id);
+    if (!transport["subscribers"].size) {
+      releaseTransport(pollUrl, sseUrl);
+    }
+  };
+}
+
 /**
  * Hook that listens to /_agent-native/events for DB change events and
  * invalidates react-query caches when changes are detected. Falls back to
@@ -557,8 +632,18 @@ export function useDbSync(
         if (src && ver > 0) bumpChangeVersion(src, ver);
       }
 
-      if (relevant.length > 0 && queryClient) {
-        const hasActionEvent = relevant.some((evt) => evt.source === "action");
+      // Awareness (cursor/presence) events never change action/extension/
+      // app-state query results, but they arrive on every peer keystroke and
+      // carry no version (so the freshness filter always passes them). Keep
+      // them out of the invalidate block or an idle collaborative doc turns
+      // every peer's cursor move into a framework-wide refetch storm; they
+      // still reach onEvent below for callers that render presence.
+      const invalidating = relevant.filter((e) => e.source !== "awareness");
+
+      if (invalidating.length > 0 && queryClient) {
+        const hasActionEvent = invalidating.some(
+          (evt) => evt.source === "action",
+        );
         if (hasActionEvent) {
           // Custom apps frequently start with raw `useQuery` calls before
           // graduating to `useActionQuery` or source-versioned query keys.
@@ -585,13 +670,13 @@ export function useDbSync(
         queryClient.invalidateQueries({ queryKey: ["tool"] });
         queryClient.invalidateQueries({ queryKey: ["tools"] });
         queryClient.invalidateQueries({ queryKey: ["app-state"] });
-        if (hasAppStateEvent(relevant, "navigate")) {
+        if (hasAppStateEvent(invalidating, "navigate")) {
           queryClient.invalidateQueries({ queryKey: ["navigate-command"] });
         }
-        if (hasAppStateEvent(relevant, "show-questions")) {
+        if (hasAppStateEvent(invalidating, "show-questions")) {
           queryClient.invalidateQueries({ queryKey: ["show-questions"] });
         }
-        if (hasAppStateEvent(relevant, "__set_url__")) {
+        if (hasAppStateEvent(invalidating, "__set_url__")) {
           queryClient.invalidateQueries({ queryKey: ["__set_url__"] });
         }
       }

package/corpus/core/src/client/use-pinch-zoom.ts

@@ -55,11 +55,57 @@ export function usePinchZoom({
 
     const clamp = (n: number) => Math.max(min, Math.min(max, n));
 
+    // rAF coalescing: multiple wheel/pointermove events can fire per frame
+    // (trackpad pinch and touch pinch both deliver many events between
+    // paints). Instead of calling setZoom() synchronously per event — which
+    // schedules a React re-render per event — stash the latest pending zoom
+    // (and its cursor-anchored scroll delta) in a ref and flush once per
+    // animation frame with the last-wins value. This preserves the exact
+    // zoom-to-cursor math; it just applies it at most once per frame.
+    //
+    // Within a burst the DOM's real scrollLeft/scrollTop do NOT move until
+    // flush() runs, so per-event math must not read them directly — every
+    // event after the first in the same frame would anchor against the
+    // pre-burst scroll position instead of where the (not-yet-committed)
+    // previous events in the burst would have scrolled to. Track a simulated
+    // running scroll position (`simScrollLeft`/`simScrollTop`, seeded from the
+    // real scroll position when a new burst starts) and use that as the
+    // anchor base, so each event's math composes exactly as if the prior
+    // events in the burst had already been applied — matching the
+    // pre-coalescing, one-setZoom-per-event behavior.
+    let pendingZoom: number | null = null;
+    let pendingScrollDelta: { dx: number; dy: number } | null = null;
+    let simScrollLeft = 0;
+    let simScrollTop = 0;
+    let rafId: number | null = null;
+
+    const flush = () => {
+      rafId = null;
+      if (pendingZoom === null) return;
+      const nextZoom = pendingZoom;
+      const scrollDelta = pendingScrollDelta;
+      pendingZoom = null;
+      pendingScrollDelta = null;
+      setZoomRef.current(nextZoom);
+      if (scrollDelta) {
+        container.scrollLeft += scrollDelta.dx;
+        container.scrollTop += scrollDelta.dy;
+      }
+    };
+
+    const scheduleFlush = () => {
+      if (rafId !== null) return;
+      rafId = requestAnimationFrame(flush);
+    };
+
     const handleWheel = (e: WheelEvent) => {
       if (!(e.ctrlKey || e.metaKey)) return;
       e.preventDefault();
 
-      const currentZoom = zoomRef.current;
+      // Use the latest not-yet-applied zoom (if a flush is pending) so rapid
+      // wheel events within the same frame compound correctly instead of
+      // each computing off the last-committed React state.
+      const currentZoom = pendingZoom ?? zoomRef.current;
       const clampedDelta = Math.max(-50, Math.min(50, e.deltaY));
       const factor = Math.exp(-clampedDelta * 0.01);
       const nextZoom = clamp(currentZoom * factor);
@@ -67,20 +113,33 @@ export function usePinchZoom({
       if (nextZoom === currentZoom) return;
 
       if (zoomToCursor) {
+        // Starting a new burst (nothing pending yet): seed the simulated
+        // scroll position from the container's real, currently-committed
+        // scroll offset.
+        if (pendingScrollDelta === null) {
+          simScrollLeft = container.scrollLeft;
+          simScrollTop = container.scrollTop;
+        }
         const rect = container.getBoundingClientRect();
-        const cx = e.clientX - rect.left + container.scrollLeft;
-        const cy = e.clientY - rect.top + container.scrollTop;
+        const cx = e.clientX - rect.left + simScrollLeft;
+        const cy = e.clientY - rect.top + simScrollTop;
         const ratio = nextZoom / currentZoom;
         const dx = cx * (ratio - 1);
         const dy = cy * (ratio - 1);
-        setZoomRef.current(nextZoom);
-        requestAnimationFrame(() => {
-          container.scrollLeft += dx;
-          container.scrollTop += dy;
-        });
+        // Advance the simulated scroll position so the next event in this
+        // same burst anchors against where this event would have left it.
+        simScrollLeft += dx;
+        simScrollTop += dy;
+        pendingZoom = nextZoom;
+        const prevDelta = pendingScrollDelta;
+        pendingScrollDelta = {
+          dx: (prevDelta?.dx ?? 0) + dx,
+          dy: (prevDelta?.dy ?? 0) + dy,
+        };
       } else {
-        setZoomRef.current(nextZoom);
+        pendingZoom = nextZoom;
       }
+      scheduleFlush();
     };
 
     const activePointers = new Map<number, { x: number; y: number }>();
@@ -105,8 +164,11 @@ export function usePinchZoom({
         const [p1, p2] = Array.from(activePointers.values());
         const distance = Math.hypot(p2.x - p1.x, p2.y - p1.y);
         const nextZoom = clamp(initialZoom * (distance / initialDistance));
-        if (nextZoom !== zoomRef.current) {
-          setZoomRef.current(nextZoom);
+        if (nextZoom !== (pendingZoom ?? zoomRef.current)) {
+          // Touch pinch has no cursor-anchoring math, so last-wins is simply
+          // the newest zoom value — no scroll delta to accumulate.
+          pendingZoom = nextZoom;
+          scheduleFlush();
         }
         e.preventDefault();
       }
@@ -132,6 +194,9 @@ export function usePinchZoom({
       container.removeEventListener("pointermove", handlePointerMove);
       container.removeEventListener("pointerup", handlePointerEnd);
       container.removeEventListener("pointercancel", handlePointerEnd);
+      if (rafId !== null) cancelAnimationFrame(rafId);
+      pendingZoom = null;
+      pendingScrollDelta = null;
     };
   }, [containerRef, enabled, min, max, zoomToCursor]);
 }