@agent-native/core 0.161.10 → 0.161.14

package/dist/client/use-db-sync.js

@@ -15,6 +15,8 @@ const HIDDEN_POLL_INTERVAL_MS = 10_000;
 const POLL_AUTH_FAILURE_COOLDOWN_MS = 60_000;
 const LOCAL_SSE_RECONNECT_BASE_MS = 1_000;
 const LOCAL_SSE_RECONNECT_MAX_MS = 30_000;
+const ACTIVE_CHAT_TTL_MS = 5 * 60 * 1_000;
+const ACTIVE_CHAT_MAX = 1_000;
 /**
  * Max cadence for SSE/poll-driven query invalidation in `useDbSync`. Events
  * that arrive within this window of the first one in a burst are merged into
@@ -42,6 +44,61 @@ class HttpStatusError extends Error {
         this.status = status;
     }
 }
+const INITIAL_SYNC_CURSOR = { version: 0, id: "" };
+function encodeSyncCursor(cursor) {
+    return `${cursor.version}.${cursor.id}`;
+}
+function decodeSyncCursor(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const separator = value.indexOf(".");
+    if (separator < 1)
+        return undefined;
+    const version = Number(value.slice(0, separator));
+    const id = value.slice(separator + 1);
+    if (!Number.isSafeInteger(version) || version < 0)
+        return undefined;
+    return { version, id };
+}
+function compareSyncCursors(a, b) {
+    if (a.version !== b.version)
+        return a.version - b.version;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+function syncEventCursor(event) {
+    if (typeof event.version !== "number" ||
+        !Number.isSafeInteger(event.version) ||
+        typeof event.cursorId !== "string") {
+        return undefined;
+    }
+    return { version: event.version, id: event.cursorId };
+}
+function maxSyncCursor(a, b) {
+    return b && compareSyncCursors(b, a) > 0 ? b : a;
+}
+function cursorForEvents(events) {
+    let cursor;
+    for (const event of events) {
+        const eventCursor = syncEventCursor(event) ??
+            (typeof event.version === "number" &&
+                Number.isSafeInteger(event.version) &&
+                event.version >= 0
+                ? { version: event.version, id: "" }
+                : undefined);
+        if (eventCursor &&
+            (!cursor || compareSyncCursors(eventCursor, cursor) > 0)) {
+            cursor = eventCursor;
+        }
+    }
+    return cursor;
+}
+function isSyncEventAfterCursor(event, cursor, subscriberVersion) {
+    const eventCursor = syncEventCursor(event);
+    if (eventCursor)
+        return compareSyncCursors(eventCursor, cursor) > 0;
+    const version = typeof event.version === "number" ? event.version : 0;
+    return version === 0 || version > subscriberVersion;
+}
 function getPollAbortMs(interval) {
     return Math.max(POLL_ABORT_MIN_MS, interval * 4);
 }
@@ -163,17 +220,35 @@ export function isInteractionCriticalSyncEvent(event) {
             INTERACTION_CRITICAL_APP_STATE_KEYS.some((key) => event.key === key ||
                 (typeof event.key === "string" && event.key.startsWith(`${key}:`)))));
 }
-async function fetchPollJson(pollUrl, since, interval, token) {
+function appStateQueryMatchesKeys(query, changedKeys) {
+    if (query.queryKey[0] !== "app-state")
+        return false;
+    // The aggregate query is the fallback for callers that read all app state.
+    if (query.queryKey.length === 1)
+        return true;
+    const queryStateKey = query.queryKey[1];
+    if (typeof queryStateKey !== "string")
+        return false;
+    return changedKeys.some((changedKey) => changedKey === "*" ||
+        changedKey === queryStateKey ||
+        changedKey.startsWith(`${queryStateKey}:`) ||
+        queryStateKey.startsWith(`${changedKey}:`));
+}
+async function fetchPollJson(pollUrl, cursor, interval, token) {
     const controller = typeof AbortController === "undefined" ? null : new AbortController();
     const timeout = controller
         ? setTimeout(() => controller.abort(), getPollAbortMs(interval))
         : null;
-    // Local path stays exactly `?since=N`; the hosted gateway also carries the
-    // subscribe token on the query string (a cross-origin fetch can't set the
-    // Authorization header for the SSE sibling either, so both use the query).
-    const url = token
-        ? `${pollUrl}${pollUrl.includes("?") ? "&" : "?"}since=${since}&token=${encodeURIComponent(token)}`
-        : `${pollUrl}?since=${since}`;
+    // The numeric `since` remains for backward-compatible servers. The
+    // composite cursor closes the same-millisecond cross-instance gap by
+    // ordering durable rows on `(version,id)`.
+    const separator = pollUrl.includes("?") ? "&" : "?";
+    const cursorQuery = `since=${cursor.version}`;
+    const compositeCursorQuery = cursor.version > 0 || cursor.id
+        ? `&cursor=${encodeURIComponent(encodeSyncCursor(cursor))}`
+        : "";
+    const tokenQuery = token ? `&token=${encodeURIComponent(token)}` : "";
+    const url = `${pollUrl}${separator}${cursorQuery}${compositeCursorQuery}${tokenQuery}`;
     try {
         const res = await fetch(url, controller ? { signal: controller.signal } : undefined);
         if (!res.ok)
@@ -192,7 +267,7 @@ class SyncTransport {
     sseUrl;
     gateway;
     subscribers = new Map();
-    versionRef = 0;
+    cursorRef = { ...INITIAL_SYNC_CURSOR };
     timer = null;
     stopped = false;
     inFlight = false;
@@ -202,7 +277,7 @@ class SyncTransport {
     sseConnected = false;
     authFailureUntil = 0;
     consecutiveFailures = 0;
-    activeChatIds = new Set();
+    activeChatIds = new Map();
     // Hosted-gateway state. `mode` starts "hosted" when a binding is present and
     // flips to "local" on health-gate revert; `token` is the current subscribe
     // token (minted from the app, rotated over the stream), never part of any
@@ -237,7 +312,9 @@ class SyncTransport {
             const base = `${this.gateway.sseUrl}?token=${encodeURIComponent(this.token)}`;
             // Cursor lets the gateway replay the reconnect gap on connect instead of
             // deferring it to the next poll; 0 on first connect means nothing to replay.
-            return this.versionRef > 0 ? `${base}&since=${this.versionRef}` : base;
+            return this.cursorRef.version > 0 || this.cursorRef.id
+                ? `${base}&since=${this.cursorRef.version}&cursor=${encodeURIComponent(encodeSyncCursor(this.cursorRef))}`
+                : base;
         }
         return this.sseUrl;
     }
@@ -322,7 +399,7 @@ class SyncTransport {
     }
     /**
      * Health-gate back to the app's own /poll + /events with the cursor intact
-     * (versionRef is untouched), so delivery stays poll-equivalent — never a
+     * (cursorRef is untouched), so delivery stays poll-equivalent - never a
      * silent stall.
      */
     revertToLocal() {
@@ -418,6 +495,12 @@ class SyncTransport {
         return isFinite(min) ? min : IDLE_POLL_INTERVAL_MS;
     }
     get isActive() {
+        const now = Date.now();
+        for (const [id, lastSeen] of this.activeChatIds) {
+            if (now - lastSeen > ACTIVE_CHAT_TTL_MS) {
+                this.activeChatIds.delete(id);
+            }
+        }
         return this.activeChatIds.size > 0;
     }
     get effectiveFallbackInterval() {
@@ -431,9 +514,9 @@ class SyncTransport {
     // -------------------------------------------------------------------------
     // Event fan-out
     // -------------------------------------------------------------------------
-    fan(events, version) {
+    fan(events, version, cursor = this.cursorRef) {
         for (const sub of this.subscribers.values()) {
-            sub.onEvents(events, version);
+            sub.onEvents(events, version, cursor);
         }
     }
     setSseConnected(connected) {
@@ -536,7 +619,7 @@ class SyncTransport {
         // already origin-scoped, and the dev gateway serves every workspace app
         // from one origin — so an origin key would elect a single leader across
         // different apps. A follower applies whatever the leader sends into its own
-        // `versionRef` (see openChannel), and that cursor is the `?since=` for its
+        // `cursorRef` (see openChannel), and that cursor is the `?since=` for its
         // own poll, so it would skip its own app's events from then on. The poll
         // URL is app-scoped, which is exactly the granularity a stream serves.
         return `${SSE_LEADER_LOCK_PREFIX}${this.pollUrl}`;
@@ -612,8 +695,9 @@ class SyncTransport {
             if (this.leaderState === "leader")
                 return;
             if (frame?.type === "events") {
-                this.applyVersion(frame.events, frame.version);
-                this.fan(frame.events, frame.version);
+                this.applyVersion(frame.events, frame.cursor ? undefined : frame.version);
+                this.cursorRef = maxSyncCursor(this.cursorRef, frame.cursor);
+                this.fan(frame.events, frame.version, this.cursorRef);
             }
             else if (frame?.type === "sse-state") {
                 this.capabilities = frame.capabilities;
@@ -719,7 +803,7 @@ class SyncTransport {
             if (this.mode === "hosted" && this.gateway) {
                 // Browser auto-reconnect reuses the URL frozen at construction, so it
                 // would replay from a stale `since`. Own the reconnect so the next
-                // connect rebuilds activeSseUrl from the current versionRef. CLOSED also
+                // connect rebuilds activeSseUrl from the current cursorRef. CLOSED also
                 // refreshes the token (expired/rotated/deploy); CONNECTING keeps it. A
                 // successful reconnect resets the count in onopen; a hard-down gateway
                 // trips the threshold and health-gates to local.
@@ -746,8 +830,18 @@ class SyncTransport {
                 const events = normalizeEventPayload(payload);
                 const version = typeof payload?.version === "number" ? payload.version : undefined;
                 this.applyVersion(events, version);
-                this.fan(events, version);
-                this.broadcast({ type: "events", events, version });
+                this.fan(events, version, this.cursorRef);
+                const eventCursor = cursorForEvents(events);
+                this.broadcast({
+                    type: "events",
+                    events,
+                    version,
+                    // A follower may only adopt a cursor for events it received. The
+                    // transport cursor can be ahead after a poll response skipped
+                    // filtered/unread durable rows, which would make the follower lose
+                    // those rows on its own safety poll.
+                    cursor: eventCursor,
+                });
             }
             catch {
                 // Ignore malformed SSE frames; polling is the safety net.
@@ -789,17 +883,15 @@ class SyncTransport {
      * Advance the transport's shared version cursor. Subscribers receive the
      * raw events and decide independently which ones are "fresh" relative to
      * their own cursor, but the transport-level cursor ensures the poll
-     * `?since=` parameter always advances.
+     * `?since=&cursor=` parameters always advance.
      */
     applyVersion(events, version) {
-        let max = typeof version === "number" ? version : 0;
+        if (typeof version === "number" && version > this.cursorRef.version) {
+            this.cursorRef = { version, id: "" };
+        }
         for (const evt of events) {
-            const v = typeof evt.version === "number" ? evt.version : 0;
-            if (v > max)
-                max = v;
+            this.cursorRef = maxSyncCursor(this.cursorRef, syncEventCursor(evt));
         }
-        if (max > this.versionRef)
-            this.versionRef = max;
     }
     async poll() {
         if (this.stopped || this.inFlight)
@@ -813,13 +905,19 @@ class SyncTransport {
                 if (!ok || this.stopped)
                     return;
             }
-            const data = await fetchPollJson(this.activePollUrl, this.versionRef, this.effectiveInterval, this.mode === "hosted" ? (this.token ?? undefined) : undefined);
+            const data = await fetchPollJson(this.activePollUrl, this.cursorRef, this.effectiveInterval, this.mode === "hosted" ? (this.token ?? undefined) : undefined);
             if (this.stopped)
                 return;
             this.consecutiveFailures = 0;
             const events = data.events ?? [];
-            this.applyVersion(events, data.version);
-            this.fan(events, data.version);
+            const responseCursor = decodeSyncCursor(data.cursor);
+            // A paged durable response's numeric version is the high-water mark,
+            // not necessarily the last row in this page. When a composite cursor is
+            // present, advance from event ids/that cursor only - applying the high
+            // water first would skip the remainder of a same-version page.
+            this.applyVersion(events, responseCursor ? undefined : data.version);
+            this.cursorRef = maxSyncCursor(this.cursorRef, responseCursor);
+            this.fan(events, data.version, this.cursorRef);
         }
         catch (err) {
             if (this.stopped)
@@ -901,10 +999,20 @@ class SyncTransport {
             ? detail.tabId
             : "__default__";
         const wasActive = this.isActive;
-        if (running)
-            this.activeChatIds.add(id);
-        else
+        if (running) {
+            // Reinsert to refresh both the TTL and insertion order for the cap.
+            this.activeChatIds.delete(id);
+            this.activeChatIds.set(id, Date.now());
+            while (this.activeChatIds.size > ACTIVE_CHAT_MAX) {
+                const oldestId = this.activeChatIds.keys().next().value;
+                if (typeof oldestId !== "string")
+                    break;
+                this.activeChatIds.delete(oldestId);
+            }
+        }
+        else {
             this.activeChatIds.delete(id);
+        }
         if (wasActive === this.isActive)
             return;
         if (this.isActive) {
@@ -932,6 +1040,7 @@ class SyncTransport {
     }
     teardown() {
         this.stopped = true;
+        this.activeChatIds.clear();
         this.closeEvents();
         // Hand this app's stream slot to a waiting tab before dropping the
         // channel, so the next leader is elected without waiting on a poll.
@@ -1071,6 +1180,7 @@ export function useDbSync(options = {}) {
         // Per-subscriber version cursor: tracks which events have already been
         // processed by THIS subscriber so stale poll re-deliveries are ignored.
         let subscriberVersion = 0;
+        let subscriberCursor = { ...INITIAL_SYNC_CURSOR };
         // Coalesce bursts of SSE-driven invalidation into at most one flush per
         // INVALIDATE_COALESCE_MS. A chatty doc (many small agent edits, several
         // peers editing at once) can otherwise deliver a handful of `action`/
@@ -1091,6 +1201,8 @@ export function useDbSync(options = {}) {
         // coalesced behavior.
         let pendingInvalidateEvents = [];
         let invalidateTimer = null;
+        let disposed = false;
+        const pendingTrailingRefreshes = [];
         function flushInvalidateBatch() {
             if (invalidateTimer) {
                 clearTimeout(invalidateTimer);
@@ -1158,23 +1270,60 @@ export function useDbSync(options = {}) {
                 // in flight, let it finish instead of aborting and immediately
                 // launching the same request again. Repeated action events otherwise
                 // turn a slow endpoint into a cancel/restart loop that never settles.
+                const hasPendingTrailingRefresh = (filters, predicateIdentity) => pendingTrailingRefreshes.some((pending) => {
+                    if (pending.filters?.dedupeKey !== filters?.dedupeKey)
+                        return false;
+                    if (filters?.dedupeKey)
+                        return true;
+                    const pendingKey = pending.filters?.queryKey;
+                    const filterKey = filters?.queryKey;
+                    if (pendingKey || filterKey) {
+                        if (!pendingKey ||
+                            !filterKey ||
+                            pendingKey.length !== filterKey.length) {
+                            return false;
+                        }
+                        return pendingKey.every((key, index) => key === filterKey[index]);
+                    }
+                    return pending.predicateIdentity === predicateIdentity;
+                });
                 const invalidateWithoutCancel = (requested) => {
                     const callerPredicate = requested?.predicate;
-                    const filters = {
+                    const normalizedFilters = {
                         ...requested,
                         predicate: (query) => !hasTerminalAuthFailure(query) &&
                             (callerPredicate?.(query) ?? true),
                     };
-                    const needsTrailingRefresh = (queryClient.isFetching?.(filters) ?? 0) > 0;
-                    const completion = queryClient.invalidateQueries(filters, {
+                    const needsTrailingRefresh = (queryClient.isFetching?.(normalizedFilters) ?? 0) > 0;
+                    const completion = queryClient.invalidateQueries(normalizedFilters, {
                         cancelRefetch: false,
                     });
                     // TanStack Query deliberately leaves an in-flight fetch alone when
                     // cancelRefetch is false. Queue one post-settlement invalidation so
                     // a write that landed after that read began cannot be cleared as
                     // fresh by the older response.
-                    if (needsTrailingRefresh && completion instanceof Promise) {
-                        void completion.then(() => queryClient.invalidateQueries(filters), () => { });
+                    if (!disposed &&
+                        needsTrailingRefresh &&
+                        completion instanceof Promise &&
+                        !hasPendingTrailingRefresh(normalizedFilters, callerPredicate)) {
+                        const pending = {
+                            filters: normalizedFilters,
+                            completion,
+                            predicateIdentity: callerPredicate,
+                        };
+                        pendingTrailingRefreshes.push(pending);
+                        void completion.then(() => {
+                            const index = pendingTrailingRefreshes.indexOf(pending);
+                            if (index < 0)
+                                return;
+                            pendingTrailingRefreshes.splice(index, 1);
+                            if (!disposed)
+                                queryClient.invalidateQueries(normalizedFilters);
+                        }, () => {
+                            const index = pendingTrailingRefreshes.indexOf(pending);
+                            if (index >= 0)
+                                pendingTrailingRefreshes.splice(index, 1);
+                        });
                     }
                 };
                 const hasActionEvent = invalidating.some((evt) => evt.source === "action" && !isSuppressedActionEvent(evt));
@@ -1240,8 +1389,26 @@ export function useDbSync(options = {}) {
                             invalidateWithoutCancel({ queryKey: ["tools"] });
                         }
                     }
-                    if (invalidating.some((evt) => evt.source === "app-state")) {
-                        invalidateWithoutCancel({ queryKey: ["app-state"] });
+                    const appStateKeys = invalidating
+                        .filter((evt) => evt.source === "app-state")
+                        .map((evt) => evt.key)
+                        .map((key) => (typeof key === "string" && key ? key : "*"));
+                    if (appStateKeys.length > 0) {
+                        const appStateDedupeKey = Array.from(new Set(appStateKeys))
+                            .sort()
+                            .map((key) => `${key.length}:${key}`)
+                            .join("|");
+                        const needsBroadAppStateRefresh = appStateKeys.some((key) => key === "*" ||
+                            isInteractionCriticalSyncEvent({
+                                source: "app-state",
+                                key,
+                            }));
+                        invalidateWithoutCancel(needsBroadAppStateRefresh
+                            ? { queryKey: ["app-state"] }
+                            : {
+                                dedupeKey: `app-state:${appStateDedupeKey}`,
+                                predicate: (query) => appStateQueryMatchesKeys(query, appStateKeys),
+                            });
                     }
                     if (hasAppStateEvent(invalidating, "navigate")) {
                         invalidateWithoutCancel({ queryKey: ["navigate-command"] });
@@ -1261,16 +1428,20 @@ export function useDbSync(options = {}) {
                 onEventRef.current?.(evt);
             }
         }
-        function onEvents(events, version) {
+        function onEvents(events, version, cursor) {
             const freshEvents = events.filter((event) => {
-                const v = typeof event.version === "number" ? event.version : 0;
-                return v === 0 || v > subscriberVersion;
+                return isSyncEventAfterCursor(event, subscriberCursor, subscriberVersion);
             });
             if (freshEvents.length > 0) {
                 queueInvalidateBatch(freshEvents);
             }
             const maxEventVersion = freshEvents.reduce((max, event) => Math.max(max, typeof event.version === "number" ? event.version : 0), 0);
             subscriberVersion = Math.max(subscriberVersion, version ?? 0, maxEventVersion);
+            for (const event of freshEvents) {
+                subscriberCursor = maxSyncCursor(subscriberCursor, syncEventCursor(event));
+            }
+            if (cursor)
+                subscriberCursor = maxSyncCursor(subscriberCursor, cursor);
         }
         const transport = getOrCreateTransport(pollUrl, sseUrl, resolveGatewayBinding(sseUrl));
         transport.add(id, {
@@ -1281,12 +1452,14 @@ export function useDbSync(options = {}) {
             fallbackInterval,
         });
         return () => {
+            disposed = true;
             if (invalidateTimer) {
                 clearTimeout(invalidateTimer);
                 // Flush synchronously on unmount so a pending batch isn't silently
                 // dropped (e.g. a route change right after an agent edit lands).
                 flushInvalidateBatch();
             }
+            pendingTrailingRefreshes.length = 0;
             transport.remove(id);
             // If the registry still holds this transport, and the transport is now
             // empty, evict it so the next mount gets a fresh instance rather than a
@@ -1335,16 +1508,21 @@ export function useScreenRefreshKey(options = {}) {
         const id = Symbol("useScreenRefreshKey");
         // Per-subscriber version cursor (same freshness logic as useDbSync).
         let subscriberVersion = 0;
-        function onEvents(events, version) {
+        let subscriberCursor = { ...INITIAL_SYNC_CURSOR };
+        function onEvents(events, version, cursor) {
             const freshEvents = events.filter((event) => {
-                const v = typeof event.version === "number" ? event.version : 0;
-                return v === 0 || v > subscriberVersion;
+                return isSyncEventAfterCursor(event, subscriberCursor, subscriberVersion);
             });
             if (freshEvents.some((e) => e.source === "screen-refresh")) {
                 setKey((k) => k + 1);
             }
             const maxEventVersion = freshEvents.reduce((max, event) => Math.max(max, typeof event.version === "number" ? event.version : 0), 0);
             subscriberVersion = Math.max(subscriberVersion, version ?? 0, maxEventVersion);
+            for (const event of freshEvents) {
+                subscriberCursor = maxSyncCursor(subscriberCursor, syncEventCursor(event));
+            }
+            if (cursor)
+                subscriberCursor = maxSyncCursor(subscriberCursor, cursor);
         }
         const transport = getOrCreateTransport(pollUrl, sseUrl, resolveGatewayBinding(sseUrl));
         transport.add(id, {

package/dist/collab/awareness.js

@@ -16,6 +16,8 @@ import { readBody } from "../server/h3-helpers.js";
 import { deleteAwarenessRow, loadAwarenessRows, upsertAwarenessRow, } from "./awareness-store.js";
 const AWARENESS_TIMEOUT = 30_000; // 30 seconds
 const CLEAR_TOMBSTONE_TTL = AWARENESS_TIMEOUT + 5_000;
+const AWARENESS_SCOPE_TIMEOUT = AWARENESS_TIMEOUT + 5_000;
+const MAX_AWARENESS_SCOPES = 10_000;
 // ---------------------------------------------------------------------------
 // Awareness event emitter — fast-path for push delivery to SSE-connected peers.
 // The SSE handler (poll-events) subscribes and forwards events to its stream.
@@ -24,21 +26,52 @@ export const AWARENESS_CHANGE_EVENT = "awareness-change";
 const _awarenessEmitter = new EventEmitter();
 _awarenessEmitter.setMaxListeners(0);
 const _awarenessScopes = new Map();
+function pruneAwarenessScopes(now) {
+    for (const [docId, entry] of _awarenessScopes) {
+        if (now - entry.lastSeen > AWARENESS_SCOPE_TIMEOUT) {
+            _awarenessScopes.delete(docId);
+        }
+    }
+    while (_awarenessScopes.size > MAX_AWARENESS_SCOPES) {
+        const oldest = _awarenessScopes.keys().next().value;
+        if (!oldest)
+            break;
+        _awarenessScopes.delete(oldest);
+    }
+}
 export function getAwarenessEmitter() {
     return _awarenessEmitter;
 }
 export function rememberAwarenessScope(docId, scope) {
-    if (!scope)
+    const now = Date.now();
+    pruneAwarenessScopes(now);
+    const existing = _awarenessScopes.get(docId);
+    if (!scope) {
+        // Agent-presence heartbeats emit scope-less awareness changes. They still
+        // prove the document is active and must keep the access scope alive.
+        if (existing) {
+            _awarenessScopes.delete(docId);
+            _awarenessScopes.set(docId, { ...existing, lastSeen: now });
+        }
         return;
-    const next = { ...(_awarenessScopes.get(docId) ?? {}), ...scope };
+    }
+    const next = {
+        ...(existing?.scope ?? {}),
+        ...scope,
+    };
     if (!next.owner && !next.orgId && !next.resourceType && !next.resourceId) {
         return;
     }
-    _awarenessScopes.set(docId, next);
+    _awarenessScopes.delete(docId);
+    _awarenessScopes.set(docId, { scope: next, lastSeen: now });
+    // Enforce the cap after insertion too. Pruning only before insertion lets
+    // the map temporarily exceed its advertised bound on every new document.
+    pruneAwarenessScopes(now);
 }
 export function emitAwarenessChange(docId, states, scope) {
     rememberAwarenessScope(docId, scope);
-    const resolvedScope = _awarenessScopes.get(docId) ?? {};
+    pruneAwarenessScopes(Date.now());
+    const resolvedScope = _awarenessScopes.get(docId)?.scope ?? {};
     const event = {
         source: "awareness",
         type: "awareness-change",

package/dist/collab/client.js

@@ -131,10 +131,21 @@ function calcBackoff(consecutiveErrors) {
 // setLocalStateField calls within a 150ms window are coalesced into one POST.
 // ---------------------------------------------------------------------------
 const _awarenessThrottleTimers = new Map();
+function awarenessThrottleKey(baseUrl, docId, clientId) {
+    return `${baseUrl}::${docId}::${clientId}`;
+}
+function cancelAwarenessPush(baseUrl, docId, clientId) {
+    const key = awarenessThrottleKey(baseUrl, docId, clientId);
+    const timer = _awarenessThrottleTimers.get(key);
+    if (timer === undefined)
+        return;
+    clearTimeout(timer);
+    _awarenessThrottleTimers.delete(key);
+}
 function scheduleAwarenessPush(baseUrl, docId, clientId, getState) {
     if (typeof window === "undefined")
         return;
-    const key = `${docId}::${clientId}`;
+    const key = awarenessThrottleKey(baseUrl, docId, clientId);
     if (_awarenessThrottleTimers.has(key))
         return; // already scheduled
     const timer = setTimeout(() => {
@@ -264,6 +275,10 @@ class CollabDocConnection {
     remove(id) {
         this.subscribers.delete(id);
         if (this.subscribers.size === 0) {
+            // A lingered connection may be remounted for StrictMode, but it has no
+            // live consumer while empty. Do not let a queued presence push escape
+            // after the last subscriber has gone away.
+            cancelAwarenessPush(this.baseUrl, this.docId, this.ydoc.clientID);
             this.scheduleDispose();
         }
         else {
@@ -305,6 +320,7 @@ class CollabDocConnection {
         // `setLocalState(null)` does not schedule a push (matches the previous
         // per-hook effect cleanup ordering).
         this.awareness.off("change", this.handleAwarenessChange);
+        cancelAwarenessPush(this.baseUrl, this.docId, this.ydoc.clientID);
         this.awareness.destroy();
         this.ydoc.destroy();
         if (collabConnectionRegistry.get(this.registryKey) === this) {

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;