experimental-a2 0.7.0 → 0.8.0

package/src/store-redis-core.ts

@@ -182,8 +182,24 @@ return { 'ok', tostring(base + 1), has_pending,
   tostring(redis.call('EXISTS', KEYS[7])) }
 `
 
-/** KEYS: counter, meta, pending, ready. ARGV: idx, attempt, error, maxFailures, nowMs. */
+/**
+ * KEYS: counter, meta, pending, ready, event snapshot pins, snapshot pin counts.
+ * ARGV: idx, attempt, error, maxFailures, nowMs.
+ */
 const FAIL_ATTEMPT_LUA = `
+local function release_snapshot_pins()
+  local refs = redis.call('SMEMBERS', KEYS[5])
+  for _, ref in ipairs(refs) do
+    local count = redis.call('HINCRBY', KEYS[6], ref, -1)
+    if count <= 0 then
+      redis.call('HDEL', KEYS[6], ref)
+      local checkpoint = cjson.decode(ref)
+      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
+    end
+  end
+  redis.call('DEL', KEYS[5])
+  if redis.call('HLEN', KEYS[6]) == 0 then redis.call('DEL', KEYS[6]) end
+end
 local function lane_field(lane, suffix)
   return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
@@ -237,6 +253,7 @@ redis.call('HDEL', KEYS[2], field .. ':ch', field .. ':ce')
 if failures >= tonumber(ARGV[4]) then
   redis.call('HSET', KEYS[2], field .. ':f', ARGV[5])
   redis.call('ZREM', KEYS[4], field)
+  release_snapshot_pins()
   return { 'dead_lettered', tostring(failures) }
 end
 return { 'failed', tostring(failures) }
@@ -330,11 +347,25 @@ return result
 `
 
 /**
- * KEYS: store, counter, ids, meta, pending, ready, watched.
+ * KEYS: store, counter, ids, meta, pending, ready, watched,
+ * event snapshot pins, snapshot pin counts.
  * ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
  * id, type, payloadJson, lane, settled.
  */
 const COMPLETE_ATTEMPT_LUA = `
+local function release_snapshot_pins()
+  local refs = redis.call('SMEMBERS', KEYS[8])
+  for _, ref in ipairs(refs) do
+    local count = redis.call('HINCRBY', KEYS[9], ref, -1)
+    if count <= 0 then
+      redis.call('HDEL', KEYS[9], ref)
+      local checkpoint = cjson.decode(ref)
+      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
+    end
+  end
+  redis.call('DEL', KEYS[8])
+  if redis.call('HLEN', KEYS[9]) == 0 then redis.call('DEL', KEYS[9]) end
+end
 local function lane_field(lane, suffix)
   return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
@@ -433,6 +464,7 @@ redis.call('HSET', KEYS[4],
   parent .. ':ri', returned_json)
 redis.call('HDEL', KEYS[4], parent .. ':ch', parent .. ':ce')
 settle(parent)
+release_snapshot_pins()
 local cause = cjson.encode({ index = tonumber(parent), attempt = attempt })
 for i = 1, n do
   local id = ARGV[5 + (i - 1) * 5 + 1]
