experimental-a2 0.21.1 → 0.22.0

package/src/internal.ts

@@ -299,6 +299,21 @@ export const DRAIN_TIMINGS: {
   failureRetryMaxMs: 30_000,
 }
 
+/**
+ * How many kernels a harness keeps, per agent, for the next step of a session
+ * in its process. Mutable only as a white-box test seam; production always
+ * uses the default.
+ */
+export const HARNESS_PARKING: { maxKernels: number } = { maxKernels: 32 }
+
+/**
+ * Per server: called when a drain of a session ends with nothing left to run
+ * for it in this process, so the layer above can let go of what it kept for
+ * that session's next step.
+ */
+export const drainSettledHooks: WeakMap<object, (sessionId: string) => void> =
+  new WeakMap()
+
 /**
  * Stream liveness knobs — the server-side SSE heartbeat and the
  * client-side stall watchdog. Paired by design: the client declares a
@@ -323,16 +338,22 @@ export const POLL_TIMINGS: {
 }
 
 /**
- * Safety-read cadence for the notify-driven redis live stream. A
- * parked feed re-reads the store at this interval even without a
- * pub/sub wake-up, so a lost notification (subscriber reconnect gap,
- * dropped PUBLISH) costs latency, never an event. Mutable only as a
- * white-box test seam.
+ * Timings for the notify-driven redis live stream. A parked feed re-reads
+ * the store every `safetyReadMs` even without a pub/sub wake-up, so a lost
+ * notification (subscriber reconnect gap, dropped PUBLISH) costs latency,
+ * never an event. Writers publish after their scripts, so wake-ups from
+ * concurrent writers can arrive out of order: a feed holds a gap for
+ * `reorderMs` before catching up with a read, and a write waits at most
+ * `publishMs` for its PUBLISH. Mutable only as a white-box test seam.
  */
 export const NOTIFY_TIMINGS: {
   safetyReadMs: number
+  reorderMs: number
+  publishMs: number
 } = {
   safetyReadMs: 10_000,
+  reorderMs: 50,
+  publishMs: 1_000,
 }
 
 /**
@@ -422,15 +443,25 @@ export const SOCKET_TIMINGS: {
 }
 
 /**
- * Client presence send cadence — a leading send immediately, then at
- * most one merged send per interval (~15Hz). Owned, not configurable
- * (decision #36's rule): coupling the cadence to the POST ack tied
- * remote cursor smoothness to RTT, and the ack serves no correctness
- * purpose on a fire-and-forget LWW plane. Mutable only as a white-box
- * test seam.
+ * Presence timings. Owned, not configurable (decision #36's rule).
+ * Mutable only as a white-box test seam.
  */
 export const PRESENCE_TIMINGS: {
+  /**
+   * Client send cadence — a leading send immediately, then at most one
+   * merged send per interval (~15Hz). Coupling the cadence to the POST
+   * ack tied remote cursor smoothness to RTT, and the ack serves no
+   * correctness purpose on a fire-and-forget LWW plane.
+   */
   sendIntervalMs: number
+  /**
+   * How long, in local receipt time, a presence applier keeps a deleted
+   * field's stamp so an older set delivered after the delete still
+   * loses. Reorders span milliseconds; the bound keeps a long-lived
+   * client with churning participants from accumulating tombstones.
+   */
+  tombstoneMs: number
 } = {
   sendIntervalMs: 66,
+  tombstoneMs: 60_000,
 }

package/src/presence-recovery.ts

@@ -1,4 +1,5 @@
 import type { PresencePatch } from './contract.ts'
+import { presenceTombstones } from './presence-tombstones.ts'
 import type { PresenceRow } from './store.ts'
 
 type Field = Pick<PresenceRow, 'participant' | 'field' | 'seen' | 'at'>
