experimental-a2 0.21.1 → 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
           }
@@ -299,8 +303,9 @@ export function createRedisNotifyStore(options: {
 
     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) {
@@ -308,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)
         )
       },
@@ -417,6 +425,8 @@ export function createRedisNotifyStore(options: {
             inbox: [],
             bytes: 0,
             dirty: true,
+            held: [],
+            gapSince: undefined,
             wake: null,
             stopRead,
           }
@@ -441,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> = {
@@ -517,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?.()) {
@@ -554,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)
@@ -568,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,
@@ -581,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'

package/src/store-sqlite.ts

@@ -75,7 +75,9 @@ create table if not exists a2_events (
   primary key (session_id, idx)
 ) strict;
 
-create unique index if not exists a2_events_event_id on a2_events (event_id);
+create unique index if not exists a2_events_session_event_id
+  on a2_events (session_id, event_id);
+drop index if exists a2_events_event_id;
 create index if not exists a2_events_types on a2_events (session_id, event_type, idx);
 
 create table if not exists a2_cursors (
@@ -485,6 +487,8 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
         set completed_idx = ?, completed_attempt = ?, returned_event_ids = ?
       where session_id = ? and consumer = ? and cursor_key = ?`,
   )
+  // A JSON null value is a tombstone: a delete's `at`, kept until it
+  // expires so an older set arriving after it still loses.
   const upsertPresence = db.prepare(
     `insert into a2_presence (ns, participant, field, value, seen, at, expires_at)
      values (?, ?, ?, ?, ?, ?, ?)
@@ -493,11 +497,7 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
        seen = excluded.seen,
        at = excluded.at,
        expires_at = excluded.expires_at
-     where a2_presence.at <= excluded.at`,
-  )
-  const deletePresence = db.prepare(
-    `delete from a2_presence
-      where ns = ? and participant = ? and field = ? and at <= ?`,
+     where a2_presence.at <= excluded.at or a2_presence.expires_at <= ?`,
   )
   const sweepPresence = db.prepare(
     'delete from a2_presence where ns = ? and expires_at <= ?',
@@ -505,13 +505,13 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
   const selectPresence = db.prepare(
     `select participant, field, value, seen, at, expires_at
        from a2_presence
-      where ns = ? and expires_at > ?
+      where ns = ? and expires_at > ? and value != 'null'
       order by participant, field`,
   )
   const selectByIds = (count: number) =>
     db.prepare(
       `select * from a2_events
-        where event_id in (${placeholders(count)})
+        where session_id = ? and event_id in (${placeholders(count)})
         order by idx`,
     )
 
@@ -561,8 +561,8 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
   }
 
   /**
-   * The rows owning `ids`. This session's rows below its clear marker do
-   * not own their ids: they are deleted here so the ids can be reused.
+   * The session's rows owning `ids`. Rows below its clear marker do not
+   * own their ids: they are deleted here so the ids can be reused.
    */
   const liveOwnersOf = (
     sessionId: string,
@@ -570,10 +570,12 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
     ids: readonly string[],
   ): EventRow[] => {
     if (ids.length === 0) return []
-    const rows = selectByIds(ids.length).all(...ids) as unknown as EventRow[]
+    const rows = selectByIds(ids.length).all(
+      sessionId,
+      ...ids,
+    ) as unknown as EventRow[]
     return rows.filter((row) => {
-      if (row.session_id !== sessionId || Number(row.idx) >= clearIndex)
-        return true
+      if (Number(row.idx) >= clearIndex) return true
       deleteEventById.run(sessionId, row.event_id)
       return false
     })
@@ -851,15 +853,6 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
           if (suppliedIds.length > 0) {
             const existing = liveOwnersOf(sessionId, clearIndex, suppliedIds)
             if (existing.length > 0) {
-              const foreign = existing.find(
-                (row) => row.session_id !== sessionId,
-              )
-              if (foreign) {
-                throw new A2Error(
-                  'PARTIAL_DUPLICATE_BATCH',
-                  `event id '${foreign.event_id}' already exists in another session`,
-                )
-              }
               if (existing.length === events.length) {
                 return {
                   events: idempotentReplay(events, existing.map(toStored)),
@@ -1244,7 +1237,10 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             const existing =
               ids.length === 0
                 ? []
-                : (selectByIds(ids.length).all(...ids) as unknown as EventRow[])
+                : (selectByIds(ids.length).all(
+                    sessionId,
+                    ...ids,
+                  ) as unknown as EventRow[])
             const byId = new Map(existing.map((row) => [row.event_id, row]))
             const ordered = ids.map((id) => byId.get(id))
             if (
@@ -1252,7 +1248,6 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
                 const cause = row ? decodeCause(row.cause) : null
                 return (
                   !row ||
-                  row.session_id !== sessionId ||
                   cause?.consumer !== consumer ||
                   cause.lane !== lane ||
                   cause.index !== index ||
@@ -1681,23 +1676,22 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             const atMs = meta.at.getTime()
             // Expiry anchors on the storage clock — the sender's `at`
             // orders writes but never anchors their lifetime.
-            const expiresAtMs = clock.now().getTime() + meta.ttlMs
+            const nowMs = clock.now().getTime()
+            const expiresAtMs = nowMs + meta.ttlMs
             for (const [field, value] of entries) {
-              // Field-wise LWW: a stored row with a strictly newer `at`
-              // survives; ties go to the incoming write (memory parity).
-              if (value === null) {
-                deletePresence.run(ns, participant, field, atMs)
-              } else {
-                upsertPresence.run(
-                  ns,
-                  participant,
-                  field,
-                  JSON.stringify(value) ?? 'null',
-                  meta.seen,
-                  atMs,
-                  expiresAtMs,
-                )
-              }
+              // Field-wise LWW against values and tombstones alike: an
+              // unexpired stored row with a strictly newer `at` survives;
+              // ties go to the incoming write (memory parity).
+              upsertPresence.run(
+                ns,
+                participant,
+                field,
+                JSON.stringify(value) ?? 'null',
+                meta.seen,
+                atMs,
+                expiresAtMs,
+                nowMs,
+              )
             }
           }),
         )

package/src/store.ts

@@ -300,6 +300,8 @@ export interface A2Store {
    * lost — return the existing rows as success. If only *some* ids
    * exist, the caller mixed an already-sent batch with fresh events —
    * always a caller bug — so throw `A2Error('PARTIAL_DUPLICATE_BATCH')`.
+   * Ids are unique per session: the same id in another session names a
+   * different event and plays no part in these checks.
    *
    * In the same atomic operation, each event's `targets` start cursor work:
    * a lane target queues the event in that consumer's lane, a null lane
@@ -538,11 +540,15 @@ export interface A2Store {
   presence?: {
     /**
      * Field-wise last-writer-wins merge of one participant's values:
-     * a field whose existing row has a strictly newer `at` (the
-     * sender's stamp) is left untouched; `null` deletes the row. Every
-     * applied write refreshes that field's expiry to the storage's own
+     * a field whose unexpired entry has a strictly newer `at` (the
+     * sender's stamp) is left untouched. `null` deletes the value but
+     * keeps a tombstone with its `at`, which takes part in the merge
+     * like a value until it expires, so a set older than the delete
+     * still loses when it arrives later. Every applied write, value or
+     * tombstone, refreshes that field's expiry to the storage's own
      * clock plus `ttlMs` — the sender stamp orders writes but never
-     * anchors their lifetime.
+     * anchors their lifetime. `subscribe` delivers applied writes only,
+     * a delete as `null`.
      */
     set(
       ns: string,
@@ -551,7 +557,10 @@ export interface A2Store {
       meta: { seen: number; at: Date; ttlMs: number },
     ): Promise<void>
 
-    /** The current map, pruned of rows at or past their `expiresAt`. */
+    /**
+     * The current map, pruned of rows at or past their `expiresAt`.
+     * Tombstones never appear.
+     */
     read(ns: string): Promise<PresenceRow[]>
 
     /**

package/dist/actor-HnGmrOZZ.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"actor-HnGmrOZZ.d.ts","names":[],"sources":["../src/actor-shared.ts","../src/actor.ts"],"mappings":";;;;;;;;;;;cAiCa,0BAA0B;;WAE5B;;WAEA;EACT,YAAY,eAAe,mBAAmB;;;;;;;;;KAepC;EACV;EACA;;;;;;;EAOA;;;KAIU,gBAAgB,UAAU,iBAAiB;EACrD,gBAAgB;IAEd;;KAIQ,oBAAoB,QAC7B,WAAW,cAAc,EAAE;;;;;;KAQlB,iBAAiB;GAExB,yBAAA,WAAW;IAAgB,OAAO,EAAE;IAAI;IAAc,IAAI;;;;;;;;;;;;KAanD,UAAU,iBACV,WAAW,eAAe,EAAE,MACjC,QAAQ,EAAE,eACV,OAAO,EAAE;;;;;;;;;KAWJ,uBAAuB;EAAmB;;;;;;;;;;;;KAY1C,kBAAkB,iBAClB,WAAW,eAAe,EAAE,MACjC,OAAO,EAAE,gBAAgB,SAAS,yBAAyB,iBAC3D,OAAO,EAAE,IAAI,SAAS,yBAAyB;;KAI1C,aAAa,UAAU;;EAEjC,OAAO;;EAEP;;EAEA;;EAEA,QAAQ;;EAER,MAAM,UAAU;;EAEhB,UAAU,kBAAkB;;;;;;;;KASlB,uBAAuB,UAAU;;EAE3C;;EAEA;;EAEA,QAAQ;;EAER,SAAS;IAAU,OAAO;IAAY;;;EAEtC,MAAM,UAAU;;EAEhB,UAAU,kBAAkB;;KAGlB,kBAAkB;EAC5B,OAAO;;EAEP;;EAEA;;EAEA;;;KAWU,qBAAqB;EAC/B,kBAAkB,iBAAiB,kBAAkB;;;;;;;;;;;;;;KClE3C,aAAa,UAAU,eAAe,gBAAgB,iBAC5D,KAAK,aAAa,IAAI,OAAO,YAAY,cAAc;EAEvD;EACA,SACE,KAAK,uBAAuB,IAC5B,OAAO,YAAY,cACT;;;;;;;;;;;;;;;;iBAiBF,WAAW,KAAK,GAC9B,SAAS,KAAK,KAAK,OAAO,aAAa;EACpC;EAAkB,SAAS,KAAK,KAAK,OAAO,aAAa;;KAIlD,aAAa,UAAU;;EAEjC;;EAEA,OAAO;;;;;EAKP,aAAa,WAAW,cAAc,aAAa,GAAG;EACtD,QAAQ;EACR,YAAY;EACZ,YAAY;MACR,gBAAgB;EAChB;;;;;;;;;;;;EAYA;;;;;;;KAQM;WACG;WAAwB;;WAExB;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;;WAGA;WACA;WACA;WACA,QAAQ,SAAS;;KAGpB,kBAAkB,UAAU;;EAEtC,aAAa,WAAW,6BAA6B;;;;;;;;;;;;EAYrD,QAAQ,OAAO;;KAGL;;EAEV;;KAGU,mBAAmB;;EAE7B;;KAGU,gBAAgB;;EAE1B,OAAO;;EAEP;;;;;EAKA;;KAGG,WACH,UAAU,eACV,gBAAgB,0BACH,YAAY,MAErB,QAAQ,YAAY,IACpB,UAAU,qBACP,QAAQ,gBAAgB,gBAE3B,OAAO,YAAY,IACnB,UAAU,qBACP,QAAQ,gBAAgB;KAE5B,WACH,UAAU,eACV,gBAAgB,0BACH,YAAY,MAErB,QAAQ,YAAY,IACpB,UAAU,qBACP;EAAU;EAAY;MAEzB,OAAO,YAAY,IACnB,UAAU,qBACP;EAAU;EAAY;;;KAGnB,YAAY,UAAU;WACvB;;;;;;;;WAQA,kBAAkB,WAAW,cAAc,WAAW,GAAG;;WAEzD,kBAAkB,WAAW,cAAc,WAAW,GAAG;;WAEzD,aAAa,QAAQ,gBAAgB;;;;;;;;;;;WAWrC,QACP,SAAS,SACT,UAAU,kBAAkB,OACzB,QAAQ;;WAEJ,SAAS,QAAQ;;KAGhB,gBAAgB,UAAU;WAC3B;;;;;;WAMA,WAAW;;WAEX,UAAU,SAAS;;WAEnB,QAAQ,SAAS;;WAEjB,SAAS,QAAQ,qBAAqB,aAAa;EAC5D,MAAM,aAAa,YAAY;;;;;;;iBAsDjB,MAAM,UAAU,eAC9B,SAAS,aAAa,KACrB,gBAAgB"}