experimental-a2 0.16.1 → 0.18.0

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

@@ -1,1583 +0,0 @@
-import { t as A2Error } from "./errors-DCk6ch5n.js";
-import { h as nullProtoRecord, r as NOTIFY_TIMINGS } from "./internal-Dq2qYxou.js";
-import { i as streamActivities, n as pollingStream, r as createStreamActivity, t as defaultSleep } from "./store-polling-CmxUbV93.js";
-import { t as idempotentReplay } from "./idempotent-replay-DVOlyYbx.js";
-import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
-import { t as pollPresence } from "./store-presence-polling-C7-XZyW9.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
-				});
-			}
-		}
-	};
-}
-//#endregion
-//#region src/store-redis-core.ts
-const READ_PAGE_SIZE = 256;
-const READ_CONCURRENCY = 16;
-/**
-* KEYS: store stream, counter, global id hash, metadata, pending, ready,
-* watched.
-* ARGV: sessionId, nowMs, n, then per event:
-* id, type, payloadJson, causeJson, lane, settled; finally notify channel.
-* Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
-* ['dup', hasPending, ...indexes] | ['partial', count] |
-* ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx].
-*/
-const APPEND_LUA = `
-local function lane_field(lane, suffix)
-  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
-end
-local function enqueue(field, idx, lane)
-  redis.call('ZADD', KEYS[5], idx, field)
-  if lane == '' then
-    redis.call('ZADD', KEYS[6], idx, field)
-    return
-  end
-  local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[4], tail_key)
-  if tail then
-    redis.call('HSET', KEYS[4], tail .. ':next', field)
-  else
-    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[6], idx, field)
-  end
-  redis.call('HSET', KEYS[4], tail_key, field)
-end
-local n = tonumber(ARGV[3])
-local base = tonumber(redis.call('GET', KEYS[2]) or '0')
-local has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
-if n == 0 then return { 'empty', has_pending } end
-local dups = {}
-for i = 1, n do
-  local id = ARGV[3 + (i - 1) * 6 + 1]
-  local existing = redis.call('HGET', KEYS[3], id)
-  if existing then
-    local rec = cjson.decode(existing)
-    if rec[1] ~= ARGV[1] then return { 'foreign', id } 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
-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)
-    if pidx < 1 or pidx > base then
-      return { 'no_parent', tostring(parsed.index) }
-    end
-    local field = tostring(pidx)
-    local dispatches = tonumber(redis.call('HGET', KEYS[4], field .. ':d') or '0')
-    if dispatches ~= tonumber(parsed.attempt) or
-       redis.call('HEXISTS', KEYS[4], field .. ':f') == 1 then
-      return { 'superseded', field }
-    end
-  end
-end
-for i = 1, n do
-  local id = ARGV[3 + (i - 1) * 6 + 1]
-  local typ = ARGV[3 + (i - 1) * 6 + 2]
-  local payload = ARGV[3 + (i - 1) * 6 + 3]
-  local cause = ARGV[3 + (i - 1) * 6 + 4]
-  local lane = ARGV[3 + (i - 1) * 6 + 5]
-  local settled = ARGV[3 + (i - 1) * 6 + 6]
-  local idx = base + i
-  redis.call('XADD', KEYS[1], tostring(idx) .. '-0',
-    'id', id, 'type', typ, 'payload', payload, 'created_at', ARGV[2],
-    'cause', cause, 'lane', lane)
-  redis.call('HSET', KEYS[3], id, cjson.encode({ ARGV[1], idx }))
-  redis.call('HSET', KEYS[4], tostring(idx) .. ':l', lane)
-  if settled == '1' then
-    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
-  else
-    enqueue(tostring(idx), idx, lane)
-  end
-end
-redis.call('SET', KEYS[2], tostring(base + n))
-has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
-if redis.call('EXISTS', KEYS[7]) == 1 then
-  redis.pcall('PUBLISH', ARGV[4 + n * 6], tostring(base + n))
-end
-return { 'ok', tostring(base + 1), has_pending }
-`;
-/**
-* KEYS: counter, meta, pending, ready, event snapshot pins, snapshot pin counts.
-* ARGV: idx, attempt, error, maxFailures, nowMs.
-*/
-const FAIL_ATTEMPT_LUA = `
-local function release_snapshot_pins()
-  local refs = redis.call('SMEMBERS', KEYS[5])
-  for _, ref in ipairs(refs) do
-    local count = redis.call('HINCRBY', KEYS[6], ref, -1)
-    if count <= 0 then
-      redis.call('HDEL', KEYS[6], ref)
-      local checkpoint = cjson.decode(ref)
-      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
-    end
-  end
-  redis.call('DEL', KEYS[5])
-  if redis.call('HLEN', KEYS[6]) == 0 then redis.call('DEL', KEYS[6]) end
-end
-local function lane_field(lane, suffix)
-  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
-end
-local function settle(field)
-  redis.call('ZREM', KEYS[3], field)
-  redis.call('ZREM', KEYS[4], field)
-  local lane = redis.call('HGET', KEYS[2], field .. ':l') or ''
-  if lane == '' then return end
-  local head_key = lane_field(lane, 'head')
-  if redis.call('HGET', KEYS[2], head_key) ~= field then return end
-  local next_field = redis.call('HGET', KEYS[2], field .. ':next')
-  while next_field and redis.call('HEXISTS', KEYS[2], next_field .. ':p') == 1 do
-    next_field = redis.call('HGET', KEYS[2], next_field .. ':next')
-  end
-  if next_field then
-    redis.call('HSET', KEYS[2], head_key, next_field)
-    if redis.call('HEXISTS', KEYS[2], next_field .. ':f') == 0 then
-      redis.call('ZADD', KEYS[4], tonumber(next_field), next_field)
-    end
-  else
-    redis.call('HDEL', KEYS[2], head_key, lane_field(lane, 'tail'))
-  end
-end
-local idx = tonumber(ARGV[1])
-if idx < 1 or idx > tonumber(redis.call('GET', KEYS[1]) or '0') then
-  return { 'missing', '0' }
-end
-local field = ARGV[1]
-local failures = tonumber(redis.call('HGET', KEYS[2], field .. ':a') or '0')
-local dispatches = tonumber(redis.call('HGET', KEYS[2], field .. ':d') or '0')
-if redis.call('HEXISTS', KEYS[2], field .. ':p') == 1 or dispatches ~= tonumber(ARGV[2]) then
-  return { 'superseded', tostring(failures) }
-end
-if redis.call('HEXISTS', KEYS[2], field .. ':f') == 1 then
-  return { 'dead_lettered', tostring(failures) }
-end
-if redis.call('HEXISTS', KEYS[2], field .. ':lfa') == 1 and
-   tonumber(redis.call('HGET', KEYS[2], field .. ':lfa')) == tonumber(ARGV[2]) and
-   redis.call('HEXISTS', KEYS[2], field .. ':ch') == 0 then
-  return { 'failed', tostring(failures) }
-end
-if redis.call('HEXISTS', KEYS[2], field .. ':ch') == 0 then
-  return { 'superseded', tostring(failures) }
-end
-failures = redis.call('HINCRBY', KEYS[2], field .. ':a', 1)
-redis.call('HSET', KEYS[2],
-  field .. ':e', ARGV[3],
-  field .. ':lf', ARGV[5],
-  field .. ':lfa', ARGV[2])
-redis.call('HDEL', KEYS[2], field .. ':ch', field .. ':ce')
-if failures >= tonumber(ARGV[4]) then
-  redis.call('HSET', KEYS[2], field .. ':f', ARGV[5])
-  redis.call('ZREM', KEYS[4], field)
-  release_snapshot_pins()
-  return { 'dead_lettered', tostring(failures) }
-end
-return { 'failed', tostring(failures) }
-`;
-/**
-* KEYS: store, counter, meta, pending, ready.
-* ARGV: holder, nowMs, expiresAtMs, excludedCount, excluded indexes.
-*/
-const CLAIM_AVAILABLE_LUA = `
-if redis.call('ZCARD', KEYS[4]) == 0 then return { 'settled' } end
-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 claimed = {}
-local retry_at = nil
-for _, field in ipairs(ready) do
-  if not excluded[field] then
-    local expires = tonumber(redis.call('HGET', KEYS[3], field .. ':ce') 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 = redis.call('HINCRBY', KEYS[3], field .. ':d', 1)
-      redis.call('HSETNX', KEYS[3], field .. ':fc', ARGV[2])
-      redis.call('HSET', KEYS[3],
-        field .. ':lc', ARGV[2],
-        field .. ':ch', ARGV[1],
-        field .. ':ce', ARGV[3])
-      claimed[#claimed + 1] = {
-        tostring(attempt),
-        redis.call('HGET', KEYS[3], field .. ':a') or '0',
-        redis.call('HGET', KEYS[3], field .. ':e') or false,
-        redis.call('HGET', KEYS[3], field .. ':fc') or false,
-        ARGV[2],
-        redis.call('HGET', KEYS[3], field .. ':lf') or false,
-        redis.call('HGET', KEYS[3], field .. ':lfa') or false,
-        ARGV[1],
-        ARGV[3],
-        entries[1]
-      }
-    end
-  end
-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
-  return result
-end
-if retry_at then return { 'busy', tostring(retry_at) } end
-return { 'settled' }
-`;
-/**
-* KEYS: counter, meta.
-* ARGV: holder, nowMs, expiresAtMs, n, then per claim: index, attempt.
-* Returns [renewedCount, ...renewed, ...superseded].
-*/
-const RENEW_CLAIMS_LUA = `
-local total = tonumber(redis.call('GET', KEYS[1]) or '0')
-local renewed = {}
-local superseded = {}
-for i = 1, tonumber(ARGV[4]) do
-  local field = ARGV[4 + (i - 1) * 2 + 1]
-  local attempt = tonumber(ARGV[4 + (i - 1) * 2 + 2])
-  local idx = tonumber(field)
-  if idx >= 1 and idx <= total then
-    local dispatches = tonumber(redis.call('HGET', KEYS[2], field .. ':d') or '0')
-    if dispatches > attempt then
-      superseded[#superseded + 1] = field
-    else
-      local expires = tonumber(redis.call('HGET', KEYS[2], field .. ':ce') or '0')
-      if tonumber(ARGV[3]) > tonumber(ARGV[2]) and
-         redis.call('HEXISTS', KEYS[2], field .. ':p') == 0 and
-         redis.call('HEXISTS', KEYS[2], field .. ':f') == 0 and
-         redis.call('HGET', KEYS[2], field .. ':ch') == ARGV[1] and
-         expires > tonumber(ARGV[2]) then
-        redis.call('HSET', KEYS[2], field .. ':ce', ARGV[3])
-        renewed[#renewed + 1] = field
-      end
-    end
-  end
-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, ids, meta, pending, ready, watched,
-* event snapshot pins, snapshot pin counts.
-* ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
-* id, type, payloadJson, lane, settled; finally notify channel.
-*/
-const COMPLETE_ATTEMPT_LUA = `
-local function release_snapshot_pins()
-  local refs = redis.call('SMEMBERS', KEYS[8])
-  for _, ref in ipairs(refs) do
-    local count = redis.call('HINCRBY', KEYS[9], ref, -1)
-    if count <= 0 then
-      redis.call('HDEL', KEYS[9], ref)
-      local checkpoint = cjson.decode(ref)
-      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
-    end
-  end
-  redis.call('DEL', KEYS[8])
-  if redis.call('HLEN', KEYS[9]) == 0 then redis.call('DEL', KEYS[9]) end
-end
-local function lane_field(lane, suffix)
-  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
-end
-local function settle(field)
-  redis.call('ZREM', KEYS[5], field)
-  redis.call('ZREM', KEYS[6], field)
-  local lane = redis.call('HGET', KEYS[4], field .. ':l') or ''
-  if lane == '' then return end
-  local head_key = lane_field(lane, 'head')
-  if redis.call('HGET', KEYS[4], head_key) ~= field then return end
-  local next_field = redis.call('HGET', KEYS[4], field .. ':next')
-  while next_field and redis.call('HEXISTS', KEYS[4], next_field .. ':p') == 1 do
-    next_field = redis.call('HGET', KEYS[4], next_field .. ':next')
-  end
-  if next_field then
-    redis.call('HSET', KEYS[4], head_key, next_field)
-    if redis.call('HEXISTS', KEYS[4], next_field .. ':f') == 0 then
-      redis.call('ZADD', KEYS[6], tonumber(next_field), next_field)
-    end
-  else
-    redis.call('HDEL', KEYS[4], head_key, lane_field(lane, 'tail'))
-  end
-end
-local function enqueue(field, idx, lane)
-  redis.call('ZADD', KEYS[5], idx, field)
-  if lane == '' then
-    redis.call('ZADD', KEYS[6], idx, field)
-    return
-  end
-  local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[4], tail_key)
-  if tail then
-    redis.call('HSET', KEYS[4], tail .. ':next', field)
-  else
-    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[6], idx, field)
-  end
-  redis.call('HSET', KEYS[4], tail_key, field)
-end
-local parent = ARGV[3]
-local attempt = tonumber(ARGV[4])
-local n = tonumber(ARGV[5])
-local total = tonumber(redis.call('GET', KEYS[2]) or '0')
-if tonumber(parent) < 1 or tonumber(parent) > total then return { 'missing' } end
-local dispatches = tonumber(redis.call('HGET', KEYS[4], parent .. ':d') or '0')
-local processed = redis.call('HGET', KEYS[4], parent .. ':p')
-local processed_attempt = tonumber(redis.call('HGET', KEYS[4], parent .. ':pa') or '0')
-if processed then
-  if processed_attempt ~= attempt then return { 'superseded' } end
-  local raw_recorded_ids = redis.call('HGET', KEYS[4], parent .. ':ri')
-  if not raw_recorded_ids then return { 'partial' } end
-  local recorded_ids = cjson.decode(raw_recorded_ids)
-  if #recorded_ids ~= n then return { 'partial' } end
-  local indexes = {}
-  for i = 1, n do
-    local id = ARGV[5 + (i - 1) * 5 + 1]
-    if recorded_ids[i] ~= id then return { 'partial' } end
-    local existing = redis.call('HGET', KEYS[3], id)
-    if not existing then return { 'partial' } end
-    local rec = cjson.decode(existing)
-    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 dispatches ~= attempt then return { 'superseded' } end
-if redis.call('HEXISTS', KEYS[4], parent .. ':ch') == 0 or
-   redis.call('HEXISTS', KEYS[4], parent .. ':f') == 1 or
-   tonumber(redis.call('HGET', KEYS[4], parent .. ':lfa') or '0') == attempt then
-  return { 'superseded' }
-end
-for i = 1, n do
-  local id = ARGV[5 + (i - 1) * 5 + 1]
-  if redis.call('HEXISTS', KEYS[3], id) == 1 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
-redis.call('HSET', KEYS[4],
-  parent .. ':p', ARGV[2],
-  parent .. ':pa', ARGV[4],
-  parent .. ':ri', returned_json)
-redis.call('HDEL', KEYS[4], parent .. ':ch', parent .. ':ce')
-settle(parent)
-release_snapshot_pins()
-local cause = cjson.encode({ index = tonumber(parent), attempt = attempt })
-for i = 1, n do
-  local id = ARGV[5 + (i - 1) * 5 + 1]
-  local typ = ARGV[5 + (i - 1) * 5 + 2]
-  local payload = ARGV[5 + (i - 1) * 5 + 3]
-  local lane = ARGV[5 + (i - 1) * 5 + 4]
-  local settled = ARGV[5 + (i - 1) * 5 + 5]
-  local idx = total + i
-  redis.call('XADD', KEYS[1], tostring(idx) .. '-0',
-    'id', id, 'type', typ, 'payload', payload, 'created_at', ARGV[2],
-    'cause', cause, 'lane', lane)
-  redis.call('HSET', KEYS[3], id, cjson.encode({ ARGV[1], idx }))
-  redis.call('HSET', KEYS[4], tostring(idx) .. ':l', lane)
-  if settled == '1' then
-    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
-  else
-    enqueue(tostring(idx), idx, lane)
-  end
-end
-redis.call('SET', KEYS[2], tostring(total + n))
-if n > 0 and redis.call('EXISTS', KEYS[7]) == 1 then
-  redis.pcall('PUBLISH', ARGV[6 + n * 5], tostring(total + n))
-end
-return { 'ok', tostring(total + 1) }
-`;
-/**
-* KEYS: head, history, event counter, event meta, pin counts.
-* ARGV: nowMs, event pin key prefix, write count, then per write:
-* index, snapshot JSON, pin count, pin event indexes.
-*/
-const PUT_SNAPSHOTS_LUA = `
-local total = tonumber(redis.call('GET', KEYS[3]) or '0')
-local writes = {}
-local 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])
-    if event_index >= 1 and event_index <= total and
-       redis.call('HEXISTS', KEYS[4], tostring(event_index) .. ':p') == 0 and
-       redis.call('HEXISTS', KEYS[4], tostring(event_index) .. ':f') == 0 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
-  writes[#writes + 1] = { index = index, snapshot = snapshot, ref = ref }
-  offset = offset + 3 + pin_count
-end
-
-local head = redis.call('GET', KEYS[1])
-local head_index = nil
-if head then head_index = tonumber(cjson.decode(head)['index']) end
-local latest = writes[#writes]
-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(writes) 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.
-*/
-const READ_STATE_LUA = `
-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
-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, '-inf', 'LIMIT', 0, 1)
-  if #historical > 0 then snapshot = historical[1] end
-end
-local frontier = redis.call('GET', KEYS[3]) or '0'
-return { head_index or '', snapshot or '', frontier }
-`;
-const fieldMap = (fields) => {
-	const map = {};
-	for (let i = 0; i + 1 < fields.length; i += 2) map[fields[i]] = fields[i + 1];
-	return map;
-};
-const STORED_EVENT_META_SUFFIXES = [
-	"p",
-	"pa",
-	"ri",
-	"ch",
-	"ce",
-	"f",
-	"fc",
-	"lc",
-	"lf",
-	"lfa",
-	"d",
-	"a",
-	"e"
-];
-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 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) }
-	};
-};
-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
-			}));
-		}
-		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 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, 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 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 watchedKey = (s) => `${prefix}:${s}:watched`;
-	const presenceKey = (s) => `${prefix}:${s}:presence`;
-	const idsKey = `${prefix}:ids`;
-	const evalScript = (script, keys, args) => call("EVAL", script, keys.length, ...keys, ...args);
-	const readFrontier = async (sessionId) => {
-		const frontier = Number(await call("GET", countKey(sessionId)) ?? 0);
-		if (!Number.isSafeInteger(frontier) || frontier < 0) throw new A2Error("STORE_UNAVAILABLE", `redis event count for session '${sessionId}' is invalid`);
-		return frontier;
-	};
-	const readRangePage = async (sessionId, afterIndex, throughIndex, limit) => {
-		if (throughIndex <= afterIndex) return [];
-		const entries = await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, `${throughIndex}-0`, "COUNT", limit);
-		if (entries.length === 0) return [];
-		const metaFields = entries.flatMap((entry) => {
-			const index = entryIndex(entry[0]);
-			return STORED_EVENT_META_SUFFIXES.map((suffix) => `${index}:${suffix}`);
-		});
-		const metaValues = await call("HMGET", metaKey(sessionId), ...metaFields) ?? [];
-		const meta = {};
-		for (let i = 0; i < metaFields.length; i += 1) {
-			const value = metaValues[i];
-			if (value !== null && value !== void 0) meta[metaFields[i]] = value;
-		}
-		return entries.map((entry) => {
-			const event = toEvent(sessionId, entry);
-			const idx = event.index;
-			const fields = fieldMap(entry[1]);
-			const processedAt = meta[`${idx}:p`];
-			const processedByAttempt = meta[`${idx}:pa`];
-			const returnedEventIds = meta[`${idx}:ri`];
-			const claimHolder = meta[`${idx}:ch`];
-			const claimExpiresAt = meta[`${idx}:ce`];
-			const failedAt = meta[`${idx}:f`];
-			const firstClaimedAt = meta[`${idx}:fc`];
-			const lastClaimedAt = meta[`${idx}:lc`];
-			const lastFailedAt = meta[`${idx}:lf`];
-			const lastFailedAttempt = meta[`${idx}:lfa`];
-			return Object.assign(event, {
-				cause: toCause(fields["cause"]),
-				lane: fields["lane"] === "" ? null : fields["lane"],
-				processedAt: processedAt === void 0 ? null : new Date(Number(processedAt)),
-				processedByAttempt: processedByAttempt === void 0 ? null : Number(processedByAttempt),
-				returnedEventIds: returnedEventIds === void 0 ? null : decodeReturnedEventIds(returnedEventIds),
-				firstClaimedAt: firstClaimedAt === void 0 ? null : new Date(Number(firstClaimedAt)),
-				lastClaimedAt: lastClaimedAt === void 0 ? null : new Date(Number(lastClaimedAt)),
-				attemptCount: Number(meta[`${idx}:d`] ?? 0),
-				claimHolder: claimHolder ?? null,
-				claimExpiresAt: claimExpiresAt === void 0 ? null : new Date(Number(claimExpiresAt)),
-				failureCount: Number(meta[`${idx}:a`] ?? 0),
-				lastFailedAt: lastFailedAt === void 0 ? null : new Date(Number(lastFailedAt)),
-				lastFailedAttempt: lastFailedAttempt === void 0 ? null : Number(lastFailedAttempt),
-				lastError: meta[`${idx}:e`] ?? null,
-				failedAt: failedAt === void 0 ? null : new Date(Number(failedAt))
-			});
-		});
-	};
-	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", READ_PAGE_SIZE);
-			if (entries.length === 0) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${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 new A2Error("STORE_UNAVAILABLE", `redis event range for session '${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 += READ_PAGE_SIZE * READ_CONCURRENCY) {
-			const ranges = Array.from({ length: Math.min(READ_CONCURRENCY, Math.ceil((throughIndex - start) / READ_PAGE_SIZE)) }, (_, position) => {
-				const after = start + position * READ_PAGE_SIZE;
-				return readEventPages(sessionId, after, Math.min(after + READ_PAGE_SIZE, 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) => {
-		if (throughIndex !== void 0 && throughIndex <= afterIndex) return [];
-		const currentFrontier = await readFrontier(sessionId);
-		const frontier = Math.min(throughIndex ?? currentFrontier, currentFrontier);
-		if (frontier <= afterIndex) return [];
-		const rows = [];
-		let nextIndex = afterIndex + 1;
-		while (nextIndex <= frontier) {
-			const page = await readRangePage(sessionId, nextIndex - 1, frontier, READ_PAGE_SIZE);
-			if (page.length === 0) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' ended before index ${frontier}`);
-			for (let position = 0; position < page.length; position += 1) if (page[position].index !== nextIndex + position) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${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;
-	};
-	return {
-		async append(sessionId, events) {
-			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`
-				];
-				const reply = await evalScript(APPEND_LUA, [
-					storeKey(sessionId),
-					countKey(sessionId),
-					idsKey,
-					metaKey(sessionId),
-					pendingKey(sessionId),
-					readyKey(sessionId),
-					watchedKey(sessionId)
-				], 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 === "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 wanted = new Set(reply.slice(2).map(Number));
-					const min = Math.min(...wanted);
-					const existing = (await readRange(sessionId, min - 1)).filter((row) => wanted.has(row.index));
-					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(async () => {
-				return await readRange(sessionId, opts?.afterIndex ?? 0, opts?.throughIndex);
-			});
-		},
-		async readHistory(sessionId, opts) {
-			return wrap(async () => {
-				const after = opts?.afterIndex ?? 0;
-				if (opts?.throughIndex !== void 0 && opts.throughIndex <= after) return [];
-				const frontier = await readFrontier(sessionId);
-				return readEventRange(sessionId, after, 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)
-				], [
-					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)], [
-					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),
-					idsKey,
-					metaKey(sessionId),
-					pendingKey(sessionId),
-					readyKey(sessionId),
-					watchedKey(sessionId),
-					snapshotEventPinsKey(sessionId, index),
-					snapshotPinCountsKey(sessionId)
-				], [
-					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 wanted = new Set(reply.slice(1).map(Number));
-					const min = Math.min(...wanted);
-					const rows = await readRange(sessionId, min - 1);
-					const byIndex = new Map(rows.map((row) => [row.index, row]));
-					const existing = reply.slice(1).map((value) => byIndex.get(Number(value)));
-					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)
-				], [
-					index,
-					attempt,
-					error,
-					maxFailures,
-					clock.now().getTime()
-				]);
-				const outcome = reply[0];
-				if (outcome === "missing") throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
-				return {
-					outcome,
-					failureCount: Number(reply[1])
-				};
-			});
-		},
-		async readState(sessionId, reducerName, stateOptions) {
-			return wrap(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 events = await readEventRange(sessionId, snapshot?.index ?? 0, frontier);
-				return {
-					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()
-				}), write.pinEventIndexes.size, ...write.pinEventIndexes);
-				await evalScript(PUT_SNAPSHOTS_LUA, [
-					snapKey(sessionId, reducerName),
-					snapHistoryKey(sessionId, reducerName),
-					countKey(sessionId),
-					metaKey(sessionId),
-					snapshotPinCountsKey(sessionId)
-				], args);
-			});
-		},
-		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 readEvents(sessionId, afterIndex) {
-			return wrap(async () => {
-				return (await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, "+", "COUNT", READ_PAGE_SIZE)).map((entry) => toEvent(sessionId, entry));
-			});
-		},
-		async markWatched(sessionId, ttlMs) {
-			await wrap(() => call("SET", watchedKey(sessionId), "1", "PX", ttlMs));
-		}
-	};
-}
-//#endregion
-//#region src/store-redis-notify.ts
-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
-	});
-	let severed = false;
-	let subscriber = null;
-	/** channel → parked-feed wake-ups, armed before each catch-up read. */
-	const wakers = /* @__PURE__ */ new Map();
-	/** channel → refcounted subscription held for each live iterator. */
-	const subscriptions = /* @__PURE__ */ new Map();
-	/**
-	* channel → last presence-marker refresh, throttling the SET.
-	* Deliberately real time (`Date.now()`), not the injected clock:
-	* the marker's PX expiry runs on server real time, and the throttle
-	* must tick with the TTL it refreshes or time-traveling tests would
-	* desync the two. Process-local and never stored, so the injected
-	* clock's every-stored-timestamp pledge is untouched.
-	*/
-	const watched = /* @__PURE__ */ new Map();
-	const presenceSubscriptions = /* @__PURE__ */ new Map();
-	const pollingStreams = /* @__PURE__ */ new Set();
-	options.onReconnect?.((channel) => {
-		for (const wake of wakers.get(channel) ?? []) 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) => {
-				const set = wakers.get(channel);
-				if (set) for (const wake of set) 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);
-		watched.delete(channel);
-		gatedSubscriber().then((conn) => conn.call("unsubscribe", channel)).catch(() => {});
-	};
-	const armWaker = (channel) => {
-		let wake;
-		const wakeup = new Promise((resolve) => {
-			wake = resolve;
-		});
-		let set = wakers.get(channel);
-		if (!set) {
-			set = /* @__PURE__ */ new Set();
-			wakers.set(channel, set);
-		}
-		set.add(wake);
-		return {
-			wakeup,
-			wake,
-			disarm: () => {
-				set.delete(wake);
-				if (set.size === 0) wakers.delete(channel);
-			}
-		};
-	};
-	return {
-		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,
-		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 interrupt = null;
-				let poller;
-				let stopActivity;
-				const activity = createStreamActivity(() => {
-					if (poller) streamActivities.get(poller)?.activate();
-				});
-				const release = () => {
-					stopActivity?.();
-					if (poller) {
-						poller.return?.();
-						pollingStreams.delete(poller);
-					}
-					if (!subscribed) return;
-					subscribed = false;
-					releaseChannel(channel);
-				};
-				const iterator = {
-					async next() {
-						for (;;) {
-							if (closed) {
-								release();
-								return {
-									value: void 0,
-									done: true
-								};
-							}
-							const row = buffer.shift();
-							if (row) {
-								last = row.index;
-								return {
-									value: row,
-									done: false
-								};
-							}
-							if (severed) {
-								release();
-								throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
-							}
-							const waker = armWaker(channel);
-							interrupt = waker.wake;
-							try {
-								if (!subscribed) {
-									subscribed = true;
-									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;
-								}
-								let marker = watched.get(channel);
-								if (!marker || Date.now() - marker.at >= NOTIFY_TIMINGS.safetyReadMs) {
-									marker = {
-										at: Date.now(),
-										ready: core.markWatched(sessionId, NOTIFY_TIMINGS.safetyReadMs * 3)
-									};
-									watched.set(channel, marker);
-								}
-								await marker.ready;
-								if (closed || severed) continue;
-								buffer = await core.readEvents(sessionId, last);
-								if (buffer.length === 0 && !closed && !severed) {
-									pending = defaultSleep(NOTIFY_TIMINGS.safetyReadMs);
-									await Promise.race([waker.wakeup, pending.promise]);
-									pending.cancel();
-									pending = null;
-								}
-							} 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 {
-								waker.disarm();
-								interrupt = null;
-							}
-						}
-					},
-					async return() {
-						closed = true;
-						pending?.cancel();
-						interrupt?.();
-						release();
-						return {
-							value: void 0,
-							done: true
-						};
-					}
-				};
-				streamActivities.set(iterator, activity);
-				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();
-			for (const set of wakers.values()) for (const wake of set) wake();
-			if (subscriber) (await subscriber.catch(() => null))?.disconnect();
-			await options.closeClient();
-		}
-	};
-}
-//#endregion
-export { createRedisNotifyStore as t };
-
-//# sourceMappingURL=store-redis-notify-BVLUfI3j.js.map