@@ -457,13 +489,61 @@ return { 'ok', tostring(total + 1),
   tostring(redis.call('EXISTS', KEYS[7])) }
 `
 
-/** KEYS: snapshot. ARGV: upToIndex, json. Guarded: never move backward. */
-const PUT_SNAPSHOT_LUA = `
-local cur = redis.call('GET', KEYS[1])
-if cur and tonumber(cjson.decode(cur)['index']) >= tonumber(ARGV[1]) then
-  return 0
+/**
+ * KEYS: head, history, event counter, event meta, pin counts.
+ * ARGV: nowMs, event pin key prefix, write count, then per write:
+ * index, snapshot JSON, pin count, pin event indexes.
+ */
+const PUT_SNAPSHOTS_LUA = `
+local total = tonumber(redis.call('GET', KEYS[3]) or '0')
+local writes = {}
+local offset = 4
+for i = 1, tonumber(ARGV[3]) do
+  local index = tonumber(ARGV[offset])
+  local snapshot = ARGV[offset + 1]
+  local pin_count = tonumber(ARGV[offset + 2])
+  local ref = cjson.encode({ KEYS[2], tostring(index) })
+  for p = 1, pin_count do
+    local event_index = tonumber(ARGV[offset + 2 + p])
+    if event_index >= 1 and event_index <= total and
+       redis.call('HEXISTS', KEYS[4], tostring(event_index) .. ':p') == 0 and
+       redis.call('HEXISTS', KEYS[4], tostring(event_index) .. ':f') == 0 then
+      local pin_key = ARGV[2] .. tostring(event_index)
+      if redis.call('SADD', pin_key, ref) == 1 then
+        redis.call('HINCRBY', KEYS[5], ref, 1)
+      end
+    end
+  end
+  writes[#writes + 1] = { index = index, snapshot = snapshot, ref = ref }
+  offset = offset + 3 + pin_count
+end
+
+local head = redis.call('GET', KEYS[1])
+local head_index = nil
+if head then head_index = tonumber(cjson.decode(head)['index']) end
+local latest = writes[#writes]
+local writes_head = not head_index or latest.index >= head_index
+local advances = not head_index or latest.index > head_index
+local final_head_index = advances and latest.index or head_index
+
+if advances and head and tonumber(redis.call('HGET', KEYS[5], cjson.encode({ KEYS[2], tostring(head_index) })) or '0') > 0 then
+  redis.call('ZREMRANGEBYSCORE', KEYS[2], head_index, head_index)
+  redis.call('ZADD', KEYS[2], head_index, head)
+end
+
+for _, write in ipairs(writes) do
+  if write.index < final_head_index then
+    redis.call('ZREMRANGEBYSCORE', KEYS[2], write.index, write.index)
+    if tonumber(redis.call('HGET', KEYS[5], write.ref) or '0') > 0 then
+      redis.call('ZADD', KEYS[2], write.index, write.snapshot)
+    end
+  end
+end
+
+if writes_head then
+  redis.call('SET', KEYS[1], latest.snapshot)
+  redis.call('ZREMRANGEBYSCORE', KEYS[2], latest.index, latest.index)
 end
-redis.call('SET', KEYS[1], ARGV[2])
 return 1
 `
 
@@ -520,11 +600,26 @@ end
 return live
 `
 
-/** KEYS: snapshot, event counter. Returns one atomic cache-plus-frontier read. */
+/**
+ * KEYS: head, history, event counter. ARGV: snapshot frontier or ''.
+ * Returns one atomic multiversion-cache-plus-log-frontier read.
+ */
 const READ_STATE_LUA = `
