experimental-a2 0.20.0 → 0.22.0

package/dist/store-redis-notify-CsJw_hfD.js

@@ -0,0 +1,3060 @@
+import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-wHd5GCpZ.js";
+import { C as stateTailReaders, i as NOTIFY_TIMINGS, y as nullProtoRecord } from "./internal-CvsrprnU.js";
+import { a as presenceTombstones, n as isSerializedEvent, r as parseSerializedEvent, t as bufferedEvents } from "./stream-buffer-DrTyiIuo.js";
+import { i as streamActivities, n as pollingStream, r as createStreamActivity, t as defaultSleep } from "./store-polling-BZt2Rf3D.js";
+import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
+import { a as idempotentReplay, n as decodeCause } from "./store-codec-DwrWlgQx.js";
+import { t as pollPresence } from "./store-presence-polling-JuAy2Ck2.js";
+//#region src/presence-recovery.ts
+const key = ({ participant, field }) => JSON.stringify([participant, field]);
+function presenceRecovery({ read, deliver, isActive }) {
+	const fields = /* @__PURE__ */ new Map();
+	const deleted = presenceTombstones();
+	const reading = /* @__PURE__ */ new Set();
+	let generation = 0;
+	let latest;
+	const remember = ({ participant, field, seen, at }) => {
+		const id = key({
+			participant,
+			field
+		});
+		const previous = fields.get(id);
+		if (!previous || previous.at.getTime() < at.getTime() || previous.at.getTime() === at.getTime() && previous.seen !== seen) fields.set(id, {
+			participant,
+			field,
+			seen,
+			at
+		});
+	};
+	const snapshot = async ({ reconcile }) => {
+		const run = generation;
+		const before = new Map(fields);
+		const changed = /* @__PURE__ */ new Set();
+		reading.add(changed);
+		try {
+			const rows = await read();
+			if (!isActive()) return rows;
+			if (run !== generation) return latest;
+			const current = rows.filter((row) => !deleted.outranks(row));
+			const live = /* @__PURE__ */ new Set();
+			for (const row of current) {
+				const id = key(row);
+				live.add(id);
+				if (changed.has(id)) continue;
+				deleted.drop(row);
+				remember(row);
+				if (reconcile) deliver({
+					participant: row.participant,
+					values: { [row.field]: row.value },
+					seen: row.seen,
+					at: row.at
+				});
+			}
+			if (reconcile) for (const [id, prior] of before) {
+				if (live.has(id) || changed.has(id) || fields.get(id) !== prior) continue;
+				fields.delete(id);
+				deleted.keep(prior);
+				deliver({
+					participant: prior.participant,
+					values: { [prior.field]: null },
+					seen: prior.seen,
+					at: prior.at
+				});
+			}
+			return current;
+		} finally {
+			reading.delete(changed);
+			if (reading.size === 0) latest = void 0;
+		}
+	};
+	return {
+		async read() {
+			let pending = latest;
+			while (pending) {
+				await pending;
+				if (latest === pending) break;
+				pending = latest;
+			}
+			return snapshot({ reconcile: false });
+		},
+		async reconnect() {
+			generation += 1;
+			latest = snapshot({ reconcile: true });
+			await latest;
+		},
+		update(patch) {
+			for (const [field, value] of Object.entries(patch.values)) {
+				if (value === void 0) continue;
+				const write = {
+					participant: patch.participant,
+					field,
+					at: patch.at
+				};
+				const id = key(write);
+				const previous = fields.get(id);
+				if (previous && previous.at.getTime() > patch.at.getTime()) continue;
+				if (deleted.outranks(write)) continue;
+				for (const changed of reading) changed.add(id);
+				if (value === null) {
+					fields.delete(id);
+					deleted.keep(write);
+				} else {
+					deleted.drop(write);
+					remember({
+						...write,
+						seen: patch.seen
+					});
+				}
+			}
+		}
+	};
+}
+const FEED_PAGE_SIZE = 1e3;
+const READ_CONCURRENCY = 16;
+/** The key layout this core writes; any other is rejected. */
+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 = 1e3;
+/** 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' }`;
+/**
+* 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 SLICED_LUA = `
+local function sliced(command, key, args)
+  local results = {}
+  for first = 1, #args, 1000 do
+    local last = math.min(first + 999, #args)
+    local reply
+    if key then
+      reply = redis.call(command, key, unpack(args, first, last))
+    else
+      reply = redis.call(command, unpack(args, first, last))
+    end
+    if type(reply) == 'table' then
+      for _, value in ipairs(reply) do results[#results + 1] = value end
+    end
+  end
+  return results
+end
+`;
+/**
+* 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 position, ref in ipairs(refs) do
+    local key = chunk_key(ref[1])
+    local group = groups[key]
+    if not group then
+      group = { positions = {}, names = {} }
+      groups[key] = group
+      order[#order + 1] = key
+    end
+    group.positions[#group.positions + 1] = position
+    for _, suffix in ipairs(suffixes) do
+      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 n, position in ipairs(group.positions) do
+      local 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, deletes, delete_order = {}, {}, {}, {}
+local function put(key, field, value)
+  local fields = writes[key]
+  if not fields then
+    fields = {}
+    writes[key] = fields
+    write_order[#write_order + 1] = key
+  end
+  fields[#fields + 1] = field
+  fields[#fields + 1] = value
+end
+local function 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
+  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
+`;
+/**
+* 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 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
+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 #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
+  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
+      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
+end
+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
+    end
+  end
+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
+    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
+  state.h = next_head
+  state.p = idx
+  state.exists = true
+  state.dirty = true
+  ready_set(cid, next_head)
+  return true
+end
+-- 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
+  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
+  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
+  return true
+end
+-- 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
+  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: 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] |
+* ['superseded', position] | ['cleared', originIndex] |
+* ['index', type, after].
+*/
+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 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 dups[#dups + 1] = owners[i] end
+end
+if #dups == n then
+  local res = { 'dup', has_pending() }
+  for i = 1, #dups do res[#res + 1] = dups[i] end
+  return res
+end
+if #dups > 0 then return { 'partial', tostring(#dups) } end
+local origin = ARGV[5]
+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 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 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 = 5 + (i - 1) * 5
+  local field = tostring(base + i)
+  redis.call('XADD', LOG, field .. '-0',
+    'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
+    '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()
+flush_ready()
+return { 'ok', tostring(base + 1), has_pending() }
+`;
+/**
+* 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 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', 256)
+  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 < 256 then
+    entry[1] = after
+  else
+    entry[1] = entry_index(entries[#entries][1]) - 1
+  end
+elseif entry[1] > after then
+  entry[1] = after
+end
+redis.call('SET', TYPED, cjson.encode(typed))
+return { entry[1] <= after and '1' or '0' }
+`;
+/**
+* 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 = `${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 = {}
+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 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
+    takes_over[#takes_over + 1] = { candidate = candidate, row = row }
+    wanted[candidate[1]] = true
+  end
+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
+  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
+flush()
+flush_ready()
+result[#result + 1] = tostring(boundary)
+result[#result + 1] = tostring(total)
+return result
+`;
+/**
+* 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 = `${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 o = 4 + (i - 1) * 4
+  local idx = tonumber(ARGV[o + 3])
+  if idx <= boundary then
+    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_rows(refs, { 'd', 'ce', 'p', 'f', 'ch', 'l' })
+local renewed = {}
+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()
+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
+return result
+`;
+/**
+* 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 = `${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
+  -- 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[i] ~= ARGV[10 + (i - 1) * 4 + 1] then return { 'partial' } end
+  end
+  local result = { 'duplicate' }
+  for i = 1, n do
+    if not owners[i] then return { 'partial' } end
+    result[#result + 1] = owners[i]
+  end
+  return result
+end
+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
+use_served(ARGV[8])
+local batch = {}
+for i = 1, n do
+  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', LOG, field .. '-0',
+    'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
+    '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
+  marks[#marks + 1] = COUNTER
+  marks[#marks + 1] = tostring(total + n)
+end
+if typed_dirty then
+  marks[#marks + 1] = TYPED
+  marks[#marks + 1] = cjson.encode(typed)
+end
+sliced('MSET', nil, marks)
+flush_states()
+flush()
+flush_ready()
+return { 'ok', tostring(total + 1) }
+`;
+/**
+* KEYS: counter.
+* ARGV: consumer, tag, index, attempt, error, maxFailures, nowMs, retryAtMs
+* or ''.
+*/
+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
+  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: 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 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_rows(refs, ${HEAD_COLUMNS})
+local result = {}
+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] = { 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: 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 = `${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 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
+end
+local snapshots = {}
+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 entry.index >= boundary then
+    snapshots[#snapshots + 1] = { index = entry.index, snapshot = entry.snapshot, ref = ref }
+  end
+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', HEAD)
+local head_index = nil
+local registered = false
+if head then
+  local record = cjson.decode(head)
+  head_index = tonumber(record['index'])
+  registered = record['r'] == 1
+end
+if head_index and head_index < boundary then
+  head, head_index, registered = nil, nil, false
+  redis.call('ZREMRANGEBYSCORE', 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', 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', 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', 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', HEAD, latest.snapshot)
+  redis.call('ZREMRANGEBYSCORE', HISTORY, latest.index, latest.index)
+end
+return 1
+`;
+/**
+* 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 = `${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 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)
+  end
+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, 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_PRUNE_LUA = `${SLICED_LUA}${PRESENCE_STAMPS_LUA}
+local now = tonumber(ARGV[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
+sliced('HDEL', KEYS[1], stale)
+return 1
+`;
+/**
+* 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 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[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')
+end
+if head_index and head_index < boundary then
+  head = nil
+  head_index = nil
+end
+local cap = ARGV[1]
+local snapshot = nil
+if head_index and (cap == '' or head_index <= tonumber(cap)) then
+  snapshot = head
+else
+  local upper = cap == '' and '+inf' or cap
+  local historical = redis.call('ZREVRANGEBYSCORE', KEYS[3], upper, boundary, 'LIMIT', 0, 1)
+  if #historical > 0 then snapshot = historical[1] end
+end
+return { head_index or '', snapshot or '', counts[1] or counts[2] or '0', tostring(boundary) }
+`;
+/**
+* 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_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)
+  end
+  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
+  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: 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 = `${BASE_LUA}
+local marker_owner = owners_of(read_bounds({ ARGV[8] }))[1]
+local head = total
+if ARGV[4] ~= '' then
+  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]
+if expected ~= '' and boundary == tonumber(expected) + 1 then
+  return { 'ok', '1', tostring(head), tostring(boundary) }
+end
+if expected ~= '' and tonumber(expected) ~= head then
+  return { 'ok', '0', tostring(head), tostring(boundary) }
+end
+if head == 0 or boundary == head then
+  return { 'ok', '1', tostring(head), tostring(boundary) }
+end
+if marker_owner then return { 'foreign' } end
+local field = tostring(head + 1)
+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: 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 = `${BASE_LUA}${SWEEP_LUA}
+local boundary = tonumber(redis.call('GET', CLEAR) or '0')
+if boundary == 0 then return {} 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
+  end
+end
+return batch
+`;
+/**
+* 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 = `${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[2]) do
+  local field = ARGV[2 + (i - 1) * 2 + 1]
+  if tonumber(field) < boundary then
+    ids[#ids + 1] = ARGV[2 + (i - 1) * 2 + 2]
+    indexes[#ids] = tonumber(field)
+    stream_ids[#ids] = field .. '-0'
+  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
+  sliced('DEL', nil, stale)
+  removed = redis.call('XDEL', LOG, unpack(stream_ids))
+end
+local done = 0
+if #redis.call('XRANGE', LOG, '-', tostring(boundary - 1) .. '-0', 'COUNT', 1) == 0 then
+  sweep(boundary)
+  done = 1
+end
+return { removed, done }
+`;
+const WAKE_PAYLOAD_LIMIT = 32768;
+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, createdAt, entries) => {
+	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;
+};
+const fieldMap = (fields) => {
+	const map = {};
+	for (let i = 0; i + 1 < fields.length; i += 2) map[fields[i]] = fields[i + 1];
+	return map;
+};
+const entryIndex = (entryId) => Number(entryId.slice(0, entryId.indexOf("-")));
+const toEvent = (sessionId, entry) => {
+	const fields = fieldMap(entry[1]);
+	return {
+		id: fields["id"],
+		type: fields["type"],
+		payload: JSON.parse(fields["payload"]),
+		index: entryIndex(entry[0]),
+		sessionId,
+		createdAt: new Date(Number(fields["created_at"]))
+	};
+};
+/**
+* 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) => {
+	const parsed = JSON.parse(raw);
+	return decodeCause(parsed.consumer === void 0 ? {
+		consumer: "a2.handlers",
+		lane: null,
+		...parsed
+	} : parsed);
+};
+/** A stream entry with its causal edge. */
+const toStoredEvent = (sessionId, entry) => {
+	const cause = fieldMap(entry[1])["cause"];
+	return Object.assign(toEvent(sessionId, entry), { cause: cause === void 0 || cause === "" ? null : decodeStreamCause(cause) });
+};
+const fieldBytes = (name) => new TextEncoder().encode(name);
+const ID_FIELD = fieldBytes("id");
+const TYPE_FIELD = fieldBytes("type");
+const PAYLOAD_FIELD = fieldBytes("payload");
+const CREATED_AT_FIELD = fieldBytes("created_at");
+const utf8 = new TextDecoder("utf-8", { ignoreBOM: true });
+const isField = (name, field) => {
+	if (name.length !== field.length) return false;
+	for (let at = 0; at < field.length; at++) if (name[at] !== field[at]) return false;
+	return true;
+};
+const bytesToSerializedEvent = (sessionId, entry) => {
+	const values = entry[1];
+	let id;
+	let type;
+	let payloadJson;
+	let createdAt;
+	for (let at = 0; at + 1 < values.length; at += 2) {
+		const name = values[at];
+		if (isField(name, ID_FIELD)) id = utf8.decode(values[at + 1]);
+		else if (isField(name, TYPE_FIELD)) type = utf8.decode(values[at + 1]);
+		else if (isField(name, PAYLOAD_FIELD)) payloadJson = utf8.decode(values[at + 1]);
+		else if (isField(name, CREATED_AT_FIELD)) createdAt = utf8.decode(values[at + 1]);
+	}
+	return {
+		id,
+		type,
+		payloadJson,
+		index: entryIndex(utf8.decode(entry[0])),
+		sessionId,
+		createdAtMs: Number(createdAt)
+	};
+};
+const toSerializedEvent = (sessionId, entry) => {
+	const fields = fieldMap(entry[1]);
+	return {
+		id: fields["id"],
+		type: fields["type"],
+		payloadJson: fields["payload"],
+		index: entryIndex(entry[0]),
+		sessionId,
+		createdAtMs: Number(fields["created_at"])
+	};
+};
+const json = (value) => JSON.stringify(value) ?? "null";
+/** How scripts name a cursor within its consumer: `#`, or `L` and its lane. */
+const tagOf = (lane) => lane === null ? "#" : `L${lane}`;
+/** The lane a cursor tag names: null for an event cursor. */
+const laneOf = (tag) => tag.startsWith("#") ? null : tag.slice(1);
+const targetsArg = (targets) => targets === void 0 || 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) => types === null ? "*" : JSON.stringify(types);
+/** The served consumers, as scripts read them; '' serves every consumer. */
+const servedArg = (consumers) => consumers === void 0 ? "" : JSON.stringify(consumers.map((consumer) => consumer.log ? [
+	consumer.name,
+	consumer.log.lane,
+	logTypesArg(consumer.log.types),
+	consumer.log.backfill ? 1 : 0
+] : [consumer.name]));
+/** A head's dispatch state from a row's HEAD_COLUMNS. */
+const dispatchOf = (consumer, lane, columns) => {
+	const column = (at) => {
+		const value = columns?.[at];
+		return value === null || value === void 0 ? null : String(value);
+	};
+	const date = (at) => {
+		const value = column(at);
+		return value === null ? null : new Date(Number(value));
+	};
+	const count = (at) => {
+		const value = column(at);
+		return value === null ? null : Number(value);
+	};
+	return {
+		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)
+	};
+};
+const toHeadEvent = (sessionId, head) => ({
+	...toStoredEvent(sessionId, head[4]),
+	...dispatchOf(head[0], laneOf(head[1]), head[3])
+});
+const compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const byHead = (a, b) => a.index - b.index || compareText(a.consumer, b.consumer);
+/** Consumer, then lane, with concurrent cursors last by head. */
+const byCursor = (a, b) => 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, reply) => {
+	const outcome = String(reply[0]);
+	if (outcome === "claimed") {
+		const count = Number(reply[1]);
+		const events = reply.slice(2, 2 + count).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,
+			head: Number(reply[3 + count])
+		};
+	}
+	if (outcome === "busy") return {
+		outcome,
+		retryAt: new Date(Number(reply[1]))
+	};
+	if (outcome === "settled") return { outcome };
+	throw new TypeError(`claim referenced a missing event in session '${sessionId}'`);
+};
+const toIndex = ({ raw, sessionId, name }) => {
+	const index = Number(raw ?? 0);
+	if (!Number.isSafeInteger(index) || index < 0) throw new A2Error("STORE_UNAVAILABLE", `redis ${name} for session '${sessionId}' is invalid`);
+	return index;
+};
+/**
+* A range read that met a gap. 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, message) => Object.assign(new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' ${message}`), { rangeGap: true });
+const isRangeGap = (error) => error instanceof A2Error && error.rangeGap === true;
+/**
+* Run a whole read, bounds included. A gap means a clear raced it, so the
+* read runs once more from fresh bounds. A second gap, from another clear or
+* from corruption, surfaces as the retryable STORE_UNAVAILABLE.
+*/
+const retryAfterGap = async (read) => {
+	try {
+		return await read();
+	} catch (error) {
+		if (!isRangeGap(error)) throw error;
+		return read();
+	}
+};
+const wrap = async (fn) => {
+	try {
+		return await fn();
+	} catch (err) {
+		if (err instanceof A2Error || err instanceof TypeError) throw err;
+		throw new A2Error("STORE_UNAVAILABLE", "redis store operation failed", { cause: err });
+	}
+};
+/**
+* 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.
+*/
+const redisSessionKey = ({ prefix, sessionId, suffix }) => `${prefix}:{${JSON.stringify(sessionId).replaceAll("{", "\\u007b").replaceAll("}", "\\u007d")}}:${suffix}`;
+function createRedisStoreCore(options) {
+	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 sessionKey = (sessionId, suffix) => redisSessionKey({
+		prefix,
+		sessionId,
+		suffix
+	});
+	const storeKey = (s) => sessionKey(s, "log");
+	const countKey = (s) => sessionKey(s, "count");
+	const clearKey = (s) => sessionKey(s, "clear");
+	const schemaKey = `${prefix}:schema`;
+	const snapKey = (s, r) => sessionKey(s, `snap:${r}`);
+	const snapHistoryKey = (s, r) => sessionKey(s, `snap-history:${r}`);
+	const presenceKey = (s) => sessionKey(s, "presence");
+	const notifyChannel = (s) => `${prefix}:${s}:notify`;
+	const presenceChannel = (s) => `${prefix}:${s}:presence`;
+	const layoutError = () => 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) !== "tagged-1") throw layoutError();
+		})(), call("EVAL", `${KEY_LOCKING}\nreturn 1`, 1, schemaKey).then(() => true, (error) => {
+			if (SHEBANG_REJECTED.test(String(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 }) => {
+		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, sessionId, keys, args) => 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, message) => {
+		let timer;
+		await Promise.race([call("PUBLISH", channel, message).catch(() => void 0), new Promise((resolve) => {
+			timer = setTimeout(resolve, NOTIFY_TIMINGS.publishMs);
+			timer.unref?.();
+		})]);
+		clearTimeout(timer);
+	};
+	/**
+	* 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, run) => {
+		for (;;) {
+			const reply = await run();
+			if (reply[0] !== "index") return reply;
+			for (;;) {
+				const [done] = await evalScript(INDEX_TYPE_LUA, sessionId, [], [String(reply[1]), Number(reply[2])]);
+				if (done === "1") break;
+			}
+		}
+	};
+	/** The frontier and clear marker, in one MGET. */
+	const readBounds = async (sessionId) => {
+		await prepared.get();
+		const [count, cleared] = await call("MGET", countKey(sessionId), clearKey(sessionId));
+		return {
+			frontier: toIndex({
+				raw: count ?? cleared,
+				sessionId,
+				name: "event count"
+			}),
+			clearIndex: toIndex({
+				raw: cleared,
+				sessionId,
+				name: "clear boundary"
+			})
+		};
+	};
+	const readClearIndex = async (sessionId) => {
+		await prepared.get();
+		return toIndex({
+			raw: await call("GET", clearKey(sessionId)),
+			sessionId,
+			name: "clear boundary"
+		});
+	};
+	const readEventPages = async (sessionId, afterIndex, throughIndex) => {
+		if (throughIndex <= afterIndex) return [];
+		const events = [];
+		let nextIndex = afterIndex + 1;
+		while (nextIndex <= throughIndex) {
+			const entries = await call("XRANGE", storeKey(sessionId), `${nextIndex}-0`, `${throughIndex}-0`, "COUNT", 256);
+			if (entries.length === 0) throw rangeGap(sessionId, `ended before index ${throughIndex}`);
+			for (let position = 0; position < entries.length; position += 1) {
+				const index = entryIndex(entries[position][0]);
+				if (index !== nextIndex + position || index > throughIndex) throw rangeGap(sessionId, "is not contiguous");
+			}
+			events.push(...entries.map((entry) => toEvent(sessionId, entry)));
+			nextIndex = events.at(-1).index + 1;
+		}
+		return events;
+	};
+	const readEventRange = async (sessionId, afterIndex, throughIndex) => {
+		const events = [];
+		for (let start = afterIndex; start < throughIndex; start += 256 * READ_CONCURRENCY) {
+			const ranges = Array.from({ length: Math.min(READ_CONCURRENCY, Math.ceil((throughIndex - start) / 256)) }, (_, position) => {
+				const after = start + position * 256;
+				return readEventPages(sessionId, after, Math.min(after + 256, throughIndex));
+			});
+			const results = await Promise.allSettled(ranges);
+			for (const result of results) {
+				if (result.status === "rejected") throw result.reason;
+				events.push(...result.value);
+			}
+		}
+		return events;
+	};
+	/** Bounded XRANGE pages restore the full-read contract on capped providers. */
+	const readRange = async (sessionId, afterIndex, throughIndex) => (await readBoundedRange(sessionId, afterIndex, throughIndex)).rows;
+	/** `readRange`, with the clear boundary its rows start at. */
+	const readBoundedRange = async (sessionId, afterIndex, throughIndex) => {
+		if (throughIndex !== void 0 && throughIndex <= afterIndex) return {
+			rows: [],
+			clearIndex: 0
+		};
+		const { frontier: currentFrontier, clearIndex } = await readBounds(sessionId);
+		const frontier = Math.min(throughIndex ?? currentFrontier, currentFrontier);
+		const after = Math.max(afterIndex, clearIndex - 1);
+		if (frontier <= after) return {
+			rows: [],
+			clearIndex
+		};
+		const rows = [];
+		let nextIndex = after + 1;
+		while (nextIndex <= frontier) {
+			const entries = await call("XRANGE", storeKey(sessionId), `${nextIndex}-0`, `${frontier}-0`, "COUNT", 256);
+			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");
+			const lastIndex = page.at(-1).index;
+			if (lastIndex < nextIndex || lastIndex > frontier) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' did not advance`);
+			rows.push(...page);
+			nextIndex = lastIndex + 1;
+		}
+		return {
+			rows,
+			clearIndex
+		};
+	};
+	const readStream = options.readStream;
+	return {
+		...readStream ? { streamEvents: async function* ({ sessionId, afterIndex, signal }) {
+			try {
+				for await (const entries of readStream({
+					key: storeKey(sessionId),
+					from: `${afterIndex + 1}-0`,
+					signal
+				})) {
+					signal.throwIfAborted();
+					yield entries.map((entry) => toSerializedEvent(sessionId, entry));
+				}
+			} catch (cause) {
+				if (cause instanceof A2Error) throw cause;
+				throw new A2Error("STORE_UNAVAILABLE", "redis stream read failed", { cause });
+			}
+		} } : {},
+		async append(sessionId, events, appendOptions) {
+			return wrap(async () => {
+				const suppliedIds = events.filter((e) => e.id !== void 0).map((e) => e.id);
+				if (new Set(suppliedIds).size !== suppliedIds.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "batch contains the same event id more than once");
+				const now = clock.now().getTime();
+				const withIds = events.map((e) => ({
+					id: e.id ?? generateId(),
+					type: e.type,
+					payload: e.payload,
+					cause: e.cause ? { ...e.cause } : null,
+					targets: e.targets
+				}));
+				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)
+					])
+				]));
+				const [verdict] = reply;
+				if (verdict === "empty") return {
+					events: [],
+					hasPending: reply[1] === "1"
+				};
+				if (verdict === "cleared") throw sessionClearedError(`scheduled work from event ${reply[1]} was cleared in session '${sessionId}'`);
+				if (verdict === "superseded") throw supersededAttemptError(sessionId, withIds[Number(reply[1]) - 1].cause);
+				if (verdict === "partial") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${reply[1]} already-appended and ${events.length - Number(reply[1])} fresh events`);
+				if (verdict === "dup") {
+					const hasPending = reply[1] === "1";
+					const firstIndex = Math.min(...reply.slice(2).map(Number));
+					const { rows: existing, clearIndex } = await retryAfterGap(() => readBoundedRange(sessionId, firstIndex - 1, firstIndex + events.length - 1));
+					if (firstIndex < clearIndex) throw new A2Error("STORE_UNAVAILABLE", `session '${sessionId}' was cleared while an append retry replayed; retry it`);
+					const replayed = idempotentReplay(events, existing);
+					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,
+						type: e.type,
+						payload: structuredClone(e.payload),
+						index: base + 1 + i,
+						sessionId,
+						createdAt: new Date(now),
+						cause: e.cause
+					})),
+					hasPending: reply[2] === "1"
+				};
+			});
+		},
+		async cursors(sessionId) {
+			return wrap(async () => {
+				return (await runScript({
+					script: CURSORS_LUA,
+					keys: [countKey(sessionId)],
+					args: [],
+					readOnly: true
+				})).map(([consumer, tag, position, head, columns]) => 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(() => readRange(sessionId, opts?.afterIndex ?? 0, opts?.throughIndex)));
+		},
+		async readHistory(sessionId, opts) {
+			const after = opts?.afterIndex ?? 0;
+			if (opts?.throughIndex !== void 0 && opts.throughIndex <= after) return [];
+			return wrap(() => retryAfterGap(async () => {
+				const { frontier, clearIndex } = await readBounds(sessionId);
+				return readEventRange(sessionId, Math.max(after, clearIndex - 1), Math.min(opts?.throughIndex ?? frontier, frontier));
+			}));
+		},
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, exclude, consumers, maxFailures, through }) {
+			return wrap(async () => {
+				const now = clock.now().getTime();
+				const expiresAt = expiresAtMs ?? now + ttlMs;
+				const excluded = exclude ?? [];
+				const reply = await evalScript(CLAIM_AVAILABLE_LUA, sessionId, [], [
+					holder,
+					now,
+					expiresAt,
+					maxFailures ?? "",
+					servedArg(consumers),
+					through ?? "",
+					excluded.length,
+					...excluded.flatMap((ref) => [ref.consumer, ref.lane === null ? `#${ref.index}` : `L${ref.lane}`])
+				]);
+				return toClaimAvailableResult(sessionId, reply);
+			});
+		},
+		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, sessionId, [], [
+					holder,
+					now,
+					expiresAt,
+					claims.length,
+					...claims.flatMap((claim) => [
+						claim.consumer,
+						tagOf(claim.lane),
+						claim.index,
+						claim.attempt
+					])
+				]);
+				const renewedCount = Number(reply[0]);
+				const refs = reply.slice(1).map((position) => {
+					const { consumer, lane, index } = claims[Number(position) - 1];
+					return {
+						consumer,
+						lane,
+						index
+					};
+				});
+				return {
+					renewed: refs.slice(0, renewedCount).toSorted(byHead),
+					superseded: refs.slice(renewedCount).toSorted(byHead)
+				};
+			});
+		},
+		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) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "batch contains the same event id more than once");
+				const now = clock.now().getTime();
+				const cause = {
+					consumer,
+					lane,
+					index,
+					attempt
+				};
+				const payloads = events.map((event) => json(event.payload));
+				const reply = await indexing(sessionId, () => evalScript(COMPLETE_ATTEMPT_LUA, sessionId, [], [
+					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)
+					])
+				]));
+				const outcome = reply[0];
+				if (outcome === "missing") throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+				if (outcome === "partial") throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event ids do not match the completed attempt");
+				if (outcome === "superseded") return { outcome };
+				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) => ({
+							id: event.id,
+							type: event.type,
+							payload: structuredClone(event.payload),
+							index: base + 1 + i,
+							sessionId,
+							createdAt: new Date(now),
+							cause: { ...cause }
+						}))
+					};
+				}
+				if (outcome === "duplicate") {
+					if (events.length === 0) return {
+						outcome: "completed",
+						events: []
+					};
+					const firstIndex = Math.min(...reply.slice(1).map(Number));
+					const { rows: existing, clearIndex } = await retryAfterGap(() => readBoundedRange(sessionId, firstIndex - 1, firstIndex + events.length - 1));
+					if (index <= clearIndex) return { outcome: "superseded" };
+					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);
+					await publish(notifyChannel(sessionId), wakeMessage(firstIndex + events.length - 1, now, []));
+					return {
+						outcome: "completed",
+						events: replayed
+					};
+				}
+				throw new TypeError(`unexpected completion outcome '${outcome}'`);
+			});
+		},
+		async failAttempt({ sessionId, consumer, lane, index, attempt, error, maxFailures, retryAfterMs }) {
+			return wrap(async () => {
+				const now = clock.now().getTime();
+				const reply = await evalScript(FAIL_ATTEMPT_LUA, sessionId, [], [
+					consumer,
+					tagOf(lane),
+					index,
+					attempt,
+					error,
+					maxFailures,
+					now,
+					retryAfterMs === void 0 ? "" : now + retryAfterMs
+				]);
+				const outcome = reply[0];
+				if (outcome === "missing") throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+				return {
+					outcome,
+					failureCount: Number(reply[1])
+				};
+			});
+		},
+		async deadLetters(sessionId) {
+			return wrap(async () => {
+				return (await runScript({
+					script: DEAD_LETTERS_LUA,
+					keys: [countKey(sessionId)],
+					args: [],
+					readOnly: true
+				})).map((head) => toHeadEvent(sessionId, head)).toSorted(byHead);
+			});
+		},
+		async redrive({ sessionId, consumer, index, action, consumers }) {
+			return wrap(async () => {
+				const [redriven, hasPending] = await indexing(sessionId, () => evalScript(REDRIVE_LUA, sessionId, [], [
+					consumer,
+					index,
+					action,
+					clock.now().getTime(),
+					servedArg(consumers)
+				]));
+				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
+				]));
+				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 runScript({
+					script: READ_STATE_LUA,
+					keys: [
+						countKey(sessionId),
+						snapKey(sessionId, reducerName),
+						snapHistoryKey(sessionId, reducerName)
+					],
+					args: [stateOptions?.snapshotThroughIndex ?? stateOptions?.throughIndex ?? ""],
+					readOnly: true
+				});
+				const rawHead = reply[0];
+				const raw = reply[1];
+				const headIndex = rawHead === "" ? null : Number(rawHead);
+				const parsed = raw === "" ? null : JSON.parse(raw);
+				const currentFrontier = Number(reply[2]);
+				if (!Number.isSafeInteger(currentFrontier) || currentFrontier < 0 || headIndex !== null && (!Number.isSafeInteger(headIndex) || headIndex < 0) || parsed !== null && (!Number.isSafeInteger(parsed.index) || parsed.index < 0)) throw new A2Error("STORE_UNAVAILABLE", `redis state frontier for session '${sessionId}' is invalid`);
+				const frontier = Math.min(currentFrontier, stateOptions?.throughIndex ?? currentFrontier);
+				const snapshot = parsed;
+				const clearIndex = Number(reply[3] ?? 0);
+				const events = await readEventRange(sessionId, Math.max(snapshot?.index ?? 0, clearIndex - 1), frontier);
+				return {
+					...clearIndex > 0 ? { clearIndex } : {},
+					headIndex,
+					snapshot: snapshot ? {
+						index: snapshot.index,
+						state: snapshot.state
+					} : null,
+					events
+				};
+			}));
+		},
+		async putSnapshots(sessionId, reducerName, writes) {
+			const byIndex = /* @__PURE__ */ new Map();
+			for (const write of writes) {
+				const existing = byIndex.get(write.index);
+				const pins = existing?.pins ?? /* @__PURE__ */ new Map();
+				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,
+					pins
+				});
+			}
+			const normalized = [...byIndex.values()].toSorted((a, b) => a.index - b.index);
+			if (normalized.length === 0) return;
+			await wrap(async () => {
+				const args = [normalized.length];
+				for (const write of normalized) args.push(write.index, json({
+					index: write.index,
+					state: write.state,
+					updatedAt: clock.now().getTime(),
+					r: 1
+				}), 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)], [...args, reducerName]);
+			});
+		},
+		presence: {
+			async set(ns, participant, values, meta) {
+				return wrap(async () => {
+					const entries = Object.entries(values);
+					if (entries.length === 0) return null;
+					const atMs = meta.at.getTime();
+					const nowMs = clock.now().getTime();
+					const expiresAtMs = nowMs + meta.ttlMs;
+					const applied = await runScript({
+						script: PRESENCE_SET_LUA,
+						keys: [presenceKey(ns)],
+						args: [
+							atMs,
+							meta.ttlMs,
+							nowMs,
+							entries.length,
+							...entries.flatMap(([field, value]) => [JSON.stringify([participant, field]), json({
+								a: atMs,
+								e: expiresAtMs,
+								s: meta.seen,
+								v: value
+							})])
+						],
+						readOnly: false
+					});
+					if (applied.length === 0) return null;
+					const appliedValues = nullProtoRecord();
+					const published = [];
+					for (const position of applied) {
+						const [field, value] = entries[Number(position) - 1];
+						appliedValues[field] = structuredClone(value);
+						published.push(`${json(field)}:${json(value)}`);
+					}
+					return {
+						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 key = presenceKey(ns);
+					const reply = await call("HGETALL", key);
+					const nowMs = clock.now().getTime();
+					const rows = [];
+					const expired = [];
+					for (let i = 0; i + 1 < reply.length; i += 2) {
+						const entry = JSON.parse(reply[i + 1]);
+						if (entry.e <= nowMs) {
+							expired.push(reply[i]);
+							continue;
+						}
+						if (entry.v === null) continue;
+						const [participant, field] = JSON.parse(reply[i]);
+						rows.push({
+							participant,
+							field,
+							value: entry.v,
+							seen: entry.s,
+							at: new Date(entry.a),
+							expiresAt: new Date(entry.e)
+						});
+					}
+					if (expired.length > 0) await runScript({
+						script: PRESENCE_PRUNE_LUA,
+						keys: [key],
+						args: [nowMs, ...expired],
+						readOnly: false
+					}).catch(() => void 0);
+					return rows;
+				});
+			}
+		},
+		async readRange(sessionId, afterIndex, throughIndex) {
+			return wrap(() => readRange(sessionId, afterIndex, throughIndex));
+		},
+		async readTail(sessionId, fromIndex, throughIndex) {
+			return wrap(async () => {
+				const [newest, clearIndex] = await Promise.all([call("XREVRANGE", storeKey(sessionId), throughIndex === void 0 ? "+" : `${throughIndex}-0`, `${fromIndex}-0`, "COUNT", 256), readClearIndex(sessionId)]);
+				if (clearIndex > fromIndex) return null;
+				const page = newest.toReversed().map((entry) => toEvent(sessionId, entry));
+				for (let position = 1; position < page.length; position += 1) if (page[position].index !== page[position - 1].index + 1) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' is not contiguous`);
+				const oldest = page[0]?.index;
+				return oldest === void 0 || oldest <= fromIndex ? page : null;
+			});
+		},
+		async clear({ sessionId, ifLastIndex, cause }) {
+			return wrap(async () => {
+				const markerId = generateId();
+				const now = clock.now().getTime();
+				const reply = await evalScript(CLEAR_LUA, sessionId, [], [
+					sessionId,
+					now,
+					ifLastIndex ?? "",
+					cause?.consumer ?? "",
+					cause ? tagOf(cause.lane) : "",
+					cause?.index ?? "",
+					cause?.attempt ?? "",
+					markerId
+				]);
+				if (reply[0] === "superseded") throw supersededAttemptError(sessionId, cause);
+				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) await publish(notifyChannel(sessionId), wakeMessage(head, now, []));
+				return {
+					cleared: reply[1] === "1",
+					index: Number(reply[2]),
+					clearIndex: Number(reply[3])
+				};
+			});
+		},
+		async reclaim(sessionId) {
+			return wrap(async () => {
+				const pairs = await evalScript(RECLAIM_BATCH_LUA, sessionId, [], [256]);
+				if (pairs.length === 0) return {
+					deleted: 0,
+					done: true
+				};
+				const [deleted, done] = await evalScript(RECLAIM_LUA, sessionId, [], [
+					sessionId,
+					pairs.length / 2,
+					...pairs
+				]);
+				return {
+					deleted: Number(deleted),
+					done: Number(done) === 1
+				};
+			});
+		},
+		clearIndex: (sessionId) => wrap(() => readClearIndex(sessionId)),
+		async readEvents(sessionId, afterIndex) {
+			return wrap(async () => {
+				return (await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, "+", "COUNT", 256)).map((entry) => toEvent(sessionId, entry));
+			});
+		},
+		async readFeedPage(sessionId, afterIndex) {
+			return wrap(async () => {
+				const range = [
+					storeKey(sessionId),
+					`${afterIndex + 1}-0`,
+					"+",
+					"COUNT",
+					FEED_PAGE_SIZE
+				];
+				if (callBytes) return (await callBytes("XRANGE", ...range)).map((entry) => bytesToSerializedEvent(sessionId, entry));
+				return (await call("XRANGE", ...range)).map((entry) => toSerializedEvent(sessionId, entry));
+			});
+		}
+	};
+}
+//#endregion
+//#region src/store-redis-notify.ts
+/** A feed that falls this far behind drops its inbox and catches up. */
+const INBOX_BYTES = 524288;
+/**
+* Parses a wake-up message: `{"f":frontier}` or a bare frontier number
+* announces events without carrying them; `{"f","t","e"}` carries them.
+* Returns null for anything else, which callers treat as a hint to catch up.
+*/
+const parseWake = (message) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(message);
+	} catch {
+		return null;
+	}
+	if (typeof parsed === "number") return Number.isSafeInteger(parsed) ? {
+		frontier: parsed,
+		createdAt: 0,
+		entries: []
+	} : null;
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const { f, t, e } = parsed;
+	if (typeof f !== "number" || !Number.isSafeInteger(f)) return null;
+	if (e === void 0) return {
+		frontier: f,
+		createdAt: 0,
+		entries: []
+	};
+	if (!Array.isArray(e) || typeof t !== "number" || !Number.isFinite(t)) return null;
+	for (const entry of e) if (!Array.isArray(entry) || entry.length !== 4 || !Number.isSafeInteger(entry[0]) || typeof entry[1] !== "string" || typeof entry[2] !== "string") return null;
+	return {
+		frontier: f,
+		createdAt: t,
+		entries: e
+	};
+};
+function createRedisNotifyStore(options) {
+	const { client, clock, ids, keyPrefix: prefix } = options;
+	const notifyChannel = (sessionId) => `${prefix}:${sessionId}:notify`;
+	const presenceChannel = (ns) => `${prefix}:${ns}:presence`;
+	const instanceId = crypto.randomUUID();
+	const core = createRedisStoreCore({
+		call: async (command, ...args) => {
+			return (await client()).call(command, ...args);
+		},
+		clock,
+		ids,
+		keyPrefix: prefix,
+		presenceSource: instanceId,
+		...options.callBytes ? { callBytes: options.callBytes } : {},
+		...options.readStream ? { readStream: options.readStream } : {}
+	});
+	let severed = false;
+	let subscriber = null;
+	/** channel → live event feeds, registered before they subscribe. */
+	const feeds = /* @__PURE__ */ new Map();
+	/** channel → refcounted subscription held for each live iterator. */
+	const subscriptions = /* @__PURE__ */ new Map();
+	const presenceSubscriptions = /* @__PURE__ */ new Map();
+	const pollingStreams = /* @__PURE__ */ new Set();
+	options.onReconnect?.((channel) => {
+		for (const feed of feeds.get(channel) ?? []) {
+			feed.dirty = true;
+			feed.wake?.();
+		}
+		presenceSubscriptions.get(channel)?.recovery?.reconnect().catch(() => {});
+	});
+	const deliverRemotePresence = ({ subscription, message }) => {
+		let parsed;
+		try {
+			parsed = JSON.parse(message);
+		} catch {
+			return;
+		}
+		if (parsed.src === instanceId) return;
+		const patch = {
+			participant: parsed.participant,
+			values: parsed.values,
+			seen: parsed.seen,
+			at: new Date(parsed.at)
+		};
+		subscription.recovery?.update(patch);
+		for (const listener of subscription.listeners) listener(patch);
+	};
+	const getSubscriber = () => {
+		subscriber ??= (async () => {
+			const conn = (await client()).duplicate();
+			conn.on("message", (channel, message) => {
+				for (const feed of feeds.get(channel) ?? []) {
+					if (feed.bytes + message.length <= INBOX_BYTES) {
+						feed.inbox.push(message);
+						feed.bytes += message.length;
+					} else {
+						feed.inbox.length = 0;
+						feed.held.length = 0;
+						feed.gapSince = void 0;
+						feed.bytes = 0;
+						feed.dirty = true;
+					}
+					feed.wake?.();
+				}
+				const subscription = presenceSubscriptions.get(channel);
+				if (subscription) deliverRemotePresence({
+					subscription,
+					message
+				});
+			});
+			return conn;
+		})();
+		return subscriber;
+	};
+	/**
+	* The subscriber, gated on connection readiness — for channel
+	* commands only (`close` uses the ungated promise, so it can never
+	* hang on an unreachable server). SUBSCRIBE carries redis's
+	* ok-loading flag, so ioredis writes it mid-handshake, ahead of the
+	* ready check's INFO — which then finds the connection already in
+	* subscriber mode and fails the check (a spurious error event plus
+	* a reconnect). ECHO has no such flag: it resolves only once the
+	* connection is ready, so every channel command chained behind it
+	* lands after the check.
+	*/
+	let subscriberGate = null;
+	const gatedSubscriber = () => {
+		subscriberGate ??= getSubscriber().then(async (conn) => {
+			await conn.call("echo", "ready");
+			return conn;
+		});
+		return subscriberGate;
+	};
+	const acquireChannel = async (channel) => {
+		const existing = subscriptions.get(channel);
+		if (existing) {
+			existing.refs += 1;
+			try {
+				await existing.ready;
+			} catch (err) {
+				existing.refs -= 1;
+				throw err;
+			}
+			return;
+		}
+		const lease = {
+			refs: 1,
+			ready: gatedSubscriber().then(async (conn) => {
+				await conn.call("subscribe", channel);
+				if (subscriptions.get(channel) !== lease || severed) return;
+				const presence = presenceSubscriptions.get(channel);
+				if (options.polling?.() && presence) {
+					presence.recovery = void 0;
+					const ns = channel.slice(prefix.length + 1, -9);
+					presence.poll = pollPresence({
+						read: () => core.presence.read(ns),
+						deliver: (patch) => {
+							for (const listener of presence.listeners) listener(patch);
+						}
+					});
+					await presence.poll.ready;
+				}
+			})
+		};
+		subscriptions.set(channel, lease);
+		try {
+			await lease.ready;
+		} catch (err) {
+			if (subscriptions.get(channel) === lease) {
+				subscriptions.delete(channel);
+				const presence = presenceSubscriptions.get(channel);
+				presence?.poll?.stop();
+				if (presence) presence.poll = void 0;
+			}
+			throw err;
+		}
+	};
+	const releaseChannel = (channel) => {
+		const lease = subscriptions.get(channel);
+		if (!lease) return;
+		lease.refs -= 1;
+		if (lease.refs > 0) return;
+		subscriptions.delete(channel);
+		gatedSubscriber().then((conn) => conn.call("unsubscribe", channel)).catch(() => {});
+	};
+	const store = {
+		append: core.append,
+		cursors: core.cursors,
+		read: core.read,
+		readHistory: core.readHistory,
+		claimAvailable: core.claimAvailable,
+		renewClaims: core.renewClaims,
+		completeAttempt: core.completeAttempt,
+		failAttempt: core.failAttempt,
+		readState: core.readState,
+		putSnapshots: core.putSnapshots,
+		clear: core.clear,
+		reclaim: core.reclaim,
+		deadLetters: core.deadLetters,
+		redrive: core.redrive,
+		wakeLog: core.wakeLog,
+		presence: {
+			async set(ns, participant, values, meta) {
+				const applied = await core.presence.set(ns, participant, values, meta);
+				if (!applied) return;
+				const { patch } = applied;
+				const channel = presenceChannel(ns);
+				const subscription = presenceSubscriptions.get(channel);
+				if (subscription) {
+					subscription.poll?.update(patch);
+					subscription.recovery?.update(patch);
+					for (const listener of subscription.listeners) listener(patch);
+				}
+				await applied.published;
+			},
+			async read(ns) {
+				const channel = presenceChannel(ns);
+				await subscriptions.get(channel)?.ready;
+				const subscription = presenceSubscriptions.get(channel);
+				return subscription?.recovery?.read() ?? subscription?.poll?.snapshot(() => core.presence.read(ns)) ?? core.presence.read(ns);
+			},
+			subscribe(ns, onPatch) {
+				const channel = presenceChannel(ns);
+				let subscription = presenceSubscriptions.get(channel);
+				if (!subscription) {
+					subscription = { listeners: /* @__PURE__ */ new Set() };
+					presenceSubscriptions.set(channel, subscription);
+					if (options.onReconnect && !options.polling?.()) {
+						const current = subscription;
+						subscription.recovery = presenceRecovery({
+							read: () => core.presence.read(ns),
+							deliver: (patch) => {
+								for (const listener of current.listeners) listener(patch);
+							},
+							isActive: () => !severed && presenceSubscriptions.get(channel) === current
+						});
+					}
+				}
+				subscription.listeners.add(onPatch);
+				acquireChannel(channel).catch(() => {});
+				let stopped = false;
+				return () => {
+					if (stopped) return;
+					stopped = true;
+					subscription.listeners.delete(onPatch);
+					if (subscription.listeners.size === 0) {
+						subscription.poll?.stop();
+						presenceSubscriptions.delete(channel);
+					}
+					releaseChannel(channel);
+				};
+			}
+		},
+		stream(sessionId, opts) {
+			const startAfter = opts?.startAfter ?? 0;
+			const channel = notifyChannel(sessionId);
+			return { [Symbol.asyncIterator]() {
+				let last = startAfter;
+				let buffer = [];
+				let closed = false;
+				let subscribed = false;
+				let pending = null;
+				let poller;
+				let stopActivity;
+				let catchup;
+				let stoppingRead;
+				const stopRead = () => {
+					const reading = catchup;
+					catchup = void 0;
+					if (reading) {
+						reading.controller.abort();
+						stoppingRead = reading.iterator.return(void 0).then(() => void 0).catch(() => {});
+					}
+					return stoppingRead ?? Promise.resolve();
+				};
+				const nextRead = async (after) => {
+					if (!catchup) {
+						const controller = new AbortController();
+						catchup = {
+							controller,
+							delivered: false,
+							iterator: core.streamEvents({
+								sessionId,
+								afterIndex: after,
+								signal: controller.signal
+							})[Symbol.asyncIterator]()
+						};
+					}
+					const reading = catchup;
+					const result = await reading.iterator.next();
+					if (result.done && catchup === reading) {
+						catchup = void 0;
+						if (reading.delivered) feed.dirty = true;
+					} else if (!result.done) reading.delivered = true;
+					return result;
+				};
+				const feed = {
+					inbox: [],
+					bytes: 0,
+					dirty: true,
+					held: [],
+					gapSince: void 0,
+					wake: null,
+					stopRead
+				};
+				const activity = createStreamActivity(() => {
+					if (poller) streamActivities.get(poller)?.activate();
+				});
+				const release = () => {
+					stopRead();
+					stopActivity?.();
+					if (poller) {
+						poller.return?.();
+						pollingStreams.delete(poller);
+					}
+					if (!subscribed) return;
+					subscribed = false;
+					const set = feeds.get(channel);
+					set?.delete(feed);
+					if (set?.size === 0) feeds.delete(channel);
+					releaseChannel(channel);
+				};
+				/**
+				* Moves carried events that continue this feed's sequence into
+				* the buffer. Writers publish after their scripts, so concurrent
+				* writers' wake-ups can arrive out of order: they apply in index
+				* order, and one past a gap is held until the gap fills or
+				* NOTIFY_TIMINGS.reorderMs passes. A message without events past
+				* the buffer, or an unreadable one, marks the feed dirty so it
+				* catches up with XRANGE.
+				*/
+				const applyInbox = () => {
+					const carried = feed.held.splice(0);
+					let announced = 0;
+					for (const message of feed.inbox.splice(0)) {
+						const wake = parseWake(message);
+						if (!wake) feed.dirty = true;
+						else if (wake.entries.length === 0) announced = Math.max(announced, wake.frontier);
+						else carried.push({
+							wake,
+							bytes: message.length
+						});
+					}
+					carried.sort((a, b) => a.wake.entries[0][0] - b.wake.entries[0][0]);
+					feed.bytes = 0;
+					for (const held of carried) {
+						if (held.wake.entries[0][0] > (buffer.at(-1)?.index ?? last) + 1) {
+							feed.held.push(held);
+							feed.bytes += held.bytes;
+							continue;
+						}
+						for (const [index, id, type, payload] of held.wake.entries) {
+							if (index <= (buffer.at(-1)?.index ?? last)) continue;
+							buffer.push({
+								id,
+								type,
+								payload,
+								index,
+								sessionId,
+								createdAt: new Date(held.wake.createdAt)
+							});
+						}
+					}
+					if (announced > (buffer.at(-1)?.index ?? last)) feed.dirty = true;
+					if (feed.held.length === 0) feed.gapSince = void 0;
+					else feed.gapSince ??= Date.now();
+				};
+				const iterator = {
+					async next() {
+						for (;;) {
+							if (closed) {
+								release();
+								return {
+									value: void 0,
+									done: true
+								};
+							}
+							const row = buffer.shift();
+							if (row) {
+								let event;
+								try {
+									event = isSerializedEvent(row) ? parseSerializedEvent(row) : row;
+								} catch (cause) {
+									buffer = [];
+									feed.dirty = true;
+									release();
+									throw new A2Error("STORE_UNAVAILABLE", "redis stream read failed", { cause });
+								}
+								last = row.index;
+								return {
+									value: event,
+									done: false
+								};
+							}
+							if (severed) {
+								release();
+								throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+							}
+							try {
+								if (!subscribed) {
+									subscribed = true;
+									let set = feeds.get(channel);
+									if (!set) {
+										set = /* @__PURE__ */ new Set();
+										feeds.set(channel, set);
+									}
+									set.add(feed);
+									const [, clearIndex] = await Promise.all([acquireChannel(channel), core.clearIndex(sessionId)]);
+									if (clearIndex - 1 > last) last = clearIndex - 1;
+									if (closed || severed) continue;
+								}
+								if (options.polling?.()) {
+									if (!poller) {
+										poller = pollingStream((after) => core.readEvents(sessionId, after), { startAfter: last })[Symbol.asyncIterator]();
+										pollingStreams.add(poller);
+										stopActivity = streamActivities.get(poller)?.subscribe(activity.setIdle);
+									}
+									const result = await poller.next();
+									if (!result.done) presenceSubscriptions.get(presenceChannel(sessionId))?.poll?.wake();
+									if (severed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+									return result;
+								}
+								if (catchup) {
+									const result = await nextRead(last);
+									if (closed || severed) continue;
+									if (!result.done) buffer = result.value;
+									continue;
+								}
+								applyInbox();
+								if (buffer.length > 0) continue;
+								if (feed.gapSince !== void 0 && Date.now() - feed.gapSince >= NOTIFY_TIMINGS.reorderMs) feed.dirty = true;
+								if (feed.dirty) {
+									feed.dirty = false;
+									feed.held.length = 0;
+									feed.gapSince = void 0;
+									if (core.streamEvents) {
+										const result = await nextRead(last);
+										if (closed || severed) continue;
+										if (!result.done) buffer = result.value;
+										continue;
+									}
+									buffer = await core.readFeedPage(sessionId, last);
+									if (buffer.length >= 1e3) feed.dirty = true;
+									continue;
+								}
+								const woken = new Promise((resolve) => {
+									feed.wake = () => resolve("wake");
+								});
+								const holding = feed.gapSince !== void 0;
+								pending = defaultSleep(holding ? Math.max(0, NOTIFY_TIMINGS.reorderMs - (Date.now() - feed.gapSince)) : NOTIFY_TIMINGS.safetyReadMs);
+								const outcome = await Promise.race([woken, pending.promise.then(() => "timer")]);
+								pending.cancel();
+								pending = null;
+								if (outcome === "timer" && !holding) feed.dirty = true;
+							} catch (err) {
+								release();
+								if (closed) return {
+									value: void 0,
+									done: true
+								};
+								if (err instanceof A2Error) throw err;
+								throw new A2Error("STORE_UNAVAILABLE", "redis store operation failed", { cause: err });
+							} finally {
+								feed.wake = null;
+							}
+						}
+					},
+					async return() {
+						closed = true;
+						pending?.cancel();
+						feed.wake?.();
+						release();
+						await stopRead();
+						return {
+							value: void 0,
+							done: true
+						};
+					}
+				};
+				streamActivities.set(iterator, activity);
+				bufferedEvents.set(iterator, () => {
+					if (closed) return void 0;
+					const row = buffer.shift();
+					if (row) last = row.index;
+					return row;
+				});
+				return iterator;
+			} };
+		},
+		async close() {
+			severed = true;
+			for (const subscription of presenceSubscriptions.values()) subscription.poll?.stop();
+			presenceSubscriptions.clear();
+			for (const poller of pollingStreams) poller.return?.();
+			pollingStreams.clear();
+			const reads = [];
+			for (const set of feeds.values()) for (const feed of set) {
+				feed.wake?.();
+				reads.push(feed.stopRead());
+			}
+			await Promise.allSettled(reads);
+			if (subscriber) (await subscriber.catch(() => null))?.disconnect();
+			await options.closeClient();
+		}
+	};
+	stateTailReaders.set(store, core.readTail);
+	return store;
+}
+//#endregion
+export { createRedisNotifyStore as t };
+
+//# sourceMappingURL=store-redis-notify-CsJw_hfD.js.map