@volter/teams 0.2.8 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/teams",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "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/server/events.mjs

@@ -1,3 +1,17 @@
 import { EventEmitter } from 'node:events';
 export class TeamEvents extends EventEmitter { publish(teamId,event){this.emit(`team:${teamId}`,event); if(event.session_id)this.emit(`session:${teamId}:${event.session_id}`,event);} subscribe(key,fn){this.on(key,fn);return()=>this.off(key,fn);} close(){this.emit('shutdown');this.removeAllListeners();} }
 export function writeSse(res,event){const cursor=event.cursor??'';res.write(`id: ${cursor}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);}
+// A stream's backlog cap is met by waiting for the response to flush, never by measuring the server's own unflushed bytes:
+// a Durable Object's SQLite answers as microtasks, so a snapshot written in one turn never lets the response drain, and a
+// 1 MiB backlog checked there cut every reader of a large team as slow (217 Task heads, 1,022 KB, with a reader that only
+// counted). Only a reader that takes nothing for the patience window is slow. Resolves 'ready', 'closed' or 'slow'.
+export const SSE_BACKLOG_BYTES=1048576, SSE_PATIENCE_MS=30000;
+export function sseRoom(res,bytes,{cap=SSE_BACKLOG_BYTES,patienceMs=SSE_PATIENCE_MS}={}){
+  // An event larger than the cap still goes out whole once nothing is waiting: a snapshot of any size completes.
+  if(res.writableLength===0||res.writableLength+bytes<=cap)return Promise.resolve('ready');
+  return new Promise(resolve=>{
+    const done=outcome=>{clearTimeout(timer);res.off('drain',drained);res.off('close',ended);resolve(outcome);};
+    const drained=()=>done('ready'),ended=()=>done('closed'),timer=setTimeout(()=>done('slow'),patienceMs);
+    res.on('drain',drained);res.on('close',ended);
+  });
+}

package/server/published-events.mjs

@@ -3,7 +3,7 @@ import { appAuthentication } from './apps.mjs';
 import { isAdmin } from './auth.mjs';
 import { exact } from './request-json.mjs';
 import { canonicalJson } from './wire.mjs';
-import { writeSse } from './events.mjs';
+import { sseRoom, writeSse } from './events.mjs';
 import { APP_EVENTS, PUBLISHABLE_EVENTS, eventReadAction } from './event-catalogue.mjs';
 import { EVENT_DATA_LIMIT } from '../event-limits.mjs';
 
@@ -99,7 +99,7 @@ async function eventStream({api,req,res,auth,url,requestId}){
   let closed=false,running=null,dirty=false;
   const close=()=>{if(closed)return;closed=true;clearInterval(timer);unsubscribe();req.off('close',close);api.events.off('shutdown',close);api.openStreams.set(auth.credential_id,Math.max(0,(api.openStreams.get(auth.credential_id)??1)-1));res.end();};
   const terminal=(type,reason)=>{if(!closed)writeSse(res,{type,reason,terminal:true});close();};
-  const write=event=>{if(closed)return false;if(res.writableLength+Buffer.byteLength(JSON.stringify(event))>1048576){terminal('resync_required','slow_reader');return false;}writeSse(res,event);return true;};
+  const write=async event=>{if(closed)return false;const room=await sseRoom(res,Buffer.byteLength(JSON.stringify(event)));if(closed||room==='closed')return false;if(room==='slow'){terminal('resync_required','slow_reader');return false;}writeSse(res,event);return true;};
   const readable=async event=>{
     const current=await liveAuth(api,auth);
     if(current.epoch!==auth.epoch)fail(409,'resync_required','authorization changed during event delivery');
@@ -120,21 +120,21 @@ async function eventStream({api,req,res,auth,url,requestId}){
         {kind:'one',sql:'SELECT COALESCE((SELECT max(sequence) FROM org_events WHERE team_id=?),(SELECT pruned_through FROM event_retention WHERE team_id=?),0) last',params:[auth.team_id,auth.team_id]},
         {kind:'query',sql:'SELECT r.sequence FROM event_resources r JOIN org_events e ON e.sequence=r.sequence WHERE r.team_id=? AND (? IS NULL OR r.source_id=?) AND (? IS NULL OR r.resource_kind IN (SELECT value FROM json_each(?)) OR e.kind IN (SELECT value FROM json_each(?))) ORDER BY r.source_id,r.resource_kind,r.resource_id',params:[auth.team_id,query.source,query.source,filterResources,filterResources,filterKinds]},
       ]);
-      cursor=head.last;write({type:'snapshot_begin'});
+      cursor=head.last;if(!await write({type:'snapshot_begin'}))return;
       for(let at=0;at<resources.length;at+=32){
         const sequences=resources.slice(at,at+32).map(row=>row.sequence);
         const rows=await api.store.query('SELECT * FROM org_events WHERE team_id=? AND sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence',[auth.team_id,JSON.stringify(sequences)]);
         if(rows.length!==sequences.length){terminal('resync_required','snapshot_retention');return;}
-        for(const row of rows){const event=eventOf(row);if(await readable(event))if(!write({type:'snapshot_item',sequence:row.sequence,data:event}))return;}
+        for(const row of rows){const event=eventOf(row);if(await readable(event))if(!await write({type:'snapshot_item',sequence:row.sequence,data:event}))return;}
       }
-      write({type:'snapshot_end',cursor:codec.encode(cursor)});
+      if(!await write({type:'snapshot_end',cursor:codec.encode(cursor)}))return;
     }
     for(;;){
       const rows=await api.store.query('SELECT * FROM org_events WHERE team_id=? AND sequence>? AND (? IS NULL OR source_id=?) AND (? IS NULL OR kind IN (SELECT value FROM json_each(?))) ORDER BY sequence LIMIT 128',[auth.team_id,cursor,query.source,query.source,filterKinds,filterKinds]);
-      if(!rows.length){cursor=Math.max(cursor,bounds.last);write({type:'checkpoint',cursor:codec.encode(cursor)});break;}
-      for(const row of rows){if(closed)return;cursor=row.sequence;const event=eventOf(row);if(await readable(event))write({type:'event',sequence:row.sequence,cursor:codec.encode(cursor),data:event});}
+      if(!rows.length){cursor=Math.max(cursor,bounds.last);await write({type:'checkpoint',cursor:codec.encode(cursor)});break;}
+      for(const row of rows){if(closed)return;cursor=row.sequence;const event=eventOf(row);if(await readable(event)&&!await write({type:'event',sequence:row.sequence,cursor:codec.encode(cursor),data:event}))return;}
       // Advance even when the reader was not authorized for a resource; never leak its data.
-      write({type:'checkpoint',cursor:codec.encode(cursor)});if(rows.length<128)break;
+      if(!await write({type:'checkpoint',cursor:codec.encode(cursor)}))return;if(rows.length<128)break;
     }
   };
   const enqueue=()=>{dirty=true;if(running)return running;running=(async()=>{while(dirty&&!closed){dirty=false;await drain();}})().catch(error=>terminal([401,403].includes(error.status)?'access_revoked':'resync_required',error.code??'unavailable')).finally(()=>{running=null;});return running;};
@@ -142,5 +142,5 @@ async function eventStream({api,req,res,auth,url,requestId}){
   const timer=setInterval(()=>void enqueue().then(()=>{if(!closed)res.write(': heartbeat\n\n');}),15000);timer.unref?.();
   req.once('close',close);api.events.once('shutdown',close);
   res.writeHead(200,{'Content-Type':'text/event-stream','Cache-Control':'no-store','X-Request-ID':requestId});await enqueue();
-  if(!closed)write({type:'checkpoint',cursor:codec.encode(cursor)});
+  if(!closed)await write({type:'checkpoint',cursor:codec.encode(cursor)});
 }