experimental-a2 0.19.0 → 0.21.1

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

@@ -0,0 +1,2919 @@
+import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-wHd5GCpZ.js";
+import { _ as nullProtoRecord, r as NOTIFY_TIMINGS, x as stateTailReaders } from "./internal-Bc4PvfHk.js";
+import { i as streamActivities, n as pollingStream, r as createStreamActivity, t as defaultSleep } from "./store-polling-DYNyxCev.js";
+import { n as isSerializedEvent, r as parseSerializedEvent, t as bufferedEvents } from "./stream-buffer-Cx7AAPGq.js";
+import { a as idempotentReplay, n as decodeCause } from "./store-codec-DwrWlgQx.js";
+import { t as pollPresence } from "./store-presence-polling-CzQ0wdtM.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 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 live = /* @__PURE__ */ new Set();
+			for (const row of rows) {
+				const id = key(row);
+				live.add(id);
+				if (changed.has(id)) continue;
+				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);
+				deliver({
+					participant: prior.participant,
+					values: { [prior.field]: null },
+					seen: prior.seen,
+					at: prior.at
+				});
+			}
+			return rows;
+		} 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 id = key({
+					participant: patch.participant,
+					field
+				});
+				const previous = fields.get(id);
+				if (previous && previous.at.getTime() > patch.at.getTime()) continue;
+				for (const changed of reading) changed.add(id);
+				if (value === null) fields.delete(id);
+				else remember({
+					participant: patch.participant,
+					field,
+					seen: patch.seen,
+					at: patch.at
+				});
+			}
+		}
+	};
+}
+const FEED_PAGE_SIZE = 1e3;
+const READ_CONCURRENCY = 16;
+/** The key layout this core writes; any other is rejected. */
+const REDIS_LAYOUT = "cursors-2";
+const LAYOUT_ERROR = "A2_LAYOUT";
+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' }`;
+/**
+* Upstash bills every call a script makes, so scripts read the counter,
+* clear marker, layout, typed-type index, and id keys 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 KEYS[2] to the prefix's layout key, and
+* derives the session's other keys.
+*/
+const BASE_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
+local COUNTER, SCHEMA = KEYS[1], KEYS[2]
+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, schema_missing = 0, 0, false
+-- 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
+-- Reads the counter, the latest clear marker, the layout, the typed types,
+-- and the extra keys in one MGET. Returns the extra keys' values, or nil when
+-- the prefix holds another layout.
+local function read_bounds(extra)
+  local keys = { COUNTER, CLEAR, SCHEMA, TYPED }
+  for _, key in ipairs(extra or {}) do keys[#keys + 1] = key end
+  local values = sliced('MGET', nil, keys)
+  if values[3] and values[3] ~= '${REDIS_LAYOUT}' then return nil end
+  total = tonumber(values[1] or '0')
+  boundary = tonumber(values[2] or '0')
+  schema_missing = not values[3]
+  if values[4] then typed = cjson.decode(values[4]) end
+  local rest = {}
+  for i = 5, #keys do rest[i - 4] = values[i] end
+  return rest
+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
+-- Event-id owners for the extra keys read_bounds returned. A record this
+-- session made below its latest clear is free.
+local function owners_of(values, session)
+  local owners = {}
+  for i = 1, #values do
+    local owner = values[i]
+    if owner then
+      local rec = cjson.decode(owner)
+      if rec[1] == session and tonumber(rec[2]) < boundary then owner = false end
+    end
+    owners[i] = owner
+  end
+  return owners
+end
+`;
+const WAKE_PAYLOAD_LIMIT = 32768;
+/**
+* Wake-up messages carry the events they announce, so a subscribed reader
+* that is caught up applies them without reading the stream:
+* `{"f":frontier,"t":createdAt,"e":[[index,id,type,payload],...]}`. Payloads
+* are the stored JSON text, inlined verbatim. A batch over
+* WAKE_PAYLOAD_LIMIT bytes publishes `{"f":frontier}` and readers catch up
+* with XRANGE.
+*/
+const WAKE_LUA = `
+local wake_entries, wake_bytes = {}, 0
+local function wake_add(field, id, typ, payload)
+  if wake_bytes + #payload > ${WAKE_PAYLOAD_LIMIT} then
+    wake_bytes = ${WAKE_PAYLOAD_LIMIT} + 1
+    return
+  end
+  local entry = '[' .. field .. ',' .. cjson.encode(id) .. ',' ..
+    cjson.encode(typ) .. ',' .. payload .. ']'
+  wake_bytes = wake_bytes + #entry + 1
+  if wake_bytes <= ${WAKE_PAYLOAD_LIMIT} then
+    wake_entries[#wake_entries + 1] = entry
+  end
+end
+local function wake(channel, frontier, created_at)
+  local message = '{"f":' .. frontier .. '}'
+  if wake_bytes <= ${WAKE_PAYLOAD_LIMIT} then
+    message = '{"f":' .. frontier .. ',"t":' .. created_at .. ',"e":[' ..
+      table.concat(wake_entries, ',') .. ']}'
+  end
+  redis.pcall('PUBLISH', channel, message)
+end
+`;
+/**
+* KEYS: counter, layout, then one id ownership key per event.
+* ARGV: sessionId, nowMs, n, served consumers, notify channel, origin index
+* or '', then per event: id, type, payloadJson, causeJson or '', targets.
+* Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
+* ['dup', hasPending, ...indexes] | ['partial', count] |
+* ['foreign', eventId] | ['superseded', position] | ['cleared', originIndex] |
+* ['index', type, after].
+*/
+const APPEND_LUA = `${BASE_LUA}${CURSOR_LUA}${WAKE_LUA}
+local session_id, now, n = ARGV[1], ARGV[2], tonumber(ARGV[3])
+use_served(ARGV[4])
+if n == 0 then return { 'empty', has_pending() } end
+local id_keys = {}
+for i = 1, n do id_keys[i] = KEYS[2 + i] end
+local values = read_bounds(id_keys)
+if not values then return redis.error_reply('${LAYOUT_ERROR}') end
+local owners = owners_of(values, session_id)
+local base = total
+local dups = {}
+for i = 1, n do
+  if owners[i] then
+    local rec = cjson.decode(owners[i])
+    if rec[1] ~= session_id then return { 'foreign', ARGV[6 + (i - 1) * 5 + 1] } end
+    dups[#dups + 1] = tostring(rec[2])
+  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[6]
+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[6 + (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 = 6 + (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 owner_writes = {}
+for i = 1, n do
+  local o = 6 + (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])
+  owner_writes[#owner_writes + 1] = KEYS[2 + i]
+  owner_writes[#owner_writes + 1] = cjson.encode({ session_id, base + i })
+  wake_add(field, ARGV[o + 1], ARGV[o + 2], ARGV[o + 3])
+end
+index_batch(batch)
+enqueue(batch)
+owner_writes[#owner_writes + 1] = COUNTER
+owner_writes[#owner_writes + 1] = tostring(base + n)
+if schema_missing then
+  owner_writes[#owner_writes + 1] = SCHEMA
+  owner_writes[#owner_writes + 1] = '${REDIS_LAYOUT}'
+end
+if typed_dirty then
+  owner_writes[#owner_writes + 1] = TYPED
+  owner_writes[#owner_writes + 1] = cjson.encode(typed)
+end
+sliced('MSET', nil, owner_writes)
+flush_states()
+flush()
+flush_ready()
+local pending = has_pending()
+wake(ARGV[5], tostring(base + n), now)
+return { 'ok', tostring(base + 1), pending }
+`;
+/**
+* KEYS: counter, layout.
+* 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}
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+local name, after = ARGV[1], tonumber(ARGV[2])
+local entry = typed[name]
+if not entry then
+  entry = { total, total }
+  typed[name] = entry
+end
+if entry[1] > after then
+  local entries = redis.call('XREVRANGE', LOG, tostring(entry[1]) .. '-0',
+    tostring(after + 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
+end
+redis.call('SET', TYPED, cjson.encode(typed))
+return { entry[1] <= after and '1' or '0' }
+`;
+/**
+* KEYS: counter, layout.
+* 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
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+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, layout.
+* 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}
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+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, layout, then one id ownership key per child.
+* ARGV: sessionId, nowMs, consumer, tag, index, attempt, child causeJson,
+* served consumers, notify channel, returned idsJson, n, then per child: id,
+* type, payloadJson, targets.
+*/
+const COMPLETE_ATTEMPT_LUA = `${BASE_LUA}${CURSOR_LUA}${WAKE_LUA}
+local session_id, now = ARGV[1], 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[11])
+local id_keys = {}
+for i = 1, n do id_keys[i] = KEYS[2 + i] end
+local values = read_bounds(id_keys)
+if not values then return redis.error_reply('${LAYOUT_ERROR}') end
+local owners = owners_of(values, session_id)
+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[11 + (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
+    local rec = cjson.decode(owners[i])
+    if rec[1] ~= session_id then return { 'partial' } end
+    result[#result + 1] = tostring(rec[2])
+  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 = 11 + (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[10])
+release_pins(idx, at, row[9])
+local owner_writes = {}
+for i = 1, n do
+  local o = 11 + (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])
+  owner_writes[#owner_writes + 1] = KEYS[2 + i]
+  owner_writes[#owner_writes + 1] = cjson.encode({ session_id, total + i })
+  wake_add(field, ARGV[o + 1], ARGV[o + 2], ARGV[o + 3])
+end
+index_batch(batch)
+enqueue(batch)
+if n > 0 then
+  owner_writes[#owner_writes + 1] = COUNTER
+  owner_writes[#owner_writes + 1] = tostring(total + n)
+  if schema_missing then
+    owner_writes[#owner_writes + 1] = SCHEMA
+    owner_writes[#owner_writes + 1] = '${REDIS_LAYOUT}'
+  end
+end
+if typed_dirty then
+  owner_writes[#owner_writes + 1] = TYPED
+  owner_writes[#owner_writes + 1] = cjson.encode(typed)
+end
+sliced('MSET', nil, owner_writes)
+flush_states()
+flush()
+flush_ready()
+if n > 0 then wake(ARGV[9], tostring(total + n), now) end
+return { 'ok', tostring(total + 1) }
+`;
+/**
+* KEYS: counter, layout.
+* ARGV: consumer, tag, index, attempt, error, maxFailures, nowMs, retryAtMs
+* or ''.
+*/
+const FAIL_ATTEMPT_LUA = `${BASE_LUA}
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+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, layout. 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}
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+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, layout. 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}
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+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, layout. 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
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+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, layout. 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}
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+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, layout, 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}
+if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+local HEAD, HISTORY = KEYS[3], KEYS[4]
+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
+`;
+/**
+* KEYS: presence hash. ARGV: atMs, ttlMs, n, then per entry:
+* hashField, valueJson ('' deletes), patchFieldJson; finally channel and
+* message prefix. Wire fragments stay JSON text to preserve arrays
+* and numeric precision through Lua. Field-wise LWW by the sender's
+* `at`: a stored entry with a strictly newer stamp survives; ties go
+* to the incoming write (memory-tier parity). Returns the applied
+* 1-based entry positions. The whole-key PEXPIRE is the coarse bound,
+* sound because core sends one uniform ttlMs; the per-entry `e` stamp
+* is the fine bound (the injected storage clock at the applied set
+* plus ttlMs — never the sender stamp), pruned on read against the
+* same clock.
+*/
+const PRESENCE_SET_LUA = `
+local at = tonumber(ARGV[1])
+local applied = {}
+local published = {}
+local n = tonumber(ARGV[3])
+for i = 1, n do
+  local field = ARGV[3 + (i - 1) * 3 + 1]
+  local value = ARGV[3 + (i - 1) * 3 + 2]
+  local existing = redis.call('HGET', KEYS[1], field)
+  if not existing or tonumber(cjson.decode(existing)['a']) <= at then
+    if value == '' then
+      redis.call('HDEL', KEYS[1], field)
+    else
+      redis.call('HSET', KEYS[1], field, value)
+    end
+    applied[#applied + 1] = tostring(i)
+    published[#published + 1] = ARGV[3 + (i - 1) * 3 + 3]
+  end
+end
+if #applied > 0 then
+  redis.call('PEXPIRE', KEYS[1], ARGV[2])
+  redis.pcall('PUBLISH', ARGV[4 + n * 3], ARGV[5 + n * 3] .. table.concat(published, ',') .. '}}')
+end
+return applied
+`;
+/**
+* KEYS: presence hash. ARGV: nowMs (the injected clock, so tests can
+* time-travel expiry against a real server). Returns the live
+* [field, value, ...] pairs; entries at or past their fine-bound
+* expiry are HDELed in the same atomic step, so a stale reader can
+* never sweep a concurrently refreshed field.
+*/
+const PRESENCE_READ_LUA = `
+local now = tonumber(ARGV[1])
+local rows = redis.call('HGETALL', KEYS[1])
+local live = {}
+for i = 1, #rows, 2 do
+  if tonumber(cjson.decode(rows[i + 1])['e']) <= now then
+    redis.call('HDEL', KEYS[1], rows[i])
+  else
+    live[#live + 1] = rows[i]
+    live[#live + 1] = rows[i + 1]
+  end
+end
+return live
+`;
+/**
+* KEYS: counter, layout, 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', KEYS[2])
+if counts[3] and counts[3] ~= '${REDIS_LAYOUT}' then
+  return redis.error_reply('${LAYOUT_ERROR}')
+end
+local boundary = tonumber(counts[2] or '0')
+local head = redis.call('GET', KEYS[3])
+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[4], upper, boundary, 'LIMIT', 0, 1)
+  if #historical > 0 then snapshot = historical[1] end
+end
+return { head_index or '', snapshot or '', counts[1] or '0', tostring(boundary) }
+`;
+/**
+* What reclaim removes once a session has no moved log left: 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.
+*/
+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)
+end
+`;
+/**
+* KEYS: counter, layout, marker id ownership key.
+* ARGV: sessionId, nowMs, ifLastIndex or '', cause consumer or '', cause tag,
+* cause index, cause attempt, marker id, notify channel.
+* Returns ['ok', cleared, head, boundary] | ['superseded'] | ['foreign'].
+* The old lifetime's log moves aside in one RENAME, so every read of the log
+* starts at the marker, and its ready set is unlinked, so claims and pending
+* checks see only the new lifetime; deletion drains the moved log. Type
+* indexes keep their older entries until then: lookups start above the
+* marker.
+*/
+const CLEAR_LUA = `${BASE_LUA}${WAKE_LUA}
+local values = read_bounds({ KEYS[3] })
+if not values then return redis.error_reply('${LAYOUT_ERROR}') end
+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 values[1] then return { 'foreign' } end
+local field = tostring(head + 1)
+local moved = SESSION .. 'cleared:' .. field
+redis.call('RENAME', LOG, moved)
+redis.call('UNLINK', READY)
+redis.call('SADD', SESSION .. 'cleared', moved)
+redis.call('XADD', LOG, field .. '-0',
+  'id', ARGV[8], 'type', CLEAR_TYPE, 'payload', 'null',
+  'created_at', ARGV[2], 'cause', '')
+local marker = { KEYS[3], cjson.encode({ ARGV[1], head + 1 }), COUNTER, field, CLEAR, field }
+if schema_missing then
+  marker[#marker + 1] = SCHEMA
+  marker[#marker + 1] = '${REDIS_LAYOUT}'
+end
+redis.call('MSET', unpack(marker))
+wake_add(field, ARGV[8], CLEAR_TYPE, 'null')
+wake(ARGV[9], field, ARGV[2])
+return { 'ok', '1', field, field }
+`;
+/**
+* KEYS: counter, layout. ARGV: page size.
+* The next deletion batch: a moved log and up to a page of its [index, id]
+* pairs, without payloads. Empty moved logs are dropped; with none left it
+* sweeps what the old lifetime 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
+for _, log in ipairs(redis.call('SMEMBERS', SESSION .. 'cleared')) do
+  local entries = redis.call('XRANGE', log, '-', '+', 'COUNT', ARGV[1])
+  if #entries > 0 then
+    local batch = { log }
+    for _, entry in ipairs(entries) do
+      local fields = entry[2]
+      for i = 1, #fields, 2 do
+        if fields[i] == 'id' then
+          batch[#batch + 1] = string.match(entry[1], '^(%d+)')
+          batch[#batch + 1] = fields[i + 1]
+          break
+        end
+      end
+    end
+    return batch
+  end
+  redis.call('DEL', log)
+  redis.call('SREM', SESSION .. 'cleared', log)
+end
+sweep(boundary)
+return {}
+`;
+/**
+* KEYS: counter, layout, moved log, then one id ownership key per entry.
+* 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 MOVED = KEYS[3]
+local id_keys, 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
+    id_keys[#id_keys + 1] = KEYS[3 + i]
+    indexes[#id_keys] = tonumber(field)
+    stream_ids[#id_keys] = field .. '-0'
+  end
+end
+if #id_keys > 0 then
+  local owners, stale_ids = sliced('MGET', nil, id_keys), {}
+  for i = 1, #id_keys do
+    if owners[i] then
+      local rec = cjson.decode(owners[i])
+      if rec[1] == ARGV[1] and tonumber(rec[2]) == indexes[i] then
+        stale_ids[#stale_ids + 1] = id_keys[i]
+      end
+    end
+  end
+  sliced('DEL', nil, stale_ids)
+  removed = redis.call('XDEL', MOVED, unpack(stream_ids))
+end
+local done = 0
+if redis.call('XLEN', MOVED) == 0 then
+  redis.call('DEL', MOVED)
+  redis.call('SREM', SESSION .. 'cleared', MOVED)
+  if redis.call('SCARD', SESSION .. 'cleared') == 0 then
+    sweep(boundary)
+    done = 1
+  end
+end
+return { removed, done }
+`;
+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. A clear moves the old lifetime's log aside, so
+* a read whose bounds predate it finds nothing where it expected events;
+* anywhere else a gap is corruption.
+*/
+const rangeGap = (sessionId, 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 });
+	}
+};
+function createRedisStoreCore(options) {
+	const { call, callBytes, clock } = options;
+	const generateId = options.ids;
+	const prefix = options.keyPrefix;
+	const storeKey = (s) => `${prefix}:${s}:log`;
+	const countKey = (s) => `${prefix}:${s}:count`;
+	const clearKey = (s) => `${prefix}:${s}:clear`;
+	const schemaKey = `${prefix}:schema`;
+	const snapKey = (s, r) => `${prefix}:${s}:snap:${r}`;
+	const snapHistoryKey = (s, r) => `${prefix}:${s}:snap-history:${r}`;
+	const presenceKey = (s) => `${prefix}:${s}:presence`;
+	const notifyChannel = (s) => `${prefix}:${s}:notify`;
+	const idKey = (id) => `${prefix}:ids:${JSON.stringify(id).replaceAll(":", "\\u003a")}`;
+	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`);
+	/** Runs a script over a session: KEYS start with its counter and the layout key. */
+	const evalScript = async (script, sessionId, keys, args) => {
+		const allKeys = [
+			countKey(sessionId),
+			schemaKey,
+			...keys
+		];
+		try {
+			return await call("EVAL", script, allKeys.length, ...allKeys, ...args);
+		} catch (error) {
+			if (String(error?.message).includes(LAYOUT_ERROR)) throw layoutError();
+			throw error;
+		}
+	};
+	/**
+	* 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, checking the layout in the same MGET. */
+	const readBounds = async (sessionId) => {
+		const [count, cleared, schema] = await call("MGET", countKey(sessionId), clearKey(sessionId), schemaKey);
+		if (schema !== null && schema !== void 0 && schema !== "cursors-2") throw layoutError();
+		return {
+			frontier: toIndex({
+				raw: count,
+				sessionId,
+				name: "event count"
+			}),
+			clearIndex: toIndex({
+				raw: cleared,
+				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 reply = await indexing(sessionId, () => evalScript(APPEND_LUA, sessionId, withIds.map((e) => idKey(e.id)), [
+					sessionId,
+					now,
+					withIds.length,
+					servedArg(appendOptions?.consumers),
+					notifyChannel(sessionId),
+					appendOptions?.originIndex ?? "",
+					...withIds.flatMap((e) => [
+						e.id,
+						e.type,
+						json(e.payload),
+						e.cause ? json(e.cause) : "",
+						targetsArg(e.targets)
+					])
+				]));
+				const [verdict] = reply;
+				if (verdict === "empty") return {
+					events: [],
+					hasPending: reply[1] === "1"
+				};
+				if (verdict === "foreign") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${reply[1]}' already exists in another session`);
+				if (verdict === "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`);
+					return {
+						events: idempotentReplay(events, existing),
+						hasPending
+					};
+				}
+				const base = Number(reply[1]) - 1;
+				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 evalScript(CURSORS_LUA, sessionId, [], [])).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 reply = await indexing(sessionId, () => evalScript(COMPLETE_ATTEMPT_LUA, sessionId, ids.map((id) => idKey(id)), [
+					sessionId,
+					now,
+					consumer,
+					tagOf(lane),
+					index,
+					attempt,
+					json(cause),
+					servedArg(consumers),
+					notifyChannel(sessionId),
+					json(ids),
+					events.length,
+					...events.flatMap((event) => [
+						event.id,
+						event.type,
+						json(event.payload),
+						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;
+					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");
+					return {
+						outcome: "completed",
+						events: idempotentReplay(events, existing)
+					};
+				}
+				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 evalScript(DEAD_LETTERS_LUA, sessionId, [], [])).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 evalScript(READ_STATE_LUA, sessionId, [snapKey(sessionId, reducerName), snapHistoryKey(sessionId, reducerName)], [stateOptions?.snapshotThroughIndex ?? stateOptions?.throughIndex ?? ""]);
+				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 expiresAtMs = clock.now().getTime() + meta.ttlMs;
+					const applied = await call("EVAL", PRESENCE_SET_LUA, 1, presenceKey(ns), atMs, meta.ttlMs, entries.length, ...entries.flatMap(([field, value]) => [
+						JSON.stringify([participant, field]),
+						value === null ? "" : json({
+							v: value,
+							s: meta.seen,
+							a: atMs,
+							e: expiresAtMs
+						}),
+						`${json(field)}:${json(value)}`
+					]), presenceKey(ns), `${json({
+						src: options.presenceSource,
+						participant,
+						seen: meta.seen,
+						at: atMs
+					}).slice(0, -1)},"values":{`);
+					if (applied.length === 0) return null;
+					const appliedValues = nullProtoRecord();
+					for (const position of applied) {
+						const [field, value] = entries[Number(position) - 1];
+						appliedValues[field] = structuredClone(value);
+					}
+					return {
+						participant,
+						values: appliedValues,
+						seen: meta.seen,
+						at: new Date(atMs)
+					};
+				});
+			},
+			async read(ns) {
+				return wrap(async () => {
+					const reply = await call("EVAL", PRESENCE_READ_LUA, 1, presenceKey(ns), clock.now().getTime());
+					const rows = [];
+					for (let i = 0; i + 1 < reply.length; i += 2) {
+						const [participant, field] = JSON.parse(reply[i]);
+						const entry = JSON.parse(reply[i + 1]);
+						rows.push({
+							participant,
+							field,
+							value: entry.v,
+							seen: entry.s,
+							at: new Date(entry.a),
+							expiresAt: new Date(entry.e)
+						});
+					}
+					return rows;
+				});
+			}
+		},
+		async readRange(sessionId, afterIndex, throughIndex) {
+			return wrap(() => readRange(sessionId, afterIndex, throughIndex));
+		},
+		async readTail(sessionId, fromIndex, throughIndex) {
+			return wrap(async () => {
+				const page = (await call("XREVRANGE", storeKey(sessionId), throughIndex === void 0 ? "+" : `${throughIndex}-0`, `${fromIndex}-0`, "COUNT", 256)).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 reply = await evalScript(CLEAR_LUA, sessionId, [idKey(markerId)], [
+					sessionId,
+					clock.now().getTime(),
+					ifLastIndex ?? "",
+					cause?.consumer ?? "",
+					cause ? tagOf(cause.lane) : "",
+					cause?.index ?? "",
+					cause?.attempt ?? "",
+					markerId,
+					notifyChannel(sessionId)
+				]);
+				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`);
+				return {
+					cleared: reply[1] === "1",
+					index: Number(reply[2]),
+					clearIndex: Number(reply[3])
+				};
+			});
+		},
+		async reclaim(sessionId) {
+			return wrap(async () => {
+				const [log, ...pairs] = await evalScript(RECLAIM_BATCH_LUA, sessionId, [], [256]);
+				if (log === void 0) return {
+					deleted: 0,
+					done: true
+				};
+				const ids = [];
+				for (let i = 1; i < pairs.length; i += 2) ids.push(pairs[i]);
+				const [deleted, done] = await evalScript(RECLAIM_LUA, sessionId, [log, ...ids.map((id) => idKey(id))], [
+					sessionId,
+					ids.length,
+					...pairs
+				]);
+				return {
+					deleted: Number(deleted),
+					done: Number(done) === 1
+				};
+			});
+		},
+		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.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 patch = await core.presence.set(ns, participant, values, meta);
+				if (!patch) return;
+				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);
+				}
+			},
+			async read(ns) {
+				const channel = presenceChannel(ns);
+				await subscriptions.get(channel)?.ready;
+				return presenceSubscriptions.get(channel)?.recovery?.read() ?? 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,
+					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. A gap, a message without events, or an unreadable
+				* message marks the feed dirty so it catches up with XRANGE.
+				*/
+				const applyInbox = () => {
+					feed.bytes = 0;
+					for (const message of feed.inbox.splice(0)) {
+						const wake = parseWake(message);
+						if (!wake) {
+							feed.dirty = true;
+							continue;
+						}
+						for (const [index, id, type, payload] of wake.entries) {
+							const expected = (buffer.at(-1)?.index ?? last) + 1;
+							if (index < expected) continue;
+							if (index > expected) {
+								feed.dirty = true;
+								break;
+							}
+							buffer.push({
+								id,
+								type,
+								payload,
+								index,
+								sessionId,
+								createdAt: new Date(wake.createdAt)
+							});
+						}
+						if (wake.frontier > (buffer.at(-1)?.index ?? last)) feed.dirty = true;
+					}
+				};
+				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);
+									await acquireChannel(channel);
+									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.dirty) {
+									feed.dirty = false;
+									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");
+								});
+								pending = defaultSleep(NOTIFY_TIMINGS.safetyReadMs);
+								const outcome = await Promise.race([woken, pending.promise.then(() => "timer")]);
+								pending.cancel();
+								pending = null;
+								if (outcome === "timer") 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-IiVdlYHc.js.map