experimental-a2 0.21.1 → 0.23.0

package/src/store-postgres.ts

@@ -570,9 +570,9 @@ const INSERTED_AFTER = `(
 
 /**
  * An append's checks, under the session lock: the session's head and pending
- * state, and what its supplied `ids` say. When every event's id belongs to
- * this session already, the batch is a retry: it stops with the committed
- * rows. Some owned, or one in another session, aborts, as does scheduled work
+ * state, and what its supplied `ids` say. Ids are unique per session. When
+ * every event's id belongs to this session already, the batch is a retry: it
+ * stops with the committed rows. Some owned aborts, as does scheduled work
  * from at or below the clear marker (`origin`). Rows below the marker own no
  * id.
  */
@@ -586,15 +586,11 @@ const APPEND_CHECKS = `
     select event.session_id, event.idx, event.event_type, event.payload,
            event.event_id, event.created_at, event.cause
       from a2_events event, boundary
-     where event.event_id = any(${param.texts('ids')})
-       and not (event.session_id = ${SESSION}
-                and event.idx < boundary.clear_index)
+     where event.session_id = ${SESSION}
+       and event.event_id = any(${param.texts('ids')})
+       and event.idx >= boundary.clear_index
   )
   select case
-    when exists (select 1 from owned where session_id <> ${SESSION}) then
-      jsonb_build_object('abort', 'foreign', 'event_id', (
-        select event_id from owned where session_id <> ${SESSION}
-         order by idx limit 1))
     when (select count(*) from owned) = ${param.bigint('count')} then
       jsonb_build_object('stop', 'replay',
         'has_pending', boundary.has_pending,
@@ -1083,9 +1079,9 @@ const RETURN_CHECKS = `
       jsonb_build_object('stop', 'superseded')
     when exists (
       select 1 from a2_events event
-       where event.event_id = any(${param.texts('ids')})
-         and not (event.session_id = ${SESSION}
-                  and event.idx < ${clearIndexOf(SESSION)})
+       where event.session_id = ${SESSION}
+         and event.event_id = any(${param.texts('ids')})
+         and event.idx >= ${clearIndexOf(SESSION)}
     ) then jsonb_build_object('abort', 'owned')
     else jsonb_build_object('base', (
       select coalesce(max(idx), 0) from a2_events
@@ -1737,8 +1733,8 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
     if (events.length === 0) return { outcome: 'completed', events: [] }
     const { rows: existing } = await query(
       `select session_id, idx, event_type, payload, event_id, created_at, cause
-         from a2_events where event_id = any($1::text[])`,
-      [ids],
+         from a2_events where session_id = $1 and event_id = any($2::text[])`,
+      [sessionId, ids],
     )
     const byId = new Map(
       existing.map((row) => [row['event_id'] as string, row]),
@@ -1754,7 +1750,6 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
         const cause = row ? decodeCause(row['cause']) : null
         return (
           !row ||
-          row['session_id'] !== sessionId ||
           cause?.consumer !== consumer ||
           cause.lane !== lane ||
           cause.index !== index ||
@@ -1849,11 +1844,6 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
           },
           abort: (reason) => {
             switch (reason['abort']) {
-              case 'foreign':
-                return new A2Error(
-                  'PARTIAL_DUPLICATE_BATCH',
-                  `event id '${String(reason['event_id'])}' already exists in another session`,
-                )
               case 'mixed': {
                 const owned = asNumber(reason['owned'])
                 return new A2Error(
@@ -2710,40 +2700,38 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
           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
           const applied: Record<string, unknown> = nullProtoRecord()
           const write = async (query: Query): Promise<void> => {
             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).
+              // Field-wise LWW against values and tombstones (a JSON null
+              // value, a delete's `at` kept until it expires) alike: an
+              // unexpired stored row with a strictly newer `at` survives;
+              // ties go to the incoming write (memory parity).
               // oxlint-disable-next-line no-await-in-loop -- independent per-field registers
-              const result = await (value === null
-                ? query(
-                    `delete from a2_presence
-                    where ns = $1 and participant = $2 and field = $3
-                      and at <= $4${notifications ? ' returning field' : ''}`,
-                    [ns, participant, field, atMs],
-                  )
-                : query(
-                    `insert into a2_presence
-                     (ns, participant, field, value, seen, at, expires_at)
-                   values ($1, $2, $3, $4::jsonb, $5, $6, $7)
-                   on conflict (ns, participant, field) do update set
-                     value = excluded.value,
-                     seen = excluded.seen,
-                     at = excluded.at,
-                     expires_at = excluded.expires_at
-                   where a2_presence.at <= excluded.at${notifications ? ' returning field' : ''}`,
-                    [
-                      ns,
-                      participant,
-                      field,
-                      jsonb(value),
-                      meta.seen,
-                      atMs,
-                      expiresAtMs,
-                    ],
-                  ))
+              const result = await query(
+                `insert into a2_presence
+                   (ns, participant, field, value, seen, at, expires_at)
+                 values ($1, $2, $3, $4::jsonb, $5, $6, $7)
+                 on conflict (ns, participant, field) do update set
+                   value = excluded.value,
+                   seen = excluded.seen,
+                   at = excluded.at,
+                   expires_at = excluded.expires_at
+                 where a2_presence.at <= excluded.at
+                    or a2_presence.expires_at <= $8${notifications ? ' returning field' : ''}`,
+                [
+                  ns,
+                  participant,
+                  field,
+                  jsonb(value),
+                  meta.seen,
+                  atMs,
+                  expiresAtMs,
+                  nowMs,
+                ],
+              )
               if (result.rows.length) applied[field] = structuredClone(value)
             }
           }
@@ -2781,7 +2769,7 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
              )
              select participant, field, value, seen, at, expires_at
                from a2_presence
-              where ns = $1 and expires_at > $2
+              where ns = $1 and expires_at > $2 and value <> 'null'::jsonb
               order by participant, field`,
             [ns, now],
           )
@@ -3025,7 +3013,9 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
       const subscription = presenceSubscriptions.get(ns)
       await subscription?.ready
       await subscription?.poll.ready
-      return read(ns)
+      return subscription
+        ? subscription.poll.snapshot(() => read(ns))
+        : read(ns)
     }
     presence.subscribe = (ns, onPatch) => {
       if (closed) throw new A2Error('STORE_UNAVAILABLE', 'the store was closed')

package/src/store-presence-polling.ts

@@ -19,6 +19,11 @@ export function pollPresence({
   sleep?: (ms: number) => Sleeper
 }): {
   ready: Promise<void>
+  /**
+   * Runs a foreground snapshot read and counts it as a poll, so a stamp a
+   * viewer paints from it is one later deletes carry.
+   */
+  snapshot(read: () => Promise<PresenceRow[]>): Promise<PresenceRow[]>
   update(patch: PresencePatch): void
   wake(): void
   stop(): void
@@ -45,6 +50,46 @@ export function pollPresence({
     // Seeding is best effort; foreground snapshots still report read errors.
     .catch(() => undefined)
 
+  /** Delivers how `rows` differ from what was seen; true when they do. */
+  const reconcile = (rows: PresenceRow[]): boolean => {
+    const live = new Set<string>()
+    let changed = false
+    for (const row of rows) {
+      const id = key(row)
+      live.add(id)
+      const prior = seen.get(id)
+      seen.set(id, row)
+      if (
+        prior?.seen === row.seen &&
+        prior.at.getTime() === row.at.getTime() &&
+        JSON.stringify(prior.value) === JSON.stringify(row.value)
+      )
+        continue
+      changed = true
+      deliver({
+        participant: row.participant,
+        values: { [row.field]: row.value },
+        seen: row.seen,
+        at: row.at,
+      })
+    }
+    for (const [id, row] of seen) {
+      if (live.has(id)) continue
+      seen.delete(id)
+      changed = true
+      deliver({
+        participant: row.participant,
+        values: { [row.field]: null },
+        seen: row.seen,
+        // The last seen stamp, never this poller's clock: only
+        // senders' clocks order the plane, and an observer-stamped
+        // delete could outrank the sender's next set.
+        at: row.at,
+      })
+    }
+    return changed
+  }
+
   const run = async (): Promise<void> => {
     await ready
     for (;;) {
@@ -60,39 +105,7 @@ export function pollPresence({
         const rows = await read()
         if (stopped) return
         if (version !== reading) continue
-        const live = new Set<string>()
-        let changed = false
-        for (const row of rows) {
-          const id = key(row)
-          live.add(id)
-          const prior = seen.get(id)
-          seen.set(id, row)
-          if (
-            prior?.seen === row.seen &&
-            prior.at.getTime() === row.at.getTime() &&
-            JSON.stringify(prior.value) === JSON.stringify(row.value)
-          )
-            continue
-          changed = true
-          deliver({
-            participant: row.participant,
-            values: { [row.field]: row.value },
-            seen: row.seen,
-            at: row.at,
-          })
-        }
-        for (const [id, row] of seen) {
-          if (live.has(id)) continue
-          seen.delete(id)
-          changed = true
-          deliver({
-            participant: row.participant,
-            values: { [row.field]: null },
-            seen: row.seen,
-            at: new Date(),
-          })
-        }
-        if (changed) activate()
+        if (reconcile(rows)) activate()
         else if (version === before)
           interval = Math.min(interval * 2, POLL_TIMINGS.idleCeilingMs)
       } catch {
@@ -103,10 +116,22 @@ export function pollPresence({
   void run()
   return {
     ready,
+    async snapshot(readSnapshot) {
+      const reading = version
+      const rows = await readSnapshot()
+      if (!stopped && version === reading && reconcile(rows)) activate()
+      return rows
+    },
     wake: activate,
     update(patch) {
       for (const [field, value] of Object.entries(patch.values)) {
-        seen.set(key({ participant: patch.participant, field }), {
+        const id = key({ participant: patch.participant, field })
+        // A deleted field is one the next read should not find.
+        if (value === null) {
+          seen.delete(id)
+          continue
+        }
+        seen.set(id, {
           participant: patch.participant,
           field,
           value,