experimental-a2 0.10.0 → 0.12.0

package/src/session-socket.ts

@@ -8,6 +8,7 @@
 
 import { A2Error } from './errors.ts'
 import { SOCKET_TIMINGS, STREAM_TIMINGS } from './internal.ts'
+import { streamActivities } from './stream-activity.ts'
 import type { Event } from './store.ts'
 import type { EventDefs, PresencePatch, PresenceSnapshot } from './contract.ts'
 import type { ParsedPushEvent, ParsedPushPresence } from './push-envelope.ts'
@@ -312,6 +313,7 @@ const handleSocketPush = async (
   req: number,
   ackSessionId: string | undefined,
   gatePush: SessionsSocketOptions['gatePush'],
+  activate: () => void,
 ): Promise<void> => {
   try {
     const events = parsePushEvents(frame['events'])
@@ -320,8 +322,10 @@ const handleSocketPush = async (
       shell.send(socketErrorAckFor(req, denial, ackSessionId))
       return
     }
+    activate()
     // oxlint-disable-next-line a2/await-handler-append -- this transport append is awaited before its ack
     const appended = await target.append(...events)
+    activate()
     shell.send(socketAckFor(req, appended, ackSessionId))
   } catch (error) {
     shell.send(socketErrorAckFor(req, asA2Error(error), ackSessionId))
@@ -418,6 +422,7 @@ export function sessionSocket<D extends EventDefs>(
             req,
             undefined,
             options?.gatePush,
+            () => streamActivities.get(subscription.iterator)?.activate(),
           ),
         )
         return
@@ -511,10 +516,10 @@ export function sessionsSocket<D extends EventDefs>(
       if (shell.torn() || subscription.stopped) return
       retire(id, subscription)
       shell.send(socketUnsubscribedFor(id))
-    } catch {
+    } catch (error) {
       if (shell.torn() || subscription.stopped) return
       retire(id, subscription)
-      shell.send(socketUnsubscribedFor(id, 'stream failed'))
+      shell.send(socketUnsubscribedFor(id, 'stream failed', asA2Error(error)))
     }
   }
 
@@ -522,23 +527,32 @@ export function sessionsSocket<D extends EventDefs>(
     id: string,
     index: number,
   ): Promise<void> => {
+    const existing = subscriptions.get(id)
+    if (existing) {
+      stopSubscription(existing)
+      subscriptions.delete(id)
+    }
     let session: Pick<Session<D>, 'stream'> | null
     try {
       session = await resolve(id, index)
-    } catch {
+    } catch (error) {
       if (!shell.torn()) {
-        shell.send(socketUnsubscribedFor(id, 'stream failed'))
+        shell.send(socketUnsubscribedFor(id, 'stream failed', asA2Error(error)))
       }
       return
     }
     if (shell.torn()) return
     if (session === null) {
-      shell.send(socketUnsubscribedFor(id, 'subscribe rejected'))
+      shell.send(
+        socketUnsubscribedFor(
+          id,
+          'subscribe rejected',
+          new A2Error('FORBIDDEN', 'the subscription is not authorized'),
+        ),
+      )
       return
     }
     const target = session as unknown as SocketSession
-    const existing = subscriptions.get(id)
-    if (existing) stopSubscription(existing)
     const subscription = socketSubscription(target, index, presence)
     subscriptions.set(id, subscription)
     shell.send(socketSubscribedFor(id))
@@ -582,6 +596,10 @@ export function sessionsSocket<D extends EventDefs>(
       req,
       sessionId,
       options?.gatePush,
+      () => {
+        const current = subscriptions.get(sessionId)
+        if (current) streamActivities.get(current.iterator)?.activate()
+      },
     )
   }
 

package/src/sse.ts

@@ -10,6 +10,7 @@ import { STREAM_TIMINGS } from './internal.ts'
 import type { Event } from './store.ts'
 import type { PresencePatch, PresenceSnapshot } from './contract.ts'
 import { invocationDeadlineMs } from './platform.ts'