@@ -22,6 +23,7 @@ export function presenceRecovery({
   update(patch: PresencePatch): void
 } {
   const fields = new Map<string, Field>()
+  const deleted = presenceTombstones()
   const reading = new Set<Set<string>>()
   let generation = 0
   let latest: Promise<PresenceRow[]> | undefined
@@ -49,11 +51,14 @@ export function presenceRecovery({
       const rows = await read()
       if (!isActive()) return rows
       if (run !== generation) return latest!
+      // A row older than its field's deletion must not resurrect it.
+      const current = rows.filter((row) => !deleted.outranks(row))
       const live = new Set<string>()
-      for (const row of rows) {
+      for (const row of current) {
         const id = key(row)
         live.add(id)
         if (changed.has(id)) continue
+        deleted.drop(row)
         remember(row)
         if (reconcile)
           deliver({
@@ -68,6 +73,7 @@ export function presenceRecovery({
           if (live.has(id) || changed.has(id) || fields.get(id) !== prior)
             continue
           fields.delete(id)
+          deleted.keep(prior)
           deliver({
             participant: prior.participant,
             values: { [prior.field]: null },
@@ -76,7 +82,7 @@ export function presenceRecovery({
           })
         }
       }
-      return rows
+      return current
     } finally {
       reading.delete(changed)
       if (reading.size === 0) latest = undefined
@@ -102,18 +108,19 @@ export function presenceRecovery({
     update(patch) {
       for (const [field, value] of Object.entries(patch.values)) {
         if (value === undefined) continue
-        const id = key({ participant: patch.participant, field })
+        const write = { participant: patch.participant, field, at: patch.at }
+        const id = key(write)
         const previous = fields.get(id)
         if (previous && previous.at.getTime() > patch.at.getTime()) continue
+        if (deleted.outranks(write)) continue
         for (const changed of reading) changed.add(id)
-        if (value === null) fields.delete(id)
-        else
-          remember({
-            participant: patch.participant,
-            field,
-            seen: patch.seen,
-            at: patch.at,
-          })
+        if (value === null) {
+          fields.delete(id)
+          deleted.keep(write)
+        } else {
+          deleted.drop(write)
+          remember({ ...write, seen: patch.seen })
+        }
       }
     },
   }

package/src/presence-tombstones.ts

@@ -0,0 +1,52 @@
+import { PRESENCE_TIMINGS } from './internal.ts'
+
+type PresenceField = { participant: string; field: string }
+type PresenceWrite = PresenceField & { at: Date }
+
+/**
+ * The deletion stamps a presence applier keeps per (participant, field),
+ * so a null keeps beating older sets that arrive after it. Each lives
+ * `PRESENCE_TIMINGS.tombstoneMs` of local receipt time and is pruned
+ * lazily on use, without timers.
+ */
+export type PresenceTombstones = {
+  /** Whether the field's deletion is strictly newer than the write. */
+  outranks(write: PresenceWrite): boolean
+  /** Keep the deletion; the caller has already ordered it past any prior one. */
+  keep(deletion: PresenceWrite): void
+  /** Forget the field's deletion once a write at or past it applies. */
+  drop(field: PresenceField): void
+}
+
+const key = ({ participant, field }: PresenceField): string =>
+  JSON.stringify([participant, field])
+
+export function presenceTombstones(): PresenceTombstones {
+  // Insertion order is receipt order, so pruning stops at the first
+  // tombstone still inside the window.
+  const stamps = new Map<string, { atMs: number; keptAtMs: number }>()
+  const prune = (): void => {
+    const cutoff = Date.now() - PRESENCE_TIMINGS.tombstoneMs
+    for (const [id, stamp] of stamps) {
+      if (stamp.keptAtMs > cutoff) return
+      stamps.delete(id)
+    }
+  }
+  return {
+    outranks(write) {
+      if (stamps.size === 0) return false
+      prune()
+      const stamp = stamps.get(key(write))
+      return stamp !== undefined && stamp.atMs > write.at.getTime()
+    },
+    keep(deletion) {
+      prune()
+      const id = key(deletion)
+      stamps.delete(id)
+      stamps.set(id, { atMs: deletion.at.getTime(), keptAtMs: Date.now() })
+    },
+    drop(field) {
+      if (stamps.size > 0) stamps.delete(key(field))
+    },
+  }
+}

package/src/push-envelope.ts

@@ -107,8 +107,8 @@ export function parsePushEvents(events: unknown): ParsedPushEvent[] {
       )
     }
     // A2 derives the ids of what consumers append, return, and schedule as
-    // UUIDv5s, from inputs a caller can know: one pushed first would take its
-    // place. Callers' own ids are v4 (crypto.randomUUID) or v8 (idempotentId).
+    // UUIDv5s, from inputs a caller can know: one pushed first into the same
+    // session would take its place. Callers' own ids are v4 (crypto.randomUUID) or v8 (idempotentId).
     if (id !== undefined && DERIVED_ID.test(id)) {
       throw invalid(
         `events[${i}].id is shaped like the ids A2 derives for consumers (a UUIDv5); use crypto.randomUUID() or idempotentId()`,

package/src/server.ts

@@ -34,6 +34,7 @@ import {
   runtimeConsumerFactory,
   runtimeConsumers,
   serverInternals,
+  drainSettledHooks,
   type DrainOutcome,
   type DrainResult,
 } from './internal.ts'
@@ -43,6 +44,7 @@ import {
   type SessionCleared,
 } from './session-clear.ts'
 import { boundedCache } from './bounded-cache.ts'
+import { presenceTombstones } from './presence-tombstones.ts'
 import { defaultSleep, type Sleeper } from './store-polling.ts'
 import { createStreamActivity, streamActivities } from './stream-activity.ts'
 import {
@@ -2529,11 +2531,13 @@ export function createServer<
       }
 
       // What this feed has already painted, per (participant, field) —
-      // the comparison state for re-read diffs.
+      // the comparison state for re-read diffs and for queued patches,
+      // with the stamps of painted nulls kept beside it.
       const painted = new Map<
         string,
         Map<string, { seen: number; atMs: number; value: string }>
       >()
+      const paintedDeletes = presenceTombstones()
 
       // One patch per (participant, field), never merged — a merged
       // stamp would let a stale field inherit a fresher sibling's
@@ -2582,10 +2586,12 @@ export function createServer<
             patches.push({
               participant,
               values: { [field]: null },
-              // A cleared field has no surviving row; its last painted
-              // `seen` and the observation time are the honest stamps.
+              // A cleared field has no surviving row, so it keeps its
+              // last painted stamps: only senders' clocks order the
+              // plane, and an observer-stamped delete could outrank the
+              // sender's next set.
               seen: prior.seen,
-              at: new Date(),
+              at: new Date(prior.atMs),
             })
           }
           if (fields.size === 0) painted.delete(participant)
@@ -2596,10 +2602,13 @@ export function createServer<
       const paint = (patch: PresencePatch): void => {
         let fields = painted.get(patch.participant)
         for (const [field, value] of Object.entries(patch.values)) {
+          const write = { participant: patch.participant, field, at: patch.at }
           if (value === null || value === undefined) {
             fields?.delete(field)
+            if (value === null) paintedDeletes.keep(write)
             continue
           }
+          paintedDeletes.drop(write)
           if (!fields) {
             fields = new Map()
             painted.set(patch.participant, fields)
@@ -2644,11 +2653,23 @@ export function createServer<
         }
         wakeQueue?.()
       }
+      // A queued patch older than what this feed painted for its field —
+      // the live value or its deletion — would repaint the past.
+      const outdated = (
+        write: Pick<PresenceRow, 'participant' | 'field' | 'at'>,
+      ): boolean => {
+        const prior = painted.get(write.participant)?.get(write.field)
+        return (
+          (prior !== undefined && prior.atMs > write.at.getTime()) ||
+          paintedDeletes.outranks(write)
+        )
+      }
       const dequeue = (): PresencePatch | null => {
         for (const [participant, fields] of queue) {
           for (const [field, stamp] of fields) {
             fields.delete(field)
             if (fields.size === 0) queue.delete(participant)
+            if (outdated({ participant, field, at: stamp.at })) continue
             return {
               participant,
               values: { [field]: stamp.value },
@@ -3430,7 +3451,29 @@ export function createServer<
     appendsEvents: boolean
   }
 
-  const drainSession = (
+  type DrainOptions = {
+    watchdogDueAt?: number | undefined
+    signal?: DrainSignal | undefined
+    /** Return a failure after arming as `failed` instead of throwing it. */
+    handOffFailure?: boolean
+    /** Claim and run only this consumer's heads, for `consume`. */
+    only?: RegisteredConsumer | undefined
+    /** With `only`: claim no head past it; what's past it is the background's. */
+    through?: number | undefined
+  }
+
+  const drainSession = async (
+    sessionId: string,
+    drainOptions: DrainOptions = {},
+  ): Promise<DrainResult> => {
+    const result = await runDrain(sessionId, drainOptions)
+    // A settled `only` drain finished one consumer's heads, not the session's.
+    if (result.settled && drainOptions.only === undefined)
+      drainSettledHooks.get(self)?.(sessionId)
+    return result
+  }
+
+  const runDrain = (
     sessionId: string,
     {
       watchdogDueAt,
@@ -3438,16 +3481,7 @@ export function createServer<
       handOffFailure = false,
       only,
       through,
-    }: {
-      watchdogDueAt?: number | undefined
-      signal?: DrainSignal | undefined
-      /** Return a failure after arming as `failed` instead of throwing it. */
-      handOffFailure?: boolean
-      /** Claim and run only this consumer's heads, for `consume`. */
-      only?: RegisteredConsumer | undefined
-      /** With `only`: claim no head past it; what's past it is the background's. */
-      through?: number | undefined
-    } = {},
+    }: DrainOptions = {},
   ): Promise<DrainResult> =>
     telemetry.span(
       'a2.drain',

package/src/store-memory.ts

@@ -74,6 +74,7 @@ type Cursor = {
   types: readonly string[] | null
 }
 
+/** A null `value` is a tombstone: it keeps a delete's `at` until it expires. */
 type PresenceEntry = {
   value: unknown
   seen: number
@@ -88,6 +89,8 @@ type SessionLog = {
   offset: number
   /** Latest clear marker, or 0. */
   clearIndex: number
+  /** The session's unique index on event ids, like the SQL schemas'. */
+  byEventId: Map<string, Row>
 }
 
 const RECLAIM_BATCH = 256
@@ -219,8 +222,6 @@ export function memory(options: MemoryStoreOptions = {}): A2Store {
   const sessions = new Map<string, SessionLog>()
   /** Session id → cursor key → cursor. */
   const cursors = new Map<string, Map<string, Cursor>>()
-  /** Global unique index on event ids, like the SQL schema's. */
-  const byEventId = new Map<string, Row>()
   /** Keyed by `${sessionId}\u0000${reducerName}` — a pure cache. */
   const snapshots = new Map<
     string,
@@ -254,7 +255,7 @@ export function memory(options: MemoryStoreOptions = {}): A2Store {
   const logOf = (sessionId: string): SessionLog => {
     let log = sessions.get(sessionId)
     if (!log) {
-      log = { rows: [], offset: 0, clearIndex: 0 }
+      log = { rows: [], offset: 0, clearIndex: 0, byEventId: new Map() }
       sessions.set(sessionId, log)
     }
     return log
@@ -270,12 +271,11 @@ export function memory(options: MemoryStoreOptions = {}): A2Store {
   const clearIndexOf = (sessionId: string): number =>
     sessions.get(sessionId)?.clearIndex ?? 0
 
-  /** The row owning `id`, ignoring this session's rows below its clear. */
+  /** The session's row owning `id`, ignoring rows below its clear. */
   const ownerOf = (sessionId: string, id: string): Row | undefined => {
-    const row = byEventId.get(id)
-    return row?.sessionId === sessionId && row.index < clearIndexOf(sessionId)
-      ? undefined
-      : row
+    const log = sessions.get(sessionId)
+    const row = log?.byEventId.get(id)
+    return log && row && row.index >= log.clearIndex ? row : undefined
   }
 
   const cursorsOf = (sessionId: string): Map<string, Cursor> => {
@@ -437,17 +437,9 @@ export function memory(options: MemoryStoreOptions = {}): A2Store {
         'batch contains the same event id more than once',
       )
     }
-    const existing = supplied
+    return supplied
       .map((candidate) => ownerOf(sessionId, candidate.id))
       .filter((row): row is Row => row !== undefined)
-    const foreign = existing.find((row) => row.sessionId !== sessionId)
-    if (foreign) {
-      throw new A2Error(
-        'PARTIAL_DUPLICATE_BATCH',
-        `event id '${foreign.id}' already exists in another session`,
-      )
-    }
-    return existing
   }
 
   /** Records the types a declared log consumer takes on its cursor. */
@@ -576,7 +568,7 @@ export function memory(options: MemoryStoreOptions = {}): A2Store {
     }
     for (const row of inserted) {
       log.rows.push(row)
-      byEventId.set(row.id, row)
+      log.byEventId.set(row.id, row)
     }
     enqueue(sessionId, inserted, events, base, consumers)
     return inserted
@@ -760,7 +752,7 @@ export function memory(options: MemoryStoreOptions = {}): A2Store {
       log.offset += removed.length
       for (const row of removed) {
         // A reused id belongs to its new row now.
-        if (byEventId.get(row.id) === row) byEventId.delete(row.id)
+        if (log.byEventId.get(row.id) === row) log.byEventId.delete(row.id)
       }
       const done = log.offset === log.clearIndex - 1
       // Writes below the marker are dropped, so one sweep at the end suffices.
@@ -1226,26 +1218,25 @@ export function memory(options: MemoryStoreOptions = {}): A2Store {
 
         // Expiry anchors on the storage's own clock — the sender's
         // `at` orders writes but never extends or shortens a lifetime.
-        const expiresAtMs = clock.now().getTime() + meta.ttlMs
+        const now = clock.now()
+        const expiresAtMs = now.getTime() + meta.ttlMs
         // Field-keyed and caller-named — null-prototype, like every
         // presence map (see `nullProtoRecord`).
         const applied: Record<string, unknown> = nullProtoRecord()
         let appliedCount = 0
         for (const [field, value] of Object.entries(values)) {
-          // Field-wise LWW by `at`; ties go to the incoming write, so
+          // Field-wise LWW by `at` against unexpired values and
+          // tombstones alike; ties go to the incoming write, so
           // same-stamp sets keep set-then-read intuition.
           const existing = fields.get(field)
-          if (existing && existing.at > meta.at) continue
-          if (value === null) {
-            fields.delete(field)
-          } else {
-            fields.set(field, {
-              value: structuredClone(value),
-              seen: meta.seen,
-              at: new Date(meta.at),
-              expiresAt: new Date(expiresAtMs),
-            })
-          }
+          if (existing && existing.expiresAt > now && existing.at > meta.at)
+            continue
+          fields.set(field, {
+            value: structuredClone(value),
+            seen: meta.seen,
+            at: new Date(meta.at),
+            expiresAt: new Date(expiresAtMs),
+          })
           applied[field] = structuredClone(value)
           appliedCount += 1
         }
@@ -1279,6 +1270,7 @@ export function memory(options: MemoryStoreOptions = {}): A2Store {
               fields.delete(field)
               continue
             }
+            if (entry.value === null) continue
             rows.push({
               participant,
               field,

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')