-local snapshot = redis.call('GET', KEYS[1])
-local frontier = redis.call('GET', KEYS[2]) or '0'
-return { snapshot or '', frontier }
+local head = redis.call('GET', KEYS[1])
+local cap = ARGV[1]
+local snapshot = nil
+if head and (cap == '' or tonumber(cjson.decode(head)['index']) <= tonumber(cap)) then
+  snapshot = head
+end
+local upper = cap == '' and '+inf' or cap
+local historical = redis.call('ZREVRANGEBYSCORE', KEYS[2], upper, '-inf', 'LIMIT', 0, 1)
+if #historical > 0 then
+  if not snapshot or tonumber(cjson.decode(historical[1])['index']) > tonumber(cjson.decode(snapshot)['index']) then
+    snapshot = historical[1]
+  end
+end
+local frontier = redis.call('GET', KEYS[3]) or '0'
+return { head or '', snapshot or '', frontier }
 `
 
 // ── wire helpers ─────────────────────────────────────────────────────
@@ -681,6 +776,14 @@ export function createRedisStoreCore(
   const pendingKey = (s: string): string => `${prefix}:${s}:pending`
   const readyKey = (s: string): string => `${prefix}:${s}:ready`
   const snapKey = (s: string, r: string): string => `${prefix}:${s}:snap:${r}`
+  const snapHistoryKey = (s: string, r: string): string =>
+    `${prefix}:${s}:snap-history:${r}`
+  const snapshotEventPinsKey = (s: string, index: number): string =>
+    `${prefix}:${s}:snapshot-pins:${index}`
+  const snapshotEventPinsPrefix = (s: string): string =>
+    `${prefix}:${s}:snapshot-pins:`
+  const snapshotPinCountsKey = (s: string): string =>
+    `${prefix}:${s}:snapshot-pin-counts`
   const watchedKey = (s: string): string => `${prefix}:${s}:watched`
   const presenceKey = (s: string): string => `${prefix}:${s}:presence`
   const idsKey = `${prefix}:ids`
@@ -1068,6 +1171,8 @@ export function createRedisStoreCore(
             pendingKey(sessionId),
             readyKey(sessionId),
             watchedKey(sessionId),
+            snapshotEventPinsKey(sessionId, index),
+            snapshotPinCountsKey(sessionId),
           ],
           [
             sessionId,
@@ -1160,6 +1265,8 @@ export function createRedisStoreCore(
             metaKey(sessionId),
             pendingKey(sessionId),
             readyKey(sessionId),
+            snapshotEventPinsKey(sessionId, index),
+            snapshotPinCountsKey(sessionId),
           ],
           [index, attempt, error, maxFailures, clock.now().getTime()],
         )) as string[]
@@ -1176,22 +1283,37 @@ export function createRedisStoreCore(
       })
     },
 
-    async readState(sessionId, reducerName) {
+    async readState(sessionId, reducerName, stateOptions) {
       return wrap(async () => {
         const reply = (await evalScript(
           READ_STATE_LUA,
-          [snapKey(sessionId, reducerName), countKey(sessionId)],
-          [],
-        )) as [string, string]
-        const raw = reply[0]
+          [
+            snapKey(sessionId, reducerName),
+            snapHistoryKey(sessionId, reducerName),
+            countKey(sessionId),
+          ],
+          [
+            stateOptions?.snapshotThroughIndex ??
+              stateOptions?.throughIndex ??
+              '',
+          ],
+        )) as [string, string, string]
+        const rawHead = reply[0]
+        const raw = reply[1]
+        const head =
+          rawHead === ''
+            ? null
+            : (JSON.parse(rawHead) as { index: number; state: unknown })
         const parsed =
           raw === ''
             ? null
             : (JSON.parse(raw) as { index: number; state: unknown })
-        const frontier = Number(reply[1])
+        const currentFrontier = Number(reply[2])
         if (
-          !Number.isSafeInteger(frontier) ||
-          frontier < 0 ||
+          !Number.isSafeInteger(currentFrontier) ||
+          currentFrontier < 0 ||
+          (head !== null &&
+            (!Number.isSafeInteger(head.index) || head.index < 0)) ||
           (parsed !== null &&
             (!Number.isSafeInteger(parsed.index) || parsed.index < 0))
         ) {
@@ -1200,26 +1322,78 @@ export function createRedisStoreCore(
             `redis state frontier for session '${sessionId}' is invalid`,
           )
         }
+        const frontier = Math.min(
+          currentFrontier,
+          stateOptions?.throughIndex ?? currentFrontier,
+        )
+        const snapshot = parsed
         const events = await readEventRange(
           sessionId,
-          parsed?.index ?? 0,
+          snapshot?.index ?? 0,
           frontier,
         )
         return {
-          snapshot: parsed
-            ? { index: parsed.index, state: parsed.state }
+          headIndex: head?.index ?? null,
+          snapshot: snapshot
+            ? { index: snapshot.index, state: snapshot.state }
             : null,
           events,
         }
       })
     },
 
-    async putSnapshot(sessionId, reducerName, index, state) {
+    async putSnapshots(sessionId, reducerName, writes) {
+      const byIndex = new Map<
+        number,
+        { index: number; state: unknown; pinEventIndexes: Set<number> }
+      >()
+      for (const write of writes) {
+        const existing = byIndex.get(write.index)
+        if (existing) {
+          existing.state = write.state
+          for (const eventIndex of write.pinEventIndexes ?? []) {
+            existing.pinEventIndexes.add(eventIndex)
+          }
+        } else {
+          byIndex.set(write.index, {
+            index: write.index,
+            state: write.state,
+            pinEventIndexes: new Set(write.pinEventIndexes ?? []),
+          })
+        }
+      }
+      const normalized = [...byIndex.values()].toSorted(
+        (a, b) => a.index - b.index,
+      )
+      if (normalized.length === 0) return
       await wrap(async () => {
+        const args: Array<string | number> = [
+          clock.now().getTime(),
+          snapshotEventPinsPrefix(sessionId),
+          normalized.length,
+        ]
+        for (const write of normalized) {
+          args.push(
+            write.index,
+            json({
+              index: write.index,
+              state: write.state,
+              updatedAt: clock.now().getTime(),
+            }),
+            write.pinEventIndexes.size,
+            ...write.pinEventIndexes,
+          )
+        }
         await evalScript(
-          PUT_SNAPSHOT_LUA,
-          [snapKey(sessionId, reducerName)],
-          [index, json({ index, state, updatedAt: clock.now().getTime() })],
+          PUT_SNAPSHOTS_LUA,
+          [
+            snapKey(sessionId, reducerName),
+            snapHistoryKey(sessionId, reducerName),
+            countKey(sessionId),
+            metaKey(sessionId),
+            snapshotPinCountsKey(sessionId),
+          ],
+          args,
         )
       })
     },

package/src/store-redis-http.ts

@@ -95,7 +95,7 @@ export function redisHttp(options: RedisHttpStoreOptions): RedisHttpStore {
     completeAttempt: core.completeAttempt,
     failAttempt: core.failAttempt,
     readState: core.readState,
-    putSnapshot: core.putSnapshot,
+    putSnapshots: core.putSnapshots,
     presence: {
       async set(ns, participant, values, meta) {
         await core.presence.set(ns, participant, values, meta)

package/src/store-redis.ts

@@ -291,7 +291,7 @@ export function redis(options: RedisStoreOptions = {}): RedisStore {
     completeAttempt: core.completeAttempt,
     failAttempt: core.failAttempt,
     readState: core.readState,
-    putSnapshot: core.putSnapshot,
+    putSnapshots: core.putSnapshots,
 
     presence: {
       async set(ns, participant, values, meta) {

package/src/store-sqlite.ts

@@ -92,6 +92,26 @@ create table if not exists a2_snapshots (
   primary key (session_id, reducer_name)
 ) strict;
 
+create table if not exists a2_snapshot_history (
+  session_id   text    not null,
+  reducer_name text    not null,
+  up_to_index  integer not null,
+  state        text    not null,
+  updated_at   integer not null,
+  primary key (session_id, reducer_name, up_to_index)
+) strict;
+
+create table if not exists a2_snapshot_pins (
+  session_id   text    not null,
+  event_index  integer not null,
+  reducer_name text    not null,
+  up_to_index  integer not null,
+  primary key (session_id, event_index, reducer_name, up_to_index)
+) strict;
+
+create index if not exists a2_snapshot_pins_checkpoint
+  on a2_snapshot_pins (session_id, reducer_name, up_to_index);
+
 create table if not exists a2_presence (
   ns          text    not null,
   participant text    not null,
@@ -242,10 +262,17 @@ type PresenceDbRow = {
 
 type StateReadRow = Partial<EventRow> & {
   row_kind: 'snapshot' | 'event'
+  head_index: number | bigint | null
   snapshot_index: number | bigint | null
   snapshot_state: string | null
 }
 
+type SnapshotHeadRow = {
+  up_to_index: number | bigint
+  state: string
+  updated_at: number | bigint
+}
+
 type AppendStatusRow = {
   max: number | bigint
   has_pending: number | bigint
@@ -747,6 +774,19 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
                claim_expires_at = null
              where session_id = ? and idx = ?`,
           ).run(now, attempt, JSON.stringify(ids), sessionId, index)