+import { streamActivities } from './stream-activity.ts'
 import {
   eventToWire,
   presencePatchToWire,
@@ -41,7 +42,10 @@ export function sseResponse(
   let deadlineTimer: ReturnType<typeof setTimeout> | undefined
   let closed = false
   let iteratorReturned = false
+  let stopActivity: (() => void) | undefined
   const stopTimers = (): void => {
+    stopActivity?.()
+    stopActivity = undefined
     if (heartbeat !== undefined) clearInterval(heartbeat)
     if (deadlineTimer !== undefined) clearTimeout(deadlineTimer)
     heartbeat = undefined
@@ -61,6 +65,19 @@ export function sseResponse(
       // early proof this is a stream. Comment frames are invisible to
       // SSE consumers.
       controller.enqueue(encoder.encode(': connected\n\n'))
+      const activity = streamActivities.get(iterator)
+      if (activity) {
+        const announce = (idle: boolean): void => {
+          if (closed) return
+          controller.enqueue(
+            encoder.encode(
+              `event: a2-activity\ndata: ${idle ? 'idle' : 'active'}\n\n`,
+            ),
+          )
+        }
+        stopActivity = activity.subscribe(announce)
+        if (activity.idle) announce(true)
+      }
       // Heartbeat: comment frames are ignored by SSE parsers but are
       // bytes on the wire — liveness proof for the client's watchdog
       // and for idle-timeout-happy intermediaries.

package/src/store-polling.ts

@@ -14,7 +14,8 @@
  */
 
 import { POLL_TIMINGS } from './internal.ts'
-import type { StoredEvent } from './store.ts'
+import type { Event } from './store.ts'
+import { createStreamActivity, streamActivities } from './stream-activity.ts'
 
 /** One cancellable sleep — the injection seam for cadence tests. */
 export type Sleeper = { promise: Promise<void>; cancel: () => void }
@@ -56,47 +57,66 @@ export type PollingStreamOptions = {
  * SSE client), waking any pending sleep immediately.
  */
 export function pollingStream(
-  readAfter: (afterIndex: number) => StoredEvent[] | Promise<StoredEvent[]>,
+  readAfter: (afterIndex: number) => Event[] | Promise<Event[]>,
   options: PollingStreamOptions,
-): AsyncIterable<StoredEvent> {
+): AsyncIterable<Event> {
   const startAfter = options.startAfter ?? 0
   const sleep = options.sleep ?? defaultSleep
 
   return {
-    [Symbol.asyncIterator](): AsyncIterator<StoredEvent> {
+    [Symbol.asyncIterator](): AsyncIterator<Event> {
       let last = startAfter
-      let buffer: StoredEvent[] = []
+      let buffer: Event[] = []
       let closed = false
       let pending: Sleeper | null = null
       let interval = floor()
+      let activityVersion = 0
+      const activity = createStreamActivity(() => {
+        if (closed) return
+        activityVersion += 1
+        interval = floor()
+        pending?.cancel()
+      })
 
-      return {
-        async next(): Promise<IteratorResult<StoredEvent>> {
+      const iterator: AsyncIterator<Event> = {
+        async next(): Promise<IteratorResult<Event>> {
           for (;;) {
             if (closed) return { value: undefined, done: true }
-            // oxlint-disable-next-line no-await-in-loop -- poll loop
-            if (buffer.length === 0) buffer = await readAfter(last)
+            try {
+              // oxlint-disable-next-line no-await-in-loop -- poll loop
+              if (buffer.length === 0) buffer = await readAfter(last)
+            } catch (error) {
+              if (closed) return { value: undefined, done: true }
+              throw error
+            }
+            if (closed) return { value: undefined, done: true }
             const row = buffer.shift()
             if (row) {
               // Activity: tighten back to the floor.
-              interval = floor()
+              activity.activate()
               last = row.index
               return { value: row, done: false }
             }
             // Empty poll: wait, then back off toward the idle ceiling.
+            activity.setIdle(interval === ceiling())
+            const version = activityVersion
             pending = sleep(interval)
             // oxlint-disable-next-line no-await-in-loop -- poll loop
             await pending.promise
             pending = null
-            interval = Math.min(interval * 2, ceiling())
+            if (version === activityVersion) {
+              interval = Math.min(interval * 2, ceiling())
+            }
           }
         },
-        async return(): Promise<IteratorResult<StoredEvent>> {
+        async return(): Promise<IteratorResult<Event>> {
           closed = true
           pending?.cancel()
           return { value: undefined, done: true }
         },
       }
+      streamActivities.set(iterator, activity)
+      return iterator
     },
   }
 }