experimental-a2 0.20.0 → 0.22.0

package/src/store-redis-notify.ts

@@ -53,6 +53,9 @@ type Feed = {
   inbox: string[]
   bytes: number
   dirty: boolean
+  /** Wake-ups past a gap, waiting up to NOTIFY_TIMINGS.reorderMs for it. */
+  held: Array<{ wake: Wake; bytes: number }>
+  gapSince: number | undefined
   wake: (() => void) | null
   stopRead: () => Promise<void>
 }
@@ -61,15 +64,14 @@ type Feed = {
 const INBOX_BYTES = 512 * 1024
 
 type WakeEntry = [index: number, id: string, type: string, payload: unknown]
+type Wake = { frontier: number; createdAt: number; entries: WakeEntry[] }
 
 /**
  * Parses a wake-up message: `{"f":frontier}` or a bare frontier number
  * announces events without carrying them; `{"f","t","e"}` carries them.
  * Returns null for anything else, which callers treat as a hint to catch up.
  */
-const parseWake = (
-  message: string,
-): { frontier: number; createdAt: number; entries: WakeEntry[] } | null => {
+const parseWake = (message: string): Wake | null => {
   let parsed: unknown
   try {
     parsed = JSON.parse(message)
@@ -187,6 +189,8 @@ export function createRedisNotifyStore(options: {
             feed.bytes += message.length
           } else {
             feed.inbox.length = 0
+            feed.held.length = 0
+            feed.gapSince = undefined
             feed.bytes = 0
             feed.dirty = true
           }
@@ -282,6 +286,7 @@ export function createRedisNotifyStore(options: {
 
   const store: A2Store & { close(): Promise<void> } = {
     append: core.append,
+    cursors: core.cursors,
     read: core.read,
     readHistory: core.readHistory!,
     claimAvailable: core.claimAvailable,
@@ -294,11 +299,13 @@ export function createRedisNotifyStore(options: {
     reclaim: core.reclaim!,
     deadLetters: core.deadLetters!,
     redrive: core.redrive!,
+    wakeLog: core.wakeLog,
 
     presence: {
       async set(ns, participant, values, meta) {
-        const patch = await core.presence.set(ns, participant, values, meta)
-        if (!patch) return
+        const applied = await core.presence.set(ns, participant, values, meta)
+        if (!applied) return
+        const { patch } = applied
         const channel = presenceChannel(ns)
         const subscription = presenceSubscriptions.get(channel)
         if (subscription) {
@@ -306,13 +313,16 @@ export function createRedisNotifyStore(options: {
           subscription.recovery?.update(patch)
           for (const listener of subscription.listeners) listener(patch)
         }
+        await applied.published
       },
 
       async read(ns) {
         const channel = presenceChannel(ns)
         await subscriptions.get(channel)?.ready
+        const subscription = presenceSubscriptions.get(channel)
         return (
-          presenceSubscriptions.get(channel)?.recovery?.read() ??
+          subscription?.recovery?.read() ??
+          subscription?.poll?.snapshot(() => core.presence.read(ns)) ??
           core.presence.read(ns)
         )
       },
@@ -415,6 +425,8 @@ export function createRedisNotifyStore(options: {
             inbox: [],
             bytes: 0,
             dirty: true,
+            held: [],
+            gapSince: undefined,
             wake: null,
             stopRead,
           }
@@ -439,36 +451,51 @@ export function createRedisNotifyStore(options: {
 
           /**
            * Moves carried events that continue this feed's sequence into
-           * the buffer. A gap, a message without events, or an unreadable
-           * message marks the feed dirty so it catches up with XRANGE.
+           * the buffer. Writers publish after their scripts, so concurrent
+           * writers' wake-ups can arrive out of order: they apply in index
+           * order, and one past a gap is held until the gap fills or
+           * NOTIFY_TIMINGS.reorderMs passes. A message without events past
+           * the buffer, or an unreadable one, marks the feed dirty so it
+           * catches up with XRANGE.
            */
           const applyInbox = (): void => {
-            feed.bytes = 0
+            const carried = feed.held.splice(0)
+            let announced = 0
             for (const message of feed.inbox.splice(0)) {
               const wake = parseWake(message)
-              if (!wake) {
-                feed.dirty = true
+              if (!wake) feed.dirty = true
+              else if (wake.entries.length === 0)
+                announced = Math.max(announced, wake.frontier)
+              else carried.push({ wake, bytes: message.length })
+            }
+            carried.sort(
+              (a, b) => a.wake.entries[0]![0] - b.wake.entries[0]![0],
+            )
+            feed.bytes = 0
+            for (const held of carried) {
+              if (
+                held.wake.entries[0]![0] >
+                (buffer.at(-1)?.index ?? last) + 1
+              ) {
+                feed.held.push(held)
+                feed.bytes += held.bytes
                 continue
               }
-              for (const [index, id, type, payload] of wake.entries) {
-                const expected = (buffer.at(-1)?.index ?? last) + 1
-                if (index < expected) continue
-                if (index > expected) {
-                  feed.dirty = true
-                  break
-                }
+              for (const [index, id, type, payload] of held.wake.entries) {
+                if (index <= (buffer.at(-1)?.index ?? last)) continue
                 buffer.push({
                   id,
                   type,
                   payload,
                   index,
                   sessionId,
-                  createdAt: new Date(wake.createdAt),
+                  createdAt: new Date(held.wake.createdAt),
                 })
               }
-              if (wake.frontier > (buffer.at(-1)?.index ?? last))
-                feed.dirty = true
             }
+            if (announced > (buffer.at(-1)?.index ?? last)) feed.dirty = true
+            if (feed.held.length === 0) feed.gapSince = undefined
+            else feed.gapSince ??= Date.now()
           }
 
           const iterator: AsyncIterator<Event> = {
@@ -515,8 +542,14 @@ export function createRedisNotifyStore(options: {
                       feeds.set(channel, set)
                     }
                     set.add(feed)
+                    // A feed starts at the latest clear at the earliest:
+                    // entries below it await reclaim.
                     // oxlint-disable-next-line no-await-in-loop -- one-time setup
-                    await acquireChannel(channel)
+                    const [, clearIndex] = await Promise.all([
+                      acquireChannel(channel),
+                      core.clearIndex(sessionId),
+                    ])
+                    if (clearIndex - 1 > last) last = clearIndex - 1
                     if (closed || severed) continue
                   }
                   if (options.polling?.()) {
@@ -552,8 +585,16 @@ export function createRedisNotifyStore(options: {
                   }
                   applyInbox()
                   if (buffer.length > 0) continue
+                  if (
+                    feed.gapSince !== undefined &&
+                    Date.now() - feed.gapSince >= NOTIFY_TIMINGS.reorderMs
+                  )
+                    feed.dirty = true
                   if (feed.dirty) {
                     feed.dirty = false
+                    // A read covers whatever the held wake-ups carry.
+                    feed.held.length = 0
+                    feed.gapSince = undefined
                     if (core.streamEvents) {
                       // oxlint-disable-next-line no-await-in-loop -- begin an incremental catch-up
                       const result = await nextRead(last)
@@ -566,12 +607,21 @@ export function createRedisNotifyStore(options: {
                     if (buffer.length >= FEED_PAGE_SIZE) feed.dirty = true
                     continue
                   }
-                  // Caught up: park until a message, a reconnect, or the
-                  // safety read that heals a lost message.
+                  // Caught up: park until a message, a reconnect, the end of
+                  // a held gap, or the safety read that heals a lost message.
                   const woken = new Promise<'wake'>((resolve) => {
                     feed.wake = () => resolve('wake')
                   })
-                  pending = defaultSleep(NOTIFY_TIMINGS.safetyReadMs)
+                  const holding = feed.gapSince !== undefined
+                  pending = defaultSleep(
+                    holding
+                      ? Math.max(
+                          0,
+                          NOTIFY_TIMINGS.reorderMs -
+                            (Date.now() - feed.gapSince!),
+                        )
+                      : NOTIFY_TIMINGS.safetyReadMs,
+                  )
                   // oxlint-disable-next-line no-await-in-loop -- live-feed loop
                   const outcome = await Promise.race([
                     woken,
@@ -579,7 +629,7 @@ export function createRedisNotifyStore(options: {
                   ])
                   pending.cancel()
                   pending = null
-                  if (outcome === 'timer') feed.dirty = true
+                  if (outcome === 'timer' && !holding) feed.dirty = true
                 } catch (err) {
                   release()
                   if (closed) return { value: undefined, done: true }

package/src/store-redis.ts

@@ -15,9 +15,8 @@
  *
  * Works with any Redis-protocol server on a single instance or a
  * non-cluster provider (Upstash — durable by default — Redis, Valkey).
- * Cluster mode is out: the atomic scripts span keys. `ioredis` is an
- * optional peer dependency; pass `url`, or inject any client exposing
- * `call`/`duplicate`/`on`/`disconnect`.
+ * `ioredis` is an optional peer dependency; pass `url`, or inject any client
+ * exposing `call`/`duplicate`/`on`/`disconnect`.
  */
 
 import { A2Error } from './errors.ts'