experimental-a2 0.20.0 → 0.22.0

package/src/store-redis-core.ts

@@ -5,26 +5,60 @@
  * `store-redis-http` (provider REST APIs).
  *
  * 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 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`.
+ * dense a2 index (`${index}-0`), so `XRANGE` is the catch-up read. Stream
+ * entries are immutable; dispatch bookkeeping lives on consumer cursors.
+ * Every write path is one atomic Lua script.
  *
- * Timestamps and claim expiry come from the injected clock so tests
- * can time-travel against a real server. Cluster mode is out: the
- * atomic scripts span keys.
+ * Every key of a session is `{p}:{"<session id as JSON>"}:<name>`, one hash
+ * tag per session (`redisSessionKey`). Each script declares keys of one
+ * session only and derives the rest, so on Upstash a script that sets
+ * `allow-key-locking` locks only its session instead of the database. Redis
+ * and Valkey reject that flag, so the store asks the server once whether it
+ * accepts it.
+ *
+ * The cursor layout, per session:
+ *
+ * - `heads:{chunk}` holds one row per (head index, consumer) in hashes of
+ *   META_CHUNK_SIZE consecutive indexes: a head's attempt and failure
+ *   fields, its kind (`l`), its lane successor (`next`), its snapshot pins,
+ *   and, once the cursor moves past it, its completion record. A new head
+ *   is a new row, so moving a cursor resets its attempt fields for free,
+ *   and an event cursor costs one row, as a handled event did.
+ * - `cursors` is one hash of every lane and log cursor: its head (`h`),
+ *   position (`p`), lane tail (`t`), or log types (`ty`). A lane's queue is
+ *   linked through the rows' `next` fields.
+ * - `runnable` is a zset of every cursor with a head, scored by the head's
+ *   index, negated while the head is dead-lettered.
+ * - `pins` counts, per snapshot, the heads that pin it.
+ *
+ * A cursor id names a cursor within its session: the consumer's byte
+ * length, `:`, the consumer, then `#{index}` for an event cursor, `L{lane}`
+ * for a lane cursor, or `G{lane}` for a log cursor. A clear supersedes every
+ * head at or below its marker at once (the `runnable` set is dropped); lane and
+ * log cursor records are reset lazily against the marker and swept by
+ * reclaim.
+ *
+ * `{p}:schema` records the layout. A store claims it once, before its first
+ * script, and refuses a prefix holding another. Keys of an unrecorded layout
+ * have other names, so they are never read.
+ *
+ * Event ids are unique per session: `id:{event id}` holds the index an id
+ * names, and leaves with its session. The conformance suite in
+ * test/conformance is the executable contract, run against a real spawned
+ * `redis-server`, and over REST behind a shim that applies Upstash's
+ * key-locking rules.
+ *
+ * Timestamps and claim expiry come from the injected clock so tests can
+ * time-travel against a real server.
  */
 
 import type { PresencePatch } from './contract.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 { NOTIFY_TIMINGS, nullProtoRecord } from './internal.ts'
