experimental-a2 0.20.0 → 0.22.0

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

@@ -1,2544 +0,0 @@
-import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-DGI4jTQ5.js";
-import { _ as nullProtoRecord, r as NOTIFY_TIMINGS, y as stateTailReaders } from "./internal-CscSY7K_.js";
-import { i as streamActivities, n as pollingStream, r as createStreamActivity, t as defaultSleep } from "./store-polling-7WJV0YWP.js";
-import { n as isSerializedEvent, r as parseSerializedEvent, t as bufferedEvents } from "./stream-buffer-Cx7AAPGq.js";
-import { t as idempotentReplay } from "./idempotent-replay-JdgMQRRm.js";
-import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
-import { t as pollPresence } from "./store-presence-polling-B1ixeqIS.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;
-const META_CHUNK_SIZE = 1e3;
-/** The metadata columns of a full stored row. */
-const STORED_EVENT_META_SUFFIXES = [
-	"p",
-	"pa",
-	"ri",
-	"ch",
-	"ce",
-	"f",
-	"fc",
-	"lc",
-	"lf",
-	"lfa",
-	"d",
-	"a",
-	"e"
-];
-/**
-* Upstash bills every call a script makes, so scripts read the counter and
-* split with one MGET, read metadata with one HMGET per hash (`read_fields`),
-* and buffer hash writes (`put`) into one HSET per hash (`flush`). Buffered
-* writes are invisible to reads until flushed, so a script must not read a
-* field it has buffered. Per-event metadata lives in hashes of
-* META_CHUNK_SIZE consecutive indexes, so no key grows with a session's
-* history. Indexes at or below the split predate chunking and stay in the
-* base hash, which also holds every session's lane pointers. An unset split
-* means the current event count, so any script that adds events must write
-* `split_write` pairs in its write phase. Including scripts bind COUNTER,
-* META (the base hash), and SPLIT first.
-*/
-const META_LUA = `
-local split, split_stored = nil, false
--- The latest clear marker lives beside the counter, {prefix}:{session}:clear,
--- and is read in the same MGET, so a session never cleared pays nothing.
-local CLEAR = string.sub(COUNTER, 1, -6) .. 'clear'
-local boundary = 0
-local function use_split(stored, count, cleared)
-  split_stored = stored ~= false
-  split = tonumber(stored or count or '0')
-  boundary = tonumber(cleared or '0')
-end
-local function mkey(field)
-  if split == nil then
-    local values = redis.call('MGET', SPLIT, COUNTER, CLEAR)
-    use_split(values[1], values[2], values[3])
-  end
-  local idx = tonumber(field)
-  if idx <= split then return META end
-  return META .. ':' .. tostring(math.floor((idx - 1) / ${META_CHUNK_SIZE}))
-end
-local function split_write(args)
-  if not split_stored then
-    args[#args + 1] = SPLIT
-    args[#args + 1] = tostring(split)
-  end
-end
-local function sliced(command, key, args)
-  local results = {}
-  for first = 1, #args, 1000 do
-    local last = math.min(first + 999, #args)
-    local reply
-    if key then
-      reply = redis.call(command, key, unpack(args, first, last))
-    else
-      reply = redis.call(command, unpack(args, first, last))
-    end
-    if type(reply) == 'table' then
-      for _, value in ipairs(reply) do results[#results + 1] = value end
-    end
-  end
-  return results
-end
-local function read_fields(fields, suffixes)
-  local groups, order = {}, {}
-  for _, field in ipairs(fields) do
-    local key = mkey(field)
-    local group = groups[key]
-    if not group then
-      group = { fields = {}, names = {} }
-      groups[key] = group
-      order[#order + 1] = key
-    end
-    group.fields[#group.fields + 1] = field
-    for _, suffix in ipairs(suffixes) do
-      group.names[#group.names + 1] = field .. ':' .. suffix
-    end
-  end
-  local rows = {}
-  for _, key in ipairs(order) do
-    local group = groups[key]
-    local values = sliced('HMGET', key, group.names)
-    for position, field in ipairs(group.fields) do
-      local row = {}
-      for column = 1, #suffixes do
-        row[column] = values[(position - 1) * #suffixes + column]
-      end
-      rows[field] = row
-    end
-  end
-  return rows
-end
-local writes, write_order = {}, {}
-local function put(key, field, value)
-  local fields = writes[key]
-  if not fields then
-    fields = {}
-    writes[key] = fields
-    write_order[#write_order + 1] = key
-  end
-  fields[#fields + 1] = field
-  fields[#fields + 1] = value
-end
-local function flush()
-  for _, key in ipairs(write_order) do sliced('HSET', key, writes[key]) end
-  writes, write_order = {}, {}
-end
-`;
-/**
-* Lane-aware enqueueing for scripts that add events. Including scripts bind
-* PENDING and READY. Lane tails are read once per lane and tracked in
-* memory, so a batch in one lane links its events without re-reading. A
-* lane emptied earlier in the script (`clear_lane`) is known to have no tail,
-* and its pointers are deleted at `flush_queue` only if nothing re-filled it.
-*/
-const ENQUEUE_LUA = `
-local function lane_field(lane, suffix)
-  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
-end
-local queued, ready_now, lane_tails, lane_order = {}, {}, {}, {}
-local function enqueue(field, lane)
-  local score = tonumber(field)
-  queued[#queued + 1] = score
-  queued[#queued + 1] = field
-  if lane == '' then
-    ready_now[#ready_now + 1] = score
-    ready_now[#ready_now + 1] = field
-    return
-  end
-  put(mkey(field), field .. ':l', lane)
-  local tail = lane_tails[lane]
-  if tail == nil then
-    tail = redis.call('HGET', META, lane_field(lane, 'tail'))
-    if tail and tonumber(tail) <= boundary then tail = false end
-    lane_order[#lane_order + 1] = lane
-  end
-  if tail then
-    put(mkey(tail), tail .. ':next', field)
-  else
-    put(META, lane_field(lane, 'head'), field)
-    ready_now[#ready_now + 1] = score
-    ready_now[#ready_now + 1] = field
-  end
-  lane_tails[lane] = field
-end
-local function clear_lane(lane)
-  if lane_tails[lane] == nil then lane_order[#lane_order + 1] = lane end
-  lane_tails[lane] = false
-end
-local function flush_queue()
-  for _, lane in ipairs(lane_order) do
-    if lane_tails[lane] then
-      put(META, lane_field(lane, 'tail'), lane_tails[lane])
-    else
-      redis.call('HDEL', META, lane_field(lane, 'head'), lane_field(lane, 'tail'))
-    end
-  end
-  sliced('ZADD', PENDING, queued)
-  sliced('ZADD', READY, ready_now)
-end
-`;
-/**
-* Settles one unfinished event for scripts that include ENQUEUE_LUA: it
-* leaves the pending and ready sets, and a lane head hands its lane to the
-* next unfinished event. A dead-lettered successor stays out of the ready set.
-*/
-const SETTLE_LUA = `
-local function settle(field, lane, next_field)
-  redis.call('ZREM', PENDING, field)
-  redis.call('ZREM', READY, field)
-  if lane == '' then return end
-  local head_key = lane_field(lane, 'head')
-  if redis.call('HGET', META, head_key) ~= field then return end
-  while next_field do
-    local row = read_fields({ next_field }, { 'p', 'f', 'next' })[next_field]
-    if not row[1] then
-      redis.call('HSET', META, head_key, next_field)
-      if not row[2] then
-        redis.call('ZADD', READY, tonumber(next_field), next_field)
-      end
-      return
-    end
-    next_field = row[3]
-  end
-  clear_lane(lane)
-end
-`;
-/**
-* Event-id ownership for scripts that add events. Each script reads the
-* counter, split, clear boundary, and per-id keys with one MGET and applies
-* the first three. Returns the owner record, or false, per event, and the
-* counter. A record this session made below its latest clear is free.
-*/
-const ID_OWNERS_LUA = `
-local function read_owners(key_offset, n, session)
-  local keys = { COUNTER, SPLIT, CLEAR }
-  for i = 1, n do keys[#keys + 1] = KEYS[key_offset + i] end
-  local values = sliced('MGET', nil, keys)
-  use_split(values[2], values[1], values[3])
-  local owners = {}
-  for i = 1, n do
-    local owner = values[3 + i]
-    if owner then
-      local rec = cjson.decode(owner)
-      if rec[1] == session and tonumber(rec[2]) < boundary then owner = false end
-    end
-    owners[i] = owner
-  end
-  return owners, values[1]
-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
-`;
-const RELEASE_PINS_LUA = `
-local function release_snapshot_pins(pins, counts)
-  local refs = redis.call('SMEMBERS', pins)
-  if #refs == 0 then return end
-  for _, ref in ipairs(refs) do
-    local count = redis.call('HINCRBY', counts, ref, -1)
-    if count <= 0 then
-      redis.call('HDEL', counts, ref)
-      local checkpoint = cjson.decode(ref)
-      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
-    end
-  end
-  redis.call('DEL', pins)
-end
-`;
-/**
-* KEYS: store stream, counter, metadata, pending, ready, metadata split,
-* then one id ownership key per event.
-* ARGV: sessionId, nowMs, n, then per event:
-* id, type, payloadJson, causeJson, lane, settled; then notify channel and
-* origin index or ''.
-* Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
-* ['dup', hasPending, ...indexes] | ['partial', count] |
-* ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx] |
-* ['cleared', originIndex].
-*/
-const APPEND_LUA = `
-local COUNTER, META, SPLIT, PENDING, READY = KEYS[2], KEYS[3], KEYS[6], KEYS[4], KEYS[5]
-${META_LUA}
-${ENQUEUE_LUA}
-${ID_OWNERS_LUA}
-${WAKE_LUA}
-local function has_pending()
-  return redis.call('ZCARD', PENDING) > 0 and '1' or '0'
-end
-local n = tonumber(ARGV[3])
-if n == 0 then return { 'empty', has_pending() } end
-local owners, count = read_owners(6, n, ARGV[1])
-local base = tonumber(count or '0')
-local dups = {}
-for i = 1, n do
-  if owners[i] then
-    local rec = cjson.decode(owners[i])
-    if rec[1] ~= ARGV[1] then return { 'foreign', ARGV[3 + (i - 1) * 6 + 1] } end
-    dups[#dups + 1] = tostring(rec[2])
-  end
-end
-if #dups == n then
-  local res = { 'dup', has_pending() }
-  for i = 1, #dups do res[#res + 1] = dups[i] end
-  return res
-end
-if #dups > 0 then return { 'partial', tostring(#dups) } end
-local origin = ARGV[5 + n * 6]
-if origin and origin ~= '' and tonumber(origin) <= boundary then
-  return { 'cleared', origin }
-end
-local causes, parents = {}, {}
-for i = 1, n do
-  local cause = ARGV[3 + (i - 1) * 6 + 4]
-  if cause ~= '' then
-    local parsed = cjson.decode(cause)
-    local pidx = tonumber(parsed.index)
-    causes[#causes + 1] = parsed
-    if pidx >= 1 and pidx <= base then parents[#parents + 1] = tostring(pidx) end
-  end
-end
-local parent_rows = read_fields(parents, { 'd', 'f', 'p' })
-local parent_pending = false
-for _, parsed in ipairs(causes) do
-  local pidx = tonumber(parsed.index)
-  if pidx <= boundary then return { 'superseded', tostring(pidx) } end
-  if pidx < 1 or pidx > base then
-    return { 'no_parent', tostring(parsed.index) }
-  end
-  local row = parent_rows[tostring(pidx)]
-  if tonumber(row[1] or '0') ~= tonumber(parsed.attempt) or row[2] then
-    return { 'superseded', tostring(pidx) }
-  end
-  -- A claimed, unprocessed parent is still in the pending set.
-  if not row[3] then parent_pending = true end
-end
-local owner_writes = {}
-for i = 1, n do
-  local o = 3 + (i - 1) * 6
-  local field = tostring(base + i)
-  redis.call('XADD', KEYS[1], field .. '-0',
-    'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
-    'created_at', ARGV[2], 'cause', ARGV[o + 4], 'lane', ARGV[o + 5])
-  owner_writes[#owner_writes + 1] = KEYS[6 + i]
-  owner_writes[#owner_writes + 1] = cjson.encode({ ARGV[1], base + i })
-  wake_add(field, ARGV[o + 1], ARGV[o + 2], ARGV[o + 3])
-  if ARGV[o + 6] == '1' then
-    put(mkey(field), field .. ':p', ARGV[2])
-  else
-    enqueue(field, ARGV[o + 5])
-  end
-end
-owner_writes[#owner_writes + 1] = COUNTER
-owner_writes[#owner_writes + 1] = tostring(base + n)
-split_write(owner_writes)
-sliced('MSET', nil, owner_writes)
-flush_queue()
-flush()
-local pending_after = (#queued > 0 or parent_pending) and '1' or has_pending()
-wake(ARGV[4 + n * 6], tostring(base + n), ARGV[2])
-return { 'ok', tostring(base + 1), pending_after }
-`;
-/**
-* KEYS: counter, meta, pending, ready, event snapshot pins, snapshot pin counts,
-* metadata split.
-* ARGV: idx, attempt, error, maxFailures, nowMs, retryAtMs ('' for none).
-*/
-const FAIL_ATTEMPT_LUA = `
-local COUNTER, META, SPLIT = KEYS[1], KEYS[2], KEYS[7]
-${META_LUA}
-${RELEASE_PINS_LUA}
-local idx = tonumber(ARGV[1])
-local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
-local total = tonumber(counts[1] or '0')
-use_split(counts[2], counts[1], counts[3])
-if idx <= boundary then return { 'cleared', '0' } end
-if idx < 1 or idx > total then return { 'missing', '0' } end
-local field = ARGV[1]
-local attempt = tonumber(ARGV[2])
-local row = read_fields({ field }, { 'a', 'd', 'p', 'f', 'lfa', 'ch' })[field]
-local failures = tonumber(row[1] or '0')
-if row[3] or tonumber(row[2] or '0') ~= attempt then
-  return { 'superseded', tostring(failures) }
-end
-if row[4] then return { 'dead_lettered', tostring(failures) } end
-if row[5] and tonumber(row[5]) == attempt and not row[6] then
-  return { 'failed', tostring(failures) }
-end
-if not row[6] then return { 'superseded', tostring(failures) } end
-failures = failures + 1
-local dead = failures >= tonumber(ARGV[4])
-local meta_key = mkey(field)
-put(meta_key, field .. ':a', tostring(failures))
-put(meta_key, field .. ':e', ARGV[3])
-put(meta_key, field .. ':lf', ARGV[5])
-put(meta_key, field .. ':lfa', ARGV[2])
-if dead then put(meta_key, field .. ':f', ARGV[5]) end
-local hold = not dead and ARGV[6] ~= ''
-if hold then put(meta_key, field .. ':ce', ARGV[6]) end
-flush()
-if hold then
-  redis.call('HDEL', meta_key, field .. ':ch')
-else
-  redis.call('HDEL', meta_key, field .. ':ch', field .. ':ce')
-end
-if dead then
-  redis.call('ZREM', KEYS[4], field)
-  release_snapshot_pins(KEYS[5], KEYS[6])
-  return { 'dead_lettered', tostring(failures) }
-end
-return { 'failed', tostring(failures) }
-`;
-/**
-* KEYS: store, counter, meta, pending, ready, metadata split, snapshot pin
-* counts.
-* ARGV: holder, nowMs, expiresAtMs, excludedCount, excluded indexes, then
-* maxFailures ('' for none) and the event snapshot-pins key prefix.
-* The ready set is a subset of the pending set, so an empty ready set is
-* enough to report 'settled'. A claimed result ends with the clear boundary.
-*/
-const CLAIM_AVAILABLE_LUA = `
-local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[6]
-${META_LUA}
-${RELEASE_PINS_LUA}
-local ready = redis.call('ZRANGE', KEYS[5], 0, -1)
-local excluded = {}
-local tail = 5 + tonumber(ARGV[4])
-for i = 1, tonumber(ARGV[4]) do excluded[ARGV[4 + i]] = true end
-local max_failures = tonumber(ARGV[tail])
-local candidates = {}
-for _, field in ipairs(ready) do
-  if not excluded[field] then candidates[#candidates + 1] = field end
-end
-local rows = read_fields(candidates, { 'ce', 'd', 'fc', 'a', 'e', 'lf', 'lfa' })
-local claimed = {}
-local dead = {}
-local retry_at = nil
-for _, field in ipairs(candidates) do
-  local row = rows[field]
-  local expires = tonumber(row[1] or '0')
-  if expires > tonumber(ARGV[2]) then
-    if not retry_at or expires < retry_at then retry_at = expires end
-  else
-    local entries = redis.call('XRANGE', KEYS[1], field .. '-0', field .. '-0')
-    if #entries == 0 then return { 'missing', field } end
-    local meta_key = mkey(field)
-    local attempt = tostring(tonumber(row[2] or '0') + 1)
-    -- An expiry that is not the current attempt's retry hold is a lapsed
-    -- claim: its attempt never finished.
-    local lapsed = row[1] and row[7] ~= row[2]
-    local failures = tonumber(row[4] or '0')
-    if lapsed then
-      failures = failures + 1
-      put(meta_key, field .. ':a', tostring(failures))
-    end
-    put(meta_key, field .. ':d', attempt)
-    if lapsed and max_failures and failures >= max_failures then
-      -- That takeover spent the last failed attempt: dead-letter, unclaimed.
-      -- Advancing the attempt fences the lapsed one; nothing runs.
-      put(meta_key, field .. ':f', ARGV[2])
-      dead[#dead + 1] = field
-      claimed[#claimed + 1] = {
-        attempt,
-        tostring(failures),
-        row[5] or false,
-        row[3] or false,
-        read_fields({ field }, { 'lc' })[field][1] or false,
-        row[6] or false,
-        row[7] or false,
-        false,
-        false,
-        entries[1],
-        ARGV[2]
-      }
-    else
-      local first_claimed = row[3] or ARGV[2]
-      put(meta_key, field .. ':fc', first_claimed)
-      put(meta_key, field .. ':lc', ARGV[2])
-      put(meta_key, field .. ':ch', ARGV[1])
-      put(meta_key, field .. ':ce', ARGV[3])
-      claimed[#claimed + 1] = {
-        attempt,
-        tostring(failures),
-        row[5] or false,
-        first_claimed,
-        ARGV[2],
-        row[6] or false,
-        row[7] or false,
-        ARGV[1],
-        ARGV[3],
-        entries[1],
-        false
-      }
-    end
-  end
-end
-flush()
-for _, field in ipairs(dead) do
-  redis.call('HDEL', mkey(field), field .. ':ch', field .. ':ce')
-  redis.call('ZREM', KEYS[5], field)
-  release_snapshot_pins(ARGV[tail + 1] .. field, KEYS[7])
-end
-if #claimed > 0 then
-  local result = { 'claimed', tostring(#claimed) }
-  for _, claim in ipairs(claimed) do
-    for _, value in ipairs(claim) do result[#result + 1] = value end
-  end
-  result[#result + 1] = tostring(boundary)
-  return result
-end
-if retry_at then return { 'busy', tostring(retry_at) } end
-return { 'settled' }
-`;
-/**
-* KEYS: counter, meta, metadata split.
-* ARGV: holder, nowMs, expiresAtMs, n, then per claim: index, attempt.
-* Returns [renewedCount, ...renewed, ...superseded].
-*/
-const RENEW_CLAIMS_LUA = `
-local COUNTER, META, SPLIT = KEYS[1], KEYS[2], KEYS[3]
-${META_LUA}
-local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
-local total = tonumber(counts[1] or '0')
-use_split(counts[2], counts[1], counts[3])
-local claims, fields, cleared = {}, {}, {}
-for i = 1, tonumber(ARGV[4]) do
-  local field = ARGV[4 + (i - 1) * 2 + 1]
-  local idx = tonumber(field)
-  if idx <= boundary then
-    cleared[#cleared + 1] = field
-  elseif idx >= 1 and idx <= total then
-    claims[#claims + 1] = { field = field, attempt = tonumber(ARGV[4 + (i - 1) * 2 + 2]) }
-    fields[#fields + 1] = field
-  end
-end
-local rows = read_fields(fields, { 'd', 'ce', 'p', 'f', 'ch' })
-local renewed = {}
-local superseded = {}
-for _, claim in ipairs(claims) do
-  local row = rows[claim.field]
-  if tonumber(row[1] or '0') > claim.attempt then
-    superseded[#superseded + 1] = claim.field
-  elseif tonumber(ARGV[3]) > tonumber(ARGV[2]) and
-         not row[3] and not row[4] and row[5] == ARGV[1] and
-         tonumber(row[2] or '0') > tonumber(ARGV[2]) then
-    put(mkey(claim.field), claim.field .. ':ce', ARGV[3])
-    renewed[#renewed + 1] = claim.field
-  end
-end
-flush()
-for _, field in ipairs(cleared) do superseded[#superseded + 1] = field end
-local result = { tostring(#renewed) }
-for i = 1, #renewed do result[#result + 1] = renewed[i] end
-for i = 1, #superseded do result[#result + 1] = superseded[i] end
-return result
-`;
-/**
-* KEYS: store, counter, meta, pending, ready, event snapshot pins, snapshot
-* pin counts, metadata split, then one id ownership key per child.
-* ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
-* id, type, payloadJson, lane, settled; finally notify channel.
-*/
-const COMPLETE_ATTEMPT_LUA = `
-local COUNTER, META, SPLIT, PENDING, READY = KEYS[2], KEYS[3], KEYS[8], KEYS[4], KEYS[5]
-${META_LUA}
-${ENQUEUE_LUA}
-${ID_OWNERS_LUA}
-${RELEASE_PINS_LUA}
-${WAKE_LUA}
-${SETTLE_LUA}
-local parent = ARGV[3]
-local attempt = tonumber(ARGV[4])
-local n = tonumber(ARGV[5])
-local owners, count = read_owners(8, n, ARGV[1])
-local total = tonumber(count or '0')
-if tonumber(parent) <= boundary then return { 'superseded' } end
-if tonumber(parent) < 1 or tonumber(parent) > total then return { 'missing' } end
-local row = read_fields({ parent }, { 'd', 'p', 'pa', 'ri', 'ch', 'f', 'lfa', 'l', 'next' })[parent]
-if row[2] then
-  if tonumber(row[3] or '0') ~= attempt then return { 'superseded' } end
-  if not row[4] then return { 'partial' } end
-  local recorded_ids = cjson.decode(row[4])
-  if #recorded_ids ~= n then return { 'partial' } end
-  for i = 1, n do
-    if recorded_ids[i] ~= ARGV[5 + (i - 1) * 5 + 1] then return { 'partial' } end
-  end
-  local indexes = {}
-  for i = 1, n do
-    if not owners[i] then return { 'partial' } end
-    local rec = cjson.decode(owners[i])
-    if rec[1] ~= ARGV[1] then return { 'partial' } end
-    local entries = redis.call('XRANGE', KEYS[1], tostring(rec[2]) .. '-0', tostring(rec[2]) .. '-0')
-    if #entries == 0 then return { 'partial' } end
-    local values = entries[1][2]
-    local cause = nil
-    for j = 1, #values, 2 do
-      if values[j] == 'cause' then cause = values[j + 1] break end
-    end
-    if not cause or cause == '' then return { 'partial' } end
-    local decoded = cjson.decode(cause)
-    if tonumber(decoded['index']) ~= tonumber(parent) or
-       tonumber(decoded['attempt']) ~= attempt then return { 'partial' } end
-    indexes[#indexes + 1] = tostring(rec[2])
-  end
-  local result = { 'duplicate' }
-  for _, idx in ipairs(indexes) do result[#result + 1] = idx end
-  return result
-end
-if tonumber(row[1] or '0') ~= attempt then return { 'superseded' } end
-if not row[5] or row[6] or tonumber(row[7] or '0') == attempt then
-  return { 'superseded' }
-end
-for i = 1, n do
-  if owners[i] then return { 'partial' } end
-end
-local returned_ids = {}
-for i = 1, n do returned_ids[i] = ARGV[5 + (i - 1) * 5 + 1] end
-local returned_json = '[]'
-if n > 0 then returned_json = cjson.encode(returned_ids) end
-local parent_key = mkey(parent)
-put(parent_key, parent .. ':p', ARGV[2])
-put(parent_key, parent .. ':pa', ARGV[4])
-put(parent_key, parent .. ':ri', returned_json)
-redis.call('HDEL', parent_key, parent .. ':ch', parent .. ':ce')
-settle(parent, row[8] or '', row[9])
-release_snapshot_pins(KEYS[6], KEYS[7])
-local cause = cjson.encode({ index = tonumber(parent), attempt = attempt })
-local owner_writes = {}
-for i = 1, n do
-  local o = 5 + (i - 1) * 5
-  local field = tostring(total + i)
-  redis.call('XADD', KEYS[1], field .. '-0',
-    'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
-    'created_at', ARGV[2], 'cause', cause, 'lane', ARGV[o + 4])
-  owner_writes[#owner_writes + 1] = KEYS[8 + i]
-  owner_writes[#owner_writes + 1] = cjson.encode({ ARGV[1], total + i })
-  wake_add(field, ARGV[o + 1], ARGV[o + 2], ARGV[o + 3])
-  if ARGV[o + 5] == '1' then
-    put(mkey(field), field .. ':p', ARGV[2])
-  else
-    enqueue(field, ARGV[o + 4])
-  end
-end
-if n > 0 then
-  owner_writes[#owner_writes + 1] = COUNTER
-  owner_writes[#owner_writes + 1] = tostring(total + n)
-  split_write(owner_writes)
-  sliced('MSET', nil, owner_writes)
-end
-flush_queue()
-flush()
-if n > 0 then wake(ARGV[6 + n * 5], tostring(total + n), ARGV[2]) end
-return { 'ok', tostring(total + 1) }
-`;
-/**
-* KEYS: counter, meta, pending, ready, metadata split.
-* ARGV: idx, action ('retry' | 'skip'), nowMs.
-* Returns [redriven, hasPending]. Acts only on an unfinished, dead-lettered
-* event above the clear boundary. A retry keeps the event pending and makes
-* it ready again when it is unlaned or its lane's head.
-*/
-const REDRIVE_LUA = `
-local COUNTER, META, SPLIT, PENDING, READY = KEYS[1], KEYS[2], KEYS[5], KEYS[3], KEYS[4]
-${META_LUA}
-${ENQUEUE_LUA}
-${SETTLE_LUA}
-local function result(redriven)
-  return { redriven, redis.call('ZCARD', PENDING) > 0 and '1' or '0' }
-end
-local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
-local total = tonumber(counts[1] or '0')
-use_split(counts[2], counts[1], counts[3])
-local idx = tonumber(ARGV[1])
-if idx <= boundary or idx > total then return result('0') end
-local field = tostring(idx)
-local row = read_fields({ field }, { 'p', 'f', 'l', 'next' })[field]
-if row[1] or not row[2] then return result('0') end
-local meta_key = mkey(field)
-local lane = row[3] or ''
-if ARGV[2] == 'skip' then
-  put(meta_key, field .. ':p', ARGV[3])
-  settle(field, lane, row[4])
-  flush_queue()
-  flush()
-else
-  redis.call('HDEL', meta_key, field .. ':f', field .. ':a')
-  if lane == '' or redis.call('HGET', META, lane_field(lane, 'head')) == field then
-    redis.call('ZADD', READY, idx, field)
-  end
-end
-return result('1')
-`;
-/**
-* KEYS: store, counter, meta, pending, metadata split.
-* Returns the dead-lettered events above the clear boundary, oldest first,
-* as pairs of a stream entry and its STORED_EVENT_META_SUFFIXES columns.
-* Every unfinished event is in the pending set, so the scan is bounded by
-* unfinished work, not history; only dead letters read their full columns.
-*/
-const DEAD_LETTERS_LUA = `
-local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[5]
-${META_LUA}
-local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
-use_split(counts[2], counts[1], counts[3])
-local candidates = {}
-for _, field in ipairs(redis.call('ZRANGE', KEYS[4], 0, -1)) do
-  if tonumber(field) > boundary then candidates[#candidates + 1] = field end
-end
-local status = read_fields(candidates, { 'p', 'f' })
-local dead = {}
-for _, field in ipairs(candidates) do
-  if status[field][2] and not status[field][1] then dead[#dead + 1] = field end
-end
-local rows = read_fields(dead, { ${STORED_EVENT_META_SUFFIXES.map((suffix) => `'${suffix}'`).join(", ")} })
-local result = {}
-for _, field in ipairs(dead) do
-  local entries = redis.call('XRANGE', KEYS[1], field .. '-0', field .. '-0')
-  if #entries > 0 then
-    result[#result + 1] = entries[1]
-    result[#result + 1] = rows[field]
-  end
-end
-return result
-`;
-/**
-* KEYS: head, history, event counter, event meta, pin counts, metadata split.
-* ARGV: nowMs, event pin key prefix, write count, then per write:
-* index, snapshot JSON, pin count, pin event indexes; finally the reducer
-* name. Writes from before the latest clear are dropped, and a head from
-* before it is replaced as if absent.
-*/
-const PUT_SNAPSHOTS_LUA = `
-local COUNTER, META, SPLIT = KEYS[3], KEYS[4], KEYS[6]
-${META_LUA}
-local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
-local total = tonumber(counts[1] or '0')
-use_split(counts[2], counts[1], counts[3])
-local pinned = {}
-local offset = 4
-for i = 1, tonumber(ARGV[3]) do
-  local pin_count = tonumber(ARGV[offset + 2])
-  for p = 1, pin_count do
-    local event_index = tonumber(ARGV[offset + 2 + p])
-    if event_index > boundary and event_index <= total then
-      pinned[#pinned + 1] = tostring(event_index)
-    end
-  end
-  offset = offset + 3 + pin_count
-end
-local status = read_fields(pinned, { 'p', 'f' })
-local snapshots = {}
-offset = 4
-for i = 1, tonumber(ARGV[3]) do
-  local index = tonumber(ARGV[offset])
-  local snapshot = ARGV[offset + 1]
-  local pin_count = tonumber(ARGV[offset + 2])
-  local ref = cjson.encode({ KEYS[2], tostring(index) })
-  for p = 1, pin_count do
-    local event_index = tonumber(ARGV[offset + 2 + p])
-    local row = status[tostring(event_index)]
-    if index >= boundary and event_index > boundary and event_index <= total and
-       not row[1] and not row[2] then
-      local pin_key = ARGV[2] .. tostring(event_index)
-      if redis.call('SADD', pin_key, ref) == 1 then
-        redis.call('HINCRBY', KEYS[5], ref, 1)
-      end
-    end
-  end
-  if index >= boundary then
-    snapshots[#snapshots + 1] = { index = index, snapshot = snapshot, ref = ref }
-  end
-  offset = offset + 3 + pin_count
-end
-if #snapshots == 0 then return 1 end
-
-local head = redis.call('GET', KEYS[1])
-local head_index = nil
-local registered = false
-if head then
-  local record = cjson.decode(head)
-  head_index = tonumber(record['index'])
-  registered = record['r'] == 1
-end
-if head_index and head_index < boundary then
-  head, head_index, registered = nil, nil, false
-  redis.call('ZREMRANGEBYSCORE', KEYS[2], '-inf', '(' .. boundary)
-end
--- Deletion finds each reducer's keys through this set instead of a scan.
--- Heads written since carry the mark, so a reducer registers once.
-if not registered then
-  redis.call('SADD', string.sub(COUNTER, 1, -6) .. 'snap-reducers', ARGV[#ARGV])
-end
-local latest = snapshots[#snapshots]
-local writes_head = not head_index or latest.index >= head_index
-local advances = not head_index or latest.index > head_index
-local final_head_index = advances and latest.index or head_index
-
-if advances and head and tonumber(redis.call('HGET', KEYS[5], cjson.encode({ KEYS[2], tostring(head_index) })) or '0') > 0 then
-  redis.call('ZREMRANGEBYSCORE', KEYS[2], head_index, head_index)
-  redis.call('ZADD', KEYS[2], head_index, head)
-end
-
-for _, write in ipairs(snapshots) do
-  if write.index < final_head_index then
-    redis.call('ZREMRANGEBYSCORE', KEYS[2], write.index, write.index)
-    if tonumber(redis.call('HGET', KEYS[5], write.ref) or '0') > 0 then
-      redis.call('ZADD', KEYS[2], write.index, write.snapshot)
-    end
-  end
-end
-
-if writes_head then
-  redis.call('SET', KEYS[1], latest.snapshot)
-  redis.call('ZREMRANGEBYSCORE', KEYS[2], 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: head, history, event counter. ARGV: snapshot frontier or ''.
-* Returns one atomic multiversion-cache-plus-log-frontier read, with the
-* clear boundary; checkpoints from before it are ignored.
-*/
-const READ_STATE_LUA = `
-local counts = redis.call('MGET', KEYS[3], string.sub(KEYS[3], 1, -6) .. 'clear')
-local boundary = tonumber(counts[2] or '0')
-local head = redis.call('GET', KEYS[1])
-local head_index = head and cjson.decode(head)['index'] or nil
-if head and (type(head_index) ~= 'number' or head_index < 0 or head_index > 9007199254740991 or head_index ~= math.floor(head_index)) then
-  return redis.error_reply('invalid snapshot head index')
-end
-if head_index and head_index < boundary then
-  head = nil
-  head_index = nil
-end
-local cap = ARGV[1]
-local snapshot = nil
-if head_index and (cap == '' or head_index <= tonumber(cap)) then
-  snapshot = head
-else
-  local upper = cap == '' and '+inf' or cap
-  local historical = redis.call('ZREVRANGEBYSCORE', KEYS[2], upper, 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) }
-`;
-/**
-* Removes every registered reducer's checkpoints below the latest clear, and
-* the pin counts that name them. Snapshot writes register each reducer in
-* {prefix}:{session}:snap-reducers, so no key scan is needed.
-*/
-const SWEEP_CHECKPOINTS_LUA = `
-local function sweep_checkpoints(session, boundary)
-  for _, reducer in ipairs(redis.call('SMEMBERS', session .. 'snap-reducers')) do
-    local head_key = session .. 'snap:' .. reducer
-    local head = redis.call('GET', head_key)
-    if head and tonumber(cjson.decode(head)['index']) < boundary then
-      redis.call('DEL', head_key)
-    end
-    redis.call('ZREMRANGEBYSCORE', session .. 'snap-history:' .. reducer, '-inf', '(' .. boundary)
-  end
-  local counts_key = session .. 'snapshot-pin-counts'
-  local counts = redis.call('HGETALL', counts_key)
-  local stale = {}
-  for i = 1, #counts, 2 do
-    if tonumber(cjson.decode(counts[i])[2]) < boundary then stale[#stale + 1] = counts[i] end
-  end
-  if #stale > 0 then redis.call('HDEL', counts_key, unpack(stale)) end
-end
-`;
-/**
-* KEYS: store stream, counter, metadata, metadata split, marker id ownership
-* key, pending, ready.
-* ARGV: sessionId, nowMs, ifLastIndex or '', cause index or '', cause
-* attempt, marker id, notify channel.
-* Returns ['ok', cleared, head, boundary] | ['no_parent', idx] |
-* ['superseded', idx] | ['foreign']. The old lifetime's log moves aside in one
-* RENAME, so every read of the log starts at the marker, and its queues are
-* unlinked, so claims and pending checks see only the new lifetime; deletion
-* drains the moved log.
-*/
-const CLEAR_LUA = `
-local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[4]
-${META_LUA}
-${WAKE_LUA}
-local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR, KEYS[5])
-local head = tonumber(counts[1] or '0')
-use_split(counts[2], counts[1], counts[3])
-if ARGV[4] ~= '' then
-  local field = ARGV[4]
-  local pidx = tonumber(field)
-  if pidx <= boundary then return { 'superseded', field } end
-  if pidx < 1 or pidx > head then return { 'no_parent', field } end
-  local row = read_fields({ field }, { 'd', 'f' })[field]
-  if tonumber(row[1] or '0') ~= tonumber(ARGV[5]) or row[2] then
-    return { 'superseded', field }
-  end
-end
-local expected = ARGV[3]
-if expected ~= '' and boundary == tonumber(expected) + 1 then
-  return { 'ok', '1', tostring(head), tostring(boundary) }
-end
-if expected ~= '' and tonumber(expected) ~= head then
-  return { 'ok', '0', tostring(head), tostring(boundary) }
-end
-if head == 0 or boundary == head then
-  return { 'ok', '1', tostring(head), tostring(boundary) }
-end
-if counts[4] then return { 'foreign' } end
-local field = tostring(head + 1)
-local session = string.sub(COUNTER, 1, -6)
-local moved = session .. 'cleared:' .. field
-redis.call('RENAME', KEYS[1], moved)
-redis.call('UNLINK', KEYS[6], KEYS[7])
-redis.call('SADD', session .. 'cleared', moved)
-redis.call('XADD', KEYS[1], field .. '-0',
-  'id', ARGV[6], 'type', '${CLEAR_EVENT_TYPE}', 'payload', 'null',
-  'created_at', ARGV[2], 'cause', '', 'lane', '')
-local writes = { KEYS[5], cjson.encode({ ARGV[1], head + 1 }), COUNTER, field, CLEAR, field }
-split_write(writes)
-redis.call('MSET', unpack(writes))
-put(mkey(field), field .. ':p', ARGV[2])
-flush()
-wake_add(field, ARGV[6], '${CLEAR_EVENT_TYPE}', 'null')
-wake(ARGV[7], field, ARGV[2])
-return { 'ok', '1', field, field }
-`;
-/**
-* KEYS: counter. ARGV: page size.
-* The next deletion batch: a moved log and up to a page of its [index, id]
-* pairs, without payloads. Empty moved logs are dropped; with none left it
-* sweeps the old checkpoints and returns nothing, so a retry finishes an
-* interrupted deletion.
-*/
-const RECLAIM_BATCH_LUA = `
-${SWEEP_CHECKPOINTS_LUA}
-local session = string.sub(KEYS[1], 1, -6)
-local boundary = tonumber(redis.call('GET', session .. 'clear') or '0')
-if boundary == 0 then return {} end
-for _, log in ipairs(redis.call('SMEMBERS', session .. 'cleared')) do
-  local entries = redis.call('XRANGE', log, '-', '+', 'COUNT', ARGV[1])
-  if #entries > 0 then
-    local batch = { log }
-    for _, entry in ipairs(entries) do
-      local fields = entry[2]
-      for i = 1, #fields, 2 do
-        if fields[i] == 'id' then
-          batch[#batch + 1] = string.match(entry[1], '^(%d+)')
-          batch[#batch + 1] = fields[i + 1]
-          break
-        end
-      end
-    end
-    return batch
-  end
-  redis.call('DEL', log)
-  redis.call('SREM', session .. 'cleared', log)
-end
-sweep_checkpoints(session, boundary)
-return {}
-`;
-/**
-* KEYS: moved log, counter, metadata, metadata split, then one id ownership
-* key per entry.
-* ARGV: sessionId, event pin key prefix, n, then per entry: index, id.
-* Deletes the listed entries below the latest clear and everything that
-* names them. An id record survives when it names another event, so an id
-* reused in the new lifetime keeps its owner. Returns [deleted, done].
-*/
-const RECLAIM_LUA = `
-local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[4]
-${META_LUA}
-${SWEEP_CHECKPOINTS_LUA}
-local function lane_field(lane, suffix)
-  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
-end
-local session = string.sub(COUNTER, 1, -6)
-local counts = redis.call('MGET', COUNTER, SPLIT, CLEAR)
-use_split(counts[2], counts[1], counts[3])
-local fields, id_keys, indexes, stream_ids, pin_keys, deleted = {}, {}, {}, {}, {}, {}
--- A concurrent reclaim may list the same batch; only XDEL says who removed it.
-local removed = 0
-for i = 1, tonumber(ARGV[3]) do
-  local field = ARGV[3 + (i - 1) * 2 + 1]
-  if tonumber(field) < boundary then
-    fields[#fields + 1] = field
-    id_keys[#fields] = KEYS[4 + i]
-    indexes[#fields] = tonumber(field)
-    stream_ids[#fields] = field .. '-0'
-    pin_keys[#fields] = ARGV[2] .. field
-    deleted[field] = true
-  end
-end
-if #fields > 0 then
-  local lanes, seen, pointers = read_fields(fields, { 'l' }), {}, {}
-  for _, field in ipairs(fields) do
-    local lane = lanes[field][1]
-    if lane and lane ~= '' and not seen[lane] then
-      seen[lane] = true
-      pointers[#pointers + 1] = lane_field(lane, 'head')
-      pointers[#pointers + 1] = lane_field(lane, 'tail')
-    end
-  end
-  if #pointers > 0 then
-    local values = redis.call('HMGET', META, unpack(pointers))
-    local stale = {}
-    for i = 1, #pointers do
-      if values[i] and deleted[values[i]] then stale[#stale + 1] = pointers[i] end
-    end
-    if #stale > 0 then redis.call('HDEL', META, unpack(stale)) end
-  end
-  local suffixes = { 'l', 'next', 'p', 'pa', 'ri', 'ch', 'ce', 'f', 'fc', 'lc', 'lf', 'lfa', 'd', 'a', 'e' }
-  local columns, order = {}, {}
-  for _, field in ipairs(fields) do
-    local key = mkey(field)
-    if not columns[key] then
-      columns[key] = {}
-      order[#order + 1] = key
-    end
-    for _, suffix in ipairs(suffixes) do
-      columns[key][#columns[key] + 1] = field .. ':' .. suffix
-    end
-  end
-  for _, key in ipairs(order) do sliced('HDEL', key, columns[key]) end
-  sliced('DEL', nil, pin_keys)
-  local owners, stale_ids = sliced('MGET', nil, id_keys), {}
-  for i = 1, #fields do
-    if owners[i] then
-      local rec = cjson.decode(owners[i])
-      if rec[1] == ARGV[1] and tonumber(rec[2]) == indexes[i] then
-        stale_ids[#stale_ids + 1] = id_keys[i]
-      end
-    end
-  end
-  if #stale_ids > 0 then sliced('DEL', nil, stale_ids) end
-  removed = redis.call('XDEL', KEYS[1], unpack(stream_ids))
-end
-local done = 0
-if redis.call('XLEN', KEYS[1]) == 0 then
-  redis.call('DEL', KEYS[1])
-  redis.call('SREM', session .. 'cleared', KEYS[1])
-  if redis.call('SCARD', session .. 'cleared') == 0 then
-    sweep_checkpoints(session, boundary)
-    done = 1
-  end
-end
-return { removed, done }
-`;
-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"]))
-	};
-};
-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";
-const toCause = (raw) => {
-	if (raw === "" || raw === void 0) return null;
-	const value = JSON.parse(raw);
-	if (!Number.isInteger(value.index) || Number(value.index) < 1 || !Number.isInteger(value.attempt) || Number(value.attempt) < 1) throw new TypeError("stored event has an invalid cause");
-	if (value.batchSize !== void 0 && (!Number.isInteger(value.batchSize) || Number(value.batchSize) < 1)) throw new TypeError("stored event has an invalid cause");
-	return {
-		index: Number(value.index),
-		attempt: Number(value.attempt),
-		...value.batchSize === void 0 ? {} : { batchSize: Number(value.batchSize) }
-	};
-};
-/** A stream entry joined with its metadata columns; absent columns are unset. */
-const toStoredEvent = (sessionId, entry, column) => {
-	const fields = fieldMap(entry[1]);
-	const date = (suffix) => {
-		const value = column(suffix);
-		return value === void 0 ? null : new Date(Number(value));
-	};
-	const count = (suffix) => {
-		const value = column(suffix);
-		return value === void 0 ? null : Number(value);
-	};
-	const returnedEventIds = column("ri");
-	return Object.assign(toEvent(sessionId, entry), {
-		cause: toCause(fields["cause"]),
-		lane: fields["lane"] === "" ? null : fields["lane"],
-		processedAt: date("p"),
-		processedByAttempt: count("pa"),
-		returnedEventIds: returnedEventIds === void 0 ? null : decodeReturnedEventIds(returnedEventIds),
-		firstClaimedAt: date("fc"),
-		lastClaimedAt: date("lc"),
-		attemptCount: count("d") ?? 0,
-		claimHolder: column("ch") ?? null,
-		claimExpiresAt: date("ce"),
-		failureCount: count("a") ?? 0,
-		lastFailedAt: date("lf"),
-		lastFailedAttempt: count("lfa"),
-		lastError: column("e") ?? null,
-		failedAt: date("f")
-	});
-};
-const toClaimAvailableResult = (sessionId, reply) => {
-	const outcome = String(reply[0]);
-	if (outcome === "claimed") {
-		const count = Number(reply[1]);
-		const events = [];
-		for (let i = 0; i < count; i++) {
-			const offset = 2 + i * 11;
-			const entry = reply[offset + 9];
-			const event = toEvent(sessionId, entry);
-			const fields = fieldMap(entry[1]);
-			events.push(Object.assign(event, {
-				cause: toCause(fields["cause"]),
-				lane: fields["lane"] === "" ? null : fields["lane"],
-				processedAt: null,
-				processedByAttempt: null,
-				returnedEventIds: null,
-				firstClaimedAt: reply[offset + 3] === null ? null : new Date(Number(reply[offset + 3])),
-				lastClaimedAt: reply[offset + 4] === null ? null : new Date(Number(reply[offset + 4])),
-				attemptCount: Number(reply[offset]),
-				claimHolder: reply[offset + 7] === null ? null : String(reply[offset + 7]),
-				claimExpiresAt: reply[offset + 8] === null ? null : new Date(Number(reply[offset + 8])),
-				failureCount: Number(reply[offset + 1]),
-				lastFailedAt: reply[offset + 5] === null ? null : new Date(Number(reply[offset + 5])),
-				lastFailedAttempt: reply[offset + 6] === null ? null : Number(reply[offset + 6]),
-				lastError: reply[offset + 2] === null ? null : String(reply[offset + 2]),
-				failedAt: reply[offset + 10] === null ? null : new Date(Number(reply[offset + 10]))
-			}));
-		}
-		const clearIndex = Number(reply[2 + count * 11] ?? 0);
-		if (clearIndex > 0) for (const event of events) event.clearIndex = clearIndex;
-		return {
-			outcome: "claimed",
-			events
-		};
-	}
-	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 metaKey = (s) => `${prefix}:${s}:meta`;
-	const metaChunkKey = (s, index) => `${metaKey(s)}:${Math.floor((index - 1) / META_CHUNK_SIZE)}`;
-	const metaSplitKey = (s) => `${prefix}:${s}:meta-split`;
-	const pendingKey = (s) => `${prefix}:${s}:pending`;
-	const readyKey = (s) => `${prefix}:${s}:ready`;
-	const snapKey = (s, r) => `${prefix}:${s}:snap:${r}`;
-	const snapHistoryKey = (s, r) => `${prefix}:${s}:snap-history:${r}`;
-	const snapshotEventPinsKey = (s, index) => `${prefix}:${s}:snapshot-pins:${index}`;
-	const snapshotEventPinsPrefix = (s) => `${prefix}:${s}:snapshot-pins:`;
-	const snapshotPinCountsKey = (s) => `${prefix}:${s}:snapshot-pin-counts`;
-	const presenceKey = (s) => `${prefix}:${s}:presence`;
-	const clearKey = (s) => `${prefix}:${s}:clear`;
-	const idKey = (id) => `${prefix}:ids:${JSON.stringify(id).replaceAll(":", "\\u003a")}`;
-	const evalScript = (script, keys, args) => call("EVAL", script, keys.length, ...keys, ...args);
-	const readRangeBounds = async (sessionId) => {
-		const [count, split, cleared] = await call("MGET", countKey(sessionId), metaSplitKey(sessionId), clearKey(sessionId));
-		const frontier = toIndex({
-			raw: count,
-			sessionId,
-			name: "event count"
-		});
-		return {
-			frontier,
-			metaSplit: split === null ? frontier : toIndex({
-				raw: split,
-				sessionId,
-				name: "metadata split"
-			}),
-			clearIndex: toIndex({
-				raw: cleared,
-				sessionId,
-				name: "clear boundary"
-			})
-		};
-	};
-	const readRangePage = async ({ sessionId, afterIndex, throughIndex, metaSplit }) => {
-		if (throughIndex <= afterIndex) return [];
-		const entries = await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, `${throughIndex}-0`, "COUNT", 256);
-		if (entries.length === 0) return [];
-		const fieldsByKey = /* @__PURE__ */ new Map();
-		for (const entry of entries) {
-			const index = entryIndex(entry[0]);
-			const key = index <= metaSplit ? metaKey(sessionId) : metaChunkKey(sessionId, index);
-			const fields = fieldsByKey.get(key) ?? [];
-			fields.push(...STORED_EVENT_META_SUFFIXES.map((suffix) => `${index}:${suffix}`));
-			fieldsByKey.set(key, fields);
-		}
-		const lookups = [...fieldsByKey];
-		const results = await Promise.allSettled(lookups.map(([key, fields]) => call("HMGET", key, ...fields)));
-		const meta = {};
-		for (let position = 0; position < lookups.length; position += 1) {
-			const result = results[position];
-			if (result.status === "rejected") throw result.reason;
-			const fields = lookups[position][1];
-			const values = result.value ?? [];
-			for (let i = 0; i < fields.length; i += 1) {
-				const value = values[i];
-				if (value !== null && value !== void 0) meta[fields[i]] = value;
-			}
-		}
-		return entries.map((entry) => {
-			const idx = entryIndex(entry[0]);
-			return toStoredEvent(sessionId, entry, (suffix) => meta[`${idx}:${suffix}`]);
-		});
-	};
-	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, metaSplit, clearIndex } = await readRangeBounds(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 page = await readRangePage({
-				sessionId,
-				afterIndex: nextIndex - 1,
-				throughIndex: frontier,
-				metaSplit
-			});
-			if (page.length === 0) throw rangeGap(sessionId, `ended before index ${frontier}`);
-			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,
-					lane: e.lane ?? null,
-					settled: e.settled === true
-				}));
-				const args = [
-					sessionId,
-					now,
-					withIds.length,
-					...withIds.flatMap((e) => [
-						e.id,
-						e.type,
-						json(e.payload),
-						e.cause ? json(e.cause) : "",
-						e.lane ?? "",
-						e.settled ? "1" : "0"
-					]),
-					`${prefix}:${sessionId}:notify`,
-					appendOptions?.originIndex ?? ""
-				];
-				const reply = await evalScript(APPEND_LUA, [
-					storeKey(sessionId),
-					countKey(sessionId),
-					metaKey(sessionId),
-					pendingKey(sessionId),
-					readyKey(sessionId),
-					metaSplitKey(sessionId),
-					...withIds.map((e) => idKey(e.id))
-				], args);
-				const [verdict] = reply;
-				if (verdict === "empty") return {
-					events: [],
-					hasPending: reply[1] === "1"
-				};
-				if (verdict === "foreign") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${reply[1]}' already exists in another session`);
-				if (verdict === "no_parent") throw new TypeError(`no event at index ${reply[1]} in session '${sessionId}'`);
-				if (verdict === "cleared") throw sessionClearedError(`scheduled work from event ${reply[1]} was cleared in session '${sessionId}'`);
-				if (verdict === "superseded") throw new A2Error("SUPERSEDED_ATTEMPT", `a newer attempt owns event ${reply[1]} in session '${sessionId}'`);
-				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,
-						lane: e.lane,
-						processedAt: e.settled ? new Date(now) : null,
-						processedByAttempt: null,
-						returnedEventIds: null,
-						firstClaimedAt: null,
-						lastClaimedAt: null,
-						attemptCount: 0,
-						claimHolder: null,
-						claimExpiresAt: null,
-						failureCount: 0,
-						lastFailedAt: null,
-						lastFailedAttempt: null,
-						lastError: null,
-						failedAt: null
-					})),
-					hasPending: reply[2] === "1"
-				};
-			});
-		},
-		async 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 [count, cleared] = await call("MGET", countKey(sessionId), clearKey(sessionId));
-				const frontier = toIndex({
-					raw: count,
-					sessionId,
-					name: "event count"
-				});
-				const clearIndex = toIndex({
-					raw: cleared,
-					sessionId,
-					name: "clear boundary"
-				});
-				return readEventRange(sessionId, Math.max(after, clearIndex - 1), Math.min(opts?.throughIndex ?? frontier, frontier));
-			}));
-		},
-		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes, maxFailures }) {
-			return wrap(async () => {
-				const now = clock.now().getTime();
-				const expiresAt = expiresAtMs ?? now + ttlMs;
-				const excluded = excludeIndexes ?? [];
-				const reply = await evalScript(CLAIM_AVAILABLE_LUA, [
-					storeKey(sessionId),
-					countKey(sessionId),
-					metaKey(sessionId),
-					pendingKey(sessionId),
-					readyKey(sessionId),
-					metaSplitKey(sessionId),
-					snapshotPinCountsKey(sessionId)
-				], [
-					holder,
-					now,
-					expiresAt,
-					excluded.length,
-					...excluded,
-					maxFailures ?? "",
-					snapshotEventPinsPrefix(sessionId)
-				]);
-				return toClaimAvailableResult(sessionId, reply);
-			});
-		},
-		async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
-			return wrap(async () => {
-				const now = clock.now().getTime();
-				const expiresAt = expiresAtMs ?? now + ttlMs;
-				const reply = await evalScript(RENEW_CLAIMS_LUA, [
-					countKey(sessionId),
-					metaKey(sessionId),
-					metaSplitKey(sessionId)
-				], [
-					holder,
-					now,
-					expiresAt,
-					claims.length,
-					...claims.flatMap((claim) => [claim.index, claim.attempt])
-				]);
-				const renewedCount = Number(reply[0]);
-				const values = reply.slice(1).map(Number);
-				return {
-					renewed: values.slice(0, renewedCount).toSorted((a, b) => a - b),
-					superseded: values.slice(renewedCount).toSorted((a, b) => a - b)
-				};
-			});
-		},
-		async completeAttempt({ sessionId, index, attempt, events }) {
-			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 reply = await evalScript(COMPLETE_ATTEMPT_LUA, [
-					storeKey(sessionId),
-					countKey(sessionId),
-					metaKey(sessionId),
-					pendingKey(sessionId),
-					readyKey(sessionId),
-					snapshotEventPinsKey(sessionId, index),
-					snapshotPinCountsKey(sessionId),
-					metaSplitKey(sessionId),
-					...ids.map((id) => idKey(id))
-				], [
-					sessionId,
-					now,
-					index,
-					attempt,
-					events.length,
-					...events.flatMap((event) => [
-						event.id,
-						event.type,
-						json(event.payload),
-						event.lane ?? "",
-						event.settled === true ? "1" : "0"
-					]),
-					`${prefix}:${sessionId}:notify`
-				]);
-				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 };
-				const cause = {
-					index,
-					attempt
-				};
-				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,
-							lane: event.lane ?? null,
-							processedAt: event.settled === true ? new Date(now) : null,
-							processedByAttempt: null,
-							returnedEventIds: null,
-							firstClaimedAt: null,
-							lastClaimedAt: null,
-							attemptCount: 0,
-							claimHolder: null,
-							claimExpiresAt: null,
-							failureCount: 0,
-							lastFailedAt: null,
-							lastFailedAttempt: null,
-							lastError: null,
-							failedAt: null
-						}))
-					};
-				}
-				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" };
-					return {
-						outcome: "completed",
-						events: idempotentReplay(events, existing)
-					};
-				}
-				throw new TypeError(`unexpected completion outcome '${outcome}'`);
-			});
-		},
-		async failAttempt({ sessionId, index, attempt, error, maxFailures, retryAfterMs }) {
-			return wrap(async () => {
-				const now = clock.now().getTime();
-				const reply = await evalScript(FAIL_ATTEMPT_LUA, [
-					countKey(sessionId),
-					metaKey(sessionId),
-					pendingKey(sessionId),
-					readyKey(sessionId),
-					snapshotEventPinsKey(sessionId, index),
-					snapshotPinCountsKey(sessionId),
-					metaSplitKey(sessionId)
-				], [
-					index,
-					attempt,
-					error,
-					maxFailures,
-					now,
-					retryAfterMs === void 0 ? "" : now + retryAfterMs
-				]);
-				const outcome = reply[0];
-				if (outcome === "cleared") return {
-					outcome: "superseded",
-					failureCount: 0
-				};
-				if (outcome === "missing") throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
-				return {
-					outcome,
-					failureCount: Number(reply[1])
-				};
-			});
-		},
-		async deadLetters(sessionId) {
-			return wrap(async () => {
-				const reply = await evalScript(DEAD_LETTERS_LUA, [
-					storeKey(sessionId),
-					countKey(sessionId),
-					metaKey(sessionId),
-					pendingKey(sessionId),
-					metaSplitKey(sessionId)
-				], []);
-				const events = [];
-				for (let i = 0; i + 1 < reply.length; i += 2) {
-					const columns = reply[i + 1];
-					events.push(toStoredEvent(sessionId, reply[i], (suffix) => columns[STORED_EVENT_META_SUFFIXES.indexOf(suffix)] ?? void 0));
-				}
-				return events;
-			});
-		},
-		async redrive({ sessionId, index, action }) {
-			return wrap(async () => {
-				const [redriven, hasPending] = await evalScript(REDRIVE_LUA, [
-					countKey(sessionId),
-					metaKey(sessionId),
-					pendingKey(sessionId),
-					readyKey(sessionId),
-					metaSplitKey(sessionId)
-				], [
-					index,
-					action,
-					clock.now().getTime()
-				]);
-				return {
-					redriven: redriven === "1",
-					hasPending: hasPending === "1"
-				};
-			});
-		},
-		async readState(sessionId, reducerName, stateOptions) {
-			return wrap(() => retryAfterGap(async () => {
-				const reply = await evalScript(READ_STATE_LUA, [
-					snapKey(sessionId, reducerName),
-					snapHistoryKey(sessionId, reducerName),
-					countKey(sessionId)
-				], [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);
-				if (existing) {
-					existing.state = write.state;
-					for (const eventIndex of write.pinEventIndexes ?? []) existing.pinEventIndexes.add(eventIndex);
-				} else byIndex.set(write.index, {
-					index: write.index,
-					state: write.state,
-					pinEventIndexes: new Set(write.pinEventIndexes ?? [])
-				});
-			}
-			const normalized = [...byIndex.values()].toSorted((a, b) => a.index - b.index);
-			if (normalized.length === 0) return;
-			await wrap(async () => {
-				const args = [
-					clock.now().getTime(),
-					snapshotEventPinsPrefix(sessionId),
-					normalized.length
-				];
-				for (const write of normalized) args.push(write.index, json({
-					index: write.index,
-					state: write.state,
-					updatedAt: clock.now().getTime(),
-					r: 1
-				}), write.pinEventIndexes.size, ...write.pinEventIndexes);
-				await evalScript(PUT_SNAPSHOTS_LUA, [
-					snapKey(sessionId, reducerName),
-					snapHistoryKey(sessionId, reducerName),
-					countKey(sessionId),
-					metaKey(sessionId),
-					snapshotPinCountsKey(sessionId),
-					metaSplitKey(sessionId)
-				], [...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 evalScript(PRESENCE_SET_LUA, [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 evalScript(PRESENCE_READ_LUA, [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, [
-					storeKey(sessionId),
-					countKey(sessionId),
-					metaKey(sessionId),
-					metaSplitKey(sessionId),
-					idKey(markerId),
-					pendingKey(sessionId),
-					readyKey(sessionId)
-				], [
-					sessionId,
-					clock.now().getTime(),
-					ifLastIndex ?? "",
-					cause?.index ?? "",
-					cause?.attempt ?? "",
-					markerId,
-					`${prefix}:${sessionId}:notify`
-				]);
-				if (reply[0] === "superseded") throw supersededAttemptError(sessionId, cause);
-				if (reply[0] === "no_parent") throw new TypeError(`no event at index ${reply[1]} in session '${sessionId}'`);
-				if (reply[0] === "foreign") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `the clear marker id '${markerId}' already exists`);
-				return {
-					cleared: reply[1] === "1",
-					index: Number(reply[2]),
-					clearIndex: Number(reply[3])
-				};
-			});
-		},
-		async reclaim(sessionId) {
-			return wrap(async () => {
-				const [log, ...pairs] = await evalScript(RECLAIM_BATCH_LUA, [countKey(sessionId)], [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, [
-					log,
-					countKey(sessionId),
-					metaKey(sessionId),
-					metaSplitKey(sessionId),
-					...ids.map((id) => idKey(id))
-				], [
-					sessionId,
-					snapshotEventPinsPrefix(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,
-		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,
-		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-CM0AfLY0.js.map