experimental-a2 0.21.1 → 0.22.0

package/dist/{store-redis-notify-IiVdlYHc.js → store-redis-notify-CsJw_hfD.js}

@@ -1,13 +1,15 @@
 import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-wHd5GCpZ.js";
-import { _ as nullProtoRecord, r as NOTIFY_TIMINGS, x as stateTailReaders } from "./internal-Bc4PvfHk.js";
-import { i as streamActivities, n as pollingStream, r as createStreamActivity, t as defaultSleep } from "./store-polling-DYNyxCev.js";
-import { n as isSerializedEvent, r as parseSerializedEvent, t as bufferedEvents } from "./stream-buffer-Cx7AAPGq.js";
+import { C as stateTailReaders, i as NOTIFY_TIMINGS, y as nullProtoRecord } from "./internal-CvsrprnU.js";
+import { a as presenceTombstones, n as isSerializedEvent, r as parseSerializedEvent, t as bufferedEvents } from "./stream-buffer-DrTyiIuo.js";
+import { i as streamActivities, n as pollingStream, r as createStreamActivity, t as defaultSleep } from "./store-polling-BZt2Rf3D.js";
+import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { a as idempotentReplay, n as decodeCause } from "./store-codec-DwrWlgQx.js";
-import { t as pollPresence } from "./store-presence-polling-CzQ0wdtM.js";
+import { t as pollPresence } from "./store-presence-polling-JuAy2Ck2.js";
 //#region src/presence-recovery.ts
 const key = ({ participant, field }) => JSON.stringify([participant, field]);
 function presenceRecovery({ read, deliver, isActive }) {
 	const fields = /* @__PURE__ */ new Map();
+	const deleted = presenceTombstones();
 	const reading = /* @__PURE__ */ new Set();
 	let generation = 0;
 	let latest;
@@ -33,11 +35,13 @@ function presenceRecovery({ read, deliver, isActive }) {
 			const rows = await read();
 			if (!isActive()) return rows;
 			if (run !== generation) return latest;
+			const current = rows.filter((row) => !deleted.outranks(row));
 			const live = /* @__PURE__ */ new Set();
-			for (const row of rows) {
+			for (const row of current) {
 				const id = key(row);
 				live.add(id);
 				if (changed.has(id)) continue;
+				deleted.drop(row);
 				remember(row);
 				if (reconcile) deliver({
 					participant: row.participant,
@@ -49,6 +53,7 @@ function presenceRecovery({ read, deliver, isActive }) {
 			if (reconcile) for (const [id, prior] of before) {
 				if (live.has(id) || changed.has(id) || fields.get(id) !== prior) continue;
 				fields.delete(id);
+				deleted.keep(prior);
 				deliver({
 					participant: prior.participant,
 					values: { [prior.field]: null },
@@ -56,7 +61,7 @@ function presenceRecovery({ read, deliver, isActive }) {
 					at: prior.at
 				});
 			}
-			return rows;
+			return current;
 		} finally {
 			reading.delete(changed);
 			if (reading.size === 0) latest = void 0;
@@ -80,20 +85,26 @@ function presenceRecovery({ read, deliver, isActive }) {
 		update(patch) {
 			for (const [field, value] of Object.entries(patch.values)) {
 				if (value === void 0) continue;
-				const id = key({
+				const write = {
 					participant: patch.participant,
-					field
-				});
+					field,
+					at: patch.at
+				};
+				const id = key(write);
 				const previous = fields.get(id);
 				if (previous && previous.at.getTime() > patch.at.getTime()) continue;
+				if (deleted.outranks(write)) continue;
 				for (const changed of reading) changed.add(id);
-				if (value === null) fields.delete(id);
-				else remember({
-					participant: patch.participant,
-					field,
-					seen: patch.seen,
-					at: patch.at
-				});
+				if (value === null) {
+					fields.delete(id);
+					deleted.keep(write);
+				} else {
+					deleted.drop(write);
+					remember({
+						...write,
+						seen: patch.seen
+					});
+				}
 			}
 		}
 	};
@@ -101,22 +112,24 @@ function presenceRecovery({ read, deliver, isActive }) {
 const FEED_PAGE_SIZE = 1e3;
 const READ_CONCURRENCY = 16;
 /** The key layout this core writes; any other is rejected. */
-const REDIS_LAYOUT = "cursors-2";
-const LAYOUT_ERROR = "A2_LAYOUT";
+const REDIS_LAYOUT = "tagged-1";
+/**
+* Upstash runs a script under a database-wide lock unless it opts into
+* locking only its keys' hash tags. Redis and Valkey reject the flag, and
+* have no such lock to opt out of: one thread runs every command.
+*/
+const KEY_LOCKING = "#!lua flags=allow-key-locking";
+const READ_ONLY_KEY_LOCKING = "#!lua flags=no-writes,allow-key-locking";
+const SHEBANG_REJECTED = /shebang|unexpected symbol near '#'/i;
 const META_CHUNK_SIZE = 1e3;
 /** A head row's dispatch columns, in the order scripts return them. */
 const HEAD_COLUMNS = `{ 'd', 'fc', 'lc', 'ch', 'ce', 'a', 'lf', 'lfa', 'e', 'f' }`;
 /**
-* Upstash bills every call a script makes, so scripts read the counter,
-* clear marker, layout, typed-type index, and id keys with one MGET
-* (`read_bounds`), read rows with one HMGET per chunk (`read_rows`), and
-* buffer hash writes (`put`, `drop`) into one HSET and one HDEL per hash
-* (`flush`). Buffered writes are invisible to reads until flushed, so a
-* script must not read a field it has buffered. Every script binds KEYS[1]
-* to the session's counter and KEYS[2] to the prefix's layout key, and
-* derives the session's other keys.
+* Issues a variadic command in calls of at most 1000 arguments, since Lua's
+* `unpack` is bounded by its stack, and concatenates table replies. An even
+* slice size keeps HSET's field/value pairs together.
 */
-const BASE_LUA = `
+const SLICED_LUA = `
 local function sliced(command, key, args)
   local results = {}
   for first = 1, #args, 1000 do
@@ -133,32 +146,55 @@ local function sliced(command, key, args)
   end
   return results
 end
-local COUNTER, SCHEMA = KEYS[1], KEYS[2]
+`;
+/**
+* Upstash bills every call a script makes, so scripts read the counter,
+* clear marker, typed-type index, and event-id owners with one MGET
+* (`read_bounds`), read rows with one HMGET per chunk
+* (`read_rows`), and buffer hash writes (`put`, `drop`) into one HSET and
+* one HDEL per hash (`flush`). Buffered writes are invisible to reads until
+* flushed, so a script must not read a field it has buffered. Every script
+* binds KEYS[1] to the session's counter and derives the session's other
+* keys, which share its hash tag.
+*/
+const BASE_LUA = `${SLICED_LUA}
+local COUNTER = KEYS[1]
 local SESSION = string.sub(COUNTER, 1, -6)
 local LOG, CLEAR = SESSION .. 'log', SESSION .. 'clear'
 local META, READY, CURSORS = SESSION .. 'heads', SESSION .. 'runnable', SESSION .. 'cursors'
 local PIN_COUNTS, TYPED = SESSION .. 'pins', SESSION .. 'typed'
 local CLEAR_TYPE = '${CLEAR_EVENT_TYPE}'
-local total, boundary, schema_missing = 0, 0, false
+local total, boundary = 0, 0
 -- The event types typed log cursors read: type → { from, last }. The type's
 -- index holds every event of it above \`from\`, and no event of it lies above
 -- \`last\`.
 local typed, typed_dirty = {}, false
--- Reads the counter, the latest clear marker, the layout, the typed types,
--- and the extra keys in one MGET. Returns the extra keys' values, or nil when
--- the prefix holds another layout.
-local function read_bounds(extra)
-  local keys = { COUNTER, CLEAR, SCHEMA, TYPED }
-  for _, key in ipairs(extra or {}) do keys[#keys + 1] = key end
+-- One key per event id holds the index it names in this session. The
+-- \`id:\` namespace keeps a raw id from spelling another session key.
+local function id_key(id) return SESSION .. 'id:' .. id end
+-- Reads the counter, the latest clear marker, the typed types, and the
+-- owners of \`ids\` in one MGET. Returns each id's index, or false.
+local function read_bounds(ids)
+  local keys = { COUNTER, CLEAR, TYPED }
+  for _, id in ipairs(ids or {}) do keys[#keys + 1] = id_key(id) end
   local values = sliced('MGET', nil, keys)
-  if values[3] and values[3] ~= '${REDIS_LAYOUT}' then return nil end
-  total = tonumber(values[1] or '0')
+  total = tonumber(values[1] or values[2] or '0')
   boundary = tonumber(values[2] or '0')
-  schema_missing = not values[3]
-  if values[4] then typed = cjson.decode(values[4]) end
-  local rest = {}
-  for i = 5, #keys do rest[i - 4] = values[i] end
-  return rest
+  if values[3] then typed = cjson.decode(values[3]) end
+  local owners = {}
+  for i = 4, #keys do owners[i - 3] = values[i] end
+  return owners
+end
+-- Event-id owners from read_bounds: an id recorded below the latest clear
+-- is free.
+local function owners_of(values)
+  local owners = {}
+  for i = 1, #values do
+    local owner = values[i]
+    if owner and tonumber(owner) < boundary then owner = false end
+    owners[i] = owner
+  end
+  return owners
 end
 local function entry_index(id) return tonumber(string.match(id, '^(%d+)')) end
 local function cid_of(consumer, tag)
@@ -603,79 +639,27 @@ local function enqueue(batch)
     state.dirty = true
   end
 end
--- Event-id owners for the extra keys read_bounds returned. A record this
--- session made below its latest clear is free.
-local function owners_of(values, session)
-  local owners = {}
-  for i = 1, #values do
-    local owner = values[i]
-    if owner then
-      local rec = cjson.decode(owner)
-      if rec[1] == session and tonumber(rec[2]) < boundary then owner = false end
-    end
-    owners[i] = owner
-  end
-  return owners
-end
-`;
-const WAKE_PAYLOAD_LIMIT = 32768;
-/**
-* Wake-up messages carry the events they announce, so a subscribed reader
-* that is caught up applies them without reading the stream:
-* `{"f":frontier,"t":createdAt,"e":[[index,id,type,payload],...]}`. Payloads
-* are the stored JSON text, inlined verbatim. A batch over
-* WAKE_PAYLOAD_LIMIT bytes publishes `{"f":frontier}` and readers catch up
-* with XRANGE.
-*/
-const WAKE_LUA = `
-local wake_entries, wake_bytes = {}, 0
-local function wake_add(field, id, typ, payload)
-  if wake_bytes + #payload > ${WAKE_PAYLOAD_LIMIT} then
-    wake_bytes = ${WAKE_PAYLOAD_LIMIT} + 1
-    return
-  end
-  local entry = '[' .. field .. ',' .. cjson.encode(id) .. ',' ..
-    cjson.encode(typ) .. ',' .. payload .. ']'
-  wake_bytes = wake_bytes + #entry + 1
-  if wake_bytes <= ${WAKE_PAYLOAD_LIMIT} then
-    wake_entries[#wake_entries + 1] = entry
-  end
-end
-local function wake(channel, frontier, created_at)
-  local message = '{"f":' .. frontier .. '}'
-  if wake_bytes <= ${WAKE_PAYLOAD_LIMIT} then
-    message = '{"f":' .. frontier .. ',"t":' .. created_at .. ',"e":[' ..
-      table.concat(wake_entries, ',') .. ']}'
-  end
-  redis.pcall('PUBLISH', channel, message)
-end
 `;
 /**
-* KEYS: counter, layout, then one id ownership key per event.
-* ARGV: sessionId, nowMs, n, served consumers, notify channel, origin index
-* or '', then per event: id, type, payloadJson, causeJson or '', targets.
+* KEYS: counter.
+* ARGV: sessionId, nowMs, n, served consumers, origin index or '', then per
+* event: id, type, payloadJson, causeJson or '', targets.
 * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
 * ['dup', hasPending, ...indexes] | ['partial', count] |
-* ['foreign', eventId] | ['superseded', position] | ['cleared', originIndex] |
+* ['superseded', position] | ['cleared', originIndex] |
 * ['index', type, after].
 */
-const APPEND_LUA = `${BASE_LUA}${CURSOR_LUA}${WAKE_LUA}
-local session_id, now, n = ARGV[1], ARGV[2], tonumber(ARGV[3])
+const APPEND_LUA = `${BASE_LUA}${CURSOR_LUA}
+local now, n = ARGV[2], tonumber(ARGV[3])
 use_served(ARGV[4])
 if n == 0 then return { 'empty', has_pending() } end
-local id_keys = {}
-for i = 1, n do id_keys[i] = KEYS[2 + i] end
-local values = read_bounds(id_keys)
-if not values then return redis.error_reply('${LAYOUT_ERROR}') end
-local owners = owners_of(values, session_id)
+local ids = {}
+for i = 1, n do ids[i] = ARGV[5 + (i - 1) * 5 + 1] end
+local owners = owners_of(read_bounds(ids))
 local base = total
 local dups = {}
 for i = 1, n do
-  if owners[i] then
-    local rec = cjson.decode(owners[i])
-    if rec[1] ~= session_id then return { 'foreign', ARGV[6 + (i - 1) * 5 + 1] } end
-    dups[#dups + 1] = tostring(rec[2])
-  end
+  if owners[i] then dups[#dups + 1] = owners[i] end
 end
 if #dups == n then
   local res = { 'dup', has_pending() }
@@ -683,13 +667,13 @@ if #dups == n then
   return res
 end
 if #dups > 0 then return { 'partial', tostring(#dups) } end
-local origin = ARGV[6]
+local origin = ARGV[5]
 if origin ~= '' and tonumber(origin) <= boundary then return { 'cleared', origin } end
 -- The attempt-currency fence: a cause's head row must still be its cursor's
 -- head, at that attempt, not dead-lettered.
 local refs, fenced = {}, {}
 for i = 1, n do
-  local raw = ARGV[6 + (i - 1) * 5 + 4]
+  local raw = ARGV[5 + (i - 1) * 5 + 4]
   if raw ~= '' then
     local cause = cjson.decode(raw)
     local index = tonumber(cause.index)
@@ -711,59 +695,54 @@ for k, cause in ipairs(fenced) do
 end
 local batch = {}
 for i = 1, n do
-  local o = 6 + (i - 1) * 5
+  local o = 5 + (i - 1) * 5
   batch[i] = { idx = base + i, type = ARGV[o + 2], targets = targets_of(ARGV[o + 5]) }
 end
 local planned, missing, after = plan(batch, base)
 if not planned then return { 'index', missing, tostring(after) } end
-local owner_writes = {}
+local marks = {}
 for i = 1, n do
-  local o = 6 + (i - 1) * 5
+  local o = 5 + (i - 1) * 5
   local field = tostring(base + i)
   redis.call('XADD', LOG, field .. '-0',
     'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
     'created_at', now, 'cause', ARGV[o + 4])
-  owner_writes[#owner_writes + 1] = KEYS[2 + i]
-  owner_writes[#owner_writes + 1] = cjson.encode({ session_id, base + i })
-  wake_add(field, ARGV[o + 1], ARGV[o + 2], ARGV[o + 3])
+  marks[#marks + 1] = id_key(ARGV[o + 1])
+  marks[#marks + 1] = field
 end
 index_batch(batch)
 enqueue(batch)
-owner_writes[#owner_writes + 1] = COUNTER
-owner_writes[#owner_writes + 1] = tostring(base + n)
-if schema_missing then
-  owner_writes[#owner_writes + 1] = SCHEMA
-  owner_writes[#owner_writes + 1] = '${REDIS_LAYOUT}'
-end
+marks[#marks + 1] = COUNTER
+marks[#marks + 1] = tostring(base + n)
 if typed_dirty then
-  owner_writes[#owner_writes + 1] = TYPED
-  owner_writes[#owner_writes + 1] = cjson.encode(typed)
+  marks[#marks + 1] = TYPED
+  marks[#marks + 1] = cjson.encode(typed)
 end
-sliced('MSET', nil, owner_writes)
+sliced('MSET', nil, marks)
 flush_states()
 flush()
 flush_ready()
-local pending = has_pending()
-wake(ARGV[5], tostring(base + n), now)
-return { 'ok', tostring(base + 1), pending }
+return { 'ok', tostring(base + 1), has_pending() }
 `;
 /**
-* KEYS: counter, layout.
+* KEYS: counter.
 * ARGV: type, after. Indexes one page of the stored log below the type's
 * index, toward `after`, registering the type first if no cursor read it
 * yet. Returns ['1'] once the index reaches `after`, else ['0'].
 */
 const INDEX_TYPE_LUA = `${BASE_LUA}
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+read_bounds()
 local name, after = ARGV[1], tonumber(ARGV[2])
 local entry = typed[name]
 if not entry then
   entry = { total, total }
   typed[name] = entry
 end
-if entry[1] > after then
+-- Entries below the latest clear belong to an old lifetime: never indexed.
+local floor = math.max(after, boundary - 1)
+if entry[1] > floor then
   local entries = redis.call('XREVRANGE', LOG, tostring(entry[1]) .. '-0',
-    tostring(after + 1) .. '-0', 'COUNT', 256)
+    tostring(floor + 1) .. '-0', 'COUNT', 256)
   local adds = {}
   for _, stored in ipairs(entries) do
     local fields = stored[2]
@@ -784,12 +763,14 @@ if entry[1] > after then
   else
     entry[1] = entry_index(entries[#entries][1]) - 1
   end
+elseif entry[1] > after then
+  entry[1] = after
 end
 redis.call('SET', TYPED, cjson.encode(typed))
 return { entry[1] <= after and '1' or '0' }
 `;
 /**
-* KEYS: counter, layout.
+* KEYS: counter.
 * ARGV: holder, nowMs, expiresAtMs, maxFailures or '', served consumers,
 * the highest head to claim or '', excluded count, then per excluded head:
 * consumer, tag.
@@ -799,7 +780,7 @@ return { entry[1] <= after and '1' or '0' }
 const CLAIM_AVAILABLE_LUA = `${BASE_LUA}${CURSOR_LUA}
 local ready = redis.call('ZRANGEBYSCORE', READY, 1, ARGV[6] == '' and '+inf' or ARGV[6], 'WITHSCORES')
 if #ready == 0 then return { 'settled' } end
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+read_bounds()
 local holder, now, expires_at = ARGV[1], tonumber(ARGV[2]), ARGV[3]
 local max_failures = tonumber(ARGV[4])
 use_served(ARGV[5])
@@ -892,13 +873,13 @@ result[#result + 1] = tostring(total)
 return result
 `;
 /**
-* KEYS: counter, layout.
+* KEYS: counter.
 * ARGV: holder, nowMs, expiresAtMs, n, then per claim: consumer, tag, index,
 * attempt. Returns [renewedCount, ...renewed, ...superseded] as 1-based
 * positions in the request.
 */
 const RENEW_CLAIMS_LUA = `${BASE_LUA}
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+read_bounds()
 local holder, now, expires_at = ARGV[1], tonumber(ARGV[2]), ARGV[3]
 local refs, items, superseded = {}, {}, {}
 for i = 1, tonumber(ARGV[4]) do
@@ -934,21 +915,19 @@ for i = 1, #superseded do result[#result + 1] = superseded[i] end
 return result
 `;
 /**
-* KEYS: counter, layout, then one id ownership key per child.
+* KEYS: counter.
 * ARGV: sessionId, nowMs, consumer, tag, index, attempt, child causeJson,
-* served consumers, notify channel, returned idsJson, n, then per child: id,
-* type, payloadJson, targets.
+* served consumers, returned idsJson, n, then per child: id, type,
+* payloadJson, targets.
 */
-const COMPLETE_ATTEMPT_LUA = `${BASE_LUA}${CURSOR_LUA}${WAKE_LUA}
-local session_id, now = ARGV[1], ARGV[2]
+const COMPLETE_ATTEMPT_LUA = `${BASE_LUA}${CURSOR_LUA}
+local now = ARGV[2]
 local consumer, tag, idx, attempt = ARGV[3], ARGV[4], tonumber(ARGV[5]), tonumber(ARGV[6])
 local at = row_of(consumer, tag)
-local n = tonumber(ARGV[11])
-local id_keys = {}
-for i = 1, n do id_keys[i] = KEYS[2 + i] end
-local values = read_bounds(id_keys)
-if not values then return redis.error_reply('${LAYOUT_ERROR}') end
-local owners = owners_of(values, session_id)
+local n = tonumber(ARGV[10])
+local ids = {}
+for i = 1, n do ids[i] = ARGV[10 + (i - 1) * 4 + 1] end
+local owners = owners_of(read_bounds(ids))
 if idx <= boundary then return { 'superseded' } end
 if idx < 1 or idx > total then return { 'missing' } end
 local row = read_rows({ { idx, at } }, { 'd', 'p', 'pa', 'ri', 'ch', 'f', 'l', 'next', 'pins' })[1]
@@ -959,14 +938,12 @@ if row[2] then
   local recorded = cjson.decode(row[4] or '[]')
   if #recorded ~= n then return { 'partial' } end
   for i = 1, n do
-    if recorded[i] ~= ARGV[11 + (i - 1) * 4 + 1] then return { 'partial' } end
+    if recorded[i] ~= ARGV[10 + (i - 1) * 4 + 1] then return { 'partial' } end
   end
   local result = { 'duplicate' }
   for i = 1, n do
     if not owners[i] then return { 'partial' } end
-    local rec = cjson.decode(owners[i])
-    if rec[1] ~= session_id then return { 'partial' } end
-    result[#result + 1] = tostring(rec[2])
+    result[#result + 1] = owners[i]
   end
   return result
 end
@@ -979,7 +956,7 @@ end
 use_served(ARGV[8])
 local batch = {}
 for i = 1, n do
-  local o = 11 + (i - 1) * 4
+  local o = 10 + (i - 1) * 4
   batch[i] = { idx = total + i, type = ARGV[o + 2], targets = targets_of(ARGV[o + 4]) }
 end
 local moved, missing = advance(consumer, row[7], idx, row[8], batch)
@@ -988,47 +965,41 @@ local planned, unindexed, after = plan(batch, total)
 if not planned then return { 'index', unindexed, tostring(after) } end
 put_row(idx, at, 'p', now)
 put_row(idx, at, 'pa', ARGV[6])
-put_row(idx, at, 'ri', ARGV[10])
+put_row(idx, at, 'ri', ARGV[9])
 release_pins(idx, at, row[9])
-local owner_writes = {}
+local marks = {}
 for i = 1, n do
-  local o = 11 + (i - 1) * 4
+  local o = 10 + (i - 1) * 4
   local field = tostring(total + i)
   redis.call('XADD', LOG, field .. '-0',
     'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
     'created_at', now, 'cause', ARGV[7])
-  owner_writes[#owner_writes + 1] = KEYS[2 + i]
-  owner_writes[#owner_writes + 1] = cjson.encode({ session_id, total + i })
-  wake_add(field, ARGV[o + 1], ARGV[o + 2], ARGV[o + 3])
+  marks[#marks + 1] = id_key(ARGV[o + 1])
+  marks[#marks + 1] = field
 end
 index_batch(batch)
 enqueue(batch)
 if n > 0 then
-  owner_writes[#owner_writes + 1] = COUNTER
-  owner_writes[#owner_writes + 1] = tostring(total + n)
-  if schema_missing then
-    owner_writes[#owner_writes + 1] = SCHEMA
-    owner_writes[#owner_writes + 1] = '${REDIS_LAYOUT}'
-  end
+  marks[#marks + 1] = COUNTER
+  marks[#marks + 1] = tostring(total + n)
 end
 if typed_dirty then
-  owner_writes[#owner_writes + 1] = TYPED
-  owner_writes[#owner_writes + 1] = cjson.encode(typed)
+  marks[#marks + 1] = TYPED
+  marks[#marks + 1] = cjson.encode(typed)
 end
-sliced('MSET', nil, owner_writes)
+sliced('MSET', nil, marks)
 flush_states()
 flush()
 flush_ready()
-if n > 0 then wake(ARGV[9], tostring(total + n), now) end
 return { 'ok', tostring(total + 1) }
 `;
 /**
-* KEYS: counter, layout.
+* KEYS: counter.
 * ARGV: consumer, tag, index, attempt, error, maxFailures, nowMs, retryAtMs
 * or ''.
 */
 const FAIL_ATTEMPT_LUA = `${BASE_LUA}
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+read_bounds()
 local consumer, tag, idx, attempt = ARGV[1], ARGV[2], tonumber(ARGV[3]), tonumber(ARGV[4])
 local at = row_of(consumer, tag)
 if idx <= boundary then return { 'superseded', '0' } end
@@ -1064,13 +1035,13 @@ flush_ready()
 return { dead and 'dead_lettered' or 'failed', tostring(failures) }
 `;
 /**
-* KEYS: counter, layout. ARGV: consumer, index, action, nowMs, served
+* KEYS: counter. ARGV: consumer, index, action, nowMs, served
 * consumers. Returns [redriven, hasPending] | ['index', type, after]. Acts
 * only on the consumer's dead-lettered head at the index, above the clear
 * marker.
 */
 const REDRIVE_LUA = `${BASE_LUA}${CURSOR_LUA}
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+read_bounds()
 use_served(ARGV[5])
 local consumer, idx = ARGV[1], tonumber(ARGV[2])
 local function result(redriven) return { redriven, has_pending() } end
@@ -1103,7 +1074,7 @@ flush_ready()
 return result('1')
 `;
 /**
-* KEYS: counter, layout. ARGV: consumer, lane, types JSON or '*', backfill
+* KEYS: counter. ARGV: consumer, lane, types JSON or '*', backfill
 * ('1' or '0'). Brings one log cursor up to date without an append, as
 * `plan` and `enqueue` would for an append carrying its types: a missing
 * cursor starts at the clear marker with backfill, else at the head with
@@ -1113,7 +1084,7 @@ return result('1')
 * columns, session head] | ['index', type, after].
 */
 const WAKE_LOG_LUA = `${BASE_LUA}${CURSOR_LUA}
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+read_bounds()
 local consumer, lane, ty = ARGV[1], ARGV[2], ARGV[3]
 local types = types_of(ty)
 local cid = cid_of(consumer, 'G' .. lane)
@@ -1158,13 +1129,13 @@ flush_ready()
 return { 'ok', tostring(state.p), state.h and tostring(state.h) or false, columns, tostring(total) }
 `;
 /**
-* KEYS: counter, layout. Returns the dead-lettered heads above the clear
+* KEYS: counter. Returns the dead-lettered heads above the clear
 * marker as [consumer, tag, index, columns, entry] tuples.
 */
 const DEAD_LETTERS_LUA = `${BASE_LUA}
 local dead = redis.call('ZRANGEBYSCORE', READY, '-inf', '(0', 'WITHSCORES')
 if #dead == 0 then return {} end
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+read_bounds()
 local refs, items = {}, {}
 for i = 1, #dead, 2 do
   local consumer, tag = parse_cid(dead[i])
@@ -1185,12 +1156,12 @@ end
 return result
 `;
 /**
-* KEYS: counter, layout. Returns every listed cursor as [consumer, tag,
+* KEYS: counter. Returns every listed cursor as [consumer, tag,
 * position, head or nil, columns]: lane and log cursors from the cursor
 * hash, read against the clear marker, then the event cursors with a head.
 */
 const CURSORS_LUA = `${BASE_LUA}
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
+read_bounds()
 local listed = {}
 local fields = redis.call('HGETALL', CURSORS)
 local records, order = {}, {}
@@ -1243,7 +1214,7 @@ end
 return result
 `;
 /**
-* KEYS: counter, layout, head, history.
+* KEYS: counter, head, history.
 * ARGV: write count, then per write: index, snapshot JSON, pin count, then
 * per pin: consumer, tag, index; finally the reducer name. Writes from
 * before the latest clear are dropped, and a head from before it is
@@ -1251,8 +1222,8 @@ return result
 * claimed row says so itself, an unclaimed head by its cursor's ready score.
 */
 const PUT_SNAPSHOTS_LUA = `${BASE_LUA}
-if not read_bounds() then return redis.error_reply('${LAYOUT_ERROR}') end
-local HEAD, HISTORY = KEYS[3], KEYS[4]
+read_bounds()
+local HEAD, HISTORY = KEYS[2], KEYS[3]
 local entries, refs, pins = {}, {}, {}
 local offset = 2
 for w = 1, tonumber(ARGV[1]) do
@@ -1367,77 +1338,75 @@ 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.
+* Presence entries are `{"a":at,"e":expiresAt,"s":seen,"v":value}`, stamps
+* first and both integers, so scripts read them with a pattern instead of
+* decoding the value.
+*/
+const PRESENCE_STAMPS_LUA = `
+local function stamps(entry)
+  local a, e = string.match(entry, '^{"a":(%-?%d+),"e":(%-?%d+),')
+  return tonumber(a), tonumber(e)
+end
+`;
+/**
+* KEYS: presence hash. ARGV: atMs, ttlMs, nowMs, n, then per entry:
+* hashField, entryJson (a null value is a tombstone). Field-wise LWW by the
+* sender's `at`: an unexpired stored entry with a strictly newer stamp
+* survives; ties go to the incoming write (memory-tier parity). Returns the applied 1-based entry
+* positions. The whole-key PEXPIRE is the coarse bound, sound because core
+* sends one uniform ttlMs; the per-entry `e` stamp is the fine bound (the
+* injected storage clock at the applied set plus ttlMs — never the sender
+* stamp), filtered on read against the same clock.
 */
-const PRESENCE_SET_LUA = `
-local at = tonumber(ARGV[1])
-local applied = {}
-local published = {}
-local n = tonumber(ARGV[3])
+const PRESENCE_SET_LUA = `${SLICED_LUA}${PRESENCE_STAMPS_LUA}
+local at, now, n = tonumber(ARGV[1]), tonumber(ARGV[3]), tonumber(ARGV[4])
+local fields = {}
+for i = 1, n do fields[i] = ARGV[4 + (i - 1) * 2 + 1] end
+local stored = sliced('HMGET', KEYS[1], fields)
+local applied, sets = {}, {}
 for i = 1, n do
-  local 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
+  local a, e = false, false
+  if stored[i] then a, e = stamps(stored[i]) end
+  if not stored[i] or a <= at or e <= now then
+    sets[#sets + 1] = fields[i]
+    sets[#sets + 1] = ARGV[4 + (i - 1) * 2 + 2]
     applied[#applied + 1] = tostring(i)
-    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
+sliced('HSET', KEYS[1], sets)
+if #applied > 0 then redis.call('PEXPIRE', KEYS[1], ARGV[2]) 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.
+* KEYS: presence hash. ARGV: nowMs, then the fields a read saw expired.
+* Deletes those still at or past their expiry, re-checked in this atomic
+* step so a stale reader never sweeps a concurrently refreshed field.
 */
-const PRESENCE_READ_LUA = `
+const PRESENCE_PRUNE_LUA = `${SLICED_LUA}${PRESENCE_STAMPS_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]
+local fields = {}
+for i = 2, #ARGV do fields[#fields + 1] = ARGV[i] end
+local stored = sliced('HMGET', KEYS[1], fields)
+local stale = {}
+for i = 1, #fields do
+  if stored[i] then
+    local _, e = stamps(stored[i])
+    if e <= now then stale[#stale + 1] = fields[i] end
   end
 end
-return live
+sliced('HDEL', KEYS[1], stale)
+return 1
 `;
 /**
-* KEYS: counter, layout, head, history. ARGV: snapshot frontier or ''.
+* KEYS: counter, head, history. ARGV: snapshot frontier or ''.
 * Returns one atomic multiversion-cache-plus-log-frontier read, with the
 * clear boundary; checkpoints from before it are ignored.
 */
 const READ_STATE_LUA = `
 local session = string.sub(KEYS[1], 1, -6)
-local counts = redis.call('MGET', KEYS[1], session .. 'clear', KEYS[2])
-if counts[3] and counts[3] ~= '${REDIS_LAYOUT}' then
-  return redis.error_reply('${LAYOUT_ERROR}')
-end
+local counts = redis.call('MGET', KEYS[1], session .. 'clear')
 local boundary = tonumber(counts[2] or '0')
-local head = redis.call('GET', KEYS[3])
+local head = redis.call('GET', KEYS[2])
 local head_index = head and cjson.decode(head)['index'] or nil
 if head and (type(head_index) ~= 'number' or head_index < 0 or head_index > 9007199254740991 or head_index ~= math.floor(head_index)) then
   return redis.error_reply('invalid snapshot head index')
@@ -1452,18 +1421,24 @@ if head_index and (cap == '' or head_index <= tonumber(cap)) then
   snapshot = head
 else
   local upper = cap == '' and '+inf' or cap
-  local historical = redis.call('ZREVRANGEBYSCORE', KEYS[4], upper, boundary, 'LIMIT', 0, 1)
+  local historical = redis.call('ZREVRANGEBYSCORE', KEYS[3], upper, boundary, 'LIMIT', 0, 1)
   if #historical > 0 then snapshot = historical[1] end
 end
-return { head_index or '', snapshot or '', counts[1] or '0', tostring(boundary) }
+return { head_index or '', snapshot or '', counts[1] or counts[2] or '0', tostring(boundary) }
 `;
 /**
-* What reclaim removes once a session has no moved log left: every
+* What reclaim removes once no entry is left below the latest clear: every
 * registered reducer's checkpoints below the latest clear and the pin counts
 * naming them (snapshot writes register each reducer in
 * {prefix}:{session}:snap-reducers, so no key scan is needed), every head
 * row below it (whole chunks, then the boundary chunk's older rows), the
 * type indexes' older entries, and the lane cursors it left idle.
+*
+* A lifetime that ended empty then collapses to the clear marker, the log
+* holding it (readers resuming before the marker still read it), and the log
+* cursors the sweep reset to the marker. The counter reads from the marker
+* when absent, type indexes rebuild lazily, and the marker's own id key goes
+* too.
 */
 const SWEEP_LUA = `
 local function sweep(boundary)
@@ -1530,22 +1505,45 @@ local function sweep(boundary)
   end
   sliced('HDEL', CURSORS, idle)
   sliced('HSET', CURSORS, moved)
+  local count = redis.call('GET', COUNTER)
+  if not count or tonumber(count) ~= boundary or redis.call('ZCARD', READY) > 0 then
+    return
+  end
+  local stale = { COUNTER, TYPED, PIN_COUNTS, chunk_key(boundary) }
+  local reducers = SESSION .. 'snap-reducers'
+  for _, reducer in ipairs(redis.call('SMEMBERS', reducers)) do
+    stale[#stale + 1] = SESSION .. 'snap:' .. reducer
+    stale[#stale + 1] = SESSION .. 'snap-history:' .. reducer
+  end
+  stale[#stale + 1] = reducers
+  local types = redis.call('GET', TYPED)
+  if types then
+    for name in pairs(cjson.decode(types)) do stale[#stale + 1] = type_key(name) end
+  end
+  local marker = redis.call('XRANGE', LOG, boundary .. '-0', boundary .. '-0')[1]
+  if marker then
+    for i = 1, #marker[2], 2 do
+      if marker[2][i] == 'id' then stale[#stale + 1] = id_key(marker[2][i + 1]) end
+    end
+  end
+  sliced('UNLINK', nil, stale)
 end
 `;
 /**
-* KEYS: counter, layout, marker id ownership key.
+* KEYS: counter.
 * ARGV: sessionId, nowMs, ifLastIndex or '', cause consumer or '', cause tag,
-* cause index, cause attempt, marker id, notify channel.
-* Returns ['ok', cleared, head, boundary] | ['superseded'] | ['foreign'].
-* The old lifetime's log moves aside in one RENAME, so every read of the log
-* starts at the marker, and its ready set is unlinked, so claims and pending
-* checks see only the new lifetime; deletion drains the moved log. Type
-* indexes keep their older entries until then: lookups start above the
-* marker.
+* cause index, cause attempt, marker id.
+* Returns ['ok', cleared, head, boundary, appended?] | ['superseded'] |
+* ['foreign']; `appended` is '1' when this call appended the marker.
+* The marker joins the same log: the old lifetime's entries stay below it
+* until reclaim deletes them, and every read of the log starts at the
+* marker. (A stream can't be renamed aside: Upstash refuses RENAME on one.)
+* The ready set is unlinked, so claims and pending checks see only the new
+* lifetime. Type indexes keep their older entries until reclaim too:
+* lookups start above the marker.
 */
-const CLEAR_LUA = `${BASE_LUA}${WAKE_LUA}
-local values = read_bounds({ KEYS[3] })
-if not values then return redis.error_reply('${LAYOUT_ERROR}') end
+const CLEAR_LUA = `${BASE_LUA}
+local marker_owner = owners_of(read_bounds({ ARGV[8] }))[1]
 local head = total
 if ARGV[4] ~= '' then
   local idx = tonumber(ARGV[6])
@@ -1565,59 +1563,45 @@ end
 if head == 0 or boundary == head then
   return { 'ok', '1', tostring(head), tostring(boundary) }
 end
-if values[1] then return { 'foreign' } end
+if marker_owner then return { 'foreign' } end
 local field = tostring(head + 1)
-local moved = SESSION .. 'cleared:' .. field
-redis.call('RENAME', LOG, moved)
 redis.call('UNLINK', READY)
-redis.call('SADD', SESSION .. 'cleared', moved)
 redis.call('XADD', LOG, field .. '-0',
   'id', ARGV[8], 'type', CLEAR_TYPE, 'payload', 'null',
   'created_at', ARGV[2], 'cause', '')
-local marker = { KEYS[3], cjson.encode({ ARGV[1], head + 1 }), COUNTER, field, CLEAR, field }
-if schema_missing then
-  marker[#marker + 1] = SCHEMA
-  marker[#marker + 1] = '${REDIS_LAYOUT}'
-end
-redis.call('MSET', unpack(marker))
-wake_add(field, ARGV[8], CLEAR_TYPE, 'null')
-wake(ARGV[9], field, ARGV[2])
-return { 'ok', '1', field, field }
+redis.call('MSET', id_key(ARGV[8]), field, COUNTER, field, CLEAR, field)
+return { 'ok', '1', field, field, '1' }
 `;
 /**
-* KEYS: counter, layout. ARGV: page size.
-* The next deletion batch: a moved log and up to a page of its [index, id]
-* pairs, without payloads. Empty moved logs are dropped; with none left it
-* sweeps what the old lifetime left and returns nothing, so a retry
-* finishes an interrupted deletion.
+* KEYS: counter. ARGV: page size.
+* The next deletion batch: up to a page of [index, id] pairs of the log's
+* entries below the latest clear. With none left it sweeps what the old
+* lifetimes left and returns nothing, so a retry finishes an interrupted
+* deletion.
 */
 const RECLAIM_BATCH_LUA = `${BASE_LUA}${SWEEP_LUA}
 local boundary = tonumber(redis.call('GET', CLEAR) or '0')
 if boundary == 0 then return {} end
-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
+local entries = redis.call('XRANGE', LOG, '-', tostring(boundary - 1) .. '-0', 'COUNT', ARGV[1])
+if #entries == 0 then
+  sweep(boundary)
+  return {}
+end
+local batch = {}
+for _, entry in ipairs(entries) do
+  local fields = entry[2]
+  for i = 1, #fields, 2 do
+    if fields[i] == 'id' then
+      batch[#batch + 1] = string.match(entry[1], '^(%d+)')
+      batch[#batch + 1] = fields[i + 1]
+      break
     end
-    return batch
   end
-  redis.call('DEL', log)
-  redis.call('SREM', SESSION .. 'cleared', log)
 end
-sweep(boundary)
-return {}
+return batch
 `;
 /**
-* KEYS: counter, layout, moved log, then one id ownership key per entry.
+* KEYS: counter.
 * ARGV: sessionId, n, then per entry: index, id.
 * Deletes the listed entries below the latest clear and their id records.
 * An id record survives when it names another event, so an id reused in the
@@ -1625,42 +1609,52 @@ return {}
 */
 const RECLAIM_LUA = `${BASE_LUA}${SWEEP_LUA}
 local boundary = tonumber(redis.call('GET', CLEAR) or '0')
-local MOVED = KEYS[3]
-local id_keys, indexes, stream_ids = {}, {}, {}
+local ids, indexes, stream_ids = {}, {}, {}
 -- A concurrent reclaim may list the same batch; only XDEL says who removed it.
 local removed = 0
 for i = 1, tonumber(ARGV[2]) do
   local field = ARGV[2 + (i - 1) * 2 + 1]
   if tonumber(field) < boundary then
-    id_keys[#id_keys + 1] = KEYS[3 + i]
-    indexes[#id_keys] = tonumber(field)
-    stream_ids[#id_keys] = field .. '-0'
-  end
-end
-if #id_keys > 0 then
-  local owners, stale_ids = sliced('MGET', nil, id_keys), {}
-  for i = 1, #id_keys do
-    if owners[i] then
-      local rec = cjson.decode(owners[i])
-      if rec[1] == ARGV[1] and tonumber(rec[2]) == indexes[i] then
-        stale_ids[#stale_ids + 1] = id_keys[i]
-      end
+    ids[#ids + 1] = ARGV[2 + (i - 1) * 2 + 2]
+    indexes[#ids] = tonumber(field)
+    stream_ids[#ids] = field .. '-0'
+  end
+end
+if #ids > 0 then
+  local keys = {}
+  for i = 1, #ids do keys[i] = id_key(ids[i]) end
+  local owners, stale = sliced('MGET', nil, keys), {}
+  for i = 1, #ids do
+    if owners[i] and tonumber(owners[i]) == indexes[i] then
+      stale[#stale + 1] = keys[i]
     end
   end
-  sliced('DEL', nil, stale_ids)
-  removed = redis.call('XDEL', MOVED, unpack(stream_ids))
+  sliced('DEL', nil, stale)
+  removed = redis.call('XDEL', LOG, unpack(stream_ids))
 end
 local done = 0
-if redis.call('XLEN', MOVED) == 0 then
-  redis.call('DEL', MOVED)
-  redis.call('SREM', SESSION .. 'cleared', MOVED)
-  if redis.call('SCARD', SESSION .. 'cleared') == 0 then
-    sweep(boundary)
-    done = 1
-  end
+if #redis.call('XRANGE', LOG, '-', tostring(boundary - 1) .. '-0', 'COUNT', 1) == 0 then
+  sweep(boundary)
+  done = 1
 end
 return { removed, done }
 `;
+const WAKE_PAYLOAD_LIMIT = 32768;
+const encoder = new TextEncoder();
+/**
+* A wake-up announcing events through `frontier`. It carries them, so a
+* caught-up reader applies them without reading the stream:
+* `{"f":frontier,"t":createdAt,"e":[[index,id,type,payload],...]}`, with
+* payloads inlined as their stored JSON text. One over WAKE_PAYLOAD_LIMIT
+* bytes, or one without entries, announces only `{"f":frontier}`, and
+* readers catch up with XRANGE.
+*/
+const wakeMessage = (frontier, createdAt, entries) => {
+	const bare = `{"f":${frontier}}`;
+	if (entries.length === 0) return bare;
+	const carried = `{"f":${frontier},"t":${createdAt},"e":[${entries.map(([index, id, type, payload]) => `[${index},${JSON.stringify(id)},${JSON.stringify(type)},${payload}]`).join(",")}]}`;
+	return encoder.encode(carried).byteLength > WAKE_PAYLOAD_LIMIT ? bare : carried;
+};
 const fieldMap = (fields) => {
 	const map = {};
 	for (let i = 0; i + 1 < fields.length; i += 2) map[fields[i]] = fields[i + 1];
@@ -1819,9 +1813,9 @@ const toIndex = ({ raw, sessionId, name }) => {
 	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.
+* A range read that met a gap. Reclaim deletes the entries below a clear, so
+* a read whose bounds predate the clear finds nothing where it expected
+* events; anywhere else a gap is corruption.
 */
 const rangeGap = (sessionId, message) => Object.assign(new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' ${message}`), { rangeGap: true });
 const isRangeGap = (error) => error instanceof A2Error && error.rangeGap === true;
@@ -1846,33 +1840,77 @@ const wrap = async (fn) => {
 		throw new A2Error("STORE_UNAVAILABLE", "redis store operation failed", { cause: err });
 	}
 };
+/**
+* A session's key. Every key of a session shares one hash tag, so a script
+* locks only its session on Upstash and stays in one slot on a cluster. The
+* tag is the session id as JSON with its braces escaped: it can't end early,
+* and no session's tag spells another's.
+*/
+const redisSessionKey = ({ prefix, sessionId, suffix }) => `${prefix}:{${JSON.stringify(sessionId).replaceAll("{", "\\u007b").replaceAll("}", "\\u007d")}}:${suffix}`;
 function createRedisStoreCore(options) {
 	const { call, callBytes, clock } = options;
 	const generateId = options.ids;
 	const prefix = options.keyPrefix;
-	const storeKey = (s) => `${prefix}:${s}:log`;
-	const countKey = (s) => `${prefix}:${s}:count`;
-	const clearKey = (s) => `${prefix}:${s}:clear`;
+	if (prefix.includes("{") || prefix.includes("}")) throw new TypeError("a redis keyPrefix cannot contain braces: they would set the hash tag of every key");
+	const sessionKey = (sessionId, suffix) => redisSessionKey({
+		prefix,
+		sessionId,
+		suffix
+	});
+	const storeKey = (s) => sessionKey(s, "log");
+	const countKey = (s) => sessionKey(s, "count");
+	const clearKey = (s) => sessionKey(s, "clear");
 	const schemaKey = `${prefix}:schema`;
-	const snapKey = (s, r) => `${prefix}:${s}:snap:${r}`;
-	const snapHistoryKey = (s, r) => `${prefix}:${s}:snap-history:${r}`;
-	const presenceKey = (s) => `${prefix}:${s}:presence`;
+	const snapKey = (s, r) => sessionKey(s, `snap:${r}`);
+	const snapHistoryKey = (s, r) => sessionKey(s, `snap-history:${r}`);
+	const presenceKey = (s) => sessionKey(s, "presence");
 	const notifyChannel = (s) => `${prefix}:${s}:notify`;
-	const idKey = (id) => `${prefix}:ids:${JSON.stringify(id).replaceAll(":", "\\u003a")}`;
+	const presenceChannel = (s) => `${prefix}:${s}:presence`;
 	const layoutError = () => new A2Error("STORE_NOT_CONFIGURED", `the redis keys under prefix '${prefix}' hold an A2 layout other than '${REDIS_LAYOUT}', from another release; point the store at a fresh keyPrefix, or give the contract a new name so it starts new sessions`);
-	/** Runs a script over a session: KEYS start with its counter and the layout key. */
-	const evalScript = async (script, sessionId, keys, args) => {
-		const allKeys = [
-			countKey(sessionId),
-			schemaKey,
-			...keys
-		];
-		try {
-			return await call("EVAL", script, allKeys.length, ...allKeys, ...args);
-		} catch (error) {
-			if (String(error?.message).includes(LAYOUT_ERROR)) throw layoutError();
+	/**
+	* Once per store, before its first script: claim or check the prefix's
+	* layout, and ask the server whether scripts may lock only their keys.
+	* Only the server's own rejection of the flag means no; a transport error
+	* fails this attempt, and the next operation asks again.
+	*/
+	const prepared = retryableLazy(async () => {
+		const [, keyLocking] = await Promise.all([(async () => {
+			await call("SET", schemaKey, REDIS_LAYOUT, "NX");
+			if (await call("GET", schemaKey) !== "tagged-1") throw layoutError();
+		})(), call("EVAL", `${KEY_LOCKING}\nreturn 1`, 1, schemaKey).then(() => true, (error) => {
+			if (SHEBANG_REJECTED.test(String(error?.message))) return false;
 			throw error;
-		}
+		})]);
+		return { keyLocking };
+	});
+	/** Runs a script; a `readOnly` one takes Upstash's shared lock. */
+	const runScript = async ({ script, keys, args, readOnly }) => {
+		const { keyLocking } = await prepared.get();
+		let source = script;
+		if (keyLocking) source = `${readOnly ? READ_ONLY_KEY_LOCKING : KEY_LOCKING}\n${script}`;
+		return call("EVAL", source, keys.length, ...keys, ...args);
+	};
+	/** Runs a writing script over a session: KEYS start with its counter. */
+	const evalScript = (script, sessionId, keys, args) => runScript({
+		script,
+		keys: [countKey(sessionId), ...keys],
+		args,
+		readOnly: false
+	});
+	/**
+	* Publishes a write's wake-up after its script, never inside it: a script
+	* holds its lock while PUBLISH waits on subscribers. Wake-ups are hints (a
+	* lost one costs subscribers a catch-up read, never an event), so a failed
+	* publish is dropped and the write waits for it at most
+	* NOTIFY_TIMINGS.publishMs.
+	*/
+	const publish = async (channel, message) => {
+		let timer;
+		await Promise.race([call("PUBLISH", channel, message).catch(() => void 0), new Promise((resolve) => {
+			timer = setTimeout(resolve, NOTIFY_TIMINGS.publishMs);
+			timer.unref?.();
+		})]);
+		clearTimeout(timer);
 	};
 	/**
 	* Runs a write that may need a type's index to reach further back first.
@@ -1889,13 +1927,13 @@ function createRedisStoreCore(options) {
 			}
 		}
 	};
-	/** The frontier and clear marker, checking the layout in the same MGET. */
+	/** The frontier and clear marker, in one MGET. */
 	const readBounds = async (sessionId) => {
-		const [count, cleared, schema] = await call("MGET", countKey(sessionId), clearKey(sessionId), schemaKey);
-		if (schema !== null && schema !== void 0 && schema !== "cursors-2") throw layoutError();
+		await prepared.get();
+		const [count, cleared] = await call("MGET", countKey(sessionId), clearKey(sessionId));
 		return {
 			frontier: toIndex({
-				raw: count,
+				raw: count ?? cleared,
 				sessionId,
 				name: "event count"
 			}),
@@ -1906,6 +1944,14 @@ function createRedisStoreCore(options) {
 			})
 		};
 	};
+	const readClearIndex = async (sessionId) => {
+		await prepared.get();
+		return toIndex({
+			raw: await call("GET", clearKey(sessionId)),
+			sessionId,
+			name: "clear boundary"
+		});
+	};
 	const readEventPages = async (sessionId, afterIndex, throughIndex) => {
 		if (throughIndex <= afterIndex) return [];
 		const events = [];
@@ -1998,17 +2044,17 @@ function createRedisStoreCore(options) {
 					cause: e.cause ? { ...e.cause } : null,
 					targets: e.targets
 				}));
-				const reply = await indexing(sessionId, () => evalScript(APPEND_LUA, sessionId, withIds.map((e) => idKey(e.id)), [
+				const payloads = withIds.map((e) => json(e.payload));
+				const reply = await indexing(sessionId, () => evalScript(APPEND_LUA, sessionId, [], [
 					sessionId,
 					now,
 					withIds.length,
 					servedArg(appendOptions?.consumers),
-					notifyChannel(sessionId),
 					appendOptions?.originIndex ?? "",
-					...withIds.flatMap((e) => [
+					...withIds.flatMap((e, i) => [
 						e.id,
 						e.type,
-						json(e.payload),
+						payloads[i],
 						e.cause ? json(e.cause) : "",
 						targetsArg(e.targets)
 					])
@@ -2018,7 +2064,6 @@ function createRedisStoreCore(options) {
 					events: [],
 					hasPending: reply[1] === "1"
 				};
-				if (verdict === "foreign") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${reply[1]}' already exists in another session`);
 				if (verdict === "cleared") throw sessionClearedError(`scheduled work from event ${reply[1]} was cleared in session '${sessionId}'`);
 				if (verdict === "superseded") throw supersededAttemptError(sessionId, withIds[Number(reply[1]) - 1].cause);
 				if (verdict === "partial") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${reply[1]} already-appended and ${events.length - Number(reply[1])} fresh events`);
@@ -2027,12 +2072,20 @@ function createRedisStoreCore(options) {
 					const firstIndex = Math.min(...reply.slice(2).map(Number));
 					const { rows: existing, clearIndex } = await retryAfterGap(() => readBoundedRange(sessionId, firstIndex - 1, firstIndex + events.length - 1));
 					if (firstIndex < clearIndex) throw new A2Error("STORE_UNAVAILABLE", `session '${sessionId}' was cleared while an append retry replayed; retry it`);
+					const replayed = idempotentReplay(events, existing);
+					await publish(notifyChannel(sessionId), wakeMessage(firstIndex + events.length - 1, now, []));
 					return {
-						events: idempotentReplay(events, existing),
+						events: replayed,
 						hasPending
 					};
 				}
 				const base = Number(reply[1]) - 1;
+				await publish(notifyChannel(sessionId), wakeMessage(base + withIds.length, now, withIds.map((e, i) => [
+					base + 1 + i,
+					e.id,
+					e.type,
+					payloads[i]
+				])));
 				return {
 					events: withIds.map((e, i) => ({
 						id: e.id,
@@ -2049,7 +2102,12 @@ function createRedisStoreCore(options) {
 		},
 		async cursors(sessionId) {
 			return wrap(async () => {
-				return (await evalScript(CURSORS_LUA, sessionId, [], [])).map(([consumer, tag, position, head, columns]) => Object.assign(dispatchOf(consumer, laneOf(tag), columns), {
+				return (await runScript({
+					script: CURSORS_LUA,
+					keys: [countKey(sessionId)],
+					args: [],
+					readOnly: true
+				})).map(([consumer, tag, position, head, columns]) => Object.assign(dispatchOf(consumer, laneOf(tag), columns), {
 					position: Number(position),
 					head: head === null ? null : Number(head)
 				})).toSorted(byCursor);
@@ -2130,7 +2188,8 @@ function createRedisStoreCore(options) {
 					index,
 					attempt
 				};
-				const reply = await indexing(sessionId, () => evalScript(COMPLETE_ATTEMPT_LUA, sessionId, ids.map((id) => idKey(id)), [
+				const payloads = events.map((event) => json(event.payload));
+				const reply = await indexing(sessionId, () => evalScript(COMPLETE_ATTEMPT_LUA, sessionId, [], [
 					sessionId,
 					now,
 					consumer,
@@ -2139,13 +2198,12 @@ function createRedisStoreCore(options) {
 					attempt,
 					json(cause),
 					servedArg(consumers),
-					notifyChannel(sessionId),
 					json(ids),
 					events.length,
-					...events.flatMap((event) => [
+					...events.flatMap((event, i) => [
 						event.id,
 						event.type,
-						json(event.payload),
+						payloads[i],
 						targetsArg(event.targets)
 					])
 				]));
@@ -2155,6 +2213,12 @@ function createRedisStoreCore(options) {
 				if (outcome === "superseded") return { outcome };
 				if (outcome === "ok") {
 					const base = Number(reply[1]) - 1;
+					if (events.length > 0) await publish(notifyChannel(sessionId), wakeMessage(base + events.length, now, events.map((event, i) => [
+						base + 1 + i,
+						event.id,
+						event.type,
+						payloads[i]
+					])));
 					return {
 						outcome: "completed",
 						events: events.map((event, i) => ({
@@ -2177,9 +2241,11 @@ function createRedisStoreCore(options) {
 					const { rows: existing, clearIndex } = await retryAfterGap(() => readBoundedRange(sessionId, firstIndex - 1, firstIndex + events.length - 1));
 					if (index <= clearIndex) return { outcome: "superseded" };
 					if (existing.some((row) => row.cause?.consumer !== consumer || row.cause.lane !== lane || row.cause.index !== index || row.cause.attempt !== attempt)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event retry does not match the committed batch");
+					const replayed = idempotentReplay(events, existing);
+					await publish(notifyChannel(sessionId), wakeMessage(firstIndex + events.length - 1, now, []));
 					return {
 						outcome: "completed",
-						events: idempotentReplay(events, existing)
+						events: replayed
 					};
 				}
 				throw new TypeError(`unexpected completion outcome '${outcome}'`);
@@ -2208,7 +2274,12 @@ function createRedisStoreCore(options) {
 		},
 		async deadLetters(sessionId) {
 			return wrap(async () => {
-				return (await evalScript(DEAD_LETTERS_LUA, sessionId, [], [])).map((head) => toHeadEvent(sessionId, head)).toSorted(byHead);
+				return (await runScript({
+					script: DEAD_LETTERS_LUA,
+					keys: [countKey(sessionId)],
+					args: [],
+					readOnly: true
+				})).map((head) => toHeadEvent(sessionId, head)).toSorted(byHead);
 			});
 		},
 		async redrive({ sessionId, consumer, index, action, consumers }) {
@@ -2246,7 +2317,16 @@ function createRedisStoreCore(options) {
 		},
 		async readState(sessionId, reducerName, stateOptions) {
 			return wrap(() => retryAfterGap(async () => {
-				const reply = await evalScript(READ_STATE_LUA, sessionId, [snapKey(sessionId, reducerName), snapHistoryKey(sessionId, reducerName)], [stateOptions?.snapshotThroughIndex ?? stateOptions?.throughIndex ?? ""]);
+				const reply = await runScript({
+					script: READ_STATE_LUA,
+					keys: [
+						countKey(sessionId),
+						snapKey(sessionId, reducerName),
+						snapHistoryKey(sessionId, reducerName)
+					],
+					args: [stateOptions?.snapshotThroughIndex ?? stateOptions?.throughIndex ?? ""],
+					readOnly: true
+				});
 				const rawHead = reply[0];
 				const raw = reply[1];
 				const headIndex = rawHead === "" ? null : Number(rawHead);
@@ -2308,43 +2388,64 @@ function createRedisStoreCore(options) {
 					const entries = Object.entries(values);
 					if (entries.length === 0) return null;
 					const atMs = meta.at.getTime();
-					const expiresAtMs = clock.now().getTime() + meta.ttlMs;
-					const applied = await call("EVAL", PRESENCE_SET_LUA, 1, presenceKey(ns), atMs, meta.ttlMs, entries.length, ...entries.flatMap(([field, value]) => [
-						JSON.stringify([participant, field]),
-						value === null ? "" : json({
-							v: value,
-							s: meta.seen,
-							a: atMs,
-							e: expiresAtMs
-						}),
-						`${json(field)}:${json(value)}`
-					]), presenceKey(ns), `${json({
-						src: options.presenceSource,
-						participant,
-						seen: meta.seen,
-						at: atMs
-					}).slice(0, -1)},"values":{`);
+					const nowMs = clock.now().getTime();
+					const expiresAtMs = nowMs + meta.ttlMs;
+					const applied = await runScript({
+						script: PRESENCE_SET_LUA,
+						keys: [presenceKey(ns)],
+						args: [
+							atMs,
+							meta.ttlMs,
+							nowMs,
+							entries.length,
+							...entries.flatMap(([field, value]) => [JSON.stringify([participant, field]), json({
+								a: atMs,
+								e: expiresAtMs,
+								s: meta.seen,
+								v: value
+							})])
+						],
+						readOnly: false
+					});
 					if (applied.length === 0) return null;
 					const appliedValues = nullProtoRecord();
+					const published = [];
 					for (const position of applied) {
 						const [field, value] = entries[Number(position) - 1];
 						appliedValues[field] = structuredClone(value);
+						published.push(`${json(field)}:${json(value)}`);
 					}
 					return {
-						participant,
-						values: appliedValues,
-						seen: meta.seen,
-						at: new Date(atMs)
+						patch: {
+							participant,
+							values: appliedValues,
+							seen: meta.seen,
+							at: new Date(atMs)
+						},
+						published: publish(presenceChannel(ns), `${json({
+							src: options.presenceSource,
+							participant,
+							seen: meta.seen,
+							at: atMs
+						}).slice(0, -1)},"values":{${published.join(",")}}}`)
 					};
 				});
 			},
 			async read(ns) {
 				return wrap(async () => {
-					const reply = await call("EVAL", PRESENCE_READ_LUA, 1, presenceKey(ns), clock.now().getTime());
+					const key = presenceKey(ns);
+					const reply = await call("HGETALL", key);
+					const nowMs = clock.now().getTime();
 					const rows = [];
+					const expired = [];
 					for (let i = 0; i + 1 < reply.length; i += 2) {
-						const [participant, field] = JSON.parse(reply[i]);
 						const entry = JSON.parse(reply[i + 1]);
+						if (entry.e <= nowMs) {
+							expired.push(reply[i]);
+							continue;
+						}
+						if (entry.v === null) continue;
+						const [participant, field] = JSON.parse(reply[i]);
 						rows.push({
 							participant,
 							field,
@@ -2354,6 +2455,12 @@ function createRedisStoreCore(options) {
 							expiresAt: new Date(entry.e)
 						});
 					}
+					if (expired.length > 0) await runScript({
+						script: PRESENCE_PRUNE_LUA,
+						keys: [key],
+						args: [nowMs, ...expired],
+						readOnly: false
+					}).catch(() => void 0);
 					return rows;
 				});
 			}
@@ -2363,7 +2470,9 @@ function createRedisStoreCore(options) {
 		},
 		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));
+				const [newest, clearIndex] = await Promise.all([call("XREVRANGE", storeKey(sessionId), throughIndex === void 0 ? "+" : `${throughIndex}-0`, `${fromIndex}-0`, "COUNT", 256), readClearIndex(sessionId)]);
+				if (clearIndex > fromIndex) return null;
+				const page = newest.toReversed().map((entry) => toEvent(sessionId, entry));
 				for (let position = 1; position < page.length; position += 1) if (page[position].index !== page[position - 1].index + 1) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' is not contiguous`);
 				const oldest = page[0]?.index;
 				return oldest === void 0 || oldest <= fromIndex ? page : null;
@@ -2372,19 +2481,27 @@ function createRedisStoreCore(options) {
 		async clear({ sessionId, ifLastIndex, cause }) {
 			return wrap(async () => {
 				const markerId = generateId();
-				const reply = await evalScript(CLEAR_LUA, sessionId, [idKey(markerId)], [
+				const now = clock.now().getTime();
+				const reply = await evalScript(CLEAR_LUA, sessionId, [], [
 					sessionId,
-					clock.now().getTime(),
+					now,
 					ifLastIndex ?? "",
 					cause?.consumer ?? "",
 					cause ? tagOf(cause.lane) : "",
 					cause?.index ?? "",
 					cause?.attempt ?? "",
-					markerId,
-					notifyChannel(sessionId)
+					markerId
 				]);
 				if (reply[0] === "superseded") throw supersededAttemptError(sessionId, cause);
 				if (reply[0] === "foreign") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `the clear marker id '${markerId}' already exists`);
+				const head = Number(reply[2]);
+				if (reply[4] === "1") await publish(notifyChannel(sessionId), wakeMessage(head, now, [[
+					head,
+					markerId,
+					CLEAR_EVENT_TYPE,
+					"null"
+				]]));
+				else if (reply[1] === "1" && head > 0) await publish(notifyChannel(sessionId), wakeMessage(head, now, []));
 				return {
 					cleared: reply[1] === "1",
 					index: Number(reply[2]),
@@ -2394,16 +2511,14 @@ function createRedisStoreCore(options) {
 		},
 		async reclaim(sessionId) {
 			return wrap(async () => {
-				const [log, ...pairs] = await evalScript(RECLAIM_BATCH_LUA, sessionId, [], [256]);
-				if (log === void 0) return {
+				const pairs = await evalScript(RECLAIM_BATCH_LUA, sessionId, [], [256]);
+				if (pairs.length === 0) return {
 					deleted: 0,
 					done: true
 				};
-				const ids = [];
-				for (let i = 1; i < pairs.length; i += 2) ids.push(pairs[i]);
-				const [deleted, done] = await evalScript(RECLAIM_LUA, sessionId, [log, ...ids.map((id) => idKey(id))], [
+				const [deleted, done] = await evalScript(RECLAIM_LUA, sessionId, [], [
 					sessionId,
-					ids.length,
+					pairs.length / 2,
 					...pairs
 				]);
 				return {
@@ -2412,6 +2527,7 @@ function createRedisStoreCore(options) {
 				};
 			});
 		},
+		clearIndex: (sessionId) => wrap(() => readClearIndex(sessionId)),
 		async readEvents(sessionId, afterIndex) {
 			return wrap(async () => {
 				return (await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, "+", "COUNT", 256)).map((entry) => toEvent(sessionId, entry));
@@ -2527,6 +2643,8 @@ function createRedisNotifyStore(options) {
 						feed.bytes += message.length;
 					} else {
 						feed.inbox.length = 0;
+						feed.held.length = 0;
+						feed.gapSince = void 0;
 						feed.bytes = 0;
 						feed.dirty = true;
 					}
@@ -2631,8 +2749,9 @@ function createRedisNotifyStore(options) {
 		wakeLog: core.wakeLog,
 		presence: {
 			async set(ns, participant, values, meta) {
-				const patch = await core.presence.set(ns, participant, values, meta);
-				if (!patch) return;
+				const applied = await core.presence.set(ns, participant, values, meta);
+				if (!applied) return;
+				const { patch } = applied;
 				const channel = presenceChannel(ns);
 				const subscription = presenceSubscriptions.get(channel);
 				if (subscription) {
@@ -2640,11 +2759,13 @@ function createRedisNotifyStore(options) {
 					subscription.recovery?.update(patch);
 					for (const listener of subscription.listeners) listener(patch);
 				}
+				await applied.published;
 			},
 			async read(ns) {
 				const channel = presenceChannel(ns);
 				await subscriptions.get(channel)?.ready;
-				return presenceSubscriptions.get(channel)?.recovery?.read() ?? core.presence.read(ns);
+				const subscription = presenceSubscriptions.get(channel);
+				return subscription?.recovery?.read() ?? subscription?.poll?.snapshot(() => core.presence.read(ns)) ?? core.presence.read(ns);
 			},
 			subscribe(ns, onPatch) {
 				const channel = presenceChannel(ns);
@@ -2725,6 +2846,8 @@ function createRedisNotifyStore(options) {
 					inbox: [],
 					bytes: 0,
 					dirty: true,
+					held: [],
+					gapSince: void 0,
 					wake: null,
 					stopRead
 				};
@@ -2747,35 +2870,48 @@ function createRedisNotifyStore(options) {
 				};
 				/**
 				* 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.
+				* the buffer. Writers publish after their scripts, so concurrent
+				* writers' wake-ups can arrive out of order: they apply in index
+				* order, and one past a gap is held until the gap fills or
+				* NOTIFY_TIMINGS.reorderMs passes. A message without events past
+				* the buffer, or an unreadable one, marks the feed dirty so it
+				* catches up with XRANGE.
 				*/
 				const applyInbox = () => {
-					feed.bytes = 0;
+					const carried = feed.held.splice(0);
+					let announced = 0;
 					for (const message of feed.inbox.splice(0)) {
 						const wake = parseWake(message);
-						if (!wake) {
-							feed.dirty = true;
+						if (!wake) feed.dirty = true;
+						else if (wake.entries.length === 0) announced = Math.max(announced, wake.frontier);
+						else carried.push({
+							wake,
+							bytes: message.length
+						});
+					}
+					carried.sort((a, b) => a.wake.entries[0][0] - b.wake.entries[0][0]);
+					feed.bytes = 0;
+					for (const held of carried) {
+						if (held.wake.entries[0][0] > (buffer.at(-1)?.index ?? last) + 1) {
+							feed.held.push(held);
+							feed.bytes += held.bytes;
 							continue;
 						}
-						for (const [index, id, type, payload] of wake.entries) {
-							const expected = (buffer.at(-1)?.index ?? last) + 1;
-							if (index < expected) continue;
-							if (index > expected) {
-								feed.dirty = true;
-								break;
-							}
+						for (const [index, id, type, payload] of held.wake.entries) {
+							if (index <= (buffer.at(-1)?.index ?? last)) continue;
 							buffer.push({
 								id,
 								type,
 								payload,
 								index,
 								sessionId,
-								createdAt: new Date(wake.createdAt)
+								createdAt: new Date(held.wake.createdAt)
 							});
 						}
-						if (wake.frontier > (buffer.at(-1)?.index ?? last)) feed.dirty = true;
 					}
+					if (announced > (buffer.at(-1)?.index ?? last)) feed.dirty = true;
+					if (feed.held.length === 0) feed.gapSince = void 0;
+					else feed.gapSince ??= Date.now();
 				};
 				const iterator = {
 					async next() {
@@ -2817,7 +2953,8 @@ function createRedisNotifyStore(options) {
 										feeds.set(channel, set);
 									}
 									set.add(feed);
-									await acquireChannel(channel);
+									const [, clearIndex] = await Promise.all([acquireChannel(channel), core.clearIndex(sessionId)]);
+									if (clearIndex - 1 > last) last = clearIndex - 1;
 									if (closed || severed) continue;
 								}
 								if (options.polling?.()) {
@@ -2839,8 +2976,11 @@ function createRedisNotifyStore(options) {
 								}
 								applyInbox();
 								if (buffer.length > 0) continue;
+								if (feed.gapSince !== void 0 && Date.now() - feed.gapSince >= NOTIFY_TIMINGS.reorderMs) feed.dirty = true;
 								if (feed.dirty) {
 									feed.dirty = false;
+									feed.held.length = 0;
+									feed.gapSince = void 0;
 									if (core.streamEvents) {
 										const result = await nextRead(last);
 										if (closed || severed) continue;
@@ -2854,11 +2994,12 @@ function createRedisNotifyStore(options) {
 								const woken = new Promise((resolve) => {
 									feed.wake = () => resolve("wake");
 								});
-								pending = defaultSleep(NOTIFY_TIMINGS.safetyReadMs);
+								const holding = feed.gapSince !== void 0;
+								pending = defaultSleep(holding ? Math.max(0, NOTIFY_TIMINGS.reorderMs - (Date.now() - feed.gapSince)) : NOTIFY_TIMINGS.safetyReadMs);
 								const outcome = await Promise.race([woken, pending.promise.then(() => "timer")]);
 								pending.cancel();
 								pending = null;
-								if (outcome === "timer") feed.dirty = true;
+								if (outcome === "timer" && !holding) feed.dirty = true;
 							} catch (err) {
 								release();
 								if (closed) return {
@@ -2916,4 +3057,4 @@ function createRedisNotifyStore(options) {
 //#endregion
 export { createRedisNotifyStore as t };
 
-//# sourceMappingURL=store-redis-notify-IiVdlYHc.js.map
+//# sourceMappingURL=store-redis-notify-CsJw_hfD.js.map