+import { retryableLazy } from './retryable-lazy.ts'
+import { decodeCause } from './store-codec.ts'
 import type { SerializedEvent } from './stream-buffer.ts'
 import type {
   A2Store,
@@ -32,8 +66,14 @@ import type {
   CompleteAttemptResult,
   Event,
   EventCause,
+  EventTarget,
+  HeadDispatch,
+  HeadEvent,
+  HeadRef,
   IdSource,
   StoreClaimAvailableResult,
+  StoreConsumer,
+  StoredCursor,
   PresenceRow,
   StoredEvent,
 } from './store.ts'
@@ -68,9 +108,9 @@ export type RedisStreamRead = (options: {
 export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
   /**
    * The storage half of the presence capability, shared by both
-   * transports. `set` returns the applied patch for local loopback,
-   * or null when every field lost the LWW race. The script publishes
-   * the applied fields for remote subscribers.
+   * transports. `set` returns the applied patch for local loopback, with
+   * the publish to remote subscribers already under way, or null when
+   * every field lost the LWW race.
    */
   presence: {
     set(
@@ -78,10 +118,15 @@ export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
       participant: string,
       values: Record<string, unknown | null>,
       meta: { seen: number; at: Date; ttlMs: number },
-    ): Promise<PresencePatch | null>
+    ): Promise<{ patch: PresencePatch; published: Promise<void> } | null>
     read(ns: string): Promise<PresenceRow[]>
   }
-  /** XRANGE + meta merge — the full-row catch-up read. */
+  /**
+   * The latest clear marker's index, or 0. Entries below it are an old
+   * lifetime's until reclaim deletes them, so a feed starts no lower.
+   */
+  clearIndex(sessionId: string): Promise<number>
+  /** XRANGE pages — the full-row catch-up read. */
   readRange(
     sessionId: string,
     afterIndex: number,
@@ -106,7 +151,8 @@ export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
   }) => 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.
+   * one newest-first page, or null when the range doesn't fit in one or
+   * starts below the latest clear.
    */
   readTail(
     sessionId: string,
@@ -119,66 +165,31 @@ export const READ_PAGE_SIZE = 256
 export const FEED_PAGE_SIZE = 1000
 const READ_CONCURRENCY = 16
 
-// ── Lua scripts (each runs atomically) ───────────────────────────────
+/** The key layout this core writes; any other is rejected. */
+export const REDIS_LAYOUT = 'tagged-1'
+
+/**
+ * Upstash runs a script under a database-wide lock unless it opts into
+ * locking only its keys' hash tags. Redis and Valkey reject the flag, and
+ * have no such lock to opt out of: one thread runs every command.
+ */
+const KEY_LOCKING = '#!lua flags=allow-key-locking'
+const READ_ONLY_KEY_LOCKING = '#!lua flags=no-writes,allow-key-locking'
+const SHEBANG_REJECTED = /shebang|unexpected symbol near '#'/i
 
 const META_CHUNK_SIZE = 1000
 
-/** The metadata columns of a full stored row. */
-const STORED_EVENT_META_SUFFIXES = [
-  'p',
-  'pa',
-  'ri',
-  'ch',
-  'ce',
-  'f',
-  'fc',
-  'lc',
-  'lf',
-  'lfa',
-  'd',
-  'a',
-  'e',
-] as const
+/** A head row's dispatch columns, in the order scripts return them. */
+const HEAD_COLUMNS = `{ 'd', 'fc', 'lc', 'ch', 'ce', 'a', 'lf', 'lfa', 'e', 'f' }`
+
+// ── Lua scripts (each runs atomically) ───────────────────────────────
 
 /**
- * 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.
+ * Issues a variadic command in calls of at most 1000 arguments, since Lua's
+ * `unpack` is bounded by its stack, and concatenates table replies. An even
+ * slice size keeps HSET's field/value pairs together.
  */
-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
+const SLICED_LUA = `
 local function sliced(command, key, args)
   local results = {}
   for first = 1, #args, 1000 do
@@ -195,36 +206,109 @@ local function sliced(command, key, args)
   end
   return results
 end
-local function read_fields(fields, suffixes)
+`
+
+/**
+ * Upstash bills every call a script makes, so scripts read the counter,
+ * clear marker, typed-type index, and event-id owners with one MGET
+ * (`read_bounds`), read rows with one HMGET per chunk
+ * (`read_rows`), and buffer hash writes (`put`, `drop`) into one HSET and
+ * one HDEL per hash (`flush`). Buffered writes are invisible to reads until
+ * flushed, so a script must not read a field it has buffered. Every script
+ * binds KEYS[1] to the session's counter and derives the session's other
+ * keys, which share its hash tag.
+ */
+const BASE_LUA = `${SLICED_LUA}
+local COUNTER = KEYS[1]
+local SESSION = string.sub(COUNTER, 1, -6)
+local LOG, CLEAR = SESSION .. 'log', SESSION .. 'clear'
+local META, READY, CURSORS = SESSION .. 'heads', SESSION .. 'runnable', SESSION .. 'cursors'
+local PIN_COUNTS, TYPED = SESSION .. 'pins', SESSION .. 'typed'
+local CLEAR_TYPE = '${CLEAR_EVENT_TYPE}'
+local total, boundary = 0, 0
+-- The event types typed log cursors read: type → { from, last }. The type's
+-- index holds every event of it above \`from\`, and no event of it lies above
+-- \`last\`.
+local typed, typed_dirty = {}, false
+-- One key per event id holds the index it names in this session. The
+-- \`id:\` namespace keeps a raw id from spelling another session key.
+local function id_key(id) return SESSION .. 'id:' .. id end
+-- Reads the counter, the latest clear marker, the typed types, and the
+-- owners of \`ids\` in one MGET. Returns each id's index, or false.
+local function read_bounds(ids)
+  local keys = { COUNTER, CLEAR, TYPED }
+  for _, id in ipairs(ids or {}) do keys[#keys + 1] = id_key(id) end
+  local values = sliced('MGET', nil, keys)
+  total = tonumber(values[1] or values[2] or '0')
+  boundary = tonumber(values[2] or '0')
+  if values[3] then typed = cjson.decode(values[3]) end
+  local owners = {}
+  for i = 4, #keys do owners[i - 3] = values[i] end
+  return owners
+end
+-- Event-id owners from read_bounds: an id recorded below the latest clear
+-- is free.
+local function owners_of(values)
+  local owners = {}
+  for i = 1, #values do
+    local owner = values[i]
+    if owner and tonumber(owner) < boundary then owner = false end
+    owners[i] = owner
+  end
+  return owners
+end
+local function entry_index(id) return tonumber(string.match(id, '^(%d+)')) end
+local function cid_of(consumer, tag)
+  return tostring(string.len(consumer)) .. ':' .. consumer .. tag
+end
+local function parse_cid(cid)
+  local colon = string.find(cid, ':', 1, true)
+  local n = tonumber(string.sub(cid, 1, colon - 1))
+  return string.sub(cid, colon + 1, colon + n), string.sub(cid, colon + n + 1)
+end
+-- A cursor's rows: its consumer, then '#' for an event cursor or 'L' .. lane
+-- for a lane or log cursor, as requests name it.
+local function row_of(consumer, tag)
+  local kind = string.sub(tag, 1, 1)
+  if kind == '#' then return cid_of(consumer, '#') end
+  if kind == 'G' then return cid_of(consumer, 'L' .. string.sub(tag, 2)) end
+  return cid_of(consumer, tag)
+end
+local function chunk_key(idx)
+  return META .. ':' .. tostring(math.floor((idx - 1) / ${META_CHUNK_SIZE}))
+end
+local function row_name(idx, row, suffix)
+  return tostring(idx) .. ':' .. row .. ':' .. suffix
+end
+-- Rows of (index, row) refs, aligned with refs; one HMGET per chunk.
+local function read_rows(refs, suffixes)
   local groups, order = {}, {}
-  for _, field in ipairs(fields) do
-    local key = mkey(field)
+  for position, ref in ipairs(refs) do
+    local key = chunk_key(ref[1])
     local group = groups[key]
     if not group then
-      group = { fields = {}, names = {} }
+      group = { positions = {}, names = {} }
       groups[key] = group
       order[#order + 1] = key
     end
-    group.fields[#group.fields + 1] = field
+    group.positions[#group.positions + 1] = position
     for _, suffix in ipairs(suffixes) do
-      group.names[#group.names + 1] = field .. ':' .. suffix
+      group.names[#group.names + 1] = row_name(ref[1], ref[2], 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
+    for n, position in ipairs(group.positions) do
       local row = {}
-      for column = 1, #suffixes do
-        row[column] = values[(position - 1) * #suffixes + column]
-      end
-      rows[field] = row
+      for column = 1, #suffixes do row[column] = values[(n - 1) * #suffixes + column] end
+      rows[position] = row
     end
   end
   return rows
 end
-local writes, write_order = {}, {}
+local writes, write_order, deletes, delete_order = {}, {}, {}, {}
 local function put(key, field, value)
   local fields = writes[key]
   if not fields then
@@ -235,199 +319,410 @@ local function put(key, field, value)
   fields[#fields + 1] = field
   fields[#fields + 1] = value
 end
+local function drop(key, field)
+  local fields = deletes[key]
+  if not fields then
+    fields = {}
+    deletes[key] = fields
+    delete_order[#delete_order + 1] = key
+  end
+  fields[#fields + 1] = field
+end
 local function flush()
   for _, key in ipairs(write_order) do sliced('HSET', key, writes[key]) end
-  writes, write_order = {}, {}
+  for _, key in ipairs(delete_order) do sliced('HDEL', key, deletes[key]) end
+  writes, write_order, deletes, delete_order = {}, {}, {}, {}
+end
+local function put_row(idx, row, suffix, value)
+  put(chunk_key(idx), row_name(idx, row, suffix), value)
+end
+local function drop_row(idx, row, suffix)
+  drop(chunk_key(idx), row_name(idx, row, suffix))
+end
+-- A request names a cursor by tag: '#' for an event cursor, 'L' .. lane for a
+-- lane or log cursor. A claimed row records its kind: '#', or the cursor's tag.
+local function owns(kind, tag)
+  if not kind then return false end
+  if tag == '#' then return kind == '#' end
+  return kind == tag or kind == 'G' .. string.sub(tag, 2)
+end
+local function cid_for(consumer, kind, idx)
+  if kind == '#' then return cid_of(consumer, '#' .. tostring(idx)) end
+  return cid_of(consumer, kind)
+end
+-- One type's index, named by the type's bytes in hex so no type can spell
+-- another key of the session.
+local function type_key(name)
+  return SESSION .. 'type:' .. (string.gsub(name, '.', function(c)
+    return string.format('%02x', string.byte(c))
+  end))
+end
+local ready_changes, ready_order = {}, {}
+local function ready_set(cid, score)
+  if ready_changes[cid] == nil then ready_order[#ready_order + 1] = cid end
+  ready_changes[cid] = score
+end
+local function flush_ready()
+  local adds, removes = {}, {}
+  for _, cid in ipairs(ready_order) do
+    local score = ready_changes[cid]
+    if score then
+      adds[#adds + 1] = score
+      adds[#adds + 1] = cid
+    else
+      removes[#removes + 1] = cid
+    end
+  end
+  sliced('ZADD', READY, adds)
+  sliced('ZREM', READY, removes)
+  ready_changes, ready_order = {}, {}
+end
+local function release_pins(idx, row, pins)
+  if not pins or pins == '' then return end
+  for _, ref in ipairs(cjson.decode(pins)) do
+    local count = redis.call('HINCRBY', PIN_COUNTS, ref, -1)
+    if count <= 0 then
+      redis.call('HDEL', PIN_COUNTS, ref)
+      local checkpoint = cjson.decode(ref)
+      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
+    end
+  end
+  put_row(idx, row, 'pins', '')
 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.
+ * Cursor movement for scripts that add events or move cursors. Lane and log
+ * cursor records are read once per script (`load_states`) and written back
+ * once (`flush_states`). A record whose head lies at or below the latest clear
+ * marker is idle, and a log cursor counts from the marker.
+ *
+ * A typed log cursor finds its next head in its types' indexes, one bounded
+ * lookup per type, skipped when `typed` shows no newer event of it. When an
+ * index does not reach back far enough yet (a typed backfill, or a type a
+ * cursor newly reads), the lookup returns the type, and the script returns
+ * `{ 'index', type, after }` before writing anything: the caller indexes
+ * that type down to `after` (INDEX_TYPE_LUA, one page per call) and runs the
+ * operation again.
  */
-const ENQUEUE_LUA = `
-local function lane_field(lane, suffix)
-  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
-end
-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
-    ready_now[#ready_now + 1] = score
-    ready_now[#ready_now + 1] = field
-    return
+const CURSOR_LUA = `
+local served_all, served_set, served_logs = true, {}, {}
+local pending_fast = false
+local function types_of(raw)
+  if not raw or raw == '*' then return nil end
+  local set = {}
+  for _, name in ipairs(cjson.decode(raw)) do set[name] = true end
+  return set
+end
+local function takes(types, kind)
+  return kind ~= CLEAR_TYPE and (types == nil or types[kind] == true)
+end
+-- The served consumers: '' for every consumer, else [[name] or
+-- [name, lane, typesJson or '*', backfill]].
+local function use_served(raw)
+  if raw == '' then return end
+  served_all = false
+  for _, entry in ipairs(cjson.decode(raw)) do
+    served_set[entry[1]] = true
+    if entry[2] then
+      served_logs[#served_logs + 1] = {
+        name = entry[1], lane = entry[2], ty = entry[3],
+        types = types_of(entry[3]), backfill = entry[4] == 1,
+      }
+    end
   end
-  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
+local function served_has(name) return served_all or served_set[name] == true end
+-- Whether a served consumer has a live head. Newest heads come first: a
+-- removed consumer's backlog is older than the work a deployment serves.
+local function has_pending()
+  if pending_fast then return '1' end
+  if served_all then return redis.call('ZCOUNT', READY, 1, '+inf') > 0 and '1' or '0' end
+  if next(served_set) == nil then return '0' end
+  local page = redis.call('ZREVRANGEBYSCORE', READY, '+inf', 1, 'LIMIT', 0, 32)
+  for _, cid in ipairs(page) do
+    if served_set[(parse_cid(cid))] then return '1' end
   end
-  if tail then
-    put(mkey(tail), tail .. ':next', field)
-  else
-    put(META, lane_field(lane, 'head'), field)
-    ready_now[#ready_now + 1] = score
-    ready_now[#ready_now + 1] = field
+  if #page < 32 then return '0' end
+  for _, cid in ipairs(redis.call('ZREVRANGEBYSCORE', READY, '+inf', 1, 'LIMIT', 32, -1)) do
+    if served_set[(parse_cid(cid))] then return '1' end
   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])
+  return '0'
+end
+local function targets_of(raw)
+  if raw == '' then return {} end
+  return cjson.decode(raw)
+end
+-- Starts indexing a type: every later event of it.
+local function register(name, from)
+  typed[name] = { from, from }
+  typed_dirty = true
+end
+-- The first stored event in (after, total] of a type in \`types\` (nil: any
+-- type), or false. Nil and a type when that type's index can't answer yet.
+local function stored_head(after, types)
+  if types == nil then
+    if after + 1 <= total then return after + 1 end
+    return false
+  end
+  local best = false
+  for name in pairs(types) do
+    local entry = typed[name]
+    if entry == nil then
+      if after < total then return nil, name end
+      register(name, total)
+    elseif entry[2] > after then
+      if entry[1] > after then return nil, name end
+      local found = redis.call('ZRANGEBYSCORE', type_key(name),
+        '(' .. tostring(after), tostring(total), 'LIMIT', 0, 1)
+      if #found > 0 then
+        local idx = tonumber(found[1])
+        if not best or idx < best then best = idx end
+      end
+    end
+  end
+  return best
+end
+-- The first event after \`after\` a log cursor takes: stored, then in the
+-- batch being appended.
+local function next_log_head(after, types, batch)
+  local head, missing = stored_head(after, types)
+  if head == nil then return nil, missing end
+  if head then return head end
+  for _, event in ipairs(batch) do
+    if event.idx > after and takes(types, event.type) then return event.idx end
+  end
+  return false
+end
+-- Indexes a batch's events of the types typed log cursors read.
+local function index_batch(batch)
+  local adds, order = {}, {}
+  for _, event in ipairs(batch) do
+    local entry = typed[event.type]
+    if entry then
+      local list = adds[event.type]
+      if not list then
+        list = {}
+        adds[event.type] = list
+        order[#order + 1] = event.type
+      end
+      list[#list + 1] = event.idx
+      list[#list + 1] = tostring(event.idx)
+      entry[2] = event.idx
+      typed_dirty = true
+    end
+  end
+  for _, name in ipairs(order) do sliced('ZADD', type_key(name), adds[name]) end
+end
+local states, state_order = {}, {}
+local function load_states(cids)
+  local need, names = {}, {}
+  for _, cid in ipairs(cids) do
+    local state = states[cid]
+    if (state == nil or state.partial) and not need[cid] then
+      need[cid] = true
+      need[#need + 1] = cid
+      names[#names + 1] = cid .. ':h'
+      names[#names + 1] = cid .. ':p'
+      names[#names + 1] = cid .. ':t'
+      names[#names + 1] = cid .. ':ty'
+    end
+  end
+  if #need == 0 then return end
+  local values = sliced('HMGET', CURSORS, names)
+  for n, cid in ipairs(need) do
+    local h, p, t, ty = values[n * 4 - 3], values[n * 4 - 2], values[n * 4 - 1], values[n * 4]
+    local tail = (t and t ~= '') and tonumber(t) or false
+    local state = states[cid]
+    if state then
+      state.t = tail
+      state.partial = nil
     else
-      redis.call('HDEL', META, lane_field(lane, 'head'), lane_field(lane, 'tail'))
+      local _, tag = parse_cid(cid)
+      state = {
+        kind = string.sub(tag, 1, 1), exists = p ~= false,
+        h = (h and h ~= '') and tonumber(h) or false,
+        p = tonumber(p or '0'), t = tail, ty = ty or false,
+      }
+      if state.h and state.h <= boundary then state.h = false end
+      if state.kind == 'G' and state.exists and state.p < boundary then state.p = boundary end
+      states[cid] = state
+      state_order[#state_order + 1] = cid
     end
   end
-  sliced('ZADD', PENDING, queued)
-  sliced('ZADD', READY, ready_now)
 end
-`
-
-/**
- * Settles one unfinished event for scripts that include ENQUEUE_LUA: it
- * leaves the pending and ready sets, and a lane head hands its lane to the
- * next unfinished event. A dead-lettered successor stays out of the ready set.
- */
-const SETTLE_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', 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)
+local function flush_states()
+  for _, cid in ipairs(state_order) do
+    local state = states[cid]
+    if state.dirty then
+      put(CURSORS, cid .. ':h', state.h and tostring(state.h) or '')
+      put(CURSORS, cid .. ':p', tostring(state.p))
+      if state.kind == 'L' then
+        if not state.partial then put(CURSORS, cid .. ':t', state.t and tostring(state.t) or '') end
+      elseif state.ty then
+        put(CURSORS, cid .. ':ty', state.ty)
       end
-      return
     end
-    next_field = row[3]
   end
-  clear_lane(lane)
 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
+-- Moves a cursor past its head \`idx\`. \`kind\` is the head row's kind;
+-- \`batch\` is the returned events, appended after the stored log. Writes
+-- nothing; returns nil and a type when that type's index must reach back
+-- to \`idx\` first.
+local function advance(consumer, kind, idx, row_next, batch)
+  if kind == '#' then
+    ready_set(cid_of(consumer, '#' .. tostring(idx)), false)
+    return true
+  end
+  local cid = cid_of(consumer, kind)
+  local state = states[cid]
+  local next_head
+  if string.sub(kind, 1, 1) == 'L' then
+    next_head = row_next and tonumber(row_next) or false
+    if not state then
+      state = { kind = 'L', exists = true, p = idx, h = false, t = false, ty = false, partial = true }
+      states[cid] = state
+      state_order[#state_order + 1] = cid
     end
-    owners[i] = owner
+    if not next_head then
+      state.t = false
+      state.partial = nil
+    end
+  else
+    local lane, raw = string.sub(kind, 2), nil
+    for _, spec in ipairs(served_logs) do
+      if spec.name == consumer and spec.lane == lane then raw = spec.ty end
+    end
+    if not raw then
+      load_states({ cid })
+      raw = states[cid].ty or '*'
+    end
+    local head, missing = next_log_head(idx, types_of(raw), batch)
+    if head == nil then return nil, missing end
+    next_head = head
+    state = states[cid]
+    if not state then
+      state = { kind = 'G', exists = true, p = idx, h = false, t = false, ty = raw }
+      states[cid] = state
+      state_order[#state_order + 1] = cid
+    end
+    state.ty = raw
   end
-  return owners, values[1]
+  state.h = next_head
+  state.p = idx
+  state.exists = true
+  state.dirty = true
+  ready_set(cid, next_head)
+  return true
 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
+-- Reads what an appended batch's cursor work needs: its lane targets'
+-- records, and the head of each served log consumer whose types it carries.
+-- Writes nothing; returns nil, a type, and an index when that type's index
+-- must reach back to the index first.
+local log_plan = {}
+local function plan(batch, base)
+  local need = {}
+  for _, event in ipairs(batch) do
+    for _, target in ipairs(event.targets) do
+      if target[2] ~= '#' then need[#need + 1] = cid_of(target[1], target[2]) end
+    end
   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
+  for _, spec in ipairs(served_logs) do
+    for _, event in ipairs(batch) do
+      if takes(spec.types, event.type) then
+        local cid = cid_of(spec.name, 'G' .. spec.lane)
+        log_plan[#log_plan + 1] = { spec = spec, first = event.idx, cid = cid }
+        need[#need + 1] = cid
+        break
+      end
+    end
   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, ',') .. ']}'
+  load_states(need)
+  for _, log in ipairs(log_plan) do
+    local state, spec = states[log.cid], log.spec
+    if not state.exists then
+      if spec.backfill then
+        local head, missing = stored_head(boundary, spec.types)
+        if head == nil then return nil, missing, boundary end
+        log.p, log.h = boundary, head or log.first
+      else
+        -- Nothing it takes is stored after its start: index its types from there.
+        for name in pairs(spec.types or {}) do
+          if typed[name] == nil then register(name, base) end
+        end
+        log.p, log.h = base, log.first
+      end
+    elseif not state.h then
+      -- Not the batch's first: a deployment that doesn't serve this consumer
+      -- may have appended events it takes since it went idle.
+      local head, missing = stored_head(state.p, spec.types)
+      if head == nil then return nil, missing, state.p end
+      log.h = head or log.first
+    end
   end
-  redis.pcall('PUBLISH', channel, message)
+  return true
 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])
+-- Starts the cursor work \`plan\` read: each event's targets, and each
+-- planned log cursor.
+local function enqueue(batch)
+  for _, event in ipairs(batch) do
+    for _, target in ipairs(event.targets) do
+      local consumer, tag = target[1], target[2]
+      if served_has(consumer) then pending_fast = true end
+      if tag == '#' then
+        ready_set(cid_of(consumer, '#' .. tostring(event.idx)), event.idx)
+      else
+        local cid = cid_of(consumer, tag)
+        local state = states[cid]
+        if state.h and state.t then
+          put_row(state.t, row_of(consumer, tag), 'next', tostring(event.idx))
+        else
+          state.h = event.idx
+          if state.p < boundary then state.p = boundary end
+          ready_set(cid, event.idx)
+        end
+        state.t = event.idx
+        state.exists = true
+        state.dirty = true
+      end
     end
   end
-  redis.call('DEL', pins)
+  for _, log in ipairs(log_plan) do
+    pending_fast = true
+    local state = states[log.cid]
+    if not state.exists then
+      state.exists, state.p, state.h = true, log.p, log.h
+      ready_set(log.cid, log.h)
+    elseif not state.h then
+      state.h = log.h
+      ready_set(log.cid, log.h)
+    end
+    state.ty = log.spec.ty
+    state.dirty = true
+  end
 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 ''.
+ * KEYS: counter.
+ * ARGV: sessionId, nowMs, n, served consumers, origin index or '', then per
+ * event: id, type, payloadJson, causeJson or '', targets.
  * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
  * ['dup', hasPending, ...indexes] | ['partial', count] |
- * ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx] |
- * ['cleared', originIndex].
+ * ['superseded', position] | ['cleared', originIndex] |
+ * ['index', type, after].
  */
-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])
+const APPEND_LUA = `${BASE_LUA}${CURSOR_LUA}
+local now, n = ARGV[2], tonumber(ARGV[3])
+use_served(ARGV[4])
 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 ids = {}
+for i = 1, n do ids[i] = ARGV[5 + (i - 1) * 5 + 1] end
+local owners = owners_of(read_bounds(ids))
+local base = total
 local dups = {}
 for i = 1, n do
-  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
+  if owners[i] then dups[#dups + 1] = owners[i] end
 end
 if #dups == n then
   local res = { 'dup', has_pending() }
@@ -435,253 +730,251 @@ if #dups == n then
   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 }
+local origin = ARGV[5]
+if origin ~= '' and tonumber(origin) <= boundary then return { 'cleared', origin } end
+-- The attempt-currency fence: a cause's head row must still be its cursor's
+-- head, at that attempt, not dead-lettered.
+local refs, fenced = {}, {}
+for i = 1, n do
+  local raw = ARGV[5 + (i - 1) * 5 + 4]
+  if raw ~= '' then
+    local cause = cjson.decode(raw)
+    local index = tonumber(cause.index)
+    if index <= boundary then return { 'superseded', tostring(i) } end
+    local tag = type(cause.lane) == 'string' and ('L' .. cause.lane) or '#'
+    refs[#refs + 1] = { index, row_of(cause.consumer, tag) }
+    fenced[#fenced + 1] = {
+      position = i, consumer = cause.consumer, attempt = tonumber(cause.attempt), tag = tag,
+    }
+  end
 end
-local causes, parents = {}, {}
+local rows = read_rows(refs, { 'd', 'f', 'p', 'l' })
+for k, cause in ipairs(fenced) do
+  local row = rows[k]
+  if tonumber(row[1] or '0') ~= cause.attempt or row[2] or row[3] or not owns(row[4], cause.tag) then
+    return { 'superseded', tostring(cause.position) }
+  end
+  if served_has(cause.consumer) then pending_fast = true end
+end
+local batch = {}
 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)
-    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 = {}
+  local o = 5 + (i - 1) * 5
+  batch[i] = { idx = base + i, type = ARGV[o + 2], targets = targets_of(ARGV[o + 5]) }
+end
+local planned, missing, after = plan(batch, base)
+if not planned then return { 'index', missing, tostring(after) } end
+local marks = {}
 for i = 1, n do
-  local o = 3 + (i - 1) * 6
+  local o = 5 + (i - 1) * 5
   local field = tostring(base + i)
-  redis.call('XADD', KEYS[1], field .. '-0',
+  redis.call('XADD', LOG, 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(field, ARGV[o + 5])
-  end
-end
-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()
+    'created_at', now, 'cause', ARGV[o + 4])
+  marks[#marks + 1] = id_key(ARGV[o + 1])
+  marks[#marks + 1] = field
+end
+index_batch(batch)
+enqueue(batch)
+marks[#marks + 1] = COUNTER
+marks[#marks + 1] = tostring(base + n)
+if typed_dirty then
+  marks[#marks + 1] = TYPED
+  marks[#marks + 1] = cjson.encode(typed)
+end
+sliced('MSET', nil, marks)
+flush_states()
 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 }
+flush_ready()
+return { 'ok', tostring(base + 1), has_pending() }
 `
 
 /**
- * KEYS: counter, meta, pending, ready, event snapshot pins, snapshot pin counts,
- * metadata split.
- * ARGV: idx, attempt, error, maxFailures, nowMs, retryAtMs ('' for none).
+ * KEYS: counter.
+ * ARGV: type, after. Indexes one page of the stored log below the type's
+ * index, toward `after`, registering the type first if no cursor read it
+ * yet. Returns ['1'] once the index reaches `after`, else ['0'].
  */
-const FAIL_ATTEMPT_LUA = `
-local COUNTER, META, SPLIT = KEYS[1], KEYS[2], KEYS[7]
-${META_LUA}
-${RELEASE_PINS_LUA}
-local idx = tonumber(ARGV[1])
-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 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 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 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
-local hold = not dead and ARGV[6] ~= ''
-if hold then put(meta_key, field .. ':ce', ARGV[6]) end
-flush()
-if hold then
-  redis.call('HDEL', meta_key, field .. ':ch')
-else
-  redis.call('HDEL', meta_key, field .. ':ch', field .. ':ce')
-end
-if dead then
-  redis.call('ZREM', KEYS[4], field)
-  release_snapshot_pins(KEYS[5], KEYS[6])
-  return { 'dead_lettered', tostring(failures) }
+const INDEX_TYPE_LUA = `${BASE_LUA}
+read_bounds()
+local name, after = ARGV[1], tonumber(ARGV[2])
+local entry = typed[name]
+if not entry then
+  entry = { total, total }
+  typed[name] = entry
+end
+-- Entries below the latest clear belong to an old lifetime: never indexed.
+local floor = math.max(after, boundary - 1)
+if entry[1] > floor then
+  local entries = redis.call('XREVRANGE', LOG, tostring(entry[1]) .. '-0',
+    tostring(floor + 1) .. '-0', 'COUNT', ${READ_PAGE_SIZE})
+  local adds = {}
+  for _, stored in ipairs(entries) do
+    local fields = stored[2]
+    for j = 1, #fields, 2 do
+      if fields[j] == 'type' then
+        if fields[j + 1] == name then
+          local idx = entry_index(stored[1])
+          adds[#adds + 1] = idx
+          adds[#adds + 1] = tostring(idx)
+        end
+        break
+      end
+    end
+  end
+  sliced('ZADD', type_key(name), adds)
+  if #entries < ${READ_PAGE_SIZE} then
+    entry[1] = after
+  else
+    entry[1] = entry_index(entries[#entries][1]) - 1
+  end
+elseif entry[1] > after then
+  entry[1] = after
 end
-return { 'failed', tostring(failures) }
+redis.call('SET', TYPED, cjson.encode(typed))
+return { entry[1] <= after and '1' or '0' }
 `
 
 /**
- * KEYS: store, counter, meta, pending, ready, metadata split, snapshot pin
- * counts.
- * ARGV: holder, nowMs, expiresAtMs, excludedCount, excluded indexes, then
- * maxFailures ('' for none) and the event snapshot-pins key prefix.
- * 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.
+ * KEYS: counter.
+ * ARGV: holder, nowMs, expiresAtMs, maxFailures or '', served consumers,
+ * the highest head to claim or '', excluded count, then per excluded head:
+ * consumer, tag.
+ * Live heads are the ready set's positive scores, so an empty one is enough
+ * to report 'settled'. A claimed result ends with the clear marker.
  */
-const CLAIM_AVAILABLE_LUA = `
-local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[6]
-${META_LUA}
-${RELEASE_PINS_LUA}
-local ready = redis.call('ZRANGE', KEYS[5], 0, -1)
+const CLAIM_AVAILABLE_LUA = `${BASE_LUA}${CURSOR_LUA}
+local ready = redis.call('ZRANGEBYSCORE', READY, 1, ARGV[6] == '' and '+inf' or ARGV[6], 'WITHSCORES')
+if #ready == 0 then return { 'settled' } end
+read_bounds()
+local holder, now, expires_at = ARGV[1], tonumber(ARGV[2]), ARGV[3]
+local max_failures = tonumber(ARGV[4])
+use_served(ARGV[5])
 local excluded = {}
-local tail = 5 + tonumber(ARGV[4])
-for i = 1, tonumber(ARGV[4]) do excluded[ARGV[4 + i]] = true end
-local max_failures = tonumber(ARGV[tail])
+for i = 1, tonumber(ARGV[7]) do
+  excluded[ARGV[7 + (i - 1) * 2 + 1] .. '\\0' .. ARGV[7 + (i - 1) * 2 + 2]] = 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 dead = {}
-local retry_at = nil
-for _, field in ipairs(candidates) do
-  local row = rows[field]
-  local expires = tonumber(row[1] or '0')
-  if expires > tonumber(ARGV[2]) then
+for i = 1, #ready, 2 do
+  local cid, idx = ready[i], tonumber(ready[i + 1])
+  local consumer, tag = parse_cid(cid)
+  local kind = string.sub(tag, 1, 1)
+  local key = consumer .. '\\0' .. (kind == 'G' and ('L' .. string.sub(tag, 2)) or tag)
+  if served_has(consumer) and not excluded[key] then
+    candidates[#candidates + 1] = {
+      idx, row_of(consumer, tag), consumer = consumer, cid = cid,
+      kind = kind == '#' and '#' or tag,
+    }
+  end
+end
+local rows = read_rows(candidates, { 'd', 'fc', 'lc', 'ch', 'ce', 'a', 'lf', 'lfa', 'e', 'f', 'pins' })
+local takes_over, retry_at, wanted = {}, nil, {}
+for position, candidate in ipairs(candidates) do
+  local row = rows[position]
+  local expires = tonumber(row[5] or '0')
+  if expires > now 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 meta_key = mkey(field)
-    local attempt = tostring(tonumber(row[2] or '0') + 1)
-    -- An expiry that is not the current attempt's retry hold is a lapsed
-    -- claim: its attempt never finished.
-    local lapsed = row[1] and row[7] ~= row[2]
-    local failures = tonumber(row[4] or '0')
-    if lapsed then
-      failures = failures + 1
-      put(meta_key, field .. ':a', tostring(failures))
-    end
-    put(meta_key, field .. ':d', attempt)
-    if lapsed and max_failures and failures >= max_failures then
-      -- That takeover spent the last failed attempt: dead-letter, unclaimed.
-      -- Advancing the attempt fences the lapsed one; nothing runs.
-      put(meta_key, field .. ':f', ARGV[2])
-      dead[#dead + 1] = field
-      claimed[#claimed + 1] = {
-        attempt,
-        tostring(failures),
-        row[5] or false,
-        row[3] or false,
-        read_fields({ field }, { 'lc' })[field][1] or false,
-        row[6] or false,
-        row[7] or false,
-        false,
-        false,
-        entries[1],
-        ARGV[2]
-      }
-    else
-      local first_claimed = row[3] or ARGV[2]
-      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,
-        tostring(failures),
-        row[5] or false,
-        first_claimed,
-        ARGV[2],
-        row[6] or false,
-        row[7] or false,
-        ARGV[1],
-        ARGV[3],
-        entries[1],
-        false
-      }
-    end
+    takes_over[#takes_over + 1] = { candidate = candidate, row = row }
+    wanted[candidate[1]] = true
   end
 end
-flush()
-for _, field in ipairs(dead) do
-  redis.call('HDEL', mkey(field), field .. ':ch', field .. ':ce')
-  redis.call('ZREM', KEYS[5], field)
-  release_snapshot_pins(ARGV[tail + 1] .. field, KEYS[7])
-end
-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
+if #takes_over == 0 then
+  if retry_at then return { 'busy', tostring(retry_at) } end
+  return { 'settled' }
+end
+-- One XRANGE per run of consecutive claimed indexes.
+local indexes, entries = {}, {}
+for idx in pairs(wanted) do indexes[#indexes + 1] = idx end
+table.sort(indexes)
+local first = 1
+while first <= #indexes do
+  local last = first
+  while last < #indexes and indexes[last + 1] == indexes[last] + 1 do last = last + 1 end
+  local range = redis.call('XRANGE', LOG, tostring(indexes[first]) .. '-0', tostring(indexes[last]) .. '-0')
+  for _, entry in ipairs(range) do entries[entry_index(entry[1])] = entry end
+  first = last + 1
+end
+for _, idx in ipairs(indexes) do
+  if not entries[idx] then return { 'missing', tostring(idx) } end
+end
+local result = { 'claimed', tostring(#takes_over) }
+for _, take in ipairs(takes_over) do
+  local candidate, row = take.candidate, take.row
+  local idx, at = candidate[1], candidate[2]
+  local attempt = tostring(tonumber(row[1] or '0') + 1)
+  -- A claim still held here lapsed: its attempt never finished.
+  local lapsed = row[4] ~= false
+  local failures = tonumber(row[6] or '0')
+  if lapsed then
+    failures = failures + 1
+    put_row(idx, at, 'a', tostring(failures))
   end
-  result[#result + 1] = tostring(boundary)
-  return result
+  put_row(idx, at, 'd', attempt)
+  local columns
+  if lapsed and max_failures and failures >= max_failures then
+    -- That takeover spent the last failed attempt: dead-letter, unclaimed.
+    -- Advancing the attempt fences the lapsed one; nothing runs.
+    put_row(idx, at, 'f', ARGV[2])
+    drop_row(idx, at, 'ch')
+    drop_row(idx, at, 'ce')
+    ready_set(candidate.cid, -idx)
+    release_pins(idx, at, row[11])
+    columns = { attempt, row[2], row[3], false, false, tostring(failures), row[7], row[8], row[9], ARGV[2] }
+  else
+    local first_claimed = row[2] or ARGV[2]
+    put_row(idx, at, 'fc', first_claimed)
+    put_row(idx, at, 'lc', ARGV[2])
+    put_row(idx, at, 'ch', holder)
+    put_row(idx, at, 'ce', expires_at)
+    put_row(idx, at, 'l', candidate.kind)
+    columns = { attempt, first_claimed, ARGV[2], holder, expires_at, tostring(failures), row[7], row[8], row[9], false }
+  end
+  result[#result + 1] = { candidate.consumer, candidate.kind, tostring(idx), columns, entries[idx] }
 end
-if retry_at then return { 'busy', tostring(retry_at) } end
-return { 'settled' }
+flush()
+flush_ready()
+result[#result + 1] = tostring(boundary)
+result[#result + 1] = tostring(total)
+return result
 `
 
 /**
- * KEYS: counter, meta, metadata split.
- * ARGV: holder, nowMs, expiresAtMs, n, then per claim: index, attempt.
- * Returns [renewedCount, ...renewed, ...superseded].
+ * KEYS: counter.
+ * ARGV: holder, nowMs, expiresAtMs, n, then per claim: consumer, tag, index,
+ * attempt. Returns [renewedCount, ...renewed, ...superseded] as 1-based
+ * positions in the request.
  */
-const RENEW_CLAIMS_LUA = `
-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 = {}, {}, {}
+const RENEW_CLAIMS_LUA = `${BASE_LUA}
+read_bounds()
+local holder, now, expires_at = ARGV[1], tonumber(ARGV[2]), ARGV[3]
+local refs, items, superseded = {}, {}, {}
 for i = 1, tonumber(ARGV[4]) do
-  local field = ARGV[4 + (i - 1) * 2 + 1]
-  local idx = tonumber(field)
+  local o = 4 + (i - 1) * 4
+  local idx = tonumber(ARGV[o + 3])
   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
+    superseded[#superseded + 1] = tostring(i)
+  else
+    local row = row_of(ARGV[o + 1], ARGV[o + 2])
+    refs[#refs + 1] = { idx, row }
+    items[#items + 1] = { position = i, idx = idx, row = row, tag = ARGV[o + 2], attempt = tonumber(ARGV[o + 4]) }
   end
 end
-local rows = read_fields(fields, { 'd', 'ce', 'p', 'f', 'ch' })
+local rows = read_rows(refs, { 'd', 'ce', 'p', 'f', 'ch', 'l' })
 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
+for k, item in ipairs(items) do
+  local row = rows[k]
+  local attempt = tonumber(row[1] or '0')
+  if row[6] and not owns(row[6], item.tag) then
+    -- Another cursor's head: this one never claimed it.
+  elseif row[3] or attempt > item.attempt then
+    superseded[#superseded + 1] = tostring(item.position)
+  elseif attempt == item.attempt and tonumber(expires_at) > now and
+         not row[4] and row[5] == holder and tonumber(row[2] or '0') > now then
+    put_row(item.idx, item.row, 'ce', expires_at)
+    renewed[#renewed + 1] = tostring(item.position)
   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
@@ -689,228 +982,393 @@ return result
 `
 
 /**
- * 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.
+ * KEYS: counter.
+ * ARGV: sessionId, nowMs, consumer, tag, index, attempt, child causeJson,
+ * served consumers, returned idsJson, n, then per child: id, type,
+ * payloadJson, targets.
  */
-const COMPLETE_ATTEMPT_LUA = `
-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}
-${SETTLE_LUA}
-local parent = ARGV[3]
-local attempt = tonumber(ARGV[4])
-local n = tonumber(ARGV[5])
-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 row = read_fields({ parent }, { 'd', 'p', 'pa', 'ri', 'ch', 'f', 'lfa', 'l', 'next' })[parent]
+const COMPLETE_ATTEMPT_LUA = `${BASE_LUA}${CURSOR_LUA}
+local now = ARGV[2]
+local consumer, tag, idx, attempt = ARGV[3], ARGV[4], tonumber(ARGV[5]), tonumber(ARGV[6])
+local at = row_of(consumer, tag)
+local n = tonumber(ARGV[10])
+local ids = {}
+for i = 1, n do ids[i] = ARGV[10 + (i - 1) * 4 + 1] end
+local owners = owners_of(read_bounds(ids))
+if idx <= boundary then return { 'superseded' } end
+if idx < 1 or idx > total then return { 'missing' } end
+local row = read_rows({ { idx, at } }, { 'd', 'p', 'pa', 'ri', 'ch', 'f', 'l', 'next', 'pins' })[1]
 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
+  -- The cursor moved past this head: a retry of its completion replays.
+  if not owns(row[7], tag) then return { 'superseded' } end
+  if not row[3] or tonumber(row[3]) ~= attempt then return { 'superseded' } end
+  local recorded = cjson.decode(row[4] or '[]')
+  if #recorded ~= n then return { 'partial' } end
   for i = 1, n do
-    if recorded_ids[i] ~= ARGV[5 + (i - 1) * 5 + 1] then return { 'partial' } end
+    if recorded[i] ~= ARGV[10 + (i - 1) * 4 + 1] then return { 'partial' } end
   end
-  local indexes = {}
+  local result = { 'duplicate' }
   for i = 1, n do
     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
-    local values = entries[1][2]
-    local cause = nil
-    for j = 1, #values, 2 do
-      if values[j] == 'cause' then cause = values[j + 1] break end
-    end
-    if not cause or cause == '' then return { 'partial' } end
-    local decoded = cjson.decode(cause)
-    if tonumber(decoded['index']) ~= tonumber(parent) or
-       tonumber(decoded['attempt']) ~= attempt then return { 'partial' } end
-    indexes[#indexes + 1] = tostring(rec[2])
+    result[#result + 1] = owners[i]
   end
-  local result = { 'duplicate' }
-  for _, idx in ipairs(indexes) do result[#result + 1] = idx end
   return result
 end
-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
+if tonumber(row[1] or '0') ~= attempt or not row[5] or row[6] or not owns(row[7], tag) then
   return { 'superseded' }
 end
 for i = 1, n do
   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
-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 = {}
+use_served(ARGV[8])
+local batch = {}
 for i = 1, n do
-  local o = 5 + (i - 1) * 5
+  local o = 10 + (i - 1) * 4
+  batch[i] = { idx = total + i, type = ARGV[o + 2], targets = targets_of(ARGV[o + 4]) }
+end
+local moved, missing = advance(consumer, row[7], idx, row[8], batch)
+if not moved then return { 'index', missing, tostring(idx) } end
+local planned, unindexed, after = plan(batch, total)
+if not planned then return { 'index', unindexed, tostring(after) } end
+put_row(idx, at, 'p', now)
+put_row(idx, at, 'pa', ARGV[6])
+put_row(idx, at, 'ri', ARGV[9])
+release_pins(idx, at, row[9])
+local marks = {}
+for i = 1, n do
+  local o = 10 + (i - 1) * 4
   local field = tostring(total + i)
-  redis.call('XADD', KEYS[1], field .. '-0',
+  redis.call('XADD', LOG, 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(field, ARGV[o + 4])
-  end
+    'created_at', now, 'cause', ARGV[7])
+  marks[#marks + 1] = id_key(ARGV[o + 1])
+  marks[#marks + 1] = field
 end
+index_batch(batch)
+enqueue(batch)
 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)
+  marks[#marks + 1] = COUNTER
+  marks[#marks + 1] = tostring(total + n)
 end
-flush_queue()
+if typed_dirty then
+  marks[#marks + 1] = TYPED
+  marks[#marks + 1] = cjson.encode(typed)
+end
+sliced('MSET', nil, marks)
+flush_states()
 flush()
-if n > 0 then wake(ARGV[6 + n * 5], tostring(total + n), ARGV[2]) end
+flush_ready()
 return { 'ok', tostring(total + 1) }
 `
 
 /**
- * KEYS: counter, meta, pending, ready, metadata split.
- * ARGV: idx, action ('retry' | 'skip'), nowMs.
- * Returns [redriven, hasPending]. Acts only on an unfinished, dead-lettered
- * event above the clear boundary. A retry keeps the event pending and makes
- * it ready again when it is unlaned or its lane's head.
+ * KEYS: counter.
+ * ARGV: consumer, tag, index, attempt, error, maxFailures, nowMs, retryAtMs
+ * or ''.
  */
-const REDRIVE_LUA = `
-local COUNTER, META, SPLIT, PENDING, READY = KEYS[1], KEYS[2], KEYS[5], KEYS[3], KEYS[4]
-${META_LUA}
-${ENQUEUE_LUA}
-${SETTLE_LUA}
-local function result(redriven)
-  return { redriven, redis.call('ZCARD', PENDING) > 0 and '1' or '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])
-local idx = tonumber(ARGV[1])
-if idx <= boundary or idx > total then return result('0') end
-local field = tostring(idx)
-local row = read_fields({ field }, { 'p', 'f', 'l', 'next' })[field]
-if row[1] or not row[2] then return result('0') end
-local meta_key = mkey(field)
-local lane = row[3] or ''
-if ARGV[2] == 'skip' then
-  put(meta_key, field .. ':p', ARGV[3])
-  settle(field, lane, row[4])
-  flush_queue()
-  flush()
+const FAIL_ATTEMPT_LUA = `${BASE_LUA}
+read_bounds()
+local consumer, tag, idx, attempt = ARGV[1], ARGV[2], tonumber(ARGV[3]), tonumber(ARGV[4])
+local at = row_of(consumer, tag)
+if idx <= boundary then return { 'superseded', '0' } end
+if idx < 1 or idx > total then return { 'missing', '0' } end
+local row = read_rows({ { idx, at } }, { 'a', 'd', 'p', 'f', 'lfa', 'ch', 'l', 'pins' })[1]
+if row[3] or (row[7] and not owns(row[7], tag)) then return { 'superseded', '0' } end
+local failures = tonumber(row[1] or '0')
+if tonumber(row[2] or '0') ~= attempt then return { 'superseded', tostring(failures) } end
+if not row[6] and row[5] and tonumber(row[5]) == attempt then
+  return { row[4] and 'dead_lettered' or 'failed', tostring(failures) }
+end
+if row[4] then return { 'dead_lettered', tostring(failures) } end
+if not row[6] then return { 'superseded', tostring(failures) } end
+failures = failures + 1
+local dead = failures >= tonumber(ARGV[6])
+put_row(idx, at, 'a', tostring(failures))
+put_row(idx, at, 'e', ARGV[5])
+put_row(idx, at, 'lf', ARGV[7])
+put_row(idx, at, 'lfa', ARGV[4])
+drop_row(idx, at, 'ch')
+if dead then
+  put_row(idx, at, 'f', ARGV[7])
+  drop_row(idx, at, 'ce')
+  ready_set(cid_for(consumer, row[7], idx), -idx)
+  release_pins(idx, at, row[8])
+elseif ARGV[8] ~= '' then
+  put_row(idx, at, 'ce', ARGV[8])
 else
-  redis.call('HDEL', meta_key, field .. ':f', field .. ':a')
-  if lane == '' or redis.call('HGET', META, lane_field(lane, 'head')) == field then
-    redis.call('ZADD', READY, idx, field)
+  drop_row(idx, at, 'ce')
+end
+flush()
+flush_ready()
+return { dead and 'dead_lettered' or 'failed', tostring(failures) }
+`
+
+/**
+ * KEYS: counter. ARGV: consumer, index, action, nowMs, served
+ * consumers. Returns [redriven, hasPending] | ['index', type, after]. Acts
+ * only on the consumer's dead-lettered head at the index, above the clear
+ * marker.
+ */
+const REDRIVE_LUA = `${BASE_LUA}${CURSOR_LUA}
+read_bounds()
+use_served(ARGV[5])
+local consumer, idx = ARGV[1], tonumber(ARGV[2])
+local function result(redriven) return { redriven, has_pending() } end
+if idx <= boundary or idx < 1 or idx > total then return result('0') end
+local cid, tag = nil, nil
+for _, member in ipairs(redis.call('ZRANGEBYSCORE', READY, -idx, -idx)) do
+  local owner, member_tag = parse_cid(member)
+  if owner == consumer then
+    cid, tag = member, member_tag
+    break
   end
 end
+if not cid then return result('0') end
+local kind = string.sub(tag, 1, 1) == '#' and '#' or tag
+local at = row_of(consumer, tag)
+if ARGV[3] == 'skip' then
+  local row = read_rows({ { idx, at } }, { 'next' })[1]
+  local moved, missing = advance(consumer, kind, idx, row[1], {})
+  if not moved then return { 'index', missing, tostring(idx) } end
+  put_row(idx, at, 'p', ARGV[4])
+  flush_states()
+  if typed_dirty then redis.call('SET', TYPED, cjson.encode(typed)) end
+else
+  drop_row(idx, at, 'f')
+  drop_row(idx, at, 'a')
+  ready_set(cid, idx)
+end
+flush()
+flush_ready()
 return result('1')
 `
 
 /**
- * KEYS: store, counter, meta, pending, metadata split.
- * Returns the dead-lettered events above the clear boundary, oldest first,
- * as pairs of a stream entry and its STORED_EVENT_META_SUFFIXES columns.
- * Every unfinished event is in the pending set, so the scan is bounded by
- * unfinished work, not history; only dead letters read their full columns.
+ * KEYS: counter. ARGV: consumer, lane, types JSON or '*', backfill
+ * ('1' or '0'). Brings one log cursor up to date without an append, as
+ * `plan` and `enqueue` would for an append carrying its types: a missing
+ * cursor starts at the clear marker with backfill, else at the head with
+ * nothing to run; an idle one takes the next stored event of its types; one
+ * with a head, claimed or not, keeps it. Records the types, and writes
+ * nothing when nothing changed. Returns ['ok', position, head or nil, head
+ * columns, session head] | ['index', type, after].
  */
-const DEAD_LETTERS_LUA = `
-local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[5]
-${META_LUA}
-local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
-use_split(counts[2], counts[1], counts[3])
-local candidates = {}
-for _, field in ipairs(redis.call('ZRANGE', KEYS[4], 0, -1)) do
-  if tonumber(field) > boundary then candidates[#candidates + 1] = field end
-end
-local status = read_fields(candidates, { 'p', 'f' })
-local dead = {}
-for _, field in ipairs(candidates) do
-  if status[field][2] and not status[field][1] then dead[#dead + 1] = field end
+const WAKE_LOG_LUA = `${BASE_LUA}${CURSOR_LUA}
+read_bounds()
+local consumer, lane, ty = ARGV[1], ARGV[2], ARGV[3]
+local types = types_of(ty)
+local cid = cid_of(consumer, 'G' .. lane)
+load_states({ cid })
+local state = states[cid]
+local had_head = state.h
+-- Nothing after the latest clear: a missing cursor stays missing.
+if not state.exists and total == boundary then
+  return { 'ok', tostring(boundary), false, {}, tostring(total) }
+end
+if not state.exists then
+  state.exists, state.p = true, total
+  if ARGV[4] == '1' then
+    local head, missing = stored_head(boundary, types)
+    if head == nil then return { 'index', missing, tostring(boundary) } end
+    state.p, state.h = boundary, head
+  else
+    -- Nothing it takes is stored after its start: index its types from there.
+    for name in pairs(types or {}) do
+      if typed[name] == nil then register(name, total) end
+    end
+  end
+  state.dirty = true
+elseif not state.h then
+  -- A deployment that doesn't serve this consumer may have appended events
+  -- it takes since it went idle.
+  local head, missing = stored_head(state.p, types)
+  if head == nil then return { 'index', missing, tostring(state.p) } end
+  if head then state.h, state.dirty = head, true end
+end
+if state.ty ~= ty then state.ty, state.dirty = ty, true end
+local columns = {}
+if had_head then
+  columns = read_rows({ { state.h, row_of(consumer, 'G' .. lane) } }, ${HEAD_COLUMNS})[1]
+elseif state.h then
+  ready_set(cid, state.h)
+end
+flush_states()
+if typed_dirty then redis.call('SET', TYPED, cjson.encode(typed)) end
+flush()
+flush_ready()
+return { 'ok', tostring(state.p), state.h and tostring(state.h) or false, columns, tostring(total) }
+`
+
+/**
+ * KEYS: counter. Returns the dead-lettered heads above the clear
+ * marker as [consumer, tag, index, columns, entry] tuples.
+ */
+const DEAD_LETTERS_LUA = `${BASE_LUA}
+local dead = redis.call('ZRANGEBYSCORE', READY, '-inf', '(0', 'WITHSCORES')
+if #dead == 0 then return {} end
+read_bounds()
+local refs, items = {}, {}
+for i = 1, #dead, 2 do
+  local consumer, tag = parse_cid(dead[i])
+  local idx = -tonumber(dead[i + 1])
+  if idx > boundary then
+    refs[#refs + 1] = { idx, row_of(consumer, tag) }
+    items[#items + 1] = { consumer, tag, idx }
+  end
 end
-local rows = read_fields(dead, { ${STORED_EVENT_META_SUFFIXES.map((suffix) => `'${suffix}'`).join(', ')} })
+local rows = read_rows(refs, ${HEAD_COLUMNS})
 local result = {}
-for _, field in ipairs(dead) do
-  local entries = redis.call('XRANGE', KEYS[1], field .. '-0', field .. '-0')
+for k, item in ipairs(items) do
+  local entries = redis.call('XRANGE', LOG, tostring(item[3]) .. '-0', tostring(item[3]) .. '-0')
   if #entries > 0 then
-    result[#result + 1] = entries[1]
-    result[#result + 1] = rows[field]
+    result[#result + 1] = { item[1], item[2], tostring(item[3]), rows[k], entries[1] }
+  end
+end
+return result
+`
+
+/**
+ * KEYS: counter. Returns every listed cursor as [consumer, tag,
+ * position, head or nil, columns]: lane and log cursors from the cursor
+ * hash, read against the clear marker, then the event cursors with a head.
+ */
+const CURSORS_LUA = `${BASE_LUA}
+read_bounds()
+local listed = {}
+local fields = redis.call('HGETALL', CURSORS)
+local records, order = {}, {}
+for i = 1, #fields, 2 do
+  local at = string.find(fields[i], ':[^:]*$')
+  local cid, suffix = string.sub(fields[i], 1, at - 1), string.sub(fields[i], at + 1)
+  if not records[cid] then
+    records[cid] = {}
+    order[#order + 1] = cid
+  end
+  records[cid][suffix] = fields[i + 1]
+end
+for _, cid in ipairs(order) do
+  local record = records[cid]
+  local consumer, tag = parse_cid(cid)
+  local head = (record.h and record.h ~= '') and tonumber(record.h) or false
+  local position = tonumber(record.p or '0')
+  if head and head <= boundary then head = false end
+  local kind = string.sub(tag, 1, 1)
+  if kind == 'G' and position < boundary then position = boundary end
+  if kind == 'G' or head or position > boundary then
+    listed[#listed + 1] = { consumer, tag, position, head }
   end
 end
+local ready = redis.call('ZRANGE', READY, 0, -1, 'WITHSCORES')
+for i = 1, #ready, 2 do
+  local consumer, tag = parse_cid(ready[i])
+  if string.sub(tag, 1, 1) == '#' then
+    local head = math.abs(tonumber(ready[i + 1]))
+    listed[#listed + 1] = { consumer, '#', head - 1, head }
+  end
+end
+local refs, positions = {}, {}
+for position, cursor in ipairs(listed) do
+  if cursor[4] then
+    refs[#refs + 1] = { cursor[4], row_of(cursor[1], cursor[2]) }
+    positions[#refs] = position
+  end
+end
+local rows = read_rows(refs, ${HEAD_COLUMNS})
+local columns = {}
+for k, position in ipairs(positions) do columns[position] = rows[k] end
+local result = {}
+for position, cursor in ipairs(listed) do
+  result[#result + 1] = {
+    cursor[1], cursor[2], tostring(cursor[3]),
+    cursor[4] and tostring(cursor[4]) or false, columns[position] or {},
+  }
+end
 return result
 `
 
 /**
- * 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; finally the reducer
- * name. Writes from before the latest clear are dropped, and a head from
- * before it is replaced as if absent.
+ * KEYS: counter, head, history.
+ * ARGV: write count, then per write: index, snapshot JSON, pin count, then
+ * per pin: consumer, tag, index; finally the reducer name. Writes from
+ * before the latest clear are dropped, and a head from before it is
+ * replaced as if absent. A pin holds only on an unfinished, live head: a
+ * claimed row says so itself, an unclaimed head by its cursor's ready score.
  */
-const PUT_SNAPSHOTS_LUA = `
-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
+const PUT_SNAPSHOTS_LUA = `${BASE_LUA}
+read_bounds()
+local HEAD, HISTORY = KEYS[2], KEYS[3]
+local entries, refs, pins = {}, {}, {}
+local offset = 2
+for w = 1, tonumber(ARGV[1]) do
+  local index = tonumber(ARGV[offset])
   local pin_count = tonumber(ARGV[offset + 2])
+  local entry = { index = index, snapshot = ARGV[offset + 1], pins = {} }
   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)
+    local o = offset + 2 + (p - 1) * 3
+    local pin = { consumer = ARGV[o + 1], tag = ARGV[o + 2], idx = tonumber(ARGV[o + 3]) }
+    if index >= boundary and pin.idx > boundary and pin.idx <= total then
+      pin.row = row_of(pin.consumer, pin.tag)
+      refs[#refs + 1] = { pin.idx, pin.row }
+      pins[#pins + 1] = pin
+      entry.pins[#entry.pins + 1] = pin
+    end
+  end
+  entries[w] = entry
+  offset = offset + 3 + pin_count * 3
+end
+local function live(consumer, tag, idx)
+  return tonumber(redis.call('ZSCORE', READY, cid_of(consumer, tag)) or '0') == idx
+end
+local rows = read_rows(refs, { 'pins', 'p', 'f', 'l' })
+local held, held_order = {}, {}
+for k, pin in ipairs(pins) do
+  local row = rows[k]
+  local valid
+  if row[2] or row[3] then
+    valid = false
+  elseif row[4] then
+    valid = owns(row[4], pin.tag)
+  elseif pin.tag == '#' then
+    valid = live(pin.consumer, '#' .. tostring(pin.idx), pin.idx)
+  else
+    valid = live(pin.consumer, pin.tag, pin.idx) or
+      live(pin.consumer, 'G' .. string.sub(pin.tag, 2), pin.idx)
+  end
+  if valid then
+    local key = tostring(pin.idx) .. ':' .. pin.row
+    if not held[key] then
+      local list = (row[1] and row[1] ~= '') and cjson.decode(row[1]) or {}
+      local set = {}
+      for _, ref in ipairs(list) do set[ref] = true end
+      held[key] = { list = list, set = set, idx = pin.idx, row = pin.row }
+      held_order[#held_order + 1] = key
     end
+    pin.held = held[key]
   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]
-  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])
-    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
+for _, entry in ipairs(entries) do
+  local ref = cjson.encode({ HISTORY, tostring(entry.index) })
+  for _, pin in ipairs(entry.pins) do
+    if pin.held and not pin.held.set[ref] then
+      pin.held.set[ref] = true
+      pin.held.list[#pin.held.list + 1] = ref
+      pin.held.dirty = true
+      redis.call('HINCRBY', PIN_COUNTS, ref, 1)
     end
   end
-  if index >= boundary then
-    snapshots[#snapshots + 1] = { index = index, snapshot = snapshot, ref = ref }
+  if entry.index >= boundary then
+    snapshots[#snapshots + 1] = { index = entry.index, snapshot = entry.snapshot, ref = ref }
   end
-  offset = offset + 3 + pin_count
 end
+for _, key in ipairs(held_order) do
+  local row = held[key]
+  if row.dirty then put_row(row.idx, row.row, 'pins', cjson.encode(row.list)) end
+end
+flush()
 if #snapshots == 0 then return 1 end
 
-local head = redis.call('GET', KEYS[1])
+local head = redis.call('GET', HEAD)
 local head_index = nil
 local registered = false
 if head then
@@ -920,109 +1378,112 @@ if head then
 end
 if head_index and head_index < boundary then
   head, head_index, registered = nil, nil, false
-  redis.call('ZREMRANGEBYSCORE', KEYS[2], '-inf', '(' .. boundary)
+  redis.call('ZREMRANGEBYSCORE', HISTORY, '-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])
+  redis.call('SADD', SESSION .. '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
 
-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)
+if advances and head and tonumber(redis.call('HGET', PIN_COUNTS, cjson.encode({ HISTORY, tostring(head_index) })) or '0') > 0 then
+  redis.call('ZREMRANGEBYSCORE', HISTORY, head_index, head_index)
+  redis.call('ZADD', HISTORY, head_index, head)
 end
 
 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
-      redis.call('ZADD', KEYS[2], write.index, write.snapshot)
+    redis.call('ZREMRANGEBYSCORE', HISTORY, write.index, write.index)
+    if tonumber(redis.call('HGET', PIN_COUNTS, write.ref) or '0') > 0 then
+      redis.call('ZADD', HISTORY, 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)
+  redis.call('SET', HEAD, latest.snapshot)
+  redis.call('ZREMRANGEBYSCORE', HISTORY, latest.index, latest.index)
 end
 return 1
 `
 
 /**
- * KEYS: presence hash. ARGV: atMs, ttlMs, n, then per entry:
- * hashField, valueJson ('' deletes), patchFieldJson; finally channel and
- * message prefix. Wire fragments stay JSON text to preserve arrays
- * and numeric precision through Lua. Field-wise LWW by the sender's
- * `at`: a stored entry with a strictly newer stamp survives; ties go
- * to the incoming write (memory-tier parity). Returns the applied
- * 1-based entry positions. The whole-key PEXPIRE is the coarse bound,
- * sound because core sends one uniform ttlMs; the per-entry `e` stamp
- * is the fine bound (the injected storage clock at the applied set
- * plus ttlMs — never the sender stamp), pruned on read against the
- * same clock.
+ * Presence entries are `{"a":at,"e":expiresAt,"s":seen,"v":value}`, stamps
+ * first and both integers, so scripts read them with a pattern instead of
+ * decoding the value.
+ */
+const PRESENCE_STAMPS_LUA = `
+local function stamps(entry)
+  local a, e = string.match(entry, '^{"a":(%-?%d+),"e":(%-?%d+),')
+  return tonumber(a), tonumber(e)
+end
+`
+
+/**
+ * KEYS: presence hash. ARGV: atMs, ttlMs, nowMs, n, then per entry:
+ * hashField, entryJson (a null value is a tombstone). Field-wise LWW by the
+ * sender's `at`: an unexpired stored entry with a strictly newer stamp
+ * survives; ties go to the incoming write (memory-tier parity). Returns the applied 1-based entry
+ * positions. The whole-key PEXPIRE is the coarse bound, sound because core
+ * sends one uniform ttlMs; the per-entry `e` stamp is the fine bound (the
+ * injected storage clock at the applied set plus ttlMs — never the sender
+ * stamp), filtered on read against the same clock.
  */
-const PRESENCE_SET_LUA = `
-local at = tonumber(ARGV[1])
-local applied = {}
-local published = {}
-local n = tonumber(ARGV[3])
+const PRESENCE_SET_LUA = `${SLICED_LUA}${PRESENCE_STAMPS_LUA}
+local at, now, n = tonumber(ARGV[1]), tonumber(ARGV[3]), tonumber(ARGV[4])
+local fields = {}
+for i = 1, n do fields[i] = ARGV[4 + (i - 1) * 2 + 1] end
+local stored = sliced('HMGET', KEYS[1], fields)
+local applied, sets = {}, {}
 for i = 1, n do
-  local field = ARGV[3 + (i - 1) * 3 + 1]
-  local value = ARGV[3 + (i - 1) * 3 + 2]
-  local existing = redis.call('HGET', KEYS[1], field)
-  if not existing or tonumber(cjson.decode(existing)['a']) <= at then
-    if value == '' then
-      redis.call('HDEL', KEYS[1], field)
-    else
-      redis.call('HSET', KEYS[1], field, value)
-    end
+  local a, e = false, false
+  if stored[i] then a, e = stamps(stored[i]) end
+  if not stored[i] or a <= at or e <= now then
+    sets[#sets + 1] = fields[i]
+    sets[#sets + 1] = ARGV[4 + (i - 1) * 2 + 2]
     applied[#applied + 1] = tostring(i)
-    published[#published + 1] = ARGV[3 + (i - 1) * 3 + 3]
   end
 end
-if #applied > 0 then
-  redis.call('PEXPIRE', KEYS[1], ARGV[2])
-  redis.pcall('PUBLISH', ARGV[4 + n * 3], ARGV[5 + n * 3] .. table.concat(published, ',') .. '}}')
-end
+sliced('HSET', KEYS[1], sets)
+if #applied > 0 then redis.call('PEXPIRE', KEYS[1], ARGV[2]) end
 return applied
 `
 
 /**
- * KEYS: presence hash. ARGV: nowMs (the injected clock, so tests can
- * time-travel expiry against a real server). Returns the live
- * [field, value, ...] pairs; entries at or past their fine-bound
- * expiry are HDELed in the same atomic step, so a stale reader can
- * never sweep a concurrently refreshed field.
+ * KEYS: presence hash. ARGV: nowMs, then the fields a read saw expired.
+ * Deletes those still at or past their expiry, re-checked in this atomic
+ * step so a stale reader never sweeps a concurrently refreshed field.
  */
-const PRESENCE_READ_LUA = `
+const PRESENCE_PRUNE_LUA = `${SLICED_LUA}${PRESENCE_STAMPS_LUA}
 local now = tonumber(ARGV[1])
-local rows = redis.call('HGETALL', KEYS[1])
-local live = {}
-for i = 1, #rows, 2 do
-  if tonumber(cjson.decode(rows[i + 1])['e']) <= now then
-    redis.call('HDEL', KEYS[1], rows[i])
-  else
-    live[#live + 1] = rows[i]
-    live[#live + 1] = rows[i + 1]
+local fields = {}
+for i = 2, #ARGV do fields[#fields + 1] = ARGV[i] end
+local stored = sliced('HMGET', KEYS[1], fields)
+local stale = {}
+for i = 1, #fields do
+  if stored[i] then
+    local _, e = stamps(stored[i])
+    if e <= now then stale[#stale + 1] = fields[i] end
   end
 end
-return live
+sliced('HDEL', KEYS[1], stale)
+return 1
 `
 
 /**
- * KEYS: head, history, event counter. ARGV: snapshot frontier or ''.
+ * KEYS: counter, head, history. ARGV: snapshot frontier or ''.
  * 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 session = string.sub(KEYS[1], 1, -6)
+local counts = redis.call('MGET', KEYS[1], session .. 'clear')
 local boundary = tonumber(counts[2] or '0')
-local head = redis.call('GET', KEYS[1])
+local head = redis.call('GET', KEYS[2])
 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')
@@ -1037,63 +1498,138 @@ 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, boundary, 'LIMIT', 0, 1)
+  local historical = redis.call('ZREVRANGEBYSCORE', KEYS[3], upper, boundary, 'LIMIT', 0, 1)
   if #historical > 0 then snapshot = historical[1] end
 end
-return { head_index or '', snapshot or '', counts[1] or '0', tostring(boundary) }
+return { head_index or '', snapshot or '', counts[1] or counts[2] 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.
+ * What reclaim removes once no entry is left below the latest clear: every
+ * registered reducer's checkpoints below the latest clear and the pin counts
+ * naming them (snapshot writes register each reducer in
+ * {prefix}:{session}:snap-reducers, so no key scan is needed), every head
+ * row below it (whole chunks, then the boundary chunk's older rows), the
+ * type indexes' older entries, and the lane cursors it left idle.
+ *
+ * A lifetime that ended empty then collapses to the clear marker, the log
+ * holding it (readers resuming before the marker still read it), and the log
+ * cursors the sweep reset to the marker. The counter reads from the marker
+ * when absent, type indexes rebuild lazily, and the marker's own id key goes
+ * too.
  */
-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
+const SWEEP_LUA = `
+local function sweep(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)
+    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 counts = redis.call('HGETALL', PIN_COUNTS)
   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
+  sliced('HDEL', PIN_COUNTS, stale)
+  local raw = redis.call('GET', TYPED)
+  if raw then
+    for name in pairs(cjson.decode(raw)) do
+      redis.call('ZREMRANGEBYSCORE', type_key(name), '-inf', '(' .. boundary)
+    end
+  end
+  local last = math.floor((boundary - 1) / ${META_CHUNK_SIZE})
+  local chunks = {}
+  for chunk = 0, last - 1 do chunks[#chunks + 1] = META .. ':' .. tostring(chunk) end
+  sliced('UNLINK', nil, chunks)
+  local older = {}
+  for _, field in ipairs(redis.call('HKEYS', META .. ':' .. tostring(last))) do
+    local idx = tonumber(string.match(field, '^(%d+):'))
+    if idx and idx < boundary then older[#older + 1] = field end
+  end
+  sliced('HDEL', META .. ':' .. tostring(last), older)
+  local fields = redis.call('HGETALL', CURSORS)
+  local records, order = {}, {}
+  for i = 1, #fields, 2 do
+    local at = string.find(fields[i], ':[^:]*$')
+    local cid, suffix = string.sub(fields[i], 1, at - 1), string.sub(fields[i], at + 1)
+    if not records[cid] then
+      records[cid] = {}
+      order[#order + 1] = cid
+    end
+    records[cid][suffix] = fields[i + 1]
+  end
+  local idle, moved = {}, {}
+  for _, cid in ipairs(order) do
+    local record = records[cid]
+    local _, tag = parse_cid(cid)
+    local head = (record.h and record.h ~= '') and tonumber(record.h) or false
+    local position = tonumber(record.p or '0')
+    if head and head <= boundary then head = false end
+    if string.sub(tag, 1, 1) == 'G' then
+      if position < boundary then position = boundary end
+      moved[#moved + 1] = cid .. ':h'
+      moved[#moved + 1] = head and tostring(head) or ''
+      moved[#moved + 1] = cid .. ':p'
+      moved[#moved + 1] = tostring(position)
+    elseif not head and position <= boundary then
+      for suffix in pairs(record) do idle[#idle + 1] = cid .. ':' .. suffix end
+    elseif not head and record.h ~= '' then
+      moved[#moved + 1] = cid .. ':h'
+      moved[#moved + 1] = ''
+    end
+  end
+  sliced('HDEL', CURSORS, idle)
+  sliced('HSET', CURSORS, moved)
+  local count = redis.call('GET', COUNTER)
+  if not count or tonumber(count) ~= boundary or redis.call('ZCARD', READY) > 0 then
+    return
+  end
+  local stale = { COUNTER, TYPED, PIN_COUNTS, chunk_key(boundary) }
+  local reducers = SESSION .. 'snap-reducers'
+  for _, reducer in ipairs(redis.call('SMEMBERS', reducers)) do
+    stale[#stale + 1] = SESSION .. 'snap:' .. reducer
+    stale[#stale + 1] = SESSION .. 'snap-history:' .. reducer
+  end
+  stale[#stale + 1] = reducers
+  local types = redis.call('GET', TYPED)
+  if types then
+    for name in pairs(cjson.decode(types)) do stale[#stale + 1] = type_key(name) end
+  end
+  local marker = redis.call('XRANGE', LOG, boundary .. '-0', boundary .. '-0')[1]
+  if marker then
+    for i = 1, #marker[2], 2 do
+      if marker[2][i] == 'id' then stale[#stale + 1] = id_key(marker[2][i + 1]) end
+    end
+  end
+  sliced('UNLINK', nil, stale)
 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.
+ * KEYS: counter.
+ * ARGV: sessionId, nowMs, ifLastIndex or '', cause consumer or '', cause tag,
+ * cause index, cause attempt, marker id.
+ * Returns ['ok', cleared, head, boundary, appended?] | ['superseded'] |
+ * ['foreign']; `appended` is '1' when this call appended the marker.
+ * The marker joins the same log: the old lifetime's entries stay below it
+ * until reclaim deletes them, and every read of the log starts at the
+ * marker. (A stream can't be renamed aside: Upstash refuses RENAME on one.)
+ * The ready set is unlinked, so claims and pending checks see only the new
+ * lifetime. Type indexes keep their older entries until reclaim too:
+ * lookups start above the marker.
  */
-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])
+const CLEAR_LUA = `${BASE_LUA}
+local marker_owner = owners_of(read_bounds({ ARGV[8] }))[1]
+local head = total
 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 }
+  local idx = tonumber(ARGV[6])
+  if idx <= boundary then return { 'superseded' } end
+  local row = read_rows({ { idx, row_of(ARGV[4], ARGV[5]) } }, { 'd', 'f', 'p', 'l' })[1]
+  if tonumber(row[1] or '0') ~= tonumber(ARGV[7]) or row[2] or row[3] or not owns(row[4], ARGV[5]) then
+    return { 'superseded' }
   end
 end
 local expected = ARGV[3]
@@ -1106,151 +1642,118 @@ end
 if head == 0 or boundary == head then
   return { 'ok', '1', tostring(head), tostring(boundary) }
 end
-if counts[4] then return { 'foreign' } end
+if marker_owner 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 }
+redis.call('UNLINK', READY)
+redis.call('XADD', LOG, field .. '-0',
+  'id', ARGV[8], 'type', CLEAR_TYPE, 'payload', 'null',
+  'created_at', ARGV[2], 'cause', '')
+redis.call('MSET', id_key(ARGV[8]), field, COUNTER, field, CLEAR, field)
+return { 'ok', '1', field, field, '1' }
 `
 
 /**
  * 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.
+ * The next deletion batch: up to a page of [index, id] pairs of the log's
+ * entries below the latest clear. With none left it sweeps what the old
+ * lifetimes left 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')
+const RECLAIM_BATCH_LUA = `${BASE_LUA}${SWEEP_LUA}
+local boundary = tonumber(redis.call('GET', 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
+local entries = redis.call('XRANGE', LOG, '-', tostring(boundary - 1) .. '-0', 'COUNT', ARGV[1])
+if #entries == 0 then
+  sweep(boundary)
+  return {}
+end
+local batch = {}
+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
-    return batch
   end
-  redis.call('DEL', log)
-  redis.call('SREM', session .. 'cleared', log)
 end
-sweep_checkpoints(session, boundary)
-return {}
+return batch
 `
 
 /**
- * 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].
+ * KEYS: counter.
+ * ARGV: sessionId, n, then per entry: index, id.
+ * Deletes the listed entries below the latest clear and their id records.
+ * 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 = {}, {}, {}, {}, {}, {}
+const RECLAIM_LUA = `${BASE_LUA}${SWEEP_LUA}
+local boundary = tonumber(redis.call('GET', CLEAR) or '0')
+local ids, indexes, stream_ids = {}, {}, {}
 -- 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]
+for i = 1, tonumber(ARGV[2]) do
+  local field = ARGV[2 + (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
+    ids[#ids + 1] = ARGV[2 + (i - 1) * 2 + 2]
+    indexes[#ids] = tonumber(field)
+    stream_ids[#ids] = field .. '-0'
   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
+if #ids > 0 then
+  local keys = {}
+  for i = 1, #ids do keys[i] = id_key(ids[i]) end
+  local owners, stale = sliced('MGET', nil, keys), {}
+  for i = 1, #ids do
+    if owners[i] and tonumber(owners[i]) == indexes[i] then
+      stale[#stale + 1] = keys[i]
     end
   end
-  if #stale_ids > 0 then sliced('DEL', nil, stale_ids) end
-  removed = redis.call('XDEL', KEYS[1], unpack(stream_ids))
+  sliced('DEL', nil, stale)
+  removed = redis.call('XDEL', LOG, 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
+if #redis.call('XRANGE', LOG, '-', tostring(boundary - 1) .. '-0', 'COUNT', 1) == 0 then
+  sweep(boundary)
+  done = 1
 end
 return { removed, done }
 `
 
 // ── wire helpers ─────────────────────────────────────────────────────
 
+const WAKE_PAYLOAD_LIMIT = 32_768
+const encoder = new TextEncoder()
+
+/**
+ * A wake-up announcing events through `frontier`. It carries them, so a
+ * caught-up reader applies them without reading the stream:
+ * `{"f":frontier,"t":createdAt,"e":[[index,id,type,payload],...]}`, with
+ * payloads inlined as their stored JSON text. One over WAKE_PAYLOAD_LIMIT
+ * bytes, or one without entries, announces only `{"f":frontier}`, and
+ * readers catch up with XRANGE.
+ */
+const wakeMessage = (
+  frontier: number,
+  createdAt: number,
+  entries: ReadonlyArray<
+    readonly [index: number, id: string, type: string, payloadJson: string]
+  >,
+): string => {
+  const bare = `{"f":${frontier}}`
+  if (entries.length === 0) return bare
+  const carried = `{"f":${frontier},"t":${createdAt},"e":[${entries
+    .map(
+      ([index, id, type, payload]) =>
+        `[${index},${JSON.stringify(id)},${JSON.stringify(type)},${payload}]`,
+    )
+    .join(',')}]}`
+  return encoder.encode(carried).byteLength > WAKE_PAYLOAD_LIMIT
+    ? bare
+    : carried
+}
+
 export type StreamEntry = [id: string, fields: string[]]
 
 const fieldMap = (fields: string[]): Record<string, string> => {
@@ -1276,6 +1779,30 @@ const toEvent = (sessionId: string, entry: StreamEntry): Event => {
   }
 }
 
+/**
+ * A stream entry's causal edge. Releases before consumers (0.17 to 0.20)
+ * recorded only the parent's index and attempt: their edge reads as the
+ * handlers table's, `a2.handlers`, as Postgres's upgrade names it, with no
+ * lane, since nothing reads an earlier release's lane.
+ */
+const decodeStreamCause = (raw: string): EventCause | null => {
+  const parsed = JSON.parse(raw) as { consumer?: unknown }
+  return decodeCause(
+    parsed.consumer === undefined
+      ? { consumer: 'a2.handlers', lane: null, ...parsed }
+      : parsed,
+  )
+}
+
+/** A stream entry with its causal edge. */
+const toStoredEvent = (sessionId: string, entry: StreamEntry): StoredEvent => {
+  const cause = fieldMap(entry[1])['cause']
+  return Object.assign(toEvent(sessionId, entry), {
+    cause:
+      cause === undefined || cause === '' ? null : decodeStreamCause(cause),
+  })
+}
+
 type ByteStreamEntry = [Uint8Array, Uint8Array[]]
 
 const fieldBytes = (name: string): Uint8Array => new TextEncoder().encode(name)
@@ -1338,75 +1865,107 @@ const toSerializedEvent = (
 
 const json = (value: unknown): string => JSON.stringify(value) ?? 'null'
 
-const toCause = (raw: string | undefined): EventCause | null => {
-  if (raw === '' || raw === undefined) return null
-  const value = JSON.parse(raw) as {
-    index?: unknown
-    attempt?: unknown
-    batchSize?: unknown
+/** How scripts name a cursor within its consumer: `#`, or `L` and its lane. */
+const tagOf = (lane: string | null): string =>
+  lane === null ? '#' : `L${lane}`
+
+/** The lane a cursor tag names: null for an event cursor. */
+const laneOf = (tag: string): string | null =>
+  tag.startsWith('#') ? null : tag.slice(1)
+
+const targetsArg = (targets: readonly EventTarget[] | undefined): string =>
+  targets === undefined || targets.length === 0
+    ? ''
+    : JSON.stringify(
+        targets.map((target) => [target.consumer, tagOf(target.lane)]),
+      )
+
+/** A log consumer's types, as scripts read them; '*' takes every type. */
+const logTypesArg = (types: readonly string[] | null): string =>
+  types === null ? '*' : JSON.stringify(types)
+
+/** The served consumers, as scripts read them; '' serves every consumer. */
+const servedArg = (consumers: readonly StoreConsumer[] | undefined): string =>
+  consumers === undefined
+    ? ''
+    : JSON.stringify(
+        consumers.map((consumer) =>
+          consumer.log
+            ? [
+                consumer.name,
+                consumer.log.lane,
+                logTypesArg(consumer.log.types),
+                consumer.log.backfill ? 1 : 0,
+              ]
+            : [consumer.name],
+        ),
+      )
+
+type Column = string | number | null | undefined
+
+/** A head's dispatch state from a row's HEAD_COLUMNS. */
+const dispatchOf = (
+  consumer: string,
+  lane: string | null,
+  columns: readonly Column[] | null | undefined,
+): HeadDispatch => {
+  const column = (at: number): string | null => {
+    const value = columns?.[at]
+    return value === null || value === undefined ? null : String(value)
   }
-  if (
-    !Number.isInteger(value.index) ||
-    Number(value.index) < 1 ||
-    !Number.isInteger(value.attempt) ||
-    Number(value.attempt) < 1
-  ) {
-    throw new TypeError('stored event has an invalid cause')
+  const date = (at: number): Date | null => {
+    const value = column(at)
+    return value === null ? null : new Date(Number(value))
   }
-  if (
-    value.batchSize !== undefined &&
-    (!Number.isInteger(value.batchSize) || Number(value.batchSize) < 1)
-  ) {
-    throw new TypeError('stored event has an invalid cause')
+  const count = (at: number): number | null => {
+    const value = column(at)
+    return value === null ? null : Number(value)
   }
   return {
-    index: Number(value.index),
-    attempt: Number(value.attempt),
-    ...(value.batchSize === undefined
-      ? {}
-      : { batchSize: Number(value.batchSize) }),
+    consumer,
+    lane,
+    firstClaimedAt: date(1),
+    lastClaimedAt: date(2),
+    attemptCount: count(0) ?? 0,
+    claimHolder: column(3),
+    claimExpiresAt: date(4),
+    failureCount: count(5) ?? 0,
+    lastFailedAt: date(6),
+    lastFailedAttempt: count(7),
+    lastError: column(8),
+    failedAt: date(9),
   }
 }
 
-type MetaSuffix = (typeof STORED_EVENT_META_SUFFIXES)[number]
-
-/** A stream entry joined with its metadata columns; absent columns are unset. */
-const toStoredEvent = (
-  sessionId: string,
+type HeadTuple = [
+  consumer: string,
+  tag: string,
+  index: string,
+  columns: Column[],
   entry: StreamEntry,
-  column: (suffix: MetaSuffix) => string | undefined,
-): StoredEvent => {
-  const fields = fieldMap(entry[1])
-  const date = (suffix: MetaSuffix): Date | null => {
-    const value = column(suffix)
-    return value === undefined ? null : new Date(Number(value))
-  }
-  const count = (suffix: MetaSuffix): number | null => {
-    const value = column(suffix)
-    return value === undefined ? null : Number(value)
-  }
-  const returnedEventIds = column('ri')
-  return Object.assign(toEvent(sessionId, entry), {
-    cause: toCause(fields['cause']),
-    lane: fields['lane'] === '' ? null : fields['lane']!,
-    processedAt: date('p'),
-    processedByAttempt: count('pa'),
-    returnedEventIds:
-      returnedEventIds === undefined
-        ? null
-        : decodeReturnedEventIds(returnedEventIds),
-    firstClaimedAt: date('fc'),
-    lastClaimedAt: date('lc'),
-    attemptCount: count('d') ?? 0,
-    claimHolder: column('ch') ?? null,
-    claimExpiresAt: date('ce'),
-    failureCount: count('a') ?? 0,
-    lastFailedAt: date('lf'),
-    lastFailedAttempt: count('lfa'),
-    lastError: column('e') ?? null,
-    failedAt: date('f'),
-  })
-}
+]
+
+const toHeadEvent = (sessionId: string, head: HeadTuple): HeadEvent => ({
+  ...toStoredEvent(sessionId, head[4]),
+  ...dispatchOf(head[0], laneOf(head[1]), head[3]),
+})
+
+const compareText = (a: string, b: string): number =>
+  a < b ? -1 : a > b ? 1 : 0
+
+const byHead = (a: HeadRef, b: HeadRef): number =>
+  a.index - b.index || compareText(a.consumer, b.consumer)
+
+/** Consumer, then lane, with concurrent cursors last by head. */
+const byCursor = (a: StoredCursor, b: StoredCursor): number =>
+  compareText(a.consumer, b.consumer) ||
+  (a.lane === null
+    ? b.lane === null
+      ? (a.head ?? 0) - (b.head ?? 0)
+      : 1
+    : b.lane === null
+      ? -1
+      : compareText(a.lane, b.lane))
 
 const toClaimAvailableResult = (
   sessionId: string,
@@ -1415,57 +1974,13 @@ const toClaimAvailableResult = (
   const outcome = String(reply[0])
   if (outcome === 'claimed') {
     const count = Number(reply[1])
-    const events: StoredEvent[] = []
-    for (let i = 0; i < count; i++) {
-      const offset = 2 + i * 11
-      const entry = reply[offset + 9] as StreamEntry
-      const event = toEvent(sessionId, entry)
-      const fields = fieldMap(entry[1])
-      events.push(
-        Object.assign(event, {
-          cause: toCause(fields['cause']),
-          lane: fields['lane'] === '' ? null : fields['lane']!,
-          processedAt: null,
-          processedByAttempt: null,
-          returnedEventIds: null,
-          firstClaimedAt:
-            reply[offset + 3] === null
-              ? null
-              : new Date(Number(reply[offset + 3])),
-          lastClaimedAt:
-            reply[offset + 4] === null
-              ? null
-              : new Date(Number(reply[offset + 4])),
-          attemptCount: Number(reply[offset]),
-          claimHolder:
-            reply[offset + 7] === null ? null : String(reply[offset + 7]),
-          claimExpiresAt:
-            reply[offset + 8] === null
-              ? null
-              : new Date(Number(reply[offset + 8])),
-          failureCount: Number(reply[offset + 1]),
-          lastFailedAt:
-            reply[offset + 5] === null
-              ? null
-              : new Date(Number(reply[offset + 5])),
-          lastFailedAttempt:
-            reply[offset + 6] === null ? null : Number(reply[offset + 6]),
-          lastError:
-            reply[offset + 2] === null ? null : String(reply[offset + 2]),
-          failedAt:
-            reply[offset + 10] === null
-              ? null
-              : new Date(Number(reply[offset + 10])),
-        }),
-      )
-    }
-    const clearIndex = Number(reply[2 + count * 11] ?? 0)
+    const events = (reply.slice(2, 2 + count) as HeadTuple[])
+      .map((head) => toHeadEvent(sessionId, head))
+      .toSorted(byHead)
+    const clearIndex = Number(reply[2 + count] ?? 0)
     if (clearIndex > 0)
       for (const event of events) event.clearIndex = clearIndex
-    return {
-      outcome: 'claimed',
-      events,
-    }
+    return { outcome: 'claimed', events, head: Number(reply[3 + count]) }
   }
   if (outcome === 'busy') {
     return { outcome, retryAt: new Date(Number(reply[1])) }
@@ -1496,9 +2011,9 @@ const toIndex = ({
 }
 
 /**
- * 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.
+ * A range read that met a gap. Reclaim deletes the entries below a clear, so
+ * a read whose bounds predate the clear finds nothing where it expected
+ * events; anywhere else a gap is corruption.
  */
 const rangeGap = (sessionId: string, message: string): A2Error =>
   Object.assign(
@@ -1538,123 +2053,185 @@ const wrap = async <T>(fn: () => Promise<T>): Promise<T> => {
   }
 }
 
+/**
+ * A session's key. Every key of a session shares one hash tag, so a script
+ * locks only its session on Upstash and stays in one slot on a cluster. The
+ * tag is the session id as JSON with its braces escaped: it can't end early,
+ * and no session's tag spells another's.
+ */
+export const redisSessionKey = ({
+  prefix,
+  sessionId,
+  suffix,
+}: {
+  prefix: string
+  sessionId: string
+  suffix: string
+}): string =>
+  `${prefix}:{${JSON.stringify(sessionId).replaceAll('{', '\\u007b').replaceAll('}', '\\u007d')}}:${suffix}`
+
 export function createRedisStoreCore(
   options: RedisStoreCoreOptions,
 ): RedisStoreCore {
   const { call, callBytes, clock } = options
   const generateId = options.ids
   const prefix = options.keyPrefix
+  if (prefix.includes('{') || prefix.includes('}')) {
+    throw new TypeError(
+      'a redis keyPrefix cannot contain braces: they would set the hash tag of every key',
+    )
+  }
 
-  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}`
+  const sessionKey = (sessionId: string, suffix: string): string =>
+    redisSessionKey({ prefix, sessionId, suffix })
+  const storeKey = (s: string): string => sessionKey(s, 'log')
+  const countKey = (s: string): string => sessionKey(s, 'count')
+  // Scripts derive the session's other keys from the counter; keep them in step.
+  const clearKey = (s: string): string => sessionKey(s, 'clear')
+  const schemaKey = `${prefix}:schema`
+  const snapKey = (s: string, r: string): string => sessionKey(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 presenceKey = (s: string): string => `${prefix}:${s}:presence`
-  // 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')}`
+    sessionKey(s, `snap-history:${r}`)
+  const presenceKey = (s: string): string => sessionKey(s, 'presence')
+  // Channels aren't keys; the notify store subscribes by these names.
+  const notifyChannel = (s: string): string => `${prefix}:${s}:notify`
+  const presenceChannel = (s: string): string => `${prefix}:${s}:presence`
+
+  const layoutError = (): A2Error =>
+    new A2Error(
+      'STORE_NOT_CONFIGURED',
+      `the redis keys under prefix '${prefix}' hold an A2 layout other than '${REDIS_LAYOUT}', from another release; point the store at a fresh keyPrefix, or give the contract a new name so it starts new sessions`,
+    )
+
+  /**
+   * Once per store, before its first script: claim or check the prefix's
+   * layout, and ask the server whether scripts may lock only their keys.
+   * Only the server's own rejection of the flag means no; a transport error
+   * fails this attempt, and the next operation asks again.
+   */
+  const prepared = retryableLazy(async () => {
+    const [, keyLocking] = await Promise.all([
+      (async () => {
+        await call('SET', schemaKey, REDIS_LAYOUT, 'NX')
+        if ((await call('GET', schemaKey)) !== REDIS_LAYOUT) throw layoutError()
+      })(),
+      call('EVAL', `${KEY_LOCKING}\nreturn 1`, 1, schemaKey).then(
+        () => true,
+        (error: unknown) => {
+          if (SHEBANG_REJECTED.test(String((error as Error)?.message)))
+            return false
+          throw error
+        },
+      ),
+    ])
+    return { keyLocking }
+  })
+
+  /** Runs a script; a `readOnly` one takes Upstash's shared lock. */
+  const runScript = async ({
+    script,
+    keys,
+    args,
+    readOnly,
+  }: {
+    script: string
+    keys: string[]
+    args: Array<string | number>
+    readOnly: boolean
+  }): Promise<unknown> => {
+    const { keyLocking } = await prepared.get()
+    let source = script
+    if (keyLocking)
+      source = `${readOnly ? READ_ONLY_KEY_LOCKING : KEY_LOCKING}\n${script}`
+    return call('EVAL', source, keys.length, ...keys, ...args)
+  }
 
+  /** Runs a writing script over a session: KEYS start with its counter. */
   const evalScript = (
     script: string,
+    sessionId: string,
     keys: string[],
     args: Array<string | number>,
-  ): Promise<unknown> => call('EVAL', script, keys.length, ...keys, ...args)
+  ): Promise<unknown> =>
+    runScript({
+      script,
+      keys: [countKey(sessionId), ...keys],
+      args,
+      readOnly: false,
+    })
+
+  /**
+   * Publishes a write's wake-up after its script, never inside it: a script
+   * holds its lock while PUBLISH waits on subscribers. Wake-ups are hints (a
+   * lost one costs subscribers a catch-up read, never an event), so a failed
+   * publish is dropped and the write waits for it at most
+   * NOTIFY_TIMINGS.publishMs.
+   */
+  const publish = async (channel: string, message: string): Promise<void> => {
+    let timer: ReturnType<typeof setTimeout> | undefined
+    await Promise.race([
+      call('PUBLISH', channel, message).catch(() => undefined),
+      new Promise<void>((resolve) => {
+        timer = setTimeout(resolve, NOTIFY_TIMINGS.publishMs)
+        ;(timer as { unref?: () => void }).unref?.()
+      }),
+    ])
+    clearTimeout(timer)
+  }
 
-  const readRangeBounds = async (
+  /**
+   * Runs a write that may need a type's index to reach further back first.
+   * Such a write returns ['index', type, after] having written nothing, and
+   * runs again once INDEX_TYPE_LUA has indexed that history, a page per call.
+   */
+  const indexing = async (
+    sessionId: string,
+    run: () => Promise<unknown>,
+  ): Promise<unknown[]> => {
+    for (;;) {
+      // oxlint-disable-next-line no-await-in-loop -- each run follows the indexing it asked for
+      const reply = (await run()) as unknown[]
+      if (reply[0] !== 'index') return reply
+      for (;;) {
+        // oxlint-disable-next-line no-await-in-loop -- each page lowers the index's floor
+        const [done] = (await evalScript(
+          INDEX_TYPE_LUA,
+          sessionId,
+          [],
+          [String(reply[1]), Number(reply[2])],
+        )) as [string]
+        if (done === '1') break
+      }
+    }
+  }
+
+  /** The frontier and clear marker, in one MGET. */
+  const readBounds = async (
     sessionId: string,
-  ): Promise<{ frontier: number; metaSplit: number; clearIndex: number }> => {
-    const [count, split, cleared] = (await call(
+  ): Promise<{ frontier: number; clearIndex: number }> => {
+    await prepared.get()
+    const [count, cleared] = (await call(
       'MGET',
       countKey(sessionId),
-      metaSplitKey(sessionId),
       clearKey(sessionId),
-    )) as [unknown, unknown, unknown]
-    const frontier = toIndex({ raw: count, sessionId, name: 'event count' })
+    )) as [unknown, unknown]
     return {
-      frontier,
-      metaSplit:
-        split === null
-          ? frontier
-          : toIndex({ raw: split, sessionId, name: 'metadata split' }),
+      // A collapsed session keeps only its clear marker.
+      frontier: toIndex({
+        raw: count ?? cleared,
+        sessionId,
+        name: 'event count',
+      }),
       clearIndex: toIndex({ raw: cleared, sessionId, name: 'clear boundary' }),
     }
   }
 
-  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',
-      storeKey(sessionId),
-      `${afterIndex + 1}-0`,
-      `${throughIndex}-0`,
-      'COUNT',
-      READ_PAGE_SIZE,
-    )) as StreamEntry[]
-    if (entries.length === 0) return []
-
-    const fieldsByKey = new Map<string, string[]>()
-    for (const entry of entries) {
-      const index = entryIndex(entry[0])
-      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 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) => {
-      const idx = entryIndex(entry[0])
-      return toStoredEvent(
-        sessionId,
-        entry,
-        (suffix) => meta[`${idx}:${suffix}`],
-      )
+  const readClearIndex = async (sessionId: string): Promise<number> => {
+    await prepared.get()
+    return toIndex({
+      raw: await call('GET', clearKey(sessionId)),
+      sessionId,
+      name: 'clear boundary',
     })
   }
 
@@ -1744,11 +2321,8 @@ export function createRedisStoreCore(
   ): Promise<{ rows: StoredEvent[]; clearIndex: number }> => {
     if (throughIndex !== undefined && throughIndex <= afterIndex)
       return { rows: [], clearIndex: 0 }
-    const {
-      frontier: currentFrontier,
-      metaSplit,
-      clearIndex,
-    } = await readRangeBounds(sessionId)
+    const { frontier: currentFrontier, clearIndex } =
+      await readBounds(sessionId)
     const frontier = Math.min(throughIndex ?? currentFrontier, currentFrontier)
     // Reads start at the latest clear marker.
     const after = Math.max(afterIndex, clearIndex - 1)
@@ -1758,15 +2332,18 @@ export function createRedisStoreCore(
     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({
-        sessionId,
-        afterIndex: nextIndex - 1,
-        throughIndex: frontier,
-        metaSplit,
-      })
-      if (page.length === 0) {
+      const entries = (await call(
+        'XRANGE',
+        storeKey(sessionId),
+        `${nextIndex}-0`,
+        `${frontier}-0`,
+        'COUNT',
+        READ_PAGE_SIZE,
+      )) as StreamEntry[]
+      if (entries.length === 0) {
         throw rangeGap(sessionId, `ended before index ${frontier}`)
       }
+      const page = entries.map((entry) => toStoredEvent(sessionId, entry))
       for (let position = 0; position < page.length; position += 1) {
         if (page[position]!.index !== nextIndex + position) {
           throw rangeGap(sessionId, 'is not contiguous')
@@ -1836,62 +2413,44 @@ export function createRedisStoreCore(
           type: e.type,
           payload: e.payload,
           cause: e.cause ? { ...e.cause } : null,
-          lane: e.lane ?? null,
-          settled: e.settled === true,
+          targets: e.targets,
         }))
-        const args: Array<string | number> = [
-          sessionId,
-          now,
-          withIds.length,
-          ...withIds.flatMap((e) => [
-            e.id,
-            e.type,
-            json(e.payload),
-            e.cause ? json(e.cause) : '',
-            e.lane ?? '',
-            e.settled ? '1' : '0',
-          ]),
-          `${prefix}:${sessionId}:notify`,
-          appendOptions?.originIndex ?? '',
-        ]
-        const reply = (await evalScript(
-          APPEND_LUA,
-          [
-            storeKey(sessionId),
-            countKey(sessionId),
-            metaKey(sessionId),
-            pendingKey(sessionId),
-            readyKey(sessionId),
-            metaSplitKey(sessionId),
-            ...withIds.map((e) => idKey(e.id)),
-          ],
-          args,
+        const payloads = withIds.map((e) => json(e.payload))
+        const reply = (await indexing(sessionId, () =>
+          evalScript(
+            APPEND_LUA,
+            sessionId,
+            [],
+            [
+              sessionId,
+              now,
+              withIds.length,
+              servedArg(appendOptions?.consumers),
+              appendOptions?.originIndex ?? '',
+              ...withIds.flatMap((e, i) => [
+                e.id,
+                e.type,
+                payloads[i]!,
+                e.cause ? json(e.cause) : '',
+                targetsArg(e.targets),
+              ]),
+            ],
+          ),
         )) as string[]
 
         const [verdict] = reply
         if (verdict === 'empty') {
           return { events: [], hasPending: reply[1] === '1' }
         }
-        if (verdict === 'foreign') {
-          throw new A2Error(
-            'PARTIAL_DUPLICATE_BATCH',
-            `event id '${reply[1]}' already exists in another session`,
-          )
-        }
-        if (verdict === 'no_parent') {
-          throw new TypeError(
-            `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',
-            `a newer attempt owns event ${reply[1]} in session '${sessionId}'`,
+          throw supersededAttemptError(
+            sessionId,
+            withIds[Number(reply[1]) - 1]!.cause!,
           )
         }
         if (verdict === 'partial') {
@@ -1918,12 +2477,23 @@ export function createRedisStoreCore(
               `session '${sessionId}' was cleared while an append retry replayed; retry it`,
             )
           }
-          return {
-            events: idempotentReplay(events, existing),
-            hasPending,
-          }
+          const replayed = idempotentReplay(events, existing)
+          // The first attempt may have committed without publishing.
+          await publish(
+            notifyChannel(sessionId),
+            wakeMessage(firstIndex + events.length - 1, now, []),
+          )
+          return { events: replayed, hasPending }
         }
         const base = Number(reply[1]) - 1
+        await publish(
+          notifyChannel(sessionId),
+          wakeMessage(
+            base + withIds.length,
+            now,
+            withIds.map((e, i) => [base + 1 + i, e.id, e.type, payloads[i]!]),
+          ),
+        )
         return {
           events: withIds.map((e, i) => ({
             id: e.id,
@@ -1933,26 +2503,39 @@ export function createRedisStoreCore(
             sessionId,
             createdAt: new Date(now),
             cause: e.cause,
-            lane: e.lane,
-            processedAt: e.settled ? new Date(now) : null,
-            processedByAttempt: null,
-            returnedEventIds: null,
-            firstClaimedAt: null,
-            lastClaimedAt: null,
-            attemptCount: 0,
-            claimHolder: null,
-            claimExpiresAt: null,
-            failureCount: 0,
-            lastFailedAt: null,
-            lastFailedAttempt: null,
-            lastError: null,
-            failedAt: null,
           })),
           hasPending: reply[2] === '1',
         }
       })
     },
 
+    async cursors(sessionId) {
+      return wrap(async () => {
+        const reply = (await runScript({
+          script: CURSORS_LUA,
+          keys: [countKey(sessionId)],
+          args: [],
+          readOnly: true,
+        })) as Array<
+          [
+            consumer: string,
+            tag: string,
+            position: string,
+            head: string | null,
+            columns: Column[],
+          ]
+        >
+        return reply
+          .map(([consumer, tag, position, head, columns]): StoredCursor =>
+            Object.assign(dispatchOf(consumer, laneOf(tag), columns), {
+              position: Number(position),
+              head: head === null ? null : Number(head),
+            }),
+          )
+          .toSorted(byCursor)
+      })
+    },
+
     async read(sessionId, opts) {
       return wrap(() =>
         retryAfterGap(() =>
@@ -1967,21 +2550,7 @@ export function createRedisStoreCore(
         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',
-          })
+          const { frontier, clearIndex } = await readBounds(sessionId)
           // Reads start at the latest clear marker.
           return readEventRange(
             sessionId,
@@ -1997,32 +2566,31 @@ export function createRedisStoreCore(
       holder,
       ttlMs,
       expiresAtMs,
-      excludeIndexes,
+      exclude,
+      consumers,
       maxFailures,
+      through,
     }) {
       return wrap(async () => {
         const now = clock.now().getTime()
         const expiresAt = expiresAtMs ?? now + ttlMs
-        const excluded = excludeIndexes ?? []
+        const excluded = exclude ?? []
         const reply = (await evalScript(
           CLAIM_AVAILABLE_LUA,
-          [
-            storeKey(sessionId),
-            countKey(sessionId),
-            metaKey(sessionId),
-            pendingKey(sessionId),
-            readyKey(sessionId),
-            metaSplitKey(sessionId),
-            snapshotPinCountsKey(sessionId),
-          ],
+          sessionId,
+          [],
           [
             holder,
             now,
             expiresAt,
-            excluded.length,
-            ...excluded,
             maxFailures ?? '',
-            snapshotEventPinsPrefix(sessionId),
+            servedArg(consumers),
+            through ?? '',
+            excluded.length,
+            ...excluded.flatMap((ref) => [
+              ref.consumer,
+              ref.lane === null ? `#${ref.index}` : `L${ref.lane}`,
+            ]),
           ],
         )) as unknown[]
         return toClaimAvailableResult(sessionId, reply)
@@ -2030,30 +2598,48 @@ export function createRedisStoreCore(
     },
 
     async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
+      if (claims.length === 0) return { renewed: [], superseded: [] }
       return wrap(async () => {
         const now = clock.now().getTime()
         const expiresAt = expiresAtMs ?? now + ttlMs
         const reply = (await evalScript(
           RENEW_CLAIMS_LUA,
-          [countKey(sessionId), metaKey(sessionId), metaSplitKey(sessionId)],
+          sessionId,
+          [],
           [
             holder,
             now,
             expiresAt,
             claims.length,
-            ...claims.flatMap((claim) => [claim.index, claim.attempt]),
+            ...claims.flatMap((claim) => [
+              claim.consumer,
+              tagOf(claim.lane),
+              claim.index,
+              claim.attempt,
+            ]),
           ],
         )) as string[]
         const renewedCount = Number(reply[0])
-        const values = reply.slice(1).map(Number)
+        const refs = reply.slice(1).map((position): HeadRef => {
+          const { consumer, lane, index } = claims[Number(position) - 1]!
+          return { consumer, lane, index }
+        })
         return {
-          renewed: values.slice(0, renewedCount).toSorted((a, b) => a - b),
-          superseded: values.slice(renewedCount).toSorted((a, b) => a - b),
+          renewed: refs.slice(0, renewedCount).toSorted(byHead),
+          superseded: refs.slice(renewedCount).toSorted(byHead),
         }
       })
     },
 
-    async completeAttempt({ sessionId, index, attempt, events }) {
+    async completeAttempt({
+      sessionId,
+      consumer,
+      lane,
+      index,
+      attempt,
+      events,
+      consumers,
+    }) {
       return wrap(async () => {
         const ids = events.map((event) => event.id)
         if (new Set(ids).size !== ids.length) {
@@ -2063,34 +2649,32 @@ export function createRedisStoreCore(
           )
         }
         const now = clock.now().getTime()
-        const reply = (await evalScript(
-          COMPLETE_ATTEMPT_LUA,
-          [
-            storeKey(sessionId),
-            countKey(sessionId),
-            metaKey(sessionId),
-            pendingKey(sessionId),
-            readyKey(sessionId),
-            snapshotEventPinsKey(sessionId, index),
-            snapshotPinCountsKey(sessionId),
-            metaSplitKey(sessionId),
-            ...ids.map((id) => idKey(id)),
-          ],
-          [
+        const cause: EventCause = { consumer, lane, index, attempt }
+        const payloads = events.map((event) => json(event.payload))
+        const reply = (await indexing(sessionId, () =>
+          evalScript(
+            COMPLETE_ATTEMPT_LUA,
             sessionId,
-            now,
-            index,
-            attempt,
-            events.length,
-            ...events.flatMap((event) => [
-              event.id,
-              event.type,
-              json(event.payload),
-              event.lane ?? '',
-              event.settled === true ? '1' : '0',
-            ]),
-            `${prefix}:${sessionId}:notify`,
-          ],
+            [],
+            [
+              sessionId,
+              now,
+              consumer,
+              tagOf(lane),
+              index,
+              attempt,
+              json(cause),
+              servedArg(consumers),
+              json(ids),
+              events.length,
+              ...events.flatMap((event, i) => [
+                event.id,
+                event.type,
+                payloads[i]!,
+                targetsArg(event.targets),
+              ]),
+            ],
+          ),
         )) as string[]
         const outcome = reply[0]
         if (outcome === 'missing') {
@@ -2106,9 +2690,23 @@ export function createRedisStoreCore(
         }
         if (outcome === 'superseded') return { outcome }
 
-        const cause = { index, attempt }
         if (outcome === 'ok') {
           const base = Number(reply[1]) - 1
+          if (events.length > 0) {
+            await publish(
+              notifyChannel(sessionId),
+              wakeMessage(
+                base + events.length,
+                now,
+                events.map((event, i) => [
+                  base + 1 + i,
+                  event.id,
+                  event.type,
+                  payloads[i]!,
+                ]),
+              ),
+            )
+          }
           return {
             outcome: 'completed',
             events: events.map((event, i) => ({
@@ -2118,21 +2716,7 @@ export function createRedisStoreCore(
               index: base + 1 + i,
               sessionId,
               createdAt: new Date(now),
-              cause,
-              lane: event.lane ?? null,
-              processedAt: event.settled === true ? new Date(now) : null,
-              processedByAttempt: null,
-              returnedEventIds: null,
-              firstClaimedAt: null,
-              lastClaimedAt: null,
-              attemptCount: 0,
-              claimHolder: null,
-              claimExpiresAt: null,
-              failureCount: 0,
-              lastFailedAt: null,
-              lastFailedAttempt: null,
-              lastError: null,
-              failedAt: null,
+              cause: { ...cause },
             })),
           } satisfies CompleteAttemptResult
         }
@@ -2150,10 +2734,27 @@ export function createRedisStoreCore(
           )
           // Cleared after the script matched the retry.
           if (index <= clearIndex) return { outcome: 'superseded' }
-          return {
-            outcome: 'completed',
-            events: idempotentReplay(events, existing),
+          if (
+            existing.some(
+              (row) =>
+                row.cause?.consumer !== consumer ||
+                row.cause.lane !== lane ||
+                row.cause.index !== index ||
+                row.cause.attempt !== attempt,
+            )
+          ) {
+            throw new A2Error(
+              'PARTIAL_DUPLICATE_BATCH',
+              'returned event retry does not match the committed batch',
+            )
           }
+          const replayed = idempotentReplay(events, existing)
+          // The first attempt may have committed without publishing.
+          await publish(
+            notifyChannel(sessionId),
+            wakeMessage(firstIndex + events.length - 1, now, []),
+          )
+          return { outcome: 'completed', events: replayed }
         }
         throw new TypeError(`unexpected completion outcome '${outcome}'`)
       })
@@ -2161,6 +2762,8 @@ export function createRedisStoreCore(
 
     async failAttempt({
       sessionId,
+      consumer,
+      lane,
       index,
       attempt,
       error,
@@ -2171,16 +2774,11 @@ export function createRedisStoreCore(
         const now = clock.now().getTime()
         const reply = (await evalScript(
           FAIL_ATTEMPT_LUA,
+          sessionId,
+          [],
           [
-            countKey(sessionId),
-            metaKey(sessionId),
-            pendingKey(sessionId),
-            readyKey(sessionId),
-            snapshotEventPinsKey(sessionId, index),
-            snapshotPinCountsKey(sessionId),
-            metaSplitKey(sessionId),
-          ],
-          [
+            consumer,
+            tagOf(lane),
             index,
             attempt,
             error,
@@ -2190,8 +2788,6 @@ export function createRedisStoreCore(
           ],
         )) 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}'`,
@@ -2206,67 +2802,84 @@ export function createRedisStoreCore(
 
     async deadLetters(sessionId) {
       return wrap(async () => {
-        const reply = (await evalScript(
-          DEAD_LETTERS_LUA,
-          [
-            storeKey(sessionId),
-            countKey(sessionId),
-            metaKey(sessionId),
-            pendingKey(sessionId),
-            metaSplitKey(sessionId),
-          ],
-          [],
-        )) as unknown[]
-        const events: StoredEvent[] = []
-        for (let i = 0; i + 1 < reply.length; i += 2) {
-          const columns = reply[i + 1] as Array<string | null>
-          events.push(
-            toStoredEvent(
-              sessionId,
-              reply[i] as StreamEntry,
-              (suffix) =>
-                columns[STORED_EVENT_META_SUFFIXES.indexOf(suffix)] ??
-                undefined,
-            ),
-          )
-        }
-        return events
+        const reply = (await runScript({
+          script: DEAD_LETTERS_LUA,
+          keys: [countKey(sessionId)],
+          args: [],
+          readOnly: true,
+        })) as HeadTuple[]
+        return reply
+          .map((head) => toHeadEvent(sessionId, head))
+          .toSorted(byHead)
       })
     },
 
-    async redrive({ sessionId, index, action }) {
+    async redrive({ sessionId, consumer, index, action, consumers }) {
       return wrap(async () => {
-        const [redriven, hasPending] = (await evalScript(
-          REDRIVE_LUA,
-          [
-            countKey(sessionId),
-            metaKey(sessionId),
-            pendingKey(sessionId),
-            readyKey(sessionId),
-            metaSplitKey(sessionId),
-          ],
-          [index, action, clock.now().getTime()],
+        const [redriven, hasPending] = (await indexing(sessionId, () =>
+          evalScript(
+            REDRIVE_LUA,
+            sessionId,
+            [],
+            [
+              consumer,
+              index,
+              action,
+              clock.now().getTime(),
+              servedArg(consumers),
+            ],
+          ),
         )) as [string, string]
         return { redriven: redriven === '1', hasPending: hasPending === '1' }
       })
     },
 
+    async wakeLog({ sessionId, consumer }) {
+      return wrap(async () => {
+        const { name, log } = consumer
+        const [, position, head, columns, sessionHead] = (await indexing(
+          sessionId,
+          () =>
+            evalScript(
+              WAKE_LOG_LUA,
+              sessionId,
+              [],
+              [name, log.lane, logTypesArg(log.types), log.backfill ? 1 : 0],
+            ),
+        )) as [
+          ok: string,
+          position: string,
+          head: string | null,
+          columns: Column[],
+          sessionHead: string,
+        ]
+        return {
+          cursor: Object.assign(dispatchOf(name, log.lane, columns), {
+            position: Number(position),
+            head: head === null ? null : Number(head),
+          }),
+          head: Number(sessionHead),
+        }
+      })
+    },
+
     async readState(sessionId, reducerName, stateOptions) {
       return wrap(() =>
         retryAfterGap(async () => {
-          const reply = (await evalScript(
-            READ_STATE_LUA,
-            [
+          const reply = (await runScript({
+            script: READ_STATE_LUA,
+            keys: [
+              countKey(sessionId),
               snapKey(sessionId, reducerName),
               snapHistoryKey(sessionId, reducerName),
-              countKey(sessionId),
             ],
-            [
+            args: [
               stateOptions?.snapshotThroughIndex ??
                 stateOptions?.throughIndex ??
                 '',
             ],
-          )) as [number | string, string, string, string]
+            readOnly: true,
+          })) as [number | string, string, string, string]
           const rawHead = reply[0]
           const raw = reply[1]
           const headIndex = rawHead === '' ? null : Number(rawHead)
@@ -2315,33 +2928,28 @@ export function createRedisStoreCore(
     async putSnapshots(sessionId, reducerName, writes) {
       const byIndex = new Map<
         number,
-        { index: number; state: unknown; pinEventIndexes: Set<number> }
+        { index: number; state: unknown; pins: Map<string, HeadRef> }
       >()
       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 {
+        const pins = existing?.pins ?? new Map<string, HeadRef>()
+        for (const pin of write.pins ?? []) {
+          pins.set(JSON.stringify([pin.consumer, pin.lane, pin.index]), pin)
+        }
+        if (existing) existing.state = write.state
+        else
           byIndex.set(write.index, {
             index: write.index,
             state: write.state,
-            pinEventIndexes: new Set(write.pinEventIndexes ?? []),
+            pins,
           })
-        }
       }
       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,
-        ]
+        const args: Array<string | number> = [normalized.length]
         for (const write of normalized) {
           args.push(
             write.index,
@@ -2352,19 +2960,20 @@ export function createRedisStoreCore(
               // This reducer is in the session's registry (PUT_SNAPSHOTS_LUA).
               r: 1,
             }),
-            write.pinEventIndexes.size,
-            ...write.pinEventIndexes,
+            write.pins.size,
+            ...[...write.pins.values()].flatMap((pin) => [
+              pin.consumer,
+              tagOf(pin.lane),
+              pin.index,
+            ]),
           )
         }
         await evalScript(
           PUT_SNAPSHOTS_LUA,
+          sessionId,
           [
             snapKey(sessionId, reducerName),
             snapHistoryKey(sessionId, reducerName),
-            countKey(sessionId),
-            metaKey(sessionId),
-            snapshotPinCountsKey(sessionId),
-            metaSplitKey(sessionId),
           ],
           [...args, reducerName],
         )
@@ -2380,69 +2989,76 @@ export function createRedisStoreCore(
           // Expiry anchors on the injected storage clock — the sender's
           // `a` stamp orders writes, the `e` stamp bounds their
           // lifetime, and the two clocks never mix.
-          const expiresAtMs = clock.now().getTime() + meta.ttlMs
+          const nowMs = clock.now().getTime()
+          const expiresAtMs = nowMs + meta.ttlMs
           // The hash field is JSON `[participant, field]`: both are
           // caller strings, so no separator character is
           // collision-safe — the JSON array is.
-          const applied = (await evalScript(
-            PRESENCE_SET_LUA,
-            [presenceKey(ns)],
-            [
+          const applied = (await runScript({
+            script: PRESENCE_SET_LUA,
+            keys: [presenceKey(ns)],
+            args: [
               atMs,
               meta.ttlMs,
+              nowMs,
               entries.length,
+              // A null is stored as a tombstone: it keeps its stamp, so an
+              // older set that arrives after it still loses.
               ...entries.flatMap(([field, value]) => [
                 JSON.stringify([participant, field]),
-                value === null
-                  ? ''
-                  : json({
-                      v: value,
-                      s: meta.seen,
-                      a: atMs,
-                      e: expiresAtMs,
-                    }),
-                `${json(field)}:${json(value)}`,
+                json({ a: atMs, e: expiresAtMs, s: meta.seen, v: value }),
               ]),
-              presenceKey(ns),
-              `${json({ src: options.presenceSource, participant, seen: meta.seen, at: atMs }).slice(0, -1)},"values":{`,
             ],
-          )) as string[]
+            readOnly: false,
+          })) as string[]
           if (applied.length === 0) return null
           // Field-keyed and caller-named — null-prototype, like every
           // presence map (see `nullProtoRecord`).
           const appliedValues: Record<string, unknown> = nullProtoRecord()
+          const published: string[] = []
           for (const position of applied) {
             const [field, value] = entries[Number(position) - 1]!
             appliedValues[field] = structuredClone(value)
+            published.push(`${json(field)}:${json(value)}`)
           }
           return {
-            participant,
-            values: appliedValues,
-            seen: meta.seen,
-            at: new Date(atMs),
+            patch: {
+              participant,
+              values: appliedValues,
+              seen: meta.seen,
+              at: new Date(atMs),
+            },
+            published: publish(
+              presenceChannel(ns),
+              `${json({ src: options.presenceSource, participant, seen: meta.seen, at: atMs }).slice(0, -1)},"values":{${published.join(',')}}}`,
+            ),
           }
         })
       },
 
       async read(ns) {
         return wrap(async () => {
-          const reply = (await evalScript(
-            PRESENCE_READ_LUA,
-            [presenceKey(ns)],
-            [clock.now().getTime()],
-          )) as string[]
+          const key = presenceKey(ns)
+          const reply = (await call('HGETALL', key)) as string[]
+          const nowMs = clock.now().getTime()
           const rows: PresenceRow[] = []
+          const expired: string[] = []
           for (let i = 0; i + 1 < reply.length; i += 2) {
-            const [participant, field] = JSON.parse(reply[i]!) as [
-              string,
-              string,
-            ]
             const entry = JSON.parse(reply[i + 1]!) as {
               v: unknown
               s: number
               a: number
               e: number
             }
+            if (entry.e <= nowMs) {
+              expired.push(reply[i]!)
+              continue
+            }
+            if (entry.v === null) continue
+            const [participant, field] = JSON.parse(reply[i]!) as [
+              string,
+              string,
+            ]
             rows.push({
               participant,
               field,
@@ -2452,6 +3068,16 @@ export function createRedisStoreCore(
               expiresAt: new Date(entry.e),
             })
           }
+          // The rows are already filtered; a failed prune only defers the
+          // deletion to the next read.
+          if (expired.length > 0) {
+            await runScript({
+              script: PRESENCE_PRUNE_LUA,
+              keys: [key],
+              args: [nowMs, ...expired],
+              readOnly: false,
+            }).catch(() => undefined)
+          }
           return rows
         })
       },
@@ -2463,14 +3089,20 @@ export function createRedisStoreCore(
 
     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[]
+        // Entries below the latest clear are an old lifetime's, awaiting
+        // reclaim: a tail that reaches them is the boundary-aware reads' job.
+        const [newest, clearIndex] = await Promise.all([
+          call(
+            'XREVRANGE',
+            storeKey(sessionId),
+            throughIndex === undefined ? '+' : `${throughIndex}-0`,
+            `${fromIndex}-0`,
+            'COUNT',
+            READ_PAGE_SIZE,
+          ) as Promise<StreamEntry[]>,
+          readClearIndex(sessionId),
+        ])
+        if (clearIndex > fromIndex) return null
         const page = newest
           .toReversed()
           .map((entry) => toEvent(sessionId, entry))
@@ -2490,41 +3122,43 @@ export function createRedisStoreCore(
     async clear({ sessionId, ifLastIndex, cause }) {
       return wrap(async () => {
         const markerId = generateId()
+        const now = clock.now().getTime()
         const reply = (await evalScript(
           CLEAR_LUA,
-          [
-            storeKey(sessionId),
-            countKey(sessionId),
-            metaKey(sessionId),
-            metaSplitKey(sessionId),
-            idKey(markerId),
-            pendingKey(sessionId),
-            readyKey(sessionId),
-          ],
+          sessionId,
+          [],
           [
             sessionId,
-            clock.now().getTime(),
+            now,
             ifLastIndex ?? '',
+            cause?.consumer ?? '',
+            cause ? tagOf(cause.lane) : '',
             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`,
           )
         }
+        const head = Number(reply[2])
+        if (reply[4] === '1') {
+          await publish(
+            notifyChannel(sessionId),
+            wakeMessage(head, now, [
+              [head, markerId, CLEAR_EVENT_TYPE, 'null'],
+            ]),
+          )
+        } else if (reply[1] === '1' && head > 0) {
+          // An earlier attempt may have appended the marker without publishing.
+          await publish(notifyChannel(sessionId), wakeMessage(head, now, []))
+        }
         return {
           cleared: reply[1] === '1',
           index: Number(reply[2]),
@@ -2535,31 +3169,25 @@ export function createRedisStoreCore(
 
     async reclaim(sessionId) {
       return wrap(async () => {
-        const [log, ...pairs] = (await evalScript(
+        const pairs = (await evalScript(
           RECLAIM_BATCH_LUA,
-          [countKey(sessionId)],
+          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]!)
+        if (pairs.length === 0) return { deleted: 0, done: true }
         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],
+          sessionId,
+          [],
+          [sessionId, pairs.length / 2, ...pairs],
         )) as [number, number]
         return { deleted: Number(deleted), done: Number(done) === 1 }
       })
     },
 
+    clearIndex: (sessionId) => wrap(() => readClearIndex(sessionId)),
+
     async readEvents(sessionId, afterIndex) {
       return wrap(async () => {
         const entries = (await call(