@volter/teams 0.1.63 → 0.1.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/teams",
-  "version": "0.1.63",
+  "version": "0.1.64",
   "type": "module",
   "description": "Volter Teams, the neutral team plane: machine identity and daemon core, the local door and server link, admission from machine grants, product doors, and the Teams server's neutral routes (company RFC 0008).",
   "license": "MIT",

package/session-follow.mjs

@@ -15,29 +15,41 @@
  */
 export function followTeamSession({ origin, teamId, sessionId, token, tail = 300, onSnapshot, onLive = () => {}, onError = () => {}, onDeleted = () => {}, fetchImpl = globalThis.fetch, retryMs = 2000 }) {
   const base = `${origin}/api/v1/teams/${encodeURIComponent(teamId)}/sessions/${encodeURIComponent(sessionId)}`;
-  const decoder = new TextDecoder();
   const controller = new AbortController();
   const headers = async () => ({ Authorization: `Bearer ${await token()}` });
   const failure = (stage, status, message) => Object.assign(new Error(message), { stage, status });
-  let reading = null;
-  const read = () => (reading ??= (async () => {
-    try {
-      const response = await fetchImpl(`${base}/messages?tail=${tail}`, { headers: await headers(), signal: controller.signal });
-      if (!response.ok) throw failure('read', response.status, `reading the session failed (${response.status})`);
-      const body = await response.json();
-      onSnapshot(body.data ?? body);
-      return body.data ?? body;
-    } finally { reading = null; }
-  })());
+  let reading = null, requested = false;
+  const read = () => {
+    requested = true;
+    return reading ??= (async () => {
+      let snapshot;
+      do {
+        requested = false;
+        const response = await fetchImpl(`${base}/messages?tail=${tail}`, { headers: await headers(), signal: AbortSignal.any([controller.signal, AbortSignal.timeout(15000)]) });
+        if (!response.ok) throw failure('read', response.status, `reading the session failed (${response.status})`);
+        const body = await response.json();
+        if (controller.signal.aborted) throw new DOMException('Session follow stopped', 'AbortError');
+        snapshot = body.data ?? body;
+        onSnapshot(snapshot);
+        // A change during the HTTP read may be newer than the capture it
+        // returned. Coalesce the callers, but do not drop that invalidation.
+      } while (requested);
+      return snapshot;
+    })().finally(() => { reading = null; });
+  };
   (async () => {
-    let cursor = null;
+    let cursor = null, following = null, watched = null;
     while (!controller.signal.aborted) {
+      const connection = new AbortController();
+      following = connection;
+      let reader;
       try {
         if (!cursor) cursor = String((await read()).event_cursor ?? '') || null;
-        const response = await fetchImpl(`${base}/events?${cursor ? `after=${encodeURIComponent(cursor)}` : 'tail=1'}`, { headers: await headers(), signal: controller.signal });
+        const response = await fetchImpl(`${base}/events?${cursor ? `after=${encodeURIComponent(cursor)}` : 'tail=1'}`, { headers: await headers(), signal: AbortSignal.any([controller.signal, connection.signal]) });
         if (!response.ok) throw failure('follow', response.status, `following the session failed (${response.status})`);
         onLive(true);
-        const reader = response.body.getReader();
+        reader = response.body.getReader();
+        const decoder = new TextDecoder();
         let buffer = '';
         for (;;) {
           const { value, done } = await reader.read();
@@ -54,13 +66,33 @@ export function followTeamSession({ origin, teamId, sessionId, token, tail = 300
             // The server ends a stream it can no longer resume (a slow reader, a retired cursor): start from a snapshot.
             if (event.terminal && event.type === 'resync_required') cursor = null;
             if (event.type === 'snapshot') onSnapshot(event.data);
-            else if (event.type === 'session_changed') read().catch((error) => { if (!controller.signal.aborted) onError({ stage: error.stage ?? 'read', status: error.status ?? null, message: error.message }); });
+            else if (event.type === 'session_changed') {
+              const refresh = read();
+              // One recovery handler per coalesced read, including when a
+              // token-expiry reconnect overtakes the unfinished HTTP read.
+              if (watched !== refresh) {
+                watched = refresh;
+                void refresh.then(() => { if (watched === refresh) watched = null; }, (error) => {
+                  if (watched === refresh) watched = null;
+                  if (controller.signal.aborted) return;
+                  // Its event cursor advanced, but its snapshot was not read.
+                  // Recover even if no further message arrives.
+                  cursor = null;
+                  following?.abort();
+                  onError({ stage: error.stage ?? 'read', status: error.status ?? null, message: error.message, snapshot: true });
+                });
+              }
+            }
             else if (event.type === 'session_deleted') { onLive(false); onDeleted(); return; }
           }
         }
       } catch (error) {
         if (controller.signal.aborted) return;
-        onError({ stage: error.stage ?? 'follow', status: error.status ?? null, message: error.message, snapshot: Boolean(cursor) });
+        if (!connection.signal.aborted) onError({ stage: error.stage ?? 'follow', status: error.status ?? null, message: error.message, snapshot: Boolean(cursor) });
+      } finally {
+        if (following === connection) following = null;
+        connection.abort();
+        await reader?.cancel().catch(() => {});
       }
       onLive(false);
       await new Promise((resolve) => setTimeout(resolve, retryMs));