experimental-a2 0.0.0 → 0.2.0

package/dist/log-redis.js

@@ -1,9 +1,10 @@
 import { t as A2Error } from "./errors-BJRMd-h6.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
+import { t as idempotentReplay } from "./idempotent-replay-BMyHrP0L.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
 //#region src/log-redis.ts
 /**
-* a2/log-redis — the push-native log backend, on Redis Streams.
+* experimental-a2/log-redis — the push-native log backend, on Redis Streams.
 *
 * The stream IS the log: each event is a stream entry whose ID is its
 * dense a2 index (`${index}-0`), so `XRANGE` is the catch-up read and
@@ -13,10 +14,8 @@ import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
 * The conformance suite in test/conformance is the executable
 * contract, run against a real spawned `redis-server`.
 *
-* Timestamps and lease expiry come from the injected clock — the lease
-* stores its logical `expiresAt` and compares against `clock.now()`,
-* with a generous real-time `PX` purely as garbage collection — so
-* tests can time-travel against a real server.
+* Timestamps and claim expiry come from the injected clock so tests can
+* time-travel against a real server.
 *
 * Works with any Redis-protocol server on a single instance or a
 * non-cluster provider (Upstash — durable by default — Redis, Valkey).
@@ -27,17 +26,40 @@ import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
 /** How long each blocking read waits before re-checking for close(). */
 const XREAD_BLOCK_MS = 1e4;
 /**
-* KEYS: log stream, counter, global id hash, session index.
+* KEYS: log stream, counter, global id hash, session index, metadata, pending, ready.
 * ARGV: sessionId, nowMs, n, then per event:
-* id, type, payloadJson, causeJson (empty when no causal edge is known).
-* Returns ['ok', firstIndex] | ['dup', ...indexes] | ['partial', count]
-* | ['foreign', eventId].
+* id, type, payloadJson, causeJson, lane, settled.
+* Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
+* ['dup', hasPending, ...indexes] | ['partial', count] |
+* ['foreign', eventId].
 */
 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[6], idx, field)
+  if lane == '' then
+    redis.call('ZADD', KEYS[7], idx, field)
+    return
+  end
+  local tail_key = lane_field(lane, 'tail')
+  local tail = redis.call('HGET', KEYS[5], tail_key)
+  if tail then
+    redis.call('HSET', KEYS[5], tail .. ':next', field)
+  else
+    redis.call('HSET', KEYS[5], lane_field(lane, 'head'), field)
+    redis.call('ZADD', KEYS[7], idx, field)
+  end
+  redis.call('HSET', KEYS[5], 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[6]) > 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) * 4 + 1]
+  local id = ARGV[3 + (i - 1) * 6 + 1]
   local existing = redis.call('HGET', KEYS[3], id)
   if existing then
     local rec = cjson.decode(existing)
@@ -46,49 +68,60 @@ for i = 1, n do
   end
 end
 if #dups == n then
-  local res = { 'dup' }
+  local res = { 'dup', has_pending }
   for i = 1, #dups do res[#res + 1] = dups[i] end
   return res
 end
 if #dups > 0 then return { 'partial', tostring(#dups) } end
-local base = tonumber(redis.call('GET', KEYS[2]) or '0')
 for i = 1, n do
-  local id = ARGV[3 + (i - 1) * 4 + 1]
-  local typ = ARGV[3 + (i - 1) * 4 + 2]
-  local payload = ARGV[3 + (i - 1) * 4 + 3]
-  local cause = ARGV[3 + (i - 1) * 4 + 4]
+  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)
+    'cause', cause, 'lane', lane)
   redis.call('HSET', KEYS[3], id, cjson.encode({ ARGV[1], idx }))
+  redis.call('HSET', KEYS[5], tostring(idx) .. ':l', lane)
+  if settled == '1' then
+    redis.call('HSET', KEYS[5], tostring(idx) .. ':p', ARGV[2])
+  else
+    enqueue(tostring(idx), idx, lane)
+  end
 end
 redis.call('SET', KEYS[2], tostring(base + n))
 redis.call('ZADD', KEYS[4], 0, ARGV[1])
-return { 'ok', tostring(base + 1) }
+has_pending = redis.call('ZCARD', KEYS[6]) > 0 and '1' or '0'
+return { 'ok', tostring(base + 1), has_pending }
 `;
-/** KEYS: counter, meta. ARGV: idx, value, field suffix. Returns 0|1. */
-const MARK_LUA = `
-local idx = tonumber(ARGV[1])
-local total = tonumber(redis.call('GET', KEYS[1]) or '0')
-if idx < 1 or idx > total then
-  return 0
-end
-local target = ARGV[1] .. ':' .. ARGV[3]
-if ARGV[3] ~= 'p' or redis.call('HEXISTS', KEYS[2], target) == 0 then
-  redis.call('HSET', KEYS[2], target, ARGV[2])
+/** KEYS: counter, meta, pending, ready. ARGV: idx, attempt, error, maxFailures, nowMs. */
+const FAIL_ATTEMPT_LUA = `
+local function lane_field(lane, suffix)
+  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
-if ARGV[3] == 'p' then
-  local head = tonumber(redis.call('HGET', KEYS[2], '__head') or '1')
-  while head <= total and redis.call('HEXISTS', KEYS[2], tostring(head) .. ':p') == 1 do
-    head = head + 1
+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
-  redis.call('HSET', KEYS[2], '__head', tostring(head))
 end
-return 1
-`;
-/** KEYS: counter, meta. ARGV: idx, attempt, error, maxFailures, nowMs. */
-const FAIL_ATTEMPT_LUA = `
 local idx = tonumber(ARGV[1])
 if idx < 1 or idx > tonumber(redis.call('GET', KEYS[1]) or '0') then
   return { 'missing', '0' }
@@ -102,143 +135,225 @@ 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)
   return { 'dead_lettered', tostring(failures) }
 end
 return { 'failed', tostring(failures) }
 `;
 /**
-* KEYS: log, counter, meta, lease.
-* ARGV: holder, nowMs, expiresAtMs, gcPxMs, maxIndex (-1 = unbounded).
+* KEYS: log, counter, meta, pending, ready.
+* ARGV: holder, nowMs, expiresAtMs, excludedCount, excluded indexes.
 */
-const CLAIM_NEXT_LUA = `
-local total = tonumber(redis.call('GET', KEYS[2]) or '0')
-local rawHead = redis.call('HGET', KEYS[3], '__head')
-local head = tonumber(rawHead or '1')
-while head <= total and redis.call('HEXISTS', KEYS[3], tostring(head) .. ':p') == 1 do
-  head = head + 1
-end
-if total > 0 or rawHead then
-  redis.call('HSET', KEYS[3], '__head', tostring(head))
+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 head > total then return { 'settled' } end
-local field = tostring(head)
-local maxIndex = tonumber(ARGV[5])
-if redis.call('HEXISTS', KEYS[3], field .. ':f') == 1 or
-   (maxIndex >= 0 and head > maxIndex) then
-  return { 'settled' }
+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
-
-local cur = redis.call('GET', KEYS[4])
-if cur then
-  local rec = cjson.decode(cur)
-  if rec[2] > tonumber(ARGV[2]) and rec[1] ~= ARGV[1] then
-    return { 'busy' }
+if retry_at then return { 'busy', tostring(retry_at) } end
+return { 'settled' }
+`;
+/**
+* KEYS: counter, meta. ARGV: holder, nowMs, expiresAtMs, n, indexes.
+*/
+const RENEW_CLAIMS_LUA = `
+local total = tonumber(redis.call('GET', KEYS[1]) or '0')
+local renewed = {}
+for i = 1, tonumber(ARGV[4]) do
+  local field = ARGV[4 + i]
+  local idx = tonumber(field)
+  local expires = tonumber(redis.call('HGET', KEYS[2], field .. ':ce') or '0')
+  if idx >= 1 and idx <= total and
+     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
-local lease = cjson.encode({ ARGV[1], tonumber(ARGV[3]) })
-redis.call('SET', KEYS[4], lease, 'PX', ARGV[4])
-
-local failures = tonumber(redis.call('HGET', KEYS[3], field .. ':a') or '0')
-local dispatches = tonumber(redis.call('HGET', KEYS[3], field .. ':d') or '0')
-local attempt = dispatches + 1
-redis.call('HSETNX', KEYS[3], field .. ':fc', ARGV[2])
-redis.call('HSET', KEYS[3], field .. ':d', tostring(attempt), field .. ':lc', ARGV[2])
-local entries = redis.call('XRANGE', KEYS[1], field .. '-0', field .. '-0')
-if #entries == 0 then return { 'missing' } end
-return {
-  'claimed', tostring(attempt), tostring(failures),
-  redis.call('HGET', KEYS[3], field .. ':e') or false,
-  redis.call('HGET', KEYS[3], field .. ':fc') or false,
-  redis.call('HGET', KEYS[3], field .. ':lc') or false,
-  redis.call('HGET', KEYS[3], field .. ':lf') or false,
-  redis.call('HGET', KEYS[3], field .. ':lfa') or false,
-  entries[1]
-}
+return renewed
 `;
 /**
-* KEYS: log, counter, meta, lease.
-* ARGV: holder, nowMs, completedIndex, attempt, maxIndex (-1 = unbounded).
+* KEYS: log, counter, ids, session index, meta, pending, ready.
+* ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
+* id, type, payloadJson, lane, settled.
 */
-const COMPLETE_AND_CLAIM_NEXT_LUA = `
-local total = tonumber(redis.call('GET', KEYS[2]) or '0')
-local completed = tonumber(ARGV[3])
-if completed < 1 or completed > total then return { 'missing' } end
-local completedField = ARGV[3]
-local completedDispatches = tonumber(redis.call('HGET', KEYS[3], completedField .. ':d') or '0')
-if redis.call('HEXISTS', KEYS[3], completedField .. ':p') == 1 or
-   completedDispatches ~= tonumber(ARGV[4]) then
-  return { 'superseded' }
+const COMPLETE_ATTEMPT_LUA = `
+local function lane_field(lane, suffix)
+  return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
-redis.call('HSET', KEYS[3],
-  completedField .. ':p', ARGV[2],
-  completedField .. ':pa', ARGV[4])
-
-local head = tonumber(redis.call('HGET', KEYS[3], '__head') or '1')
-while head <= total and redis.call('HEXISTS', KEYS[3], tostring(head) .. ':p') == 1 do
-  head = head + 1
+local function settle(field)
+  redis.call('ZREM', KEYS[6], field)
+  redis.call('ZREM', KEYS[7], field)
+  local lane = redis.call('HGET', KEYS[5], field .. ':l') or ''
+  if lane == '' then return end
+  local head_key = lane_field(lane, 'head')
+  if redis.call('HGET', KEYS[5], head_key) ~= field then return end
+  local next_field = redis.call('HGET', KEYS[5], field .. ':next')
+  while next_field and redis.call('HEXISTS', KEYS[5], next_field .. ':p') == 1 do
+    next_field = redis.call('HGET', KEYS[5], next_field .. ':next')
+  end
+  if next_field then
+    redis.call('HSET', KEYS[5], head_key, next_field)
+    if redis.call('HEXISTS', KEYS[5], next_field .. ':f') == 0 then
+      redis.call('ZADD', KEYS[7], tonumber(next_field), next_field)
+    end
+  else
+    redis.call('HDEL', KEYS[5], head_key, lane_field(lane, 'tail'))
+  end
 end
-redis.call('HSET', KEYS[3], '__head', tostring(head))
-if head > total then return { 'settled' } end
-local field = tostring(head)
-local maxIndex = tonumber(ARGV[5])
-if redis.call('HEXISTS', KEYS[3], field .. ':f') == 1 or
-   (maxIndex >= 0 and head > maxIndex) then
-  return { 'settled' }
+local function enqueue(field, idx, lane)
+  redis.call('ZADD', KEYS[6], idx, field)
+  if lane == '' then
+    redis.call('ZADD', KEYS[7], idx, field)
+    return
+  end
+  local tail_key = lane_field(lane, 'tail')
+  local tail = redis.call('HGET', KEYS[5], tail_key)
+  if tail then
+    redis.call('HSET', KEYS[5], tail .. ':next', field)
+  else
+    redis.call('HSET', KEYS[5], lane_field(lane, 'head'), field)
+    redis.call('ZADD', KEYS[7], idx, field)
+  end
+  redis.call('HSET', KEYS[5], tail_key, field)
 end
-
-local cur = redis.call('GET', KEYS[4])
-if not cur then return { 'busy' } end
-local lease = cjson.decode(cur)
-if lease[1] ~= ARGV[1] or lease[2] <= tonumber(ARGV[2]) then
-  return { 'busy' }
+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[5], parent .. ':d') or '0')
+local processed = redis.call('HGET', KEYS[5], parent .. ':p')
+local processed_attempt = tonumber(redis.call('HGET', KEYS[5], parent .. ':pa') or '0')
+if processed then
+  if processed_attempt ~= attempt then return { 'superseded' } end
+  local raw_recorded_ids = redis.call('HGET', KEYS[5], 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
-
-local failures = tonumber(redis.call('HGET', KEYS[3], field .. ':a') or '0')
-local dispatches = tonumber(redis.call('HGET', KEYS[3], field .. ':d') or '0')
-local attempt = dispatches + 1
-redis.call('HSETNX', KEYS[3], field .. ':fc', ARGV[2])
-redis.call('HSET', KEYS[3], field .. ':d', tostring(attempt), field .. ':lc', ARGV[2])
-local entries = redis.call('XRANGE', KEYS[1], field .. '-0', field .. '-0')
-if #entries == 0 then return { 'missing' } end
-return {
-  'claimed', tostring(attempt), tostring(failures),
-  redis.call('HGET', KEYS[3], field .. ':e') or false,
-  redis.call('HGET', KEYS[3], field .. ':fc') or false,
-  redis.call('HGET', KEYS[3], field .. ':lc') or false,
-  redis.call('HGET', KEYS[3], field .. ':lf') or false,
-  redis.call('HGET', KEYS[3], field .. ':lfa') or false,
-  entries[1]
-}
-`;
-/**
-* KEYS: lease. ARGV: holder, nowMs, expiresAtMs, gcPxMs. Logical expiry is
-* the stored expiresAt vs now (exclusive: expiresAt <= now is free) —
-* the PX is garbage collection only, never the semantics.
-*/
-const LEASE_ACQUIRE_LUA = `
-local cur = redis.call('GET', KEYS[1])
-if cur then
-  local rec = cjson.decode(cur)
-  if rec[2] > tonumber(ARGV[2]) and rec[1] ~= ARGV[1] then return 0 end
+if dispatches ~= attempt then return { 'superseded' } end
+if redis.call('HEXISTS', KEYS[5], parent .. ':ch') == 0 or
+   redis.call('HEXISTS', KEYS[5], parent .. ':f') == 1 or
+   tonumber(redis.call('HGET', KEYS[5], parent .. ':lfa') or '0') == attempt then
+  return { 'superseded' }
 end
-local rec = cjson.encode({ ARGV[1], tonumber(ARGV[3]) })
-redis.call('SET', KEYS[1], rec, 'PX', ARGV[4])
-return 1
-`;
-/** KEYS: lease. ARGV: holder. Only the holder may release. */
-const LEASE_RELEASE_LUA = `
-local cur = redis.call('GET', KEYS[1])
-if cur and cjson.decode(cur)[1] == ARGV[1] then
-  redis.call('DEL', KEYS[1])
+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
-return 1
+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[5],
+  parent .. ':p', ARGV[2],
+  parent .. ':pa', ARGV[4],
+  parent .. ':ri', returned_json)
+redis.call('HDEL', KEYS[5], parent .. ':ch', parent .. ':ce')
+settle(parent)
+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[5], tostring(idx) .. ':l', lane)
+  if settled == '1' then
+    redis.call('HSET', KEYS[5], tostring(idx) .. ':p', ARGV[2])
+  else
+    enqueue(tostring(idx), idx, lane)
+  end
+end
+redis.call('SET', KEYS[2], tostring(total + n))
+redis.call('ZADD', KEYS[4], 0, ARGV[1])
+return { 'ok', tostring(total + 1) }
 `;
 /** KEYS: snapshot. ARGV: upToIndex, json. Guarded: never move backward. */
 const PUT_SNAPSHOT_LUA = `
@@ -282,38 +397,53 @@ 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)
+		attempt: Number(value.attempt),
+		...value.batchSize === void 0 ? {} : { batchSize: Number(value.batchSize) }
 	};
 };
-const toClaimResult = (sessionId, reply) => {
+const toClaimAvailableResult = (sessionId, reply) => {
 	const outcome = String(reply[0]);
 	if (outcome === "claimed") {
-		const entry = reply[8];
-		const event = toEvent(sessionId, entry);
-		const fields = fieldMap(entry[1]);
-		return {
-			outcome: "claimed",
-			event: Object.assign(event, {
+		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,
-				firstClaimedAt: reply[4] === null ? null : new Date(Number(reply[4])),
-				lastClaimedAt: reply[5] === null ? null : new Date(Number(reply[5])),
-				attemptCount: Number(reply[1]),
-				failureCount: Number(reply[2]),
-				lastFailedAt: reply[6] === null ? null : new Date(Number(reply[6])),
-				lastFailedAttempt: reply[7] === null ? null : Number(reply[7]),
-				lastError: reply[3] === null ? null : String(reply[3]),
+				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" || outcome === "settled") return { outcome };
+	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 toHandoffResult = (sessionId, reply) => String(reply[0]) === "superseded" ? { outcome: "superseded" } : toClaimResult(sessionId, reply);
 const wrap = async (fn) => {
 	try {
 		return await fn();
@@ -330,14 +460,15 @@ function redis(options = {}) {
 	const logKey = (s) => `${prefix}:${s}:log`;
 	const countKey = (s) => `${prefix}:${s}:count`;
 	const metaKey = (s) => `${prefix}:${s}:meta`;
-	const leaseKey = (s) => `${prefix}:${s}:lease`;
+	const pendingKey = (s) => `${prefix}:${s}:pending`;
+	const readyKey = (s) => `${prefix}:${s}:ready`;
 	const snapKey = (s, r) => `${prefix}:${s}:snap:${r}`;
 	const idsKey = `${prefix}:ids`;
 	const sessionsKey = `${prefix}:sessions`;
 	const connection = retryableLazy(async () => {
 		if (options.client) return options.client;
 		return new (await (import("ioredis").catch(() => {
-			throw new A2Error("LOG_NOT_CONFIGURED", "a2/log-redis with a url needs the 'ioredis' package (optional peer dependency) — install it, or inject a client");
+			throw new A2Error("LOG_NOT_CONFIGURED", "experimental-a2/log-redis with a url needs the 'ioredis' package (optional peer dependency) — install it, or inject a client");
 		}))).default(options.url);
 	});
 	const client = connection.get;
@@ -346,18 +477,6 @@ function redis(options = {}) {
 	};
 	/** Every live-feed connection, so close() can sever them. */
 	const streamConnections = /* @__PURE__ */ new Set();
-	const ensureSessionIndex = retryableLazy(() => wrap(async () => {
-		const c = await client();
-		let cursor = "0";
-		const keyStart = `${prefix}:`;
-		const keyEnd = ":count";
-		do {
-			const reply = await c.call("SCAN", cursor, "MATCH", `${escapeGlob(prefix)}:*:count`, "COUNT", 200);
-			cursor = reply[0];
-			const ids = reply[1].filter((key) => key.startsWith(keyStart) && key.endsWith(keyEnd)).map((key) => key.slice(keyStart.length, -6));
-			if (ids.length > 0) await c.call("ZADD", sessionsKey, ...ids.flatMap((id) => [0, id]));
-		} while (cursor !== "0");
-	})).get;
 	/** XRANGE + meta merge — the raw read both `read` and dup-returns use. */
 	const readRange = async (sessionId, afterIndex) => {
 		const c = await client();
@@ -370,6 +489,9 @@ function redis(options = {}) {
 			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`];
@@ -377,11 +499,15 @@ function redis(options = {}) {
 			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 : JSON.parse(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),
@@ -392,7 +518,6 @@ function redis(options = {}) {
 	};
 	return {
 		async append(sessionId, events) {
-			if (events.length === 0) return [];
 			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");
@@ -401,7 +526,9 @@ function redis(options = {}) {
 					id: e.id ?? generateId(),
 					type: e.type,
 					payload: e.payload,
-					cause: e.cause ? { ...e.cause } : null
+					cause: e.cause ? { ...e.cause } : null,
+					lane: e.lane ?? null,
+					settled: e.settled === true
 				}));
 				const args = [
 					sessionId,
@@ -411,101 +538,195 @@ function redis(options = {}) {
 						e.id,
 						e.type,
 						json(e.payload),
-						e.cause ? json(e.cause) : ""
+						e.cause ? json(e.cause) : "",
+						e.lane ?? "",
+						e.settled ? "1" : "0"
 					])
 				];
 				const reply = await evalScript(APPEND_LUA, [
 					logKey(sessionId),
 					countKey(sessionId),
 					idsKey,
-					sessionsKey
+					sessionsKey,
+					metaKey(sessionId),
+					pendingKey(sessionId),
+					readyKey(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 === "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 wanted = new Set(reply.slice(1).map(Number));
+					const hasPending = reply[1] === "1";
+					const wanted = new Set(reply.slice(2).map(Number));
 					const min = Math.min(...wanted);
-					return (await readRange(sessionId, min - 1)).filter((r) => wanted.has(r.index));
+					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 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,
-					processedAt: null,
-					processedByAttempt: null,
-					firstClaimedAt: null,
-					lastClaimedAt: null,
-					attemptCount: 0,
-					failureCount: 0,
-					lastFailedAt: null,
-					lastFailedAttempt: null,
-					lastError: null,
-					failedAt: null
-				}));
+				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 () => {
-				const rows = await readRange(sessionId, opts?.afterIndex ?? 0);
-				return opts?.unprocessedOnly ? rows.filter((r) => r.processedAt === null) : rows;
+				return await readRange(sessionId, opts?.afterIndex ?? 0);
 			});
 		},
-		async claimNext({ sessionId, holder, ttlMs, expiresAtMs, maxIndex }) {
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes }) {
 			return wrap(async () => {
 				const now = clock.now().getTime();
 				const expiresAt = expiresAtMs ?? now + ttlMs;
-				const effectiveTtlMs = Math.max(1, expiresAt - now);
-				const gcPx = Math.max(effectiveTtlMs * 10, 6e4);
-				const reply = await evalScript(CLAIM_NEXT_LUA, [
+				const excluded = excludeIndexes ?? [];
+				const reply = await evalScript(CLAIM_AVAILABLE_LUA, [
 					logKey(sessionId),
 					countKey(sessionId),
 					metaKey(sessionId),
-					leaseKey(sessionId)
+					pendingKey(sessionId),
+					readyKey(sessionId)
 				], [
 					holder,
 					now,
 					expiresAt,
-					gcPx,
-					maxIndex ?? -1
+					excluded.length,
+					...excluded
 				]);
-				return toClaimResult(sessionId, reply);
+				return toClaimAvailableResult(sessionId, reply);
 			});
 		},
-		async completeAndClaimNext({ sessionId, holder, completedIndex, attempt, maxIndex }) {
+		async renewClaims({ sessionId, holder, indexes, ttlMs, expiresAtMs }) {
 			return wrap(async () => {
-				const reply = await evalScript(COMPLETE_AND_CLAIM_NEXT_LUA, [
+				const now = clock.now().getTime();
+				const expiresAt = expiresAtMs ?? now + ttlMs;
+				return (await evalScript(RENEW_CLAIMS_LUA, [countKey(sessionId), metaKey(sessionId)], [
+					holder,
+					now,
+					expiresAt,
+					indexes.length,
+					...indexes
+				])).map(Number);
+			});
+		},
+		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, [
 					logKey(sessionId),
 					countKey(sessionId),
+					idsKey,
+					sessionsKey,
 					metaKey(sessionId),
-					leaseKey(sessionId)
+					pendingKey(sessionId),
+					readyKey(sessionId)
 				], [
-					holder,
-					clock.now().getTime(),
-					completedIndex,
+					sessionId,
+					now,
+					index,
 					attempt,
-					maxIndex ?? -1
+					events.length,
+					...events.flatMap((event) => [
+						event.id,
+						event.type,
+						json(event.payload),
+						event.lane ?? "",
+						event.settled === true ? "1" : "0"
+					])
 				]);
-				return toHandoffResult(sessionId, reply);
-			});
-		},
-		async markProcessed(sessionId, index) {
-			await wrap(async () => {
-				if (await evalScript(MARK_LUA, [countKey(sessionId), metaKey(sessionId)], [
+				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,
-					clock.now().getTime(),
-					"p"
-				]) === 0) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+					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)], [
+				const reply = await evalScript(FAIL_ATTEMPT_LUA, [
+					countKey(sessionId),
+					metaKey(sessionId),
+					pendingKey(sessionId),
+					readyKey(sessionId)
+				], [
 					index,
 					attempt,
 					error,
@@ -520,15 +741,6 @@ function redis(options = {}) {
 				};
 			});
 		},
-		async markFailed(sessionId, index) {
-			await wrap(async () => {
-				if (await evalScript(MARK_LUA, [countKey(sessionId), metaKey(sessionId)], [
-					index,
-					clock.now().getTime(),
-					"f"
-				]) === 0) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
-			});
-		},
 		async readState(sessionId, reducerName) {
 			return wrap(async () => {
 				const reply = await evalScript(READ_STATE_LUA, [snapKey(sessionId, reducerName), logKey(sessionId)], []);
@@ -555,7 +767,6 @@ function redis(options = {}) {
 		inspect: {
 			async listSessions(inspectionOptions) {
 				return wrap(async () => {
-					await ensureSessionIndex();
 					const c = await client();
 					const minimum = inspectionOptions.cursor === void 0 ? `[${inspectionOptions.prefix}` : `(${inspectionOptions.cursor}`;
 					const candidates = await c.call("ZRANGEBYLEX", sessionsKey, minimum, "+", "LIMIT", 0, inspectionOptions.limit + 1);
@@ -677,27 +888,6 @@ function redis(options = {}) {
 				};
 			} };
 		},
-		lease: {
-			async acquire({ sessionId, holder, ttlMs, expiresAtMs }) {
-				return wrap(async () => {
-					const now = clock.now().getTime();
-					const expiresAt = expiresAtMs ?? now + ttlMs;
-					const effectiveTtlMs = Math.max(1, expiresAt - now);
-					const gcPx = Math.max(effectiveTtlMs * 10, 6e4);
-					return await evalScript(LEASE_ACQUIRE_LUA, [leaseKey(sessionId)], [
-						holder,
-						now,
-						expiresAt,
-						gcPx
-					]) === 1;
-				});
-			},
-			async release({ sessionId, holder }) {
-				await wrap(async () => {
-					await evalScript(LEASE_RELEASE_LUA, [leaseKey(sessionId)], [holder]);
-				});
-			}
-		},
 		async close() {
 			for (const conn of streamConnections) conn.disconnect();
 			streamConnections.clear();