experimental-a2 0.6.0 → 0.8.0

package/src/store-redis-core.ts

@@ -23,7 +23,6 @@ import { nullProtoRecord } from './internal.ts'
 import { decodeReturnedEventIds } from './store-codec.ts'
 import type {
   A2Store,
-  A2StoreInspection,
   Clock,
   CompleteAttemptResult,
   Event,
@@ -56,11 +55,7 @@ export type RedisStoreCoreOptions = {
   notify?: (sessionId: string, count: number) => void
 }
 
-export type RedisStoreCore = Omit<
-  A2Store,
-  'stream' | 'inspect' | 'presence'
-> & {
-  inspect: A2StoreInspection
+export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
   /**
    * The storage half of the presence capability, shared by both
    * transports. `set` returns the applied patch — null when every
@@ -98,8 +93,8 @@ const READ_PAGE_SIZE = 256
 // ── Lua scripts (each runs atomically) ───────────────────────────────
 
 /**
- * KEYS: store stream, counter, global id hash, session index, metadata,
- * pending, ready, watched.
+ * KEYS: store stream, counter, global id hash, metadata, pending, ready,
+ * watched.
  * ARGV: sessionId, nowMs, n, then per event:
  * id, type, payloadJson, causeJson, lane, settled.
  * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending, watched] |
@@ -111,24 +106,24 @@ local function lane_field(lane, suffix)
   return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
 local function enqueue(field, idx, lane)
-  redis.call('ZADD', KEYS[6], idx, field)
+  redis.call('ZADD', KEYS[5], idx, field)
   if lane == '' then
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('ZADD', KEYS[6], idx, field)
     return
   end
   local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[5], tail_key)
+  local tail = redis.call('HGET', KEYS[4], tail_key)
   if tail then
-    redis.call('HSET', KEYS[5], tail .. ':next', field)
+    redis.call('HSET', KEYS[4], tail .. ':next', field)
   else
-    redis.call('HSET', KEYS[5], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
+    redis.call('ZADD', KEYS[6], idx, field)
   end
-  redis.call('HSET', KEYS[5], tail_key, field)
+  redis.call('HSET', KEYS[4], tail_key, field)
 end
 local n = tonumber(ARGV[3])
 local base = tonumber(redis.call('GET', KEYS[2]) or '0')
-local has_pending = redis.call('ZCARD', KEYS[6]) > 0 and '1' or '0'
+local has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
 if n == 0 then return { 'empty', has_pending } end
 local dups = {}
 for i = 1, n do
@@ -155,9 +150,9 @@ for i = 1, n do
       return { 'no_parent', tostring(parsed.index) }
     end
     local field = tostring(pidx)
-    local dispatches = tonumber(redis.call('HGET', KEYS[5], field .. ':d') or '0')
+    local dispatches = tonumber(redis.call('HGET', KEYS[4], field .. ':d') or '0')
     if dispatches ~= tonumber(parsed.attempt) or
-       redis.call('HEXISTS', KEYS[5], field .. ':f') == 1 then
+       redis.call('HEXISTS', KEYS[4], field .. ':f') == 1 then
       return { 'superseded', field }
     end
   end
@@ -174,22 +169,37 @@ for i = 1, n do
     'id', id, 'type', typ, 'payload', payload, 'created_at', ARGV[2],
     'cause', cause, 'lane', lane)
   redis.call('HSET', KEYS[3], id, cjson.encode({ ARGV[1], idx }))
-  redis.call('HSET', KEYS[5], tostring(idx) .. ':l', lane)
+  redis.call('HSET', KEYS[4], tostring(idx) .. ':l', lane)
   if settled == '1' then
-    redis.call('HSET', KEYS[5], tostring(idx) .. ':p', ARGV[2])
+    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
   else
     enqueue(tostring(idx), idx, lane)
   end
 end
 redis.call('SET', KEYS[2], tostring(base + n))
-redis.call('ZADD', KEYS[4], 0, ARGV[1])
-has_pending = redis.call('ZCARD', KEYS[6]) > 0 and '1' or '0'
+has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
 return { 'ok', tostring(base + 1), has_pending,
-  tostring(redis.call('EXISTS', KEYS[8])) }
+  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
@@ -243,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) }
@@ -336,61 +347,75 @@ return result
 `
 
 /**
- * KEYS: store, counter, ids, session index, 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
 local function settle(field)
+  redis.call('ZREM', KEYS[5], field)
   redis.call('ZREM', KEYS[6], field)
-  redis.call('ZREM', KEYS[7], field)
-  local lane = redis.call('HGET', KEYS[5], field .. ':l') or ''
+  local lane = redis.call('HGET', KEYS[4], field .. ':l') or ''
   if lane == '' then return end
   local head_key = lane_field(lane, 'head')
-  if redis.call('HGET', KEYS[5], head_key) ~= field then return end
-  local next_field = redis.call('HGET', KEYS[5], field .. ':next')
-  while next_field and redis.call('HEXISTS', KEYS[5], next_field .. ':p') == 1 do
-    next_field = redis.call('HGET', KEYS[5], next_field .. ':next')
+  if redis.call('HGET', KEYS[4], head_key) ~= field then return end
+  local next_field = redis.call('HGET', KEYS[4], field .. ':next')
+  while next_field and redis.call('HEXISTS', KEYS[4], next_field .. ':p') == 1 do
+    next_field = redis.call('HGET', KEYS[4], next_field .. ':next')
   end
   if next_field then
-    redis.call('HSET', KEYS[5], head_key, next_field)
-    if redis.call('HEXISTS', KEYS[5], next_field .. ':f') == 0 then
-      redis.call('ZADD', KEYS[7], tonumber(next_field), next_field)
+    redis.call('HSET', KEYS[4], head_key, next_field)
+    if redis.call('HEXISTS', KEYS[4], next_field .. ':f') == 0 then
+      redis.call('ZADD', KEYS[6], tonumber(next_field), next_field)
     end
   else
-    redis.call('HDEL', KEYS[5], head_key, lane_field(lane, 'tail'))
+    redis.call('HDEL', KEYS[4], head_key, lane_field(lane, 'tail'))
   end
 end
 local function enqueue(field, idx, lane)
-  redis.call('ZADD', KEYS[6], idx, field)
+  redis.call('ZADD', KEYS[5], idx, field)
   if lane == '' then
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('ZADD', KEYS[6], idx, field)
     return
   end
   local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[5], tail_key)
+  local tail = redis.call('HGET', KEYS[4], tail_key)
   if tail then
-    redis.call('HSET', KEYS[5], tail .. ':next', field)
+    redis.call('HSET', KEYS[4], tail .. ':next', field)
   else
-    redis.call('HSET', KEYS[5], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
+    redis.call('ZADD', KEYS[6], idx, field)
   end
-  redis.call('HSET', KEYS[5], tail_key, field)
+  redis.call('HSET', KEYS[4], tail_key, field)
 end
 local parent = ARGV[3]
 local attempt = tonumber(ARGV[4])
 local n = tonumber(ARGV[5])
 local total = tonumber(redis.call('GET', KEYS[2]) or '0')
 if tonumber(parent) < 1 or tonumber(parent) > total then return { 'missing' } end
-local dispatches = tonumber(redis.call('HGET', KEYS[5], parent .. ':d') or '0')
-local processed = redis.call('HGET', KEYS[5], parent .. ':p')
-local processed_attempt = tonumber(redis.call('HGET', KEYS[5], parent .. ':pa') or '0')
+local dispatches = tonumber(redis.call('HGET', KEYS[4], parent .. ':d') or '0')
+local processed = redis.call('HGET', KEYS[4], parent .. ':p')
+local processed_attempt = tonumber(redis.call('HGET', KEYS[4], parent .. ':pa') or '0')
 if processed then
   if processed_attempt ~= attempt then return { 'superseded' } end
-  local raw_recorded_ids = redis.call('HGET', KEYS[5], parent .. ':ri')
+  local raw_recorded_ids = redis.call('HGET', KEYS[4], parent .. ':ri')
   if not raw_recorded_ids then return { 'partial' } end
   local recorded_ids = cjson.decode(raw_recorded_ids)
   if #recorded_ids ~= n then return { 'partial' } end
@@ -420,9 +445,9 @@ if processed then
   return result
 end
 if dispatches ~= attempt then return { 'superseded' } end
-if redis.call('HEXISTS', KEYS[5], parent .. ':ch') == 0 or
-   redis.call('HEXISTS', KEYS[5], parent .. ':f') == 1 or
-   tonumber(redis.call('HGET', KEYS[5], parent .. ':lfa') or '0') == attempt then
+if redis.call('HEXISTS', KEYS[4], parent .. ':ch') == 0 or
+   redis.call('HEXISTS', KEYS[4], parent .. ':f') == 1 or
+   tonumber(redis.call('HGET', KEYS[4], parent .. ':lfa') or '0') == attempt then
   return { 'superseded' }
 end
 for i = 1, n do
@@ -433,12 +458,13 @@ local returned_ids = {}
 for i = 1, n do returned_ids[i] = ARGV[5 + (i - 1) * 5 + 1] end
 local returned_json = '[]'
 if n > 0 then returned_json = cjson.encode(returned_ids) end
-redis.call('HSET', KEYS[5],
+redis.call('HSET', KEYS[4],
   parent .. ':p', ARGV[2],
   parent .. ':pa', ARGV[4],
   parent .. ':ri', returned_json)
-redis.call('HDEL', KEYS[5], parent .. ':ch', parent .. ':ce')
+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]
@@ -451,26 +477,73 @@ for i = 1, n do
     'id', id, 'type', typ, 'payload', payload, 'created_at', ARGV[2],
     'cause', cause, 'lane', lane)
   redis.call('HSET', KEYS[3], id, cjson.encode({ ARGV[1], idx }))
-  redis.call('HSET', KEYS[5], tostring(idx) .. ':l', lane)
+  redis.call('HSET', KEYS[4], tostring(idx) .. ':l', lane)
   if settled == '1' then
-    redis.call('HSET', KEYS[5], tostring(idx) .. ':p', ARGV[2])
+    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
   else
     enqueue(tostring(idx), idx, lane)
   end
 end
 redis.call('SET', KEYS[2], tostring(total + n))
-redis.call('ZADD', KEYS[4], 0, ARGV[1])
 return { 'ok', tostring(total + 1),
-  tostring(redis.call('EXISTS', KEYS[8])) }
+  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
 `
 
@@ -527,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 ─────────────────────────────────────────────────────
@@ -579,14 +667,6 @@ const toEvent = (sessionId: string, entry: StreamEntry): Event => {
 
 const json = (value: unknown): string => JSON.stringify(value) ?? 'null'
 
-const escapeGlob = (value: string): string =>
-  value
-    .replaceAll('\\', '\\\\')
-    .replaceAll('*', '\\*')
-    .replaceAll('?', '\\?')
-    .replaceAll('[', '\\[')
-    .replaceAll(']', '\\]')
-
 const toCause = (raw: string | undefined): EventCause | null => {
   if (raw === '' || raw === undefined) return null
   const value = JSON.parse(raw) as {
@@ -696,10 +776,17 @@ 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`
-  const sessionsKey = `${prefix}:sessions`
 
   const evalScript = (
     script: string,
@@ -924,7 +1011,6 @@ export function createRedisStoreCore(
             storeKey(sessionId),
             countKey(sessionId),
             idsKey,
-            sessionsKey,
             metaKey(sessionId),
             pendingKey(sessionId),
             readyKey(sessionId),
@@ -1081,11 +1167,12 @@ export function createRedisStoreCore(
             storeKey(sessionId),
             countKey(sessionId),
             idsKey,
-            sessionsKey,
             metaKey(sessionId),
             pendingKey(sessionId),
             readyKey(sessionId),
             watchedKey(sessionId),
+            snapshotEventPinsKey(sessionId, index),
+            snapshotPinCountsKey(sessionId),
           ],
           [
             sessionId,
@@ -1178,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[]
@@ -1194,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))
         ) {
@@ -1218,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,
         )
       })
     },
@@ -1325,152 +1481,6 @@ export function createRedisStoreCore(
       },
     },
 
-    inspect: {
-      async listSessions(inspectionOptions) {
-        return wrap(async () => {
-          const minimum =
-            inspectionOptions.cursor === undefined
-              ? `[${inspectionOptions.prefix}`
-              : `(${inspectionOptions.cursor}`
-          const candidates = (await call(
-            'ZRANGEBYLEX',
-            sessionsKey,
-            minimum,
-            '+',
-            'LIMIT',
-            0,
-            inspectionOptions.limit + 1,
-          )) as string[]
-          const sessionIds = candidates
-            .filter((id) => id.startsWith(inspectionOptions.prefix))
-            .slice(0, inspectionOptions.limit)
-
-          const sessions = await Promise.all(
-            sessionIds.map(async (sessionId) => {
-              const rows = await readRange(sessionId, 0)
-              const first = rows[0]!
-              let updatedAt = first.createdAt
-              let pendingCount = 0
-              let failedCount = 0
-              let attemptCount = 0
-              let failureCount = 0
-              for (const row of rows) {
-                attemptCount += row.attemptCount
-                failureCount += row.failureCount
-                if (row.processedAt === null && row.failedAt === null) {
-                  pendingCount += 1
-                }
-                if (row.failedAt !== null) failedCount += 1
-                for (const timestamp of [
-                  row.createdAt,
-                  row.firstClaimedAt,
-                  row.lastClaimedAt,
-                  row.lastFailedAt,
-                  row.processedAt,
-                  row.failedAt,
-                ]) {
-                  if (timestamp && timestamp > updatedAt) updatedAt = timestamp
-                }
-              }
-              return {
-                sessionId,
-                eventCount: rows.length,
-                pendingCount,
-                failedCount,
-                attemptCount,
-                failureCount,
-                firstEventAt: first.createdAt,
-                updatedAt,
-              }
-            }),
-          )
-          return {
-            sessions: sessions.toSorted((a, b) =>
-              a.sessionId.localeCompare(b.sessionId),
-            ),
-            cursor:
-              candidates.length > inspectionOptions.limit &&
-              candidates[inspectionOptions.limit]?.startsWith(
-                inspectionOptions.prefix,
-              )
-                ? (sessionIds.at(-1) ?? null)
-                : null,
-          }
-        })
-      },
-      async readEvents(sessionId, pageOptions) {
-        return wrap(async () => {
-          const currentFrontier = await readFrontier(sessionId)
-          const throughIndex = Math.min(
-            pageOptions.throughIndex ?? currentFrontier,
-            currentFrontier,
-          )
-          const events = await readRangePage(
-            sessionId,
-            pageOptions.afterIndex,
-            throughIndex,
-            pageOptions.limit,
-          )
-          if (throughIndex > pageOptions.afterIndex && events.length === 0) {
-            throw new A2Error(
-              'STORE_UNAVAILABLE',
-              `redis event range for session '${sessionId}' ended before index ${throughIndex}`,
-            )
-          }
-          for (let position = 0; position < events.length; position += 1) {
-            if (
-              events[position]!.index !==
-              pageOptions.afterIndex + position + 1
-            ) {
-              throw new A2Error(
-                'STORE_UNAVAILABLE',
-                `redis event range for session '${sessionId}' is not contiguous`,
-              )
-            }
-          }
-          return { events, throughIndex }
-        })
-      },
-      async listSnapshots(sessionId) {
-        return wrap(async () => {
-          const start = `${prefix}:${sessionId}:snap:`
-          let cursor = '0'
-          const keys: string[] = []
-          do {
-            // oxlint-disable-next-line no-await-in-loop -- each SCAN cursor comes from the prior reply
-            const reply = (await call(
-              'SCAN',
-              cursor,
-              'MATCH',
-              `${escapeGlob(start)}*`,
-              'COUNT',
-              100,
-            )) as [string, string[]]
-            cursor = reply[0]
-            keys.push(...reply[1].filter((key) => key.startsWith(start)))
-          } while (cursor !== '0')
-          const snapshots = await Promise.all(
-            keys.map(async (key) => {
-              const raw = (await call('GET', key)) as string | null
-              if (raw === null) return null
-              const parsed = JSON.parse(raw) as {
-                index: number
-                updatedAt?: number
-              }
-              return {
-                reducerName: key.slice(start.length),
-                index: parsed.index,
-                updatedAt: new Date(parsed.updatedAt ?? 0),
-              }
-            }),
-          )
-          return snapshots
-            .filter((snapshot) => snapshot !== null)
-            .toSorted((a, b) => a.reducerName.localeCompare(b.reducerName))
-        })
-      },
-    },
-
     async readRange(sessionId, afterIndex, throughIndex) {
       return wrap(() => readRange(sessionId, afterIndex, throughIndex))
     },