+          db.prepare(
+            'delete from a2_snapshot_pins where session_id = ? and event_index = ?',
+          ).run(sessionId, index)
+          db.prepare(
+            `delete from a2_snapshot_history
+              where session_id = ?
+                and not exists (
+                  select 1 from a2_snapshot_pins pin
+                   where pin.session_id = a2_snapshot_history.session_id
+                     and pin.reducer_name = a2_snapshot_history.reducer_name
+                     and pin.up_to_index = a2_snapshot_history.up_to_index
+                )`,
+          ).run(sessionId)
           if (parent.lane !== null) {
             promoteLaneHead.run(sessionId, sessionId, parent.lane)
           }
@@ -835,6 +875,21 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             sessionId,
             index,
           )
+          if (deadLettered) {
+            db.prepare(
+              'delete from a2_snapshot_pins where session_id = ? and event_index = ?',
+            ).run(sessionId, index)
+            db.prepare(
+              `delete from a2_snapshot_history
+                where session_id = ?
+                  and not exists (
+                    select 1 from a2_snapshot_pins pin
+                     where pin.session_id = a2_snapshot_history.session_id
+                       and pin.reducer_name = a2_snapshot_history.reducer_name
+                       and pin.up_to_index = a2_snapshot_history.up_to_index
+                  )`,
+            ).run(sessionId)
+          }
           return {
             outcome: deadLettered ? 'dead_lettered' : 'failed',
             failureCount: nextFailureCount,
@@ -843,18 +898,32 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
       )
     },
 
-    async readState(sessionId, reducerName) {
+    async readState(sessionId, reducerName, stateOptions) {
       return wrap(() => {
+        const throughIndex = stateOptions?.throughIndex ?? null
+        const snapshotThroughIndex =
+          stateOptions?.snapshotThroughIndex ?? throughIndex
         const rows = db
           .prepare(
-            `with snapshot as materialized (
-             select up_to_index, state
+            `with head as materialized (
+             select up_to_index, state, updated_at
                from a2_snapshots
-               where session_id = ? and reducer_name = ?
+              where session_id = ? and reducer_name = ?
+           ), snapshot as materialized (
+             select up_to_index, state from (
+               select up_to_index, state from head
+                where (? is null or up_to_index <= ?)
+               union all
+               select up_to_index, state
+                 from a2_snapshot_history
+                where session_id = ? and reducer_name = ?
+                  and (? is null or up_to_index <= ?)
+             ) order by up_to_index desc limit 1
              )
              select 0 as row_order, 'snapshot' as row_kind,
-                    snapshot.up_to_index as snapshot_index,
-                    snapshot.state as snapshot_state,
+                    (select up_to_index from head) as head_index,
+                    (select up_to_index from snapshot) as snapshot_index,
+                    (select state from snapshot) as snapshot_state,
                     null as session_id, null as idx, null as event_type,
                     null as payload, null as event_id, null as created_at,
                     null as cause, null as lane, null as lane_ready,
@@ -866,25 +935,44 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
                     null as last_failed_attempt, null as last_error,
                     null as failed_at, null as claim_holder,
                     null as claim_expires_at
-             from snapshot
              union all
              select 1 as row_order, 'event' as row_kind,
+                    (select up_to_index from head) as head_index,
                     null as snapshot_index, null as snapshot_state,
                     event.*
              from a2_events as event
              where event.session_id = ?
                and event.idx > coalesce((select up_to_index from snapshot), 0)
+               and (? is null or event.idx <= ?)
              order by row_order, idx`,
           )
-          .all(sessionId, reducerName, sessionId) as unknown as StateReadRow[]
+          .all(
+            sessionId,
+            reducerName,
+            snapshotThroughIndex,
+            snapshotThroughIndex,
+            sessionId,
+            reducerName,
+            snapshotThroughIndex,
+            snapshotThroughIndex,
+            sessionId,
+            throughIndex,
+            throughIndex,
+          ) as unknown as StateReadRow[]
         const snapshot = rows.find((row) => row.row_kind === 'snapshot')
         return {
-          snapshot: snapshot
-            ? {
-                index: Number(snapshot.snapshot_index),
-                state: JSON.parse(snapshot.snapshot_state!),
-              }
-            : null,
+          headIndex:
+            snapshot?.head_index === null || snapshot?.head_index === undefined
+              ? null
+              : Number(snapshot.head_index),
+          snapshot:
+            snapshot?.snapshot_index !== null &&
+            snapshot?.snapshot_index !== undefined
+              ? {
+                  index: Number(snapshot.snapshot_index),
+                  state: JSON.parse(snapshot.snapshot_state!),
+                }
+              : null,
           events: rows
             .filter(
               (row): row is StateReadRow & EventRow => row.row_kind === 'event',
@@ -894,26 +982,95 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
       })
     },
 
-    async putSnapshot(sessionId, reducerName, index, state) {
-      wrap(() => {
-        // Guarded upsert: a slower concurrent writer must never clobber
-        // a further-along snapshot (spec §3).
-        db.prepare(
-          `insert into a2_snapshots (session_id, reducer_name, up_to_index, state, updated_at)
-           values (?, ?, ?, ?, ?)
-           on conflict (session_id, reducer_name) do update set
-             up_to_index = excluded.up_to_index,
-             state = excluded.state,
-             updated_at = excluded.updated_at
-           where excluded.up_to_index > a2_snapshots.up_to_index`,
-        ).run(
-          sessionId,
-          reducerName,
-          index,
-          JSON.stringify(state) ?? 'null',
-          clock.now().getTime(),
-        )
-      })
+    async putSnapshots(sessionId, reducerName, writes) {
+      await wrap(() =>
+        tx(() => {
+          const selectHead = db.prepare(
+            `select up_to_index, state, updated_at from a2_snapshots
+              where session_id = ? and reducer_name = ?`,
+          )
+          const unfinished = db.prepare(
+            `select 1 from a2_events
+              where session_id = ? and idx = ?
+                and processed_at is null and failed_at is null`,
+          )
+          const insertPin = db.prepare(
+            `insert or ignore into a2_snapshot_pins
+               (session_id, event_index, reducer_name, up_to_index)
+             values (?, ?, ?, ?)`,
+          )
+          const hasPin = db.prepare(
+            `select 1 from a2_snapshot_pins
+              where session_id = ? and reducer_name = ? and up_to_index = ?
+              limit 1`,
+          )
+          const putHistory = db.prepare(
+            `insert into a2_snapshot_history
+               (session_id, reducer_name, up_to_index, state, updated_at)
+             values (?, ?, ?, ?, ?)
+             on conflict (session_id, reducer_name, up_to_index) do update set
+               state = excluded.state, updated_at = excluded.updated_at`,
+          )
+          const putHead = db.prepare(
+            `insert into a2_snapshots
+               (session_id, reducer_name, up_to_index, state, updated_at)
+             values (?, ?, ?, ?, ?)
+             on conflict (session_id, reducer_name) do update set
+               up_to_index = excluded.up_to_index,
+               state = excluded.state,
+               updated_at = excluded.updated_at
+             where excluded.up_to_index >= a2_snapshots.up_to_index`,
+          )
+          const deleteHistory = db.prepare(
+            `delete from a2_snapshot_history
+              where session_id = ? and reducer_name = ? and up_to_index = ?`,
+          )
+          for (const write of writes.toSorted((a, b) => a.index - b.index)) {
+            for (const eventIndex of write.pinEventIndexes ?? []) {
+              if (unfinished.get(sessionId, eventIndex)) {
+                insertPin.run(sessionId, eventIndex, reducerName, write.index)
+              }
+            }
+            const head = selectHead.get(sessionId, reducerName) as
+              SnapshotHeadRow | undefined
+            const now = clock.now().getTime()
+            if (!head || write.index >= Number(head.up_to_index)) {
+              if (
+                head &&
+                write.index > Number(head.up_to_index) &&
+                hasPin.get(sessionId, reducerName, Number(head.up_to_index))
+              ) {
+                putHistory.run(
+                  sessionId,
+                  reducerName,
+                  Number(head.up_to_index),
+                  head.state,
+                  Number(head.updated_at),
+                )
+              }
+              putHead.run(
+                sessionId,
+                reducerName,
+                write.index,
+                JSON.stringify(write.state) ?? 'null',
+                now,
+              )
+              deleteHistory.run(sessionId, reducerName, write.index)
+            } else if (
+              write.index < Number(head.up_to_index) &&
+              hasPin.get(sessionId, reducerName, write.index)
+            ) {
+              putHistory.run(
+                sessionId,
+                reducerName,
+                write.index,
+                JSON.stringify(write.state) ?? 'null',
+                now,
+              )
+            }
+          }
+        }),
+      )
     },
 
     presence: {