experimental-a2 0.16.1 → 0.18.0

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

@@ -0,0 +1,2493 @@
+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-B2T3U4Rq.js";
+import { i as streamActivities, n as pollingStream, r as createStreamActivity, t as defaultSleep } from "./store-polling-B5FcwJfo.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-BAwS8RWn.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.
+*/
+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
+flush()
+redis.call('HDEL', meta_key, field .. ':ch', field .. ':ce')
+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.
+* ARGV: holder, nowMs, expiresAtMs, excludedCount, excluded indexes.
+* The ready set is a subset of the pending set, so an empty ready set is
+* enough to report 'settled'. A claimed result ends with the clear boundary.
+*/
+const CLAIM_AVAILABLE_LUA = `
+local COUNTER, META, SPLIT = KEYS[2], KEYS[3], KEYS[6]
+${META_LUA}
+local ready = redis.call('ZRANGE', KEYS[5], 0, -1)
+local excluded = {}
+for i = 1, tonumber(ARGV[4]) do excluded[ARGV[4 + i]] = true end
+local candidates = {}
+for _, field in ipairs(ready) do
+  if not excluded[field] then candidates[#candidates + 1] = field end
+end
+local rows = read_fields(candidates, { 'ce', 'd', 'fc', 'a', 'e', 'lf', 'lfa' })
+local claimed = {}
+local retry_at = nil
+for _, field in ipairs(candidates) do
+  local row = rows[field]
+  local expires = tonumber(row[1] or '0')
+  if expires > tonumber(ARGV[2]) then
+    if not retry_at or expires < retry_at then retry_at = expires end
+  else
+    local entries = redis.call('XRANGE', KEYS[1], field .. '-0', field .. '-0')
+    if #entries == 0 then return { 'missing', field } end
+    local attempt = tostring(tonumber(row[2] or '0') + 1)
+    local first_claimed = row[3] or ARGV[2]
+    local meta_key = mkey(field)
+    put(meta_key, field .. ':d', attempt)
+    put(meta_key, field .. ':fc', first_claimed)
+    put(meta_key, field .. ':lc', ARGV[2])
+    put(meta_key, field .. ':ch', ARGV[1])
+    put(meta_key, field .. ':ce', ARGV[3])
+    claimed[#claimed + 1] = {
+      attempt,
+      row[4] or '0',
+      row[5] or false,
+      first_claimed,
+      ARGV[2],
+      row[6] or false,
+      row[7] or false,
+      ARGV[1],
+      ARGV[3],
+      entries[1]
+    }
+  end
+end
+flush()
+if #claimed > 0 then
+  local result = { 'claimed', tostring(#claimed) }
+  for _, claim in ipairs(claimed) do
+    for _, value in ipairs(claim) do result[#result + 1] = value end
+  end
+  result[#result + 1] = tostring(boundary)
+  return result
+end
+if retry_at then return { 'busy', tostring(retry_at) } end
+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 * 10;
+			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: new Date(Number(reply[offset + 4])),
+				attemptCount: Number(reply[offset]),
+				claimHolder: String(reply[offset + 7]),
+				claimExpiresAt: 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: null
+			}));
+		}
+		const clearIndex = Number(reply[2 + count * 10] ?? 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 }) {
+			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)
+				], [
+					holder,
+					now,
+					expiresAt,
+					excluded.length,
+					...excluded
+				]);
+				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 }) {
+			return wrap(async () => {
+				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,
+					clock.now().getTime()
+				]);
+				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-BRITti_o.js.map