experimental-a2 0.16.1 → 0.17.0

package/src/store-redis-core.ts

@@ -6,8 +6,11 @@
  *
  * The stream IS the store: each event is a stream entry whose ID is its
  * dense a2 index (`${index}-0`), so `XRANGE` is the catch-up read.
- * Mutable drain/failure bookkeeping lives in a side hash (stream
- * entries are immutable); every write path is one atomic Lua script.
+ * Mutable drain/failure bookkeeping lives in side hashes of fixed index
+ * ranges (stream entries are immutable); every write path is one atomic
+ * Lua script.
+ * Global event-id ownership is one key per id, so no key grows with
+ * the number of sessions.
  * The conformance suite in test/conformance is the executable
  * contract, run against a real spawned `redis-server`.
  *
@@ -17,10 +20,12 @@
  */
 
 import type { PresencePatch } from './contract.ts'
-import { A2Error } from './errors.ts'
+import { A2Error, supersededAttemptError } from './errors.ts'
+import { CLEAR_EVENT_TYPE, sessionClearedError } from './session-clear.ts'
 import { idempotentReplay } from './idempotent-replay.ts'
 import { nullProtoRecord } from './internal.ts'
 import { decodeReturnedEventIds } from './store-codec.ts'
+import type { SerializedEvent } from './stream-buffer.ts'
 import type {
   A2Store,
   Clock,
@@ -41,12 +46,25 @@ export type RedisCall = (
 
 export type RedisStoreCoreOptions = {
   call: RedisCall
+  /**
+   * Issues a command whose bulk replies arrive as raw bytes. Live feed
+   * catch-up pages use it to decode only the fields a row needs.
+   */
+  callBytes?: RedisCall
   clock: Clock
   ids: IdSource
   keyPrefix: string
   presenceSource: string
+  readStream?: RedisStreamRead
 }
 
+/** Stream entries from `from` onward, in nonempty ordered batches. */
+export type RedisStreamRead = (options: {
+  key: string
+  from: string
+  signal: AbortSignal
+}) => AsyncGenerator<StreamEntry[], void>
+
 export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
   /**
    * The storage half of the presence capability, shared by both
@@ -72,233 +90,464 @@ export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
   /** One bounded XRANGE page of public events for live feeds. */
   readEvents(sessionId: string, afterIndex: number): Promise<Event[]>
   /**
-   * Declare the session watched for `ttlMs` — writes publish wake-ups
-   * only while this presence marker lives. Live feeds refresh it
-   * ahead of expiry; an expired marker degrades latency to the safety
-   * cadence, never delivery.
+   * One bounded XRANGE page of catch-up rows for a live feed without a
+   * streaming reader, payloads left as stored JSON. The reply is held whole,
+   * so a page retains up to `FEED_PAGE_SIZE` entries.
+   */
+  readFeedPage(
+    sessionId: string,
+    afterIndex: number,
+  ): Promise<SerializedEvent[]>
+  /** Catch-up events after `afterIndex`, in nonempty ordered batches. */
+  streamEvents?: (options: {
+    sessionId: string
+    afterIndex: number
+    signal: AbortSignal
+  }) => AsyncGenerator<SerializedEvent[], void>
+  /**
+   * Events from `fromIndex` through `throughIndex` or the newest entry in
+   * one newest-first page, or null when the range doesn't fit in one.
    */
-  markWatched(sessionId: string, ttlMs: number): Promise<void>
+  readTail(
+    sessionId: string,
+    fromIndex: number,
+    throughIndex?: number,
+  ): Promise<Event[] | null>
 }
 
-const READ_PAGE_SIZE = 256
+export const READ_PAGE_SIZE = 256
+export const FEED_PAGE_SIZE = 1000
 const READ_CONCURRENCY = 16
 
 // ── Lua scripts (each runs atomically) ───────────────────────────────
 
+const META_CHUNK_SIZE = 1000
+
 /**
- * KEYS: store stream, counter, global id hash, metadata, pending, ready,
- * watched.
- * ARGV: sessionId, nowMs, n, then per event:
- * id, type, payloadJson, causeJson, lane, settled; finally notify channel.
- * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
- * ['dup', hasPending, ...indexes] | ['partial', count] |
- * ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx].
+ * Upstash bills every call a script makes, so scripts read the counter and
+ * split with one MGET, read metadata with one HMGET per hash (`read_fields`),
+ * and buffer hash writes (`put`) into one HSET per hash (`flush`). Buffered
+ * writes are invisible to reads until flushed, so a script must not read a
+ * field it has buffered. Per-event metadata lives in hashes of
+ * META_CHUNK_SIZE consecutive indexes, so no key grows with a session's
+ * history. Indexes at or below the split predate chunking and stay in the
+ * base hash, which also holds every session's lane pointers. An unset split
+ * means the current event count, so any script that adds events must write
+ * `split_write` pairs in its write phase. Including scripts bind COUNTER,
+ * META (the base hash), and SPLIT first.
  */
-const APPEND_LUA = `
+const META_LUA = `
+local split, split_stored = nil, false
+-- The latest clear marker lives beside the counter, {prefix}:{session}:clear,
+-- and is read in the same MGET, so a session never cleared pays nothing.
+local CLEAR = string.sub(COUNTER, 1, -6) .. 'clear'
+local boundary = 0
+local function use_split(stored, count, cleared)
+  split_stored = stored ~= false
+  split = tonumber(stored or count or '0')
+  boundary = tonumber(cleared or '0')
+end
+local function mkey(field)
+  if split == nil then
+    local values = redis.call('MGET', SPLIT, COUNTER, CLEAR)
+    use_split(values[1], values[2], values[3])
+  end
+  local idx = tonumber(field)
+  if idx <= split then return META end
+  return META .. ':' .. tostring(math.floor((idx - 1) / ${META_CHUNK_SIZE}))
+end
+local function split_write(args)
+  if not split_stored then
+    args[#args + 1] = SPLIT
+    args[#args + 1] = tostring(split)
+  end
+end
+local function sliced(command, key, args)
+  local results = {}
+  for first = 1, #args, 1000 do
+    local last = math.min(first + 999, #args)
+    local reply
+    if key then
+      reply = redis.call(command, key, unpack(args, first, last))
+    else
+      reply = redis.call(command, unpack(args, first, last))
+    end
+    if type(reply) == 'table' then
+      for _, value in ipairs(reply) do results[#results + 1] = value end
+    end
+  end
+  return results
+end
+local function read_fields(fields, suffixes)
+  local groups, order = {}, {}
+  for _, field in ipairs(fields) do
+    local key = mkey(field)
+    local group = groups[key]
+    if not group then
+      group = { fields = {}, names = {} }
+      groups[key] = group
+      order[#order + 1] = key
+    end
+    group.fields[#group.fields + 1] = field
+    for _, suffix in ipairs(suffixes) do
+      group.names[#group.names + 1] = field .. ':' .. suffix
+    end
+  end
+  local rows = {}
+  for _, key in ipairs(order) do
+    local group = groups[key]
+    local values = sliced('HMGET', key, group.names)
+    for position, field in ipairs(group.fields) do
+      local row = {}
+      for column = 1, #suffixes do
+        row[column] = values[(position - 1) * #suffixes + column]
+      end
+      rows[field] = row
+    end
+  end
+  return rows
+end
+local writes, write_order = {}, {}
+local function put(key, field, value)
+  local fields = writes[key]
+  if not fields then
+    fields = {}
+    writes[key] = fields
+    write_order[#write_order + 1] = key
+  end
+  fields[#fields + 1] = field
+  fields[#fields + 1] = value
+end
+local function flush()
+  for _, key in ipairs(write_order) do sliced('HSET', key, writes[key]) end
+  writes, write_order = {}, {}
+end
+`
+
+/**
+ * Lane-aware enqueueing for scripts that add events. Including scripts bind
+ * PENDING and READY. Lane tails are read once per lane and tracked in
+ * memory, so a batch in one lane links its events without re-reading. A
+ * lane emptied earlier in the script (`clear_lane`) is known to have no tail,
+ * and its pointers are deleted at `flush_queue` only if nothing re-filled it.
+ */
+const ENQUEUE_LUA = `
 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[5], idx, field)
+local queued, ready_now, lane_tails, lane_order = {}, {}, {}, {}
+local function enqueue(field, lane)
+  local score = tonumber(field)
+  queued[#queued + 1] = score
+  queued[#queued + 1] = field
   if lane == '' then
-    redis.call('ZADD', KEYS[6], idx, field)
+    ready_now[#ready_now + 1] = score
+    ready_now[#ready_now + 1] = field
     return
   end
-  local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[4], tail_key)
+  put(mkey(field), field .. ':l', lane)
+  local tail = lane_tails[lane]
+  if tail == nil then
+    tail = redis.call('HGET', META, lane_field(lane, 'tail'))
+    if tail and tonumber(tail) <= boundary then tail = false end
+    lane_order[#lane_order + 1] = lane
+  end
   if tail then
-    redis.call('HSET', KEYS[4], tail .. ':next', field)
+    put(mkey(tail), tail .. ':next', field)
   else
-    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[6], idx, field)
+    put(META, lane_field(lane, 'head'), field)
+    ready_now[#ready_now + 1] = score
+    ready_now[#ready_now + 1] = field
+  end
+  lane_tails[lane] = field
+end
+local function clear_lane(lane)
+  if lane_tails[lane] == nil then lane_order[#lane_order + 1] = lane end
+  lane_tails[lane] = false
+end
+local function flush_queue()
+  for _, lane in ipairs(lane_order) do
+    if lane_tails[lane] then
+      put(META, lane_field(lane, 'tail'), lane_tails[lane])
+    else
+      redis.call('HDEL', META, lane_field(lane, 'head'), lane_field(lane, 'tail'))
+    end
   end
-  redis.call('HSET', KEYS[4], tail_key, field)
+  sliced('ZADD', PENDING, queued)
+  sliced('ZADD', READY, ready_now)
+end
+`
+
+/**
+ * Event-id ownership for scripts that add events. Each script reads the
+ * counter, split, clear boundary, and per-id keys with one MGET and applies
+ * the first three. Returns the owner record, or false, per event, and the
+ * counter. A record this session made below its latest clear is free.
+ */
+const ID_OWNERS_LUA = `
+local function read_owners(key_offset, n, session)
+  local keys = { COUNTER, SPLIT, CLEAR }
+  for i = 1, n do keys[#keys + 1] = KEYS[key_offset + i] end
+  local values = sliced('MGET', nil, keys)
+  use_split(values[2], values[1], values[3])
+  local owners = {}
+  for i = 1, n do
+    local owner = values[3 + i]
+    if owner then
+      local rec = cjson.decode(owner)
+      if rec[1] == session and tonumber(rec[2]) < boundary then owner = false end
+    end
+    owners[i] = owner
+  end
+  return owners, values[1]
+end
+`
+
+const WAKE_PAYLOAD_LIMIT = 32_768
+
+/**
+ * Wake-up messages carry the events they announce, so a subscribed reader
+ * that is caught up applies them without reading the stream:
+ * `{"f":frontier,"t":createdAt,"e":[[index,id,type,payload],...]}`. Payloads
+ * are the stored JSON text, inlined verbatim. A batch over
+ * WAKE_PAYLOAD_LIMIT bytes publishes `{"f":frontier}` and readers catch up
+ * with XRANGE.
+ */
+const WAKE_LUA = `
+local wake_entries, wake_bytes = {}, 0
+local function wake_add(field, id, typ, payload)
+  if wake_bytes + #payload > ${WAKE_PAYLOAD_LIMIT} then
+    wake_bytes = ${WAKE_PAYLOAD_LIMIT} + 1
+    return
+  end
+  local entry = '[' .. field .. ',' .. cjson.encode(id) .. ',' ..
+    cjson.encode(typ) .. ',' .. payload .. ']'
+  wake_bytes = wake_bytes + #entry + 1
+  if wake_bytes <= ${WAKE_PAYLOAD_LIMIT} then
+    wake_entries[#wake_entries + 1] = entry
+  end
+end
+local function wake(channel, frontier, created_at)
+  local message = '{"f":' .. frontier .. '}'
+  if wake_bytes <= ${WAKE_PAYLOAD_LIMIT} then
+    message = '{"f":' .. frontier .. ',"t":' .. created_at .. ',"e":[' ..
+      table.concat(wake_entries, ',') .. ']}'
+  end
+  redis.pcall('PUBLISH', channel, message)
+end
+`
+
+const RELEASE_PINS_LUA = `
+local function release_snapshot_pins(pins, counts)
+  local refs = redis.call('SMEMBERS', pins)
+  if #refs == 0 then return end
+  for _, ref in ipairs(refs) do
+    local count = redis.call('HINCRBY', counts, ref, -1)
+    if count <= 0 then
+      redis.call('HDEL', counts, ref)
+      local checkpoint = cjson.decode(ref)
+      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
+    end
+  end
+  redis.call('DEL', pins)
+end
+`
+
+/**
+ * KEYS: store stream, counter, metadata, pending, ready, metadata split,
+ * then one id ownership key per event.
+ * ARGV: sessionId, nowMs, n, then per event:
+ * id, type, payloadJson, causeJson, lane, settled; then notify channel and
+ * origin index or ''.
+ * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
+ * ['dup', hasPending, ...indexes] | ['partial', count] |
+ * ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx] |
+ * ['cleared', originIndex].
+ */
+const APPEND_LUA = `
+local COUNTER, META, SPLIT, PENDING, READY = KEYS[2], KEYS[3], KEYS[6], KEYS[4], KEYS[5]
+${META_LUA}
+${ENQUEUE_LUA}
+${ID_OWNERS_LUA}
+${WAKE_LUA}
+local function has_pending()
+  return redis.call('ZCARD', PENDING) > 0 and '1' or '0'
 end
 local n = tonumber(ARGV[3])
-local base = tonumber(redis.call('GET', KEYS[2]) or '0')
-local has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
-if n == 0 then return { 'empty', has_pending } end
+if n == 0 then return { 'empty', has_pending() } end
+local owners, count = read_owners(6, n, ARGV[1])
+local base = tonumber(count or '0')
 local dups = {}
 for i = 1, n do
-  local id = ARGV[3 + (i - 1) * 6 + 1]
-  local existing = redis.call('HGET', KEYS[3], id)
-  if existing then
-    local rec = cjson.decode(existing)
-    if rec[1] ~= ARGV[1] then return { 'foreign', id } end
+  if owners[i] then
+    local rec = cjson.decode(owners[i])
+    if rec[1] ~= ARGV[1] then return { 'foreign', ARGV[3 + (i - 1) * 6 + 1] } end
     dups[#dups + 1] = tostring(rec[2])
   end
 end
 if #dups == n then
-  local res = { 'dup', has_pending }
+  local res = { 'dup', has_pending() }
   for i = 1, #dups do res[#res + 1] = dups[i] end
   return res
 end
 if #dups > 0 then return { 'partial', tostring(#dups) } end
+local origin = ARGV[5 + n * 6]
+if origin and origin ~= '' and tonumber(origin) <= boundary then
+  return { 'cleared', origin }
+end
+local causes, parents = {}, {}
 for i = 1, n do
   local cause = ARGV[3 + (i - 1) * 6 + 4]
   if cause ~= '' then
     local parsed = cjson.decode(cause)
     local pidx = tonumber(parsed.index)
-    if pidx < 1 or pidx > base then
-      return { 'no_parent', tostring(parsed.index) }
-    end
-    local field = tostring(pidx)
-    local dispatches = tonumber(redis.call('HGET', KEYS[4], field .. ':d') or '0')
-    if dispatches ~= tonumber(parsed.attempt) or
-       redis.call('HEXISTS', KEYS[4], field .. ':f') == 1 then
-      return { 'superseded', field }
-    end
+    causes[#causes + 1] = parsed
+    if pidx >= 1 and pidx <= base then parents[#parents + 1] = tostring(pidx) end
+  end
+end
+local parent_rows = read_fields(parents, { 'd', 'f', 'p' })
+local parent_pending = false
+for _, parsed in ipairs(causes) do
+  local pidx = tonumber(parsed.index)
+  if pidx <= boundary then return { 'superseded', tostring(pidx) } end
+  if pidx < 1 or pidx > base then
+    return { 'no_parent', tostring(parsed.index) }
   end
+  local row = parent_rows[tostring(pidx)]
+  if tonumber(row[1] or '0') ~= tonumber(parsed.attempt) or row[2] then
+    return { 'superseded', tostring(pidx) }
+  end
+  -- A claimed, unprocessed parent is still in the pending set.
+  if not row[3] then parent_pending = true end
 end
+local owner_writes = {}
 for i = 1, n do
-  local id = ARGV[3 + (i - 1) * 6 + 1]
-  local typ = ARGV[3 + (i - 1) * 6 + 2]
-  local payload = ARGV[3 + (i - 1) * 6 + 3]
-  local cause = ARGV[3 + (i - 1) * 6 + 4]
-  local lane = ARGV[3 + (i - 1) * 6 + 5]
-  local settled = ARGV[3 + (i - 1) * 6 + 6]
-  local idx = base + i
-  redis.call('XADD', KEYS[1], tostring(idx) .. '-0',
-    '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[4], tostring(idx) .. ':l', lane)
-  if settled == '1' then
-    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
+  local o = 3 + (i - 1) * 6
+  local field = tostring(base + i)
+  redis.call('XADD', KEYS[1], field .. '-0',
+    'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
+    'created_at', ARGV[2], 'cause', ARGV[o + 4], 'lane', ARGV[o + 5])
+  owner_writes[#owner_writes + 1] = KEYS[6 + i]
+  owner_writes[#owner_writes + 1] = cjson.encode({ ARGV[1], base + i })
+  wake_add(field, ARGV[o + 1], ARGV[o + 2], ARGV[o + 3])
+  if ARGV[o + 6] == '1' then
+    put(mkey(field), field .. ':p', ARGV[2])
   else
-    enqueue(tostring(idx), idx, lane)
+    enqueue(field, ARGV[o + 5])
   end
 end
-redis.call('SET', KEYS[2], tostring(base + n))
-has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
-if redis.call('EXISTS', KEYS[7]) == 1 then
-  redis.pcall('PUBLISH', ARGV[4 + n * 6], tostring(base + n))
-end
-return { 'ok', tostring(base + 1), has_pending }
+owner_writes[#owner_writes + 1] = COUNTER
+owner_writes[#owner_writes + 1] = tostring(base + n)
+split_write(owner_writes)
+sliced('MSET', nil, owner_writes)
+flush_queue()
+flush()
+local pending_after = (#queued > 0 or parent_pending) and '1' or has_pending()
+wake(ARGV[4 + n * 6], tostring(base + n), ARGV[2])
+return { 'ok', tostring(base + 1), pending_after }
 `
 
 /**
- * KEYS: counter, meta, pending, ready, event snapshot pins, snapshot pin counts.
+ * KEYS: counter, meta, pending, ready, event snapshot pins, snapshot pin counts,
+ * metadata split.
  * 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
-local function settle(field)
-  redis.call('ZREM', KEYS[3], field)
-  redis.call('ZREM', KEYS[4], field)
-  local lane = redis.call('HGET', KEYS[2], field .. ':l') or ''
-  if lane == '' then return end
-  local head_key = lane_field(lane, 'head')
-  if redis.call('HGET', KEYS[2], head_key) ~= field then return end
-  local next_field = redis.call('HGET', KEYS[2], field .. ':next')
-  while next_field and redis.call('HEXISTS', KEYS[2], next_field .. ':p') == 1 do
-    next_field = redis.call('HGET', KEYS[2], next_field .. ':next')
-  end
-  if next_field then
-    redis.call('HSET', KEYS[2], head_key, next_field)
-    if redis.call('HEXISTS', KEYS[2], next_field .. ':f') == 0 then
-      redis.call('ZADD', KEYS[4], tonumber(next_field), next_field)
-    end
-  else
-    redis.call('HDEL', KEYS[2], head_key, lane_field(lane, 'tail'))
-  end
-end
+local COUNTER, META, SPLIT = KEYS[1], KEYS[2], KEYS[7]
+${META_LUA}
+${RELEASE_PINS_LUA}
 local idx = tonumber(ARGV[1])
-if idx < 1 or idx > tonumber(redis.call('GET', KEYS[1]) or '0') then
-  return { 'missing', '0' }
-end
+local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
+local total = tonumber(counts[1] or '0')
+use_split(counts[2], counts[1], counts[3])
+if idx <= boundary then return { 'cleared', '0' } end
+if idx < 1 or idx > total then return { 'missing', '0' } end
 local field = ARGV[1]
-local failures = tonumber(redis.call('HGET', KEYS[2], field .. ':a') or '0')
-local dispatches = tonumber(redis.call('HGET', KEYS[2], field .. ':d') or '0')
-if redis.call('HEXISTS', KEYS[2], field .. ':p') == 1 or dispatches ~= tonumber(ARGV[2]) then
+local attempt = tonumber(ARGV[2])
+local row = read_fields({ field }, { 'a', 'd', 'p', 'f', 'lfa', 'ch' })[field]
+local failures = tonumber(row[1] or '0')
+if row[3] or tonumber(row[2] or '0') ~= attempt then
   return { 'superseded', tostring(failures) }
 end
-if redis.call('HEXISTS', KEYS[2], field .. ':f') == 1 then
-  return { 'dead_lettered', tostring(failures) }
-end
-if redis.call('HEXISTS', KEYS[2], field .. ':lfa') == 1 and
-   tonumber(redis.call('HGET', KEYS[2], field .. ':lfa')) == tonumber(ARGV[2]) and
-   redis.call('HEXISTS', KEYS[2], field .. ':ch') == 0 then
+if row[4] then return { 'dead_lettered', tostring(failures) } end
+if row[5] and tonumber(row[5]) == attempt and not row[6] then
   return { 'failed', tostring(failures) }
 end
-if redis.call('HEXISTS', KEYS[2], field .. ':ch') == 0 then
-  return { 'superseded', tostring(failures) }
-end
-failures = redis.call('HINCRBY', KEYS[2], field .. ':a', 1)
-redis.call('HSET', KEYS[2],
-  field .. ':e', ARGV[3],
-  field .. ':lf', ARGV[5],
-  field .. ':lfa', ARGV[2])
-redis.call('HDEL', KEYS[2], field .. ':ch', field .. ':ce')
-if failures >= tonumber(ARGV[4]) then
-  redis.call('HSET', KEYS[2], field .. ':f', ARGV[5])
+if not row[6] then return { 'superseded', tostring(failures) } end
+failures = failures + 1
+local dead = failures >= tonumber(ARGV[4])
+local meta_key = mkey(field)
+put(meta_key, field .. ':a', tostring(failures))
+put(meta_key, field .. ':e', ARGV[3])
+put(meta_key, field .. ':lf', ARGV[5])
+put(meta_key, field .. ':lfa', ARGV[2])
+if dead then put(meta_key, field .. ':f', ARGV[5]) end
+flush()
+redis.call('HDEL', meta_key, field .. ':ch', field .. ':ce')
+if dead then
   redis.call('ZREM', KEYS[4], field)
-  release_snapshot_pins()
+  release_snapshot_pins(KEYS[5], KEYS[6])
   return { 'dead_lettered', tostring(failures) }
 end
 return { 'failed', tostring(failures) }
 `
 
 /**
- * KEYS: store, counter, meta, pending, ready.
+ * KEYS: store, counter, meta, pending, ready, metadata split.
  * ARGV: holder, nowMs, expiresAtMs, excludedCount, excluded indexes.
+ * The ready set is a subset of the pending set, so an empty ready set is
+ * enough to report 'settled'. A claimed result ends with the clear boundary.
  */
 const CLAIM_AVAILABLE_LUA = `
-if redis.call('ZCARD', KEYS[4]) == 0 then return { 'settled' } end
+local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[6]
+${META_LUA}
 local ready = redis.call('ZRANGE', KEYS[5], 0, -1)
 local excluded = {}
 for i = 1, tonumber(ARGV[4]) do excluded[ARGV[4 + i]] = true end
+local candidates = {}
+for _, field in ipairs(ready) do
+  if not excluded[field] then candidates[#candidates + 1] = field end
+end
+local rows = read_fields(candidates, { 'ce', 'd', 'fc', 'a', 'e', 'lf', 'lfa' })
 local claimed = {}
 local retry_at = nil
-for _, field in ipairs(ready) do
-  if not excluded[field] then
-    local expires = tonumber(redis.call('HGET', KEYS[3], field .. ':ce') or '0')
-    if expires > tonumber(ARGV[2]) then
-      if not retry_at or expires < retry_at then retry_at = expires end
-    else
-      local entries = redis.call('XRANGE', KEYS[1], field .. '-0', field .. '-0')
-      if #entries == 0 then return { 'missing', field } end
-      local attempt = redis.call('HINCRBY', KEYS[3], field .. ':d', 1)
-      redis.call('HSETNX', KEYS[3], field .. ':fc', ARGV[2])
-      redis.call('HSET', KEYS[3],
-        field .. ':lc', ARGV[2],
-        field .. ':ch', ARGV[1],
-        field .. ':ce', ARGV[3])
-      claimed[#claimed + 1] = {
-        tostring(attempt),
-        redis.call('HGET', KEYS[3], field .. ':a') or '0',
-        redis.call('HGET', KEYS[3], field .. ':e') or false,
-        redis.call('HGET', KEYS[3], field .. ':fc') or false,
-        ARGV[2],
-        redis.call('HGET', KEYS[3], field .. ':lf') or false,
-        redis.call('HGET', KEYS[3], field .. ':lfa') or false,
-        ARGV[1],
-        ARGV[3],
-        entries[1]
-      }
-    end
+for _, field in ipairs(candidates) do
+  local row = rows[field]
+  local expires = tonumber(row[1] or '0')
+  if expires > tonumber(ARGV[2]) then
+    if not retry_at or expires < retry_at then retry_at = expires end
+  else
+    local entries = redis.call('XRANGE', KEYS[1], field .. '-0', field .. '-0')
+    if #entries == 0 then return { 'missing', field } end
+    local attempt = tostring(tonumber(row[2] or '0') + 1)
+    local first_claimed = row[3] or ARGV[2]
+    local meta_key = mkey(field)
+    put(meta_key, field .. ':d', attempt)
+    put(meta_key, field .. ':fc', first_claimed)
+    put(meta_key, field .. ':lc', ARGV[2])
+    put(meta_key, field .. ':ch', ARGV[1])
+    put(meta_key, field .. ':ce', ARGV[3])
+    claimed[#claimed + 1] = {
+      attempt,
+      row[4] or '0',
+      row[5] or false,
+      first_claimed,
+      ARGV[2],
+      row[6] or false,
+      row[7] or false,
+      ARGV[1],
+      ARGV[3],
+      entries[1]
+    }
   end
 end
+flush()
 if #claimed > 0 then
   local result = { 'claimed', tostring(#claimed) }
   for _, claim in ipairs(claimed) do
     for _, value in ipairs(claim) do result[#result + 1] = value end
   end
+  result[#result + 1] = tostring(boundary)
   return result
 end
 if retry_at then return { 'busy', tostring(retry_at) } end
@@ -306,35 +555,43 @@ return { 'settled' }
 `
 
 /**
- * KEYS: counter, meta.
+ * KEYS: counter, meta, metadata split.
  * ARGV: holder, nowMs, expiresAtMs, n, then per claim: index, attempt.
  * Returns [renewedCount, ...renewed, ...superseded].
  */
 const RENEW_CLAIMS_LUA = `
-local total = tonumber(redis.call('GET', KEYS[1]) or '0')
-local renewed = {}
-local superseded = {}
+local COUNTER, META, SPLIT = KEYS[1], KEYS[2], KEYS[3]
+${META_LUA}
+local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
+local total = tonumber(counts[1] or '0')
+use_split(counts[2], counts[1], counts[3])
+local claims, fields, cleared = {}, {}, {}
 for i = 1, tonumber(ARGV[4]) do
   local field = ARGV[4 + (i - 1) * 2 + 1]
-  local attempt = tonumber(ARGV[4 + (i - 1) * 2 + 2])
   local idx = tonumber(field)
-  if idx >= 1 and idx <= total then
-    local dispatches = tonumber(redis.call('HGET', KEYS[2], field .. ':d') or '0')
-    if dispatches > attempt then
-      superseded[#superseded + 1] = field
-    else
-      local expires = tonumber(redis.call('HGET', KEYS[2], field .. ':ce') or '0')
-      if tonumber(ARGV[3]) > tonumber(ARGV[2]) and
-         redis.call('HEXISTS', KEYS[2], field .. ':p') == 0 and
-         redis.call('HEXISTS', KEYS[2], field .. ':f') == 0 and
-         redis.call('HGET', KEYS[2], field .. ':ch') == ARGV[1] and
-         expires > tonumber(ARGV[2]) then
-        redis.call('HSET', KEYS[2], field .. ':ce', ARGV[3])
-        renewed[#renewed + 1] = field
-      end
-    end
+  if idx <= boundary then
+    cleared[#cleared + 1] = field
+  elseif idx >= 1 and idx <= total then
+    claims[#claims + 1] = { field = field, attempt = tonumber(ARGV[4 + (i - 1) * 2 + 2]) }
+    fields[#fields + 1] = field
+  end
+end
+local rows = read_fields(fields, { 'd', 'ce', 'p', 'f', 'ch' })
+local renewed = {}
+local superseded = {}
+for _, claim in ipairs(claims) do
+  local row = rows[claim.field]
+  if tonumber(row[1] or '0') > claim.attempt then
+    superseded[#superseded + 1] = claim.field
+  elseif tonumber(ARGV[3]) > tonumber(ARGV[2]) and
+         not row[3] and not row[4] and row[5] == ARGV[1] and
+         tonumber(row[2] or '0') > tonumber(ARGV[2]) then
+    put(mkey(claim.field), claim.field .. ':ce', ARGV[3])
+    renewed[#renewed + 1] = claim.field
   end
 end
+flush()
+for _, field in ipairs(cleared) do superseded[#superseded + 1] = field end
 local result = { tostring(#renewed) }
 for i = 1, #renewed do result[#result + 1] = renewed[i] end
 for i = 1, #superseded do result[#result + 1] = superseded[i] end
@@ -342,85 +599,57 @@ return result
 `
 
 /**
- * KEYS: store, counter, ids, meta, pending, ready, watched,
- * event snapshot pins, snapshot pin counts.
+ * KEYS: store, counter, meta, pending, ready, event snapshot pins, snapshot
+ * pin counts, metadata split, then one id ownership key per child.
  * ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
  * id, type, payloadJson, lane, settled; finally notify channel.
  */
 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)
-  local lane = redis.call('HGET', KEYS[4], field .. ':l') or ''
+local COUNTER, META, SPLIT, PENDING, READY = KEYS[2], KEYS[3], KEYS[8], KEYS[4], KEYS[5]
+${META_LUA}
+${ENQUEUE_LUA}
+${ID_OWNERS_LUA}
+${RELEASE_PINS_LUA}
+${WAKE_LUA}
+local function settle(field, lane, next_field)
+  redis.call('ZREM', PENDING, field)
+  redis.call('ZREM', READY, field)
   if lane == '' then return end
   local head_key = lane_field(lane, 'head')
-  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[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)
+  if redis.call('HGET', META, head_key) ~= field then return end
+  while next_field do
+    local row = read_fields({ next_field }, { 'p', 'f', 'next' })[next_field]
+    if not row[1] then
+      redis.call('HSET', META, head_key, next_field)
+      if not row[2] then
+        redis.call('ZADD', READY, tonumber(next_field), next_field)
+      end
+      return
     end
-  else
-    redis.call('HDEL', KEYS[4], head_key, lane_field(lane, 'tail'))
-  end
-end
-local function enqueue(field, idx, lane)
-  redis.call('ZADD', KEYS[5], idx, field)
-  if lane == '' then
-    redis.call('ZADD', KEYS[6], idx, field)
-    return
-  end
-  local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[4], tail_key)
-  if tail then
-    redis.call('HSET', KEYS[4], tail .. ':next', field)
-  else
-    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[6], idx, field)
+    next_field = row[3]
   end
-  redis.call('HSET', KEYS[4], tail_key, field)
+  clear_lane(lane)
 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')
+local owners, count = read_owners(8, n, ARGV[1])
+local total = tonumber(count or '0')
+if tonumber(parent) <= boundary then return { 'superseded' } end
 if tonumber(parent) < 1 or tonumber(parent) > total then return { 'missing' } end
-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[4], parent .. ':ri')
-  if not raw_recorded_ids then return { 'partial' } end
-  local recorded_ids = cjson.decode(raw_recorded_ids)
+local row = read_fields({ parent }, { 'd', 'p', 'pa', 'ri', 'ch', 'f', 'lfa', 'l', 'next' })[parent]
+if row[2] then
+  if tonumber(row[3] or '0') ~= attempt then return { 'superseded' } end
+  if not row[4] then return { 'partial' } end
+  local recorded_ids = cjson.decode(row[4])
   if #recorded_ids ~= n then return { 'partial' } end
+  for i = 1, n do
+    if recorded_ids[i] ~= ARGV[5 + (i - 1) * 5 + 1] then return { 'partial' } end
+  end
   local indexes = {}
   for i = 1, n do
-    local id = ARGV[5 + (i - 1) * 5 + 1]
-    if recorded_ids[i] ~= id then return { 'partial' } end
-    local existing = redis.call('HGET', KEYS[3], id)
-    if not existing then return { 'partial' } end
-    local rec = cjson.decode(existing)
+    if not owners[i] then return { 'partial' } end
+    local rec = cjson.decode(owners[i])
     if rec[1] ~= ARGV[1] then return { 'partial' } end
     local entries = redis.call('XRANGE', KEYS[1], tostring(rec[2]) .. '-0', tostring(rec[2]) .. '-0')
     if #entries == 0 then return { 'partial' } end
@@ -439,62 +668,81 @@ if processed then
   for _, idx in ipairs(indexes) do result[#result + 1] = idx end
   return result
 end
-if dispatches ~= attempt then return { 'superseded' } end
-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
+if tonumber(row[1] or '0') ~= attempt then return { 'superseded' } end
+if not row[5] or row[6] or tonumber(row[7] or '0') == attempt then
   return { 'superseded' }
 end
 for i = 1, n do
-  local id = ARGV[5 + (i - 1) * 5 + 1]
-  if redis.call('HEXISTS', KEYS[3], id) == 1 then return { 'partial' } end
+  if owners[i] then return { 'partial' } end
 end
 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[4],
-  parent .. ':p', ARGV[2],
-  parent .. ':pa', ARGV[4],
-  parent .. ':ri', returned_json)
-redis.call('HDEL', KEYS[4], parent .. ':ch', parent .. ':ce')
-settle(parent)
-release_snapshot_pins()
+local parent_key = mkey(parent)
+put(parent_key, parent .. ':p', ARGV[2])
+put(parent_key, parent .. ':pa', ARGV[4])
+put(parent_key, parent .. ':ri', returned_json)
+redis.call('HDEL', parent_key, parent .. ':ch', parent .. ':ce')
+settle(parent, row[8] or '', row[9])
+release_snapshot_pins(KEYS[6], KEYS[7])
 local cause = cjson.encode({ index = tonumber(parent), attempt = attempt })
+local owner_writes = {}
 for i = 1, n do
-  local id = ARGV[5 + (i - 1) * 5 + 1]
-  local typ = ARGV[5 + (i - 1) * 5 + 2]
-  local payload = ARGV[5 + (i - 1) * 5 + 3]
-  local lane = ARGV[5 + (i - 1) * 5 + 4]
-  local settled = ARGV[5 + (i - 1) * 5 + 5]
-  local idx = total + i
-  redis.call('XADD', KEYS[1], tostring(idx) .. '-0',
-    '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[4], tostring(idx) .. ':l', lane)
-  if settled == '1' then
-    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
+  local o = 5 + (i - 1) * 5
+  local field = tostring(total + i)
+  redis.call('XADD', KEYS[1], field .. '-0',
+    'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
+    'created_at', ARGV[2], 'cause', cause, 'lane', ARGV[o + 4])
+  owner_writes[#owner_writes + 1] = KEYS[8 + i]
+  owner_writes[#owner_writes + 1] = cjson.encode({ ARGV[1], total + i })
+  wake_add(field, ARGV[o + 1], ARGV[o + 2], ARGV[o + 3])
+  if ARGV[o + 5] == '1' then
+    put(mkey(field), field .. ':p', ARGV[2])
   else
-    enqueue(tostring(idx), idx, lane)
+    enqueue(field, ARGV[o + 4])
   end
 end
-redis.call('SET', KEYS[2], tostring(total + n))
-if n > 0 and redis.call('EXISTS', KEYS[7]) == 1 then
-  redis.pcall('PUBLISH', ARGV[6 + n * 5], tostring(total + n))
+if n > 0 then
+  owner_writes[#owner_writes + 1] = COUNTER
+  owner_writes[#owner_writes + 1] = tostring(total + n)
+  split_write(owner_writes)
+  sliced('MSET', nil, owner_writes)
 end
+flush_queue()
+flush()
+if n > 0 then wake(ARGV[6 + n * 5], tostring(total + n), ARGV[2]) end
 return { 'ok', tostring(total + 1) }
 `
 
 /**
- * KEYS: head, history, event counter, event meta, pin counts.
+ * KEYS: head, history, event counter, event meta, pin counts, metadata split.
  * ARGV: nowMs, event pin key prefix, write count, then per write:
- * index, snapshot JSON, pin count, pin event indexes.
+ * index, snapshot JSON, pin count, pin event indexes; finally the reducer
+ * name. Writes from before the latest clear are dropped, and a head from
+ * before it is replaced as if absent.
  */
 const PUT_SNAPSHOTS_LUA = `
-local total = tonumber(redis.call('GET', KEYS[3]) or '0')
-local writes = {}
+local COUNTER, META, SPLIT = KEYS[3], KEYS[4], KEYS[6]
+${META_LUA}
+local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
+local total = tonumber(counts[1] or '0')
+use_split(counts[2], counts[1], counts[3])
+local pinned = {}
 local offset = 4
+for i = 1, tonumber(ARGV[3]) do
+  local pin_count = tonumber(ARGV[offset + 2])
+  for p = 1, pin_count do
+    local event_index = tonumber(ARGV[offset + 2 + p])
+    if event_index > boundary and event_index <= total then
+      pinned[#pinned + 1] = tostring(event_index)
+    end
+  end
+  offset = offset + 3 + pin_count
+end
+local status = read_fields(pinned, { 'p', 'f' })
+local snapshots = {}
+offset = 4
 for i = 1, tonumber(ARGV[3]) do
   local index = tonumber(ARGV[offset])
   local snapshot = ARGV[offset + 1]
@@ -502,23 +750,40 @@ for i = 1, tonumber(ARGV[3]) do
   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 row = status[tostring(event_index)]
+    if index >= boundary and event_index > boundary and event_index <= total and
+       not row[1] and not row[2] 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 }
+  if index >= boundary then
+    snapshots[#snapshots + 1] = { index = index, snapshot = snapshot, ref = ref }
+  end
   offset = offset + 3 + pin_count
 end
+if #snapshots == 0 then return 1 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 registered = false
+if head then
+  local record = cjson.decode(head)
+  head_index = tonumber(record['index'])
+  registered = record['r'] == 1
+end
+if head_index and head_index < boundary then
+  head, head_index, registered = nil, nil, false
+  redis.call('ZREMRANGEBYSCORE', KEYS[2], '-inf', '(' .. boundary)
+end
+-- Deletion finds each reducer's keys through this set instead of a scan.
+-- Heads written since carry the mark, so a reducer registers once.
+if not registered then
+  redis.call('SADD', string.sub(COUNTER, 1, -6) .. 'snap-reducers', ARGV[#ARGV])
+end
+local latest = snapshots[#snapshots]
 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
@@ -528,7 +793,7 @@ if advances and head and tonumber(redis.call('HGET', KEYS[5], cjson.encode({ KEY
   redis.call('ZADD', KEYS[2], head_index, head)
 end
 
-for _, write in ipairs(writes) do
+for _, write in ipairs(snapshots) 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
@@ -607,30 +872,242 @@ return live
 
 /**
  * KEYS: head, history, event counter. ARGV: snapshot frontier or ''.
- * Returns one atomic multiversion-cache-plus-log-frontier read.
+ * Returns one atomic multiversion-cache-plus-log-frontier read, with the
+ * clear boundary; checkpoints from before it are ignored.
  */
 const READ_STATE_LUA = `
+local counts = redis.call('MGET', KEYS[3], string.sub(KEYS[3], 1, -6) .. 'clear')
+local boundary = tonumber(counts[2] or '0')
 local head = redis.call('GET', KEYS[1])
 local head_index = head and cjson.decode(head)['index'] or nil
 if head and (type(head_index) ~= 'number' or head_index < 0 or head_index > 9007199254740991 or head_index ~= math.floor(head_index)) then
   return redis.error_reply('invalid snapshot head index')
 end
+if head_index and head_index < boundary then
+  head = nil
+  head_index = nil
+end
 local cap = ARGV[1]
 local snapshot = nil
 if head_index and (cap == '' or head_index <= tonumber(cap)) then
   snapshot = head
 else
   local upper = cap == '' and '+inf' or cap
-  local historical = redis.call('ZREVRANGEBYSCORE', KEYS[2], upper, '-inf', 'LIMIT', 0, 1)
+  local historical = redis.call('ZREVRANGEBYSCORE', KEYS[2], upper, boundary, 'LIMIT', 0, 1)
   if #historical > 0 then snapshot = historical[1] end
 end
-local frontier = redis.call('GET', KEYS[3]) or '0'
-return { head_index or '', snapshot or '', frontier }
+return { head_index or '', snapshot or '', counts[1] or '0', tostring(boundary) }
+`
+
+/**
+ * Removes every registered reducer's checkpoints below the latest clear, and
+ * the pin counts that name them. Snapshot writes register each reducer in
+ * {prefix}:{session}:snap-reducers, so no key scan is needed.
+ */
+const SWEEP_CHECKPOINTS_LUA = `
+local function sweep_checkpoints(session, boundary)
+  for _, reducer in ipairs(redis.call('SMEMBERS', session .. 'snap-reducers')) do
+    local head_key = session .. 'snap:' .. reducer
+    local head = redis.call('GET', head_key)
+    if head and tonumber(cjson.decode(head)['index']) < boundary then
+      redis.call('DEL', head_key)
+    end
+    redis.call('ZREMRANGEBYSCORE', session .. 'snap-history:' .. reducer, '-inf', '(' .. boundary)
+  end
+  local counts_key = session .. 'snapshot-pin-counts'
+  local counts = redis.call('HGETALL', counts_key)
+  local stale = {}
+  for i = 1, #counts, 2 do
+    if tonumber(cjson.decode(counts[i])[2]) < boundary then stale[#stale + 1] = counts[i] end
+  end
+  if #stale > 0 then redis.call('HDEL', counts_key, unpack(stale)) end
+end
+`
+
+/**
+ * KEYS: store stream, counter, metadata, metadata split, marker id ownership
+ * key, pending, ready.
+ * ARGV: sessionId, nowMs, ifLastIndex or '', cause index or '', cause
+ * attempt, marker id, notify channel.
+ * Returns ['ok', cleared, head, boundary] | ['no_parent', idx] |
+ * ['superseded', idx] | ['foreign']. The old lifetime's log moves aside in one
+ * RENAME, so every read of the log starts at the marker, and its queues are
+ * unlinked, so claims and pending checks see only the new lifetime; deletion
+ * drains the moved log.
+ */
+const CLEAR_LUA = `
+local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[4]
+${META_LUA}
+${WAKE_LUA}
+local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR, KEYS[5])
+local head = tonumber(counts[1] or '0')
+use_split(counts[2], counts[1], counts[3])
+if ARGV[4] ~= '' then
+  local field = ARGV[4]
+  local pidx = tonumber(field)
+  if pidx <= boundary then return { 'superseded', field } end
+  if pidx < 1 or pidx > head then return { 'no_parent', field } end
+  local row = read_fields({ field }, { 'd', 'f' })[field]
+  if tonumber(row[1] or '0') ~= tonumber(ARGV[5]) or row[2] then
+    return { 'superseded', field }
+  end
+end
+local expected = ARGV[3]
+if expected ~= '' and boundary == tonumber(expected) + 1 then
+  return { 'ok', '1', tostring(head), tostring(boundary) }
+end
+if expected ~= '' and tonumber(expected) ~= head then
+  return { 'ok', '0', tostring(head), tostring(boundary) }
+end
+if head == 0 or boundary == head then
+  return { 'ok', '1', tostring(head), tostring(boundary) }
+end
+if counts[4] then return { 'foreign' } end
+local field = tostring(head + 1)
+local session = string.sub(COUNTER, 1, -6)
+local moved = session .. 'cleared:' .. field
+redis.call('RENAME', KEYS[1], moved)
+redis.call('UNLINK', KEYS[6], KEYS[7])
+redis.call('SADD', session .. 'cleared', moved)
+redis.call('XADD', KEYS[1], field .. '-0',
+  'id', ARGV[6], 'type', '${CLEAR_EVENT_TYPE}', 'payload', 'null',
+  'created_at', ARGV[2], 'cause', '', 'lane', '')
+local writes = { KEYS[5], cjson.encode({ ARGV[1], head + 1 }), COUNTER, field, CLEAR, field }
+split_write(writes)
+redis.call('MSET', unpack(writes))
+put(mkey(field), field .. ':p', ARGV[2])
+flush()
+wake_add(field, ARGV[6], '${CLEAR_EVENT_TYPE}', 'null')
+wake(ARGV[7], field, ARGV[2])
+return { 'ok', '1', field, field }
+`
+
+/**
+ * KEYS: counter. ARGV: page size.
+ * The next deletion batch: a moved log and up to a page of its [index, id]
+ * pairs, without payloads. Empty moved logs are dropped; with none left it
+ * sweeps the old checkpoints and returns nothing, so a retry finishes an
+ * interrupted deletion.
+ */
+const RECLAIM_BATCH_LUA = `
+${SWEEP_CHECKPOINTS_LUA}
+local session = string.sub(KEYS[1], 1, -6)
+local boundary = tonumber(redis.call('GET', session .. 'clear') or '0')
+if boundary == 0 then return {} end
+for _, log in ipairs(redis.call('SMEMBERS', session .. 'cleared')) do
+  local entries = redis.call('XRANGE', log, '-', '+', 'COUNT', ARGV[1])
+  if #entries > 0 then
+    local batch = { log }
+    for _, entry in ipairs(entries) do
+      local fields = entry[2]
+      for i = 1, #fields, 2 do
+        if fields[i] == 'id' then
+          batch[#batch + 1] = string.match(entry[1], '^(%d+)')
+          batch[#batch + 1] = fields[i + 1]
+          break
+        end
+      end
+    end
+    return batch
+  end
+  redis.call('DEL', log)
+  redis.call('SREM', session .. 'cleared', log)
+end
+sweep_checkpoints(session, boundary)
+return {}
+`
+
+/**
+ * KEYS: moved log, counter, metadata, metadata split, then one id ownership
+ * key per entry.
+ * ARGV: sessionId, event pin key prefix, n, then per entry: index, id.
+ * Deletes the listed entries below the latest clear and everything that
+ * names them. An id record survives when it names another event, so an id
+ * reused in the new lifetime keeps its owner. Returns [deleted, done].
+ */
+const RECLAIM_LUA = `
+local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[4]
+${META_LUA}
+${SWEEP_CHECKPOINTS_LUA}
+local function lane_field(lane, suffix)
+  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
+end
+local session = string.sub(COUNTER, 1, -6)
+local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
+use_split(counts[2], counts[1], counts[3])
+local fields, id_keys, indexes, stream_ids, pin_keys, deleted = {}, {}, {}, {}, {}, {}
+-- A concurrent reclaim may list the same batch; only XDEL says who removed it.
+local removed = 0
+for i = 1, tonumber(ARGV[3]) do
+  local field = ARGV[3 + (i - 1) * 2 + 1]
+  if tonumber(field) < boundary then
+    fields[#fields + 1] = field
+    id_keys[#fields] = KEYS[4 + i]
+    indexes[#fields] = tonumber(field)
+    stream_ids[#fields] = field .. '-0'
+    pin_keys[#fields] = ARGV[2] .. field
+    deleted[field] = true
+  end
+end
+if #fields > 0 then
+  local lanes, seen, pointers = read_fields(fields, { 'l' }), {}, {}
+  for _, field in ipairs(fields) do
+    local lane = lanes[field][1]
+    if lane and lane ~= '' and not seen[lane] then
+      seen[lane] = true
+      pointers[#pointers + 1] = lane_field(lane, 'head')
+      pointers[#pointers + 1] = lane_field(lane, 'tail')
+    end
+  end
+  if #pointers > 0 then
+    local values = redis.call('HMGET', META, unpack(pointers))
+    local stale = {}
+    for i = 1, #pointers do
+      if values[i] and deleted[values[i]] then stale[#stale + 1] = pointers[i] end
+    end
+    if #stale > 0 then redis.call('HDEL', META, unpack(stale)) end
+  end
+  local suffixes = { 'l', 'next', 'p', 'pa', 'ri', 'ch', 'ce', 'f', 'fc', 'lc', 'lf', 'lfa', 'd', 'a', 'e' }
+  local columns, order = {}, {}
+  for _, field in ipairs(fields) do
+    local key = mkey(field)
+    if not columns[key] then
+      columns[key] = {}
+      order[#order + 1] = key
+    end
+    for _, suffix in ipairs(suffixes) do
+      columns[key][#columns[key] + 1] = field .. ':' .. suffix
+    end
+  end
+  for _, key in ipairs(order) do sliced('HDEL', key, columns[key]) end
+  sliced('DEL', nil, pin_keys)
+  local owners, stale_ids = sliced('MGET', nil, id_keys), {}
+  for i = 1, #fields do
+    if owners[i] then
+      local rec = cjson.decode(owners[i])
+      if rec[1] == ARGV[1] and tonumber(rec[2]) == indexes[i] then
+        stale_ids[#stale_ids + 1] = id_keys[i]
+      end
+    end
+  end
+  if #stale_ids > 0 then sliced('DEL', nil, stale_ids) end
+  removed = redis.call('XDEL', KEYS[1], unpack(stream_ids))
+end
+local done = 0
+if redis.call('XLEN', KEYS[1]) == 0 then
+  redis.call('DEL', KEYS[1])
+  redis.call('SREM', session .. 'cleared', KEYS[1])
+  if redis.call('SCARD', session .. 'cleared') == 0 then
+    sweep_checkpoints(session, boundary)
+    done = 1
+  end
+end
+return { removed, done }
 `
 
 // ── wire helpers ─────────────────────────────────────────────────────
 
-type StreamEntry = [id: string, fields: string[]]
+export type StreamEntry = [id: string, fields: string[]]
 
 const fieldMap = (fields: string[]): Record<string, string> => {
   const map: Record<string, string> = {}
@@ -671,6 +1148,66 @@ const toEvent = (sessionId: string, entry: StreamEntry): Event => {
   }
 }
 
+type ByteStreamEntry = [Uint8Array, Uint8Array[]]
+
+const fieldBytes = (name: string): Uint8Array => new TextEncoder().encode(name)
+const ID_FIELD = fieldBytes('id')
+const TYPE_FIELD = fieldBytes('type')
+const PAYLOAD_FIELD = fieldBytes('payload')
+const CREATED_AT_FIELD = fieldBytes('created_at')
+// A leading U+FEFF is part of a stored id or type, never a byte-order mark.
+const utf8 = new TextDecoder('utf-8', { ignoreBOM: true })
+
+const isField = (name: Uint8Array, field: Uint8Array): boolean => {
+  if (name.length !== field.length) return false
+  for (let at = 0; at < field.length; at++)
+    if (name[at] !== field[at]) return false
+  return true
+}
+
+const bytesToSerializedEvent = (
+  sessionId: string,
+  entry: ByteStreamEntry,
+): SerializedEvent => {
+  const values = entry[1]
+  let id: string | undefined
+  let type: string | undefined
+  let payloadJson: string | undefined
+  let createdAt: string | undefined
+  for (let at = 0; at + 1 < values.length; at += 2) {
+    const name = values[at]!
+    if (isField(name, ID_FIELD)) id = utf8.decode(values[at + 1])
+    else if (isField(name, TYPE_FIELD)) type = utf8.decode(values[at + 1])
+    else if (isField(name, PAYLOAD_FIELD))
+      payloadJson = utf8.decode(values[at + 1])
+    else if (isField(name, CREATED_AT_FIELD))
+      createdAt = utf8.decode(values[at + 1])
+  }
+  return {
+    id: id!,
+    type: type!,
+    payloadJson: payloadJson!,
+    index: entryIndex(utf8.decode(entry[0])),
+    sessionId,
+    createdAtMs: Number(createdAt),
+  }
+}
+
+const toSerializedEvent = (
+  sessionId: string,
+  entry: StreamEntry,
+): SerializedEvent => {
+  const fields = fieldMap(entry[1])
+  return {
+    id: fields['id']!,
+    type: fields['type']!,
+    payloadJson: fields['payload']!,
+    index: entryIndex(entry[0]),
+    sessionId,
+    createdAtMs: Number(fields['created_at']),
+  }
+}
+
 const json = (value: unknown): string => JSON.stringify(value) ?? 'null'
 
 const toCause = (raw: string | undefined): EventCause | null => {
@@ -744,6 +1281,9 @@ const toClaimAvailableResult = (
         }),
       )
     }
+    const clearIndex = Number(reply[2 + count * 10] ?? 0)
+    if (clearIndex > 0)
+      for (const event of events) event.clearIndex = clearIndex
     return {
       outcome: 'claimed',
       events,
@@ -758,6 +1298,57 @@ const toClaimAvailableResult = (
   )
 }
 
+const toIndex = ({
+  raw,
+  sessionId,
+  name,
+}: {
+  raw: unknown
+  sessionId: string
+  name: string
+}): number => {
+  const index = Number(raw ?? 0)
+  if (!Number.isSafeInteger(index) || index < 0) {
+    throw new A2Error(
+      'STORE_UNAVAILABLE',
+      `redis ${name} for session '${sessionId}' is invalid`,
+    )
+  }
+  return index
+}
+
+/**
+ * A range read that met a gap. A clear moves the old lifetime's log aside, so
+ * a read whose bounds predate it finds nothing where it expected events;
+ * anywhere else a gap is corruption.
+ */
+const rangeGap = (sessionId: string, message: string): A2Error =>
+  Object.assign(
+    new A2Error(
+      'STORE_UNAVAILABLE',
+      `redis event range for session '${sessionId}' ${message}`,
+    ),
+    { rangeGap: true },
+  )
+
+const isRangeGap = (error: unknown): boolean =>
+  error instanceof A2Error &&
+  (error as { rangeGap?: boolean }).rangeGap === true
+
+/**
+ * Run a whole read, bounds included. A gap means a clear raced it, so the
+ * read runs once more from fresh bounds. A second gap, from another clear or
+ * from corruption, surfaces as the retryable STORE_UNAVAILABLE.
+ */
+const retryAfterGap = async <T>(read: () => Promise<T>): Promise<T> => {
+  try {
+    return await read()
+  } catch (error) {
+    if (!isRangeGap(error)) throw error
+    return read()
+  }
+}
+
 const wrap = async <T>(fn: () => Promise<T>): Promise<T> => {
   try {
     return await fn()
@@ -772,13 +1363,16 @@ const wrap = async <T>(fn: () => Promise<T>): Promise<T> => {
 export function createRedisStoreCore(
   options: RedisStoreCoreOptions,
 ): RedisStoreCore {
-  const { call, clock } = options
+  const { call, callBytes, clock } = options
   const generateId = options.ids
   const prefix = options.keyPrefix
 
   const storeKey = (s: string): string => `${prefix}:${s}:log`
   const countKey = (s: string): string => `${prefix}:${s}:count`
   const metaKey = (s: string): string => `${prefix}:${s}:meta`
+  const metaChunkKey = (s: string, index: number): string =>
+    `${metaKey(s)}:${Math.floor((index - 1) / META_CHUNK_SIZE)}`
+  const metaSplitKey = (s: string): string => `${prefix}:${s}:meta-split`
   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}`
@@ -790,9 +1384,15 @@ export function createRedisStoreCore(
     `${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`
+  // Scripts derive this from the counter key; keep the two in step.
+  const clearKey = (s: string): string => `${prefix}:${s}:clear`
+  // One ownership key per event id; reclaim deletes those naming cleared events.
+  // Session ids are raw and may contain colons, so a raw id could name a
+  // session key (`ids:count`). A JSON string with escaped colons starts with
+  // a quote and has no colon, so it never matches a session key's suffix.
+  const idKey = (id: string): string =>
+    `${prefix}:ids:${JSON.stringify(id).replaceAll(':', '\\u003a')}`
 
   const evalScript = (
     script: string,
@@ -800,23 +1400,37 @@ export function createRedisStoreCore(
     args: Array<string | number>,
   ): Promise<unknown> => call('EVAL', script, keys.length, ...keys, ...args)
 
-  const readFrontier = async (sessionId: string): Promise<number> => {
-    const frontier = Number((await call('GET', countKey(sessionId))) ?? 0)
-    if (!Number.isSafeInteger(frontier) || frontier < 0) {
-      throw new A2Error(
-        'STORE_UNAVAILABLE',
-        `redis event count for session '${sessionId}' is invalid`,
-      )
+  const readRangeBounds = async (
+    sessionId: string,
+  ): Promise<{ frontier: number; metaSplit: number; clearIndex: number }> => {
+    const [count, split, cleared] = (await call(
+      'MGET',
+      countKey(sessionId),
+      metaSplitKey(sessionId),
+      clearKey(sessionId),
+    )) as [unknown, unknown, unknown]
+    const frontier = toIndex({ raw: count, sessionId, name: 'event count' })
+    return {
+      frontier,
+      metaSplit:
+        split === null
+          ? frontier
+          : toIndex({ raw: split, sessionId, name: 'metadata split' }),
+      clearIndex: toIndex({ raw: cleared, sessionId, name: 'clear boundary' }),
     }
-    return frontier
   }
 
-  const readRangePage = async (
-    sessionId: string,
-    afterIndex: number,
-    throughIndex: number,
-    limit: number,
-  ): Promise<StoredEvent[]> => {
+  const readRangePage = async ({
+    sessionId,
+    afterIndex,
+    throughIndex,
+    metaSplit,
+  }: {
+    sessionId: string
+    afterIndex: number
+    throughIndex: number
+    metaSplit: number
+  }): Promise<StoredEvent[]> => {
     if (throughIndex <= afterIndex) return []
     const entries = (await call(
       'XRANGE',
@@ -824,23 +1438,36 @@ export function createRedisStoreCore(
       `${afterIndex + 1}-0`,
       `${throughIndex}-0`,
       'COUNT',
-      limit,
+      READ_PAGE_SIZE,
     )) as StreamEntry[]
     if (entries.length === 0) return []
 
-    const metaFields = entries.flatMap((entry) => {
+    const fieldsByKey = new Map<string, string[]>()
+    for (const entry of entries) {
       const index = entryIndex(entry[0])
-      return STORED_EVENT_META_SUFFIXES.map((suffix) => `${index}:${suffix}`)
-    })
-    const metaValues =
-      ((await call('HMGET', metaKey(sessionId), ...metaFields)) as Array<
-        string | null
-      > | null) ?? []
+      const key =
+        index <= metaSplit ? metaKey(sessionId) : metaChunkKey(sessionId, index)
+      const fields = fieldsByKey.get(key) ?? []
+      fields.push(
+        ...STORED_EVENT_META_SUFFIXES.map((suffix) => `${index}:${suffix}`),
+      )
+      fieldsByKey.set(key, fields)
+    }
+    const lookups = [...fieldsByKey]
+    const results = await Promise.allSettled(
+      lookups.map(([key, fields]) => call('HMGET', key, ...fields)),
+    )
     const meta: Record<string, string> = {}
-    for (let i = 0; i < metaFields.length; i += 1) {
-      const value = metaValues[i]
-      if (value !== null && value !== undefined) {
-        meta[metaFields[i]!] = value
+    for (let position = 0; position < lookups.length; position += 1) {
+      const result = results[position]!
+      if (result.status === 'rejected') throw result.reason
+      const fields = lookups[position]![1]
+      const values = (result.value as Array<string | null> | null) ?? []
+      for (let i = 0; i < fields.length; i += 1) {
+        const value = values[i]
+        if (value !== null && value !== undefined) {
+          meta[fields[i]!] = value
+        }
       }
     }
     return entries.map((entry) => {
@@ -910,18 +1537,12 @@ export function createRedisStoreCore(
         READ_PAGE_SIZE,
       )) as StreamEntry[]
       if (entries.length === 0) {
-        throw new A2Error(
-          'STORE_UNAVAILABLE',
-          `redis event range for session '${sessionId}' ended before index ${throughIndex}`,
-        )
+        throw rangeGap(sessionId, `ended before index ${throughIndex}`)
       }
       for (let position = 0; position < entries.length; position += 1) {
         const index = entryIndex(entries[position]![0])
         if (index !== nextIndex + position || index > throughIndex) {
-          throw new A2Error(
-            'STORE_UNAVAILABLE',
-            `redis event range for session '${sessionId}' is not contiguous`,
-          )
+          throw rangeGap(sessionId, 'is not contiguous')
         }
       }
       events.push(...entries.map((entry) => toEvent(sessionId, entry)))
@@ -972,34 +1593,43 @@ export function createRedisStoreCore(
     sessionId: string,
     afterIndex: number,
     throughIndex?: number,
-  ): Promise<StoredEvent[]> => {
-    if (throughIndex !== undefined && throughIndex <= afterIndex) return []
-    const currentFrontier = await readFrontier(sessionId)
+  ): Promise<StoredEvent[]> =>
+    (await readBoundedRange(sessionId, afterIndex, throughIndex)).rows
+
+  /** `readRange`, with the clear boundary its rows start at. */
+  const readBoundedRange = async (
+    sessionId: string,
+    afterIndex: number,
+    throughIndex?: number,
+  ): Promise<{ rows: StoredEvent[]; clearIndex: number }> => {
+    if (throughIndex !== undefined && throughIndex <= afterIndex)
+      return { rows: [], clearIndex: 0 }
+    const {
+      frontier: currentFrontier,
+      metaSplit,
+      clearIndex,
+    } = await readRangeBounds(sessionId)
     const frontier = Math.min(throughIndex ?? currentFrontier, currentFrontier)
-    if (frontier <= afterIndex) return []
+    // Reads start at the latest clear marker.
+    const after = Math.max(afterIndex, clearIndex - 1)
+    if (frontier <= after) return { rows: [], clearIndex }
 
     const rows: StoredEvent[] = []
-    let nextIndex = afterIndex + 1
+    let nextIndex = after + 1
     while (nextIndex <= frontier) {
       // oxlint-disable-next-line no-await-in-loop -- each page advances the dense frozen range
-      const page = await readRangePage(
+      const page = await readRangePage({
         sessionId,
-        nextIndex - 1,
-        frontier,
-        READ_PAGE_SIZE,
-      )
+        afterIndex: nextIndex - 1,
+        throughIndex: frontier,
+        metaSplit,
+      })
       if (page.length === 0) {
-        throw new A2Error(
-          'STORE_UNAVAILABLE',
-          `redis event range for session '${sessionId}' ended before index ${frontier}`,
-        )
+        throw rangeGap(sessionId, `ended before index ${frontier}`)
       }
       for (let position = 0; position < page.length; position += 1) {
         if (page[position]!.index !== nextIndex + position) {
-          throw new A2Error(
-            'STORE_UNAVAILABLE',
-            `redis event range for session '${sessionId}' is not contiguous`,
-          )
+          throw rangeGap(sessionId, 'is not contiguous')
         }
       }
       const lastIndex = page.at(-1)!.index
@@ -1012,11 +1642,45 @@ export function createRedisStoreCore(
       rows.push(...page)
       nextIndex = lastIndex + 1
     }
-    return rows
+    return { rows, clearIndex }
   }
 
+  const readStream = options.readStream
   return {
-    async append(sessionId, events) {
+    ...(readStream
+      ? {
+          streamEvents: async function* ({
+            sessionId,
+            afterIndex,
+            signal,
+          }: {
+            sessionId: string
+            afterIndex: number
+            signal: AbortSignal
+          }): AsyncGenerator<SerializedEvent[], void> {
+            try {
+              for await (const entries of readStream({
+                key: storeKey(sessionId),
+                from: `${afterIndex + 1}-0`,
+                signal,
+              })) {
+                signal.throwIfAborted()
+                yield entries.map((entry) =>
+                  toSerializedEvent(sessionId, entry),
+                )
+              }
+            } catch (cause) {
+              if (cause instanceof A2Error) throw cause
+              throw new A2Error(
+                'STORE_UNAVAILABLE',
+                'redis stream read failed',
+                { cause },
+              )
+            }
+          },
+        }
+      : {}),
+    async append(sessionId, events, appendOptions) {
       return wrap(async () => {
         const supplied = events.filter((e) => e.id !== undefined)
         const suppliedIds = supplied.map((e) => e.id as string)
@@ -1048,17 +1712,18 @@ export function createRedisStoreCore(
             e.settled ? '1' : '0',
           ]),
           `${prefix}:${sessionId}:notify`,
+          appendOptions?.originIndex ?? '',
         ]
         const reply = (await evalScript(
           APPEND_LUA,
           [
             storeKey(sessionId),
             countKey(sessionId),
-            idsKey,
             metaKey(sessionId),
             pendingKey(sessionId),
             readyKey(sessionId),
-            watchedKey(sessionId),
+            metaSplitKey(sessionId),
+            ...withIds.map((e) => idKey(e.id)),
           ],
           args,
         )) as string[]
@@ -1078,6 +1743,11 @@ export function createRedisStoreCore(
             `no event at index ${reply[1]} in session '${sessionId}'`,
           )
         }
+        if (verdict === 'cleared') {
+          throw sessionClearedError(
+            `scheduled work from event ${reply[1]} was cleared in session '${sessionId}'`,
+          )
+        }
         if (verdict === 'superseded') {
           throw new A2Error(
             'SUPERSEDED_ATTEMPT',
@@ -1091,13 +1761,23 @@ export function createRedisStoreCore(
           )
         }
         if (verdict === 'dup') {
-          // A retry of a committed batch whose ack was lost — return
-          // the original rows, ordered by index like every adapter.
           const hasPending = reply[1] === '1'
-          const wanted = new Set(reply.slice(2).map(Number))
-          const min = Math.min(...wanted)
-          const rows = await readRange(sessionId, min - 1)
-          const existing = rows.filter((row) => wanted.has(row.index))
+          const firstIndex = Math.min(...reply.slice(2).map(Number))
+          // A valid retry occupies exactly events.length consecutive indexes.
+          const { rows: existing, clearIndex } = await retryAfterGap(() =>
+            readBoundedRange(
+              sessionId,
+              firstIndex - 1,
+              firstIndex + events.length - 1,
+            ),
+          )
+          if (firstIndex < clearIndex) {
+            // Cleared after the script matched the retry: the ids are free.
+            throw new A2Error(
+              'STORE_UNAVAILABLE',
+              `session '${sessionId}' was cleared while an append retry replayed; retry it`,
+            )
+          }
           return {
             events: idempotentReplay(events, existing),
             hasPending,
@@ -1134,28 +1814,42 @@ export function createRedisStoreCore(
     },
 
     async read(sessionId, opts) {
-      return wrap(async () => {
-        const rows = await readRange(
-          sessionId,
-          opts?.afterIndex ?? 0,
-          opts?.throughIndex,
-        )
-        return rows
-      })
+      return wrap(() =>
+        retryAfterGap(() =>
+          readRange(sessionId, opts?.afterIndex ?? 0, opts?.throughIndex),
+        ),
+      )
     },
 
     async readHistory(sessionId, opts) {
-      return wrap(async () => {
-        const after = opts?.afterIndex ?? 0
-        if (opts?.throughIndex !== undefined && opts.throughIndex <= after)
-          return []
-        const frontier = await readFrontier(sessionId)
-        return readEventRange(
-          sessionId,
-          after,
-          Math.min(opts?.throughIndex ?? frontier, frontier),
-        )
-      })
+      const after = opts?.afterIndex ?? 0
+      if (opts?.throughIndex !== undefined && opts.throughIndex <= after)
+        return []
+      return wrap(() =>
+        retryAfterGap(async () => {
+          const [count, cleared] = (await call(
+            'MGET',
+            countKey(sessionId),
+            clearKey(sessionId),
+          )) as [unknown, unknown]
+          const frontier = toIndex({
+            raw: count,
+            sessionId,
+            name: 'event count',
+          })
+          const clearIndex = toIndex({
+            raw: cleared,
+            sessionId,
+            name: 'clear boundary',
+          })
+          // Reads start at the latest clear marker.
+          return readEventRange(
+            sessionId,
+            Math.max(after, clearIndex - 1),
+            Math.min(opts?.throughIndex ?? frontier, frontier),
+          )
+        }),
+      )
     },
 
     async claimAvailable({
@@ -1177,6 +1871,7 @@ export function createRedisStoreCore(
             metaKey(sessionId),
             pendingKey(sessionId),
             readyKey(sessionId),
+            metaSplitKey(sessionId),
           ],
           [holder, now, expiresAt, excluded.length, ...excluded],
         )) as unknown[]
@@ -1190,7 +1885,7 @@ export function createRedisStoreCore(
         const expiresAt = expiresAtMs ?? now + ttlMs
         const reply = (await evalScript(
           RENEW_CLAIMS_LUA,
-          [countKey(sessionId), metaKey(sessionId)],
+          [countKey(sessionId), metaKey(sessionId), metaSplitKey(sessionId)],
           [
             holder,
             now,
@@ -1223,13 +1918,13 @@ export function createRedisStoreCore(
           [
             storeKey(sessionId),
             countKey(sessionId),
-            idsKey,
             metaKey(sessionId),
             pendingKey(sessionId),
             readyKey(sessionId),
-            watchedKey(sessionId),
             snapshotEventPinsKey(sessionId, index),
             snapshotPinCountsKey(sessionId),
+            metaSplitKey(sessionId),
+            ...ids.map((id) => idKey(id)),
           ],
           [
             sessionId,
@@ -1295,13 +1990,16 @@ export function createRedisStoreCore(
           if (events.length === 0) {
             return { outcome: 'completed', events: [] }
           }
-          const wanted = new Set(reply.slice(1).map(Number))
-          const min = Math.min(...wanted)
-          const rows = await readRange(sessionId, min - 1)
-          const byIndex = new Map(rows.map((row) => [row.index, row]))
-          const existing = reply
-            .slice(1)
-            .map((value) => byIndex.get(Number(value))!)
+          const firstIndex = Math.min(...reply.slice(1).map(Number))
+          const { rows: existing, clearIndex } = await retryAfterGap(() =>
+            readBoundedRange(
+              sessionId,
+              firstIndex - 1,
+              firstIndex + events.length - 1,
+            ),
+          )
+          // Cleared after the script matched the retry.
+          if (index <= clearIndex) return { outcome: 'superseded' }
           return {
             outcome: 'completed',
             events: idempotentReplay(events, existing),
@@ -1322,10 +2020,13 @@ export function createRedisStoreCore(
             readyKey(sessionId),
             snapshotEventPinsKey(sessionId, index),
             snapshotPinCountsKey(sessionId),
+            metaSplitKey(sessionId),
           ],
           [index, attempt, error, maxFailures, clock.now().getTime()],
         )) as string[]
         const outcome = reply[0]
+        if (outcome === 'cleared')
+          return { outcome: 'superseded', failureCount: 0 }
         if (outcome === 'missing') {
           throw new TypeError(
             `no event at index ${index} in session '${sessionId}'`,
@@ -1339,59 +2040,64 @@ export function createRedisStoreCore(
     },
 
     async readState(sessionId, reducerName, stateOptions) {
-      return wrap(async () => {
-        const reply = (await evalScript(
-          READ_STATE_LUA,
-          [
-            snapKey(sessionId, reducerName),
-            snapHistoryKey(sessionId, reducerName),
-            countKey(sessionId),
-          ],
-          [
-            stateOptions?.snapshotThroughIndex ??
-              stateOptions?.throughIndex ??
-              '',
-          ],
-        )) as [number | string, string, string]
-        const rawHead = reply[0]
-        const raw = reply[1]
-        const headIndex = rawHead === '' ? null : Number(rawHead)
-        const parsed =
-          raw === ''
-            ? null
-            : (JSON.parse(raw) as { index: number; state: unknown })
-        const currentFrontier = Number(reply[2])
-        if (
-          !Number.isSafeInteger(currentFrontier) ||
-          currentFrontier < 0 ||
-          (headIndex !== null &&
-            (!Number.isSafeInteger(headIndex) || headIndex < 0)) ||
-          (parsed !== null &&
-            (!Number.isSafeInteger(parsed.index) || parsed.index < 0))
-        ) {
-          throw new A2Error(
-            'STORE_UNAVAILABLE',
-            `redis state frontier for session '${sessionId}' is invalid`,
+      return wrap(() =>
+        retryAfterGap(async () => {
+          const reply = (await evalScript(
+            READ_STATE_LUA,
+            [
+              snapKey(sessionId, reducerName),
+              snapHistoryKey(sessionId, reducerName),
+              countKey(sessionId),
+            ],
+            [
+              stateOptions?.snapshotThroughIndex ??
+                stateOptions?.throughIndex ??
+                '',
+            ],
+          )) as [number | string, string, string, string]
+          const rawHead = reply[0]
+          const raw = reply[1]
+          const headIndex = rawHead === '' ? null : Number(rawHead)
+          const parsed =
+            raw === ''
+              ? null
+              : (JSON.parse(raw) as { index: number; state: unknown })
+          const currentFrontier = Number(reply[2])
+          if (
+            !Number.isSafeInteger(currentFrontier) ||
+            currentFrontier < 0 ||
+            (headIndex !== null &&
+              (!Number.isSafeInteger(headIndex) || headIndex < 0)) ||
+            (parsed !== null &&
+              (!Number.isSafeInteger(parsed.index) || parsed.index < 0))
+          ) {
+            throw new A2Error(
+              'STORE_UNAVAILABLE',
+              `redis state frontier for session '${sessionId}' is invalid`,
+            )
+          }
+          const frontier = Math.min(
+            currentFrontier,
+            stateOptions?.throughIndex ?? currentFrontier,
           )
-        }
-        const frontier = Math.min(
-          currentFrontier,
-          stateOptions?.throughIndex ?? currentFrontier,
-        )
-        const snapshot = parsed
-        const events = await readEventRange(
-          sessionId,
-          snapshot?.index ?? 0,
-          frontier,
-        )
-        return {
-          headIndex,
-          snapshot: snapshot
-            ? { index: snapshot.index, state: snapshot.state }
-            : null,
-          events,
-        }
-      })
+          const snapshot = parsed
+          const clearIndex = Number(reply[3] ?? 0)
+          // The fold starts at the latest clear marker when no checkpoint is newer.
+          const events = await readEventRange(
+            sessionId,
+            Math.max(snapshot?.index ?? 0, clearIndex - 1),
+            frontier,
+          )
+          return {
+            ...(clearIndex > 0 ? { clearIndex } : {}),
+            headIndex,
+            snapshot: snapshot
+              ? { index: snapshot.index, state: snapshot.state }
+              : null,
+            events,
+          }
+        }),
+      )
     },
 
     async putSnapshots(sessionId, reducerName, writes) {
@@ -1431,6 +2137,8 @@ export function createRedisStoreCore(
               index: write.index,
               state: write.state,
               updatedAt: clock.now().getTime(),
+              // This reducer is in the session's registry (PUT_SNAPSHOTS_LUA).
+              r: 1,
             }),
             write.pinEventIndexes.size,
             ...write.pinEventIndexes,
@@ -1444,8 +2152,9 @@ export function createRedisStoreCore(
             countKey(sessionId),
             metaKey(sessionId),
             snapshotPinCountsKey(sessionId),
+            metaSplitKey(sessionId),
           ],
-          args,
+          [...args, reducerName],
         )
       })
     },
@@ -1540,6 +2249,105 @@ export function createRedisStoreCore(
       return wrap(() => readRange(sessionId, afterIndex, throughIndex))
     },
 
+    async readTail(sessionId, fromIndex, throughIndex) {
+      return wrap(async () => {
+        const newest = (await call(
+          'XREVRANGE',
+          storeKey(sessionId),
+          throughIndex === undefined ? '+' : `${throughIndex}-0`,
+          `${fromIndex}-0`,
+          'COUNT',
+          READ_PAGE_SIZE,
+        )) as StreamEntry[]
+        const page = newest
+          .toReversed()
+          .map((entry) => toEvent(sessionId, entry))
+        for (let position = 1; position < page.length; position += 1) {
+          if (page[position]!.index !== page[position - 1]!.index + 1) {
+            throw new A2Error(
+              'STORE_UNAVAILABLE',
+              `redis event range for session '${sessionId}' is not contiguous`,
+            )
+          }
+        }
+        const oldest = page[0]?.index
+        return oldest === undefined || oldest <= fromIndex ? page : null
+      })
+    },
+
+    async clear({ sessionId, ifLastIndex, cause }) {
+      return wrap(async () => {
+        const markerId = generateId()
+        const reply = (await evalScript(
+          CLEAR_LUA,
+          [
+            storeKey(sessionId),
+            countKey(sessionId),
+            metaKey(sessionId),
+            metaSplitKey(sessionId),
+            idKey(markerId),
+            pendingKey(sessionId),
+            readyKey(sessionId),
+          ],
+          [
+            sessionId,
+            clock.now().getTime(),
+            ifLastIndex ?? '',
+            cause?.index ?? '',
+            cause?.attempt ?? '',
+            markerId,
+            `${prefix}:${sessionId}:notify`,
+          ],
+        )) as string[]
+        if (reply[0] === 'superseded') {
+          throw supersededAttemptError(sessionId, cause!)
+        }
+        if (reply[0] === 'no_parent') {
+          throw new TypeError(
+            `no event at index ${reply[1]} in session '${sessionId}'`,
+          )
+        }
+        if (reply[0] === 'foreign') {
+          throw new A2Error(
+            'PARTIAL_DUPLICATE_BATCH',
+            `the clear marker id '${markerId}' already exists`,
+          )
+        }
+        return {
+          cleared: reply[1] === '1',
+          index: Number(reply[2]),
+          clearIndex: Number(reply[3]),
+        }
+      })
+    },
+
+    async reclaim(sessionId) {
+      return wrap(async () => {
+        const [log, ...pairs] = (await evalScript(
+          RECLAIM_BATCH_LUA,
+          [countKey(sessionId)],
+          [READ_PAGE_SIZE],
+        )) as string[]
+        if (log === undefined) return { deleted: 0, done: true }
+        // Id keys are built here, like append's: they use JSON.stringify,
+        // whose escaping cjson does not reproduce.
+        const ids: string[] = []
+        for (let i = 1; i < pairs.length; i += 2) ids.push(pairs[i]!)
+        const [deleted, done] = (await evalScript(
+          RECLAIM_LUA,
+          [
+            log,
+            countKey(sessionId),
+            metaKey(sessionId),
+            metaSplitKey(sessionId),
+            ...ids.map((id) => idKey(id)),
+          ],
+          [sessionId, snapshotEventPinsPrefix(sessionId), ids.length, ...pairs],
+        )) as [number, number]
+        return { deleted: Number(deleted), done: Number(done) === 1 }
+      })
+    },
+
     async readEvents(sessionId, afterIndex) {
       return wrap(async () => {
         const entries = (await call(
@@ -1553,9 +2361,27 @@ export function createRedisStoreCore(
         return entries.map((entry) => toEvent(sessionId, entry))
       })
     },
-
-    async markWatched(sessionId, ttlMs) {
-      await wrap(() => call('SET', watchedKey(sessionId), '1', 'PX', ttlMs))
+    async readFeedPage(sessionId, afterIndex) {
+      return wrap(async () => {
+        const range = [
+          storeKey(sessionId),
+          `${afterIndex + 1}-0`,
+          '+',
+          'COUNT',
+          FEED_PAGE_SIZE,
+        ] as const
+        if (callBytes) {
+          const entries = (await callBytes(
+            'XRANGE',
+            ...range,
+          )) as ByteStreamEntry[]
+          return entries.map((entry) =>
+            bytesToSerializedEvent(sessionId, entry),
+          )
+        }
+        const entries = (await call('XRANGE', ...range)) as StreamEntry[]
+        return entries.map((entry) => toSerializedEvent(sessionId, entry))
+      })
     },
   }
 }