experimental-a2 0.6.0 → 0.8.0

package/dist/{store-redis-core-BFLwz0Wj.js → store-redis-core-DT01r4GZ.js}

@@ -1,12 +1,12 @@
 import { t as A2Error } from "./errors-BQuJpe82.js";
-import { g as nullProtoRecord } from "./internal-DstsI6Re.js";
+import { h as nullProtoRecord } from "./internal-DRXJ56EI.js";
 import { t as idempotentReplay } from "./idempotent-replay-DuqEkYA7.js";
 import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
 //#region src/store-redis-core.ts
 const READ_PAGE_SIZE = 256;
 /**
-* KEYS: store stream, counter, global id hash, session index, metadata,
-* pending, ready, watched.
+* KEYS: store stream, counter, global id hash, metadata, pending, ready,
+* watched.
 * ARGV: sessionId, nowMs, n, then per event:
 * id, type, payloadJson, causeJson, lane, settled.
 * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending, watched] |
@@ -18,24 +18,24 @@ 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)
+  redis.call('ZADD', KEYS[5], idx, field)
   if lane == '' then
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('ZADD', KEYS[6], idx, field)
     return
   end
   local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[5], tail_key)
+  local tail = redis.call('HGET', KEYS[4], tail_key)
   if tail then
-    redis.call('HSET', KEYS[5], tail .. ':next', field)
+    redis.call('HSET', KEYS[4], tail .. ':next', field)
   else
-    redis.call('HSET', KEYS[5], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
+    redis.call('ZADD', KEYS[6], idx, field)
   end
-  redis.call('HSET', KEYS[5], tail_key, field)
+  redis.call('HSET', KEYS[4], tail_key, field)
 end
 local n = tonumber(ARGV[3])
 local base = tonumber(redis.call('GET', KEYS[2]) or '0')
-local has_pending = redis.call('ZCARD', KEYS[6]) > 0 and '1' or '0'
+local has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
 if n == 0 then return { 'empty', has_pending } end
 local dups = {}
 for i = 1, n do
@@ -62,9 +62,9 @@ for i = 1, n do
       return { 'no_parent', tostring(parsed.index) }
     end
     local field = tostring(pidx)
-    local dispatches = tonumber(redis.call('HGET', KEYS[5], field .. ':d') or '0')
+    local dispatches = tonumber(redis.call('HGET', KEYS[4], field .. ':d') or '0')
     if dispatches ~= tonumber(parsed.attempt) or
-       redis.call('HEXISTS', KEYS[5], field .. ':f') == 1 then
+       redis.call('HEXISTS', KEYS[4], field .. ':f') == 1 then
       return { 'superseded', field }
     end
   end
@@ -81,21 +81,36 @@ for i = 1, n do
     '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)
+  redis.call('HSET', KEYS[4], tostring(idx) .. ':l', lane)
   if settled == '1' then
-    redis.call('HSET', KEYS[5], tostring(idx) .. ':p', ARGV[2])
+    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
   else
     enqueue(tostring(idx), idx, lane)
   end
 end
 redis.call('SET', KEYS[2], tostring(base + n))
-redis.call('ZADD', KEYS[4], 0, ARGV[1])
-has_pending = redis.call('ZCARD', KEYS[6]) > 0 and '1' or '0'
+has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
 return { 'ok', tostring(base + 1), has_pending,
-  tostring(redis.call('EXISTS', KEYS[8])) }
+  tostring(redis.call('EXISTS', KEYS[7])) }
 `;
-/** KEYS: counter, meta, pending, ready. ARGV: idx, attempt, error, maxFailures, nowMs. */
+/**
+* KEYS: counter, meta, pending, ready, event snapshot pins, snapshot pin counts.
+* ARGV: idx, attempt, error, maxFailures, nowMs.
+*/
 const FAIL_ATTEMPT_LUA = `
+local function release_snapshot_pins()
+  local refs = redis.call('SMEMBERS', KEYS[5])
+  for _, ref in ipairs(refs) do
+    local count = redis.call('HINCRBY', KEYS[6], ref, -1)
+    if count <= 0 then
+      redis.call('HDEL', KEYS[6], ref)
+      local checkpoint = cjson.decode(ref)
+      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
+    end
+  end
+  redis.call('DEL', KEYS[5])
+  if redis.call('HLEN', KEYS[6]) == 0 then redis.call('DEL', KEYS[6]) end
+end
 local function lane_field(lane, suffix)
   return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
@@ -149,6 +164,7 @@ redis.call('HDEL', KEYS[2], field .. ':ch', field .. ':ce')
 if failures >= tonumber(ARGV[4]) then
   redis.call('HSET', KEYS[2], field .. ':f', ARGV[5])
   redis.call('ZREM', KEYS[4], field)
+  release_snapshot_pins()
   return { 'dead_lettered', tostring(failures) }
 end
 return { 'failed', tostring(failures) }
@@ -239,61 +255,75 @@ for i = 1, #superseded do result[#result + 1] = superseded[i] end
 return result
 `;
 /**
-* KEYS: store, counter, ids, session index, meta, pending, ready, watched.
+* KEYS: store, counter, ids, meta, pending, ready, watched,
+* event snapshot pins, snapshot pin counts.
 * ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
 * id, type, payloadJson, lane, settled.
 */
 const COMPLETE_ATTEMPT_LUA = `
+local function release_snapshot_pins()
+  local refs = redis.call('SMEMBERS', KEYS[8])
+  for _, ref in ipairs(refs) do
+    local count = redis.call('HINCRBY', KEYS[9], ref, -1)
+    if count <= 0 then
+      redis.call('HDEL', KEYS[9], ref)
+      local checkpoint = cjson.decode(ref)
+      redis.call('ZREMRANGEBYSCORE', checkpoint[1], checkpoint[2], checkpoint[2])
+    end
+  end
+  redis.call('DEL', KEYS[8])
+  if redis.call('HLEN', KEYS[9]) == 0 then redis.call('DEL', KEYS[9]) end
+end
 local function lane_field(lane, suffix)
   return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
 local function settle(field)
+  redis.call('ZREM', KEYS[5], field)
   redis.call('ZREM', KEYS[6], field)
-  redis.call('ZREM', KEYS[7], field)
-  local lane = redis.call('HGET', KEYS[5], field .. ':l') or ''
+  local lane = redis.call('HGET', KEYS[4], field .. ':l') or ''
   if lane == '' then return end
   local head_key = lane_field(lane, 'head')
-  if redis.call('HGET', KEYS[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')
+  if redis.call('HGET', KEYS[4], head_key) ~= field then return end
+  local next_field = redis.call('HGET', KEYS[4], field .. ':next')
+  while next_field and redis.call('HEXISTS', KEYS[4], next_field .. ':p') == 1 do
+    next_field = redis.call('HGET', KEYS[4], next_field .. ':next')
   end
   if next_field then
-    redis.call('HSET', KEYS[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)
+    redis.call('HSET', KEYS[4], head_key, next_field)
+    if redis.call('HEXISTS', KEYS[4], next_field .. ':f') == 0 then
+      redis.call('ZADD', KEYS[6], tonumber(next_field), next_field)
     end
   else
-    redis.call('HDEL', KEYS[5], head_key, lane_field(lane, 'tail'))
+    redis.call('HDEL', KEYS[4], head_key, lane_field(lane, 'tail'))
   end
 end
 local function enqueue(field, idx, lane)
-  redis.call('ZADD', KEYS[6], idx, field)
+  redis.call('ZADD', KEYS[5], idx, field)
   if lane == '' then
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('ZADD', KEYS[6], idx, field)
     return
   end
   local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[5], tail_key)
+  local tail = redis.call('HGET', KEYS[4], tail_key)
   if tail then
-    redis.call('HSET', KEYS[5], tail .. ':next', field)
+    redis.call('HSET', KEYS[4], tail .. ':next', field)
   else
-    redis.call('HSET', KEYS[5], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
+    redis.call('ZADD', KEYS[6], idx, field)
   end
-  redis.call('HSET', KEYS[5], tail_key, field)
+  redis.call('HSET', KEYS[4], tail_key, field)
 end
 local parent = ARGV[3]
 local attempt = tonumber(ARGV[4])
 local n = tonumber(ARGV[5])
 local total = tonumber(redis.call('GET', KEYS[2]) or '0')
 if tonumber(parent) < 1 or tonumber(parent) > total then return { 'missing' } end
-local dispatches = tonumber(redis.call('HGET', KEYS[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')
+local dispatches = tonumber(redis.call('HGET', KEYS[4], parent .. ':d') or '0')
+local processed = redis.call('HGET', KEYS[4], parent .. ':p')
+local processed_attempt = tonumber(redis.call('HGET', KEYS[4], parent .. ':pa') or '0')
 if processed then
   if processed_attempt ~= attempt then return { 'superseded' } end
-  local raw_recorded_ids = redis.call('HGET', KEYS[5], parent .. ':ri')
+  local raw_recorded_ids = redis.call('HGET', KEYS[4], parent .. ':ri')
   if not raw_recorded_ids then return { 'partial' } end
   local recorded_ids = cjson.decode(raw_recorded_ids)
   if #recorded_ids ~= n then return { 'partial' } end
@@ -323,9 +353,9 @@ if processed then
   return result
 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
+if redis.call('HEXISTS', KEYS[4], parent .. ':ch') == 0 or
+   redis.call('HEXISTS', KEYS[4], parent .. ':f') == 1 or
+   tonumber(redis.call('HGET', KEYS[4], parent .. ':lfa') or '0') == attempt then
   return { 'superseded' }
 end
 for i = 1, n do
@@ -336,12 +366,13 @@ 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],
+redis.call('HSET', KEYS[4],
   parent .. ':p', ARGV[2],
   parent .. ':pa', ARGV[4],
   parent .. ':ri', returned_json)
-redis.call('HDEL', KEYS[5], parent .. ':ch', parent .. ':ce')
+redis.call('HDEL', KEYS[4], parent .. ':ch', parent .. ':ce')
 settle(parent)
+release_snapshot_pins()
 local cause = cjson.encode({ index = tonumber(parent), attempt = attempt })
 for i = 1, n do
   local id = ARGV[5 + (i - 1) * 5 + 1]
@@ -354,25 +385,72 @@ for i = 1, n do
     '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)
+  redis.call('HSET', KEYS[4], tostring(idx) .. ':l', lane)
   if settled == '1' then
-    redis.call('HSET', KEYS[5], tostring(idx) .. ':p', ARGV[2])
+    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
   else
     enqueue(tostring(idx), idx, lane)
   end
 end
 redis.call('SET', KEYS[2], tostring(total + n))
-redis.call('ZADD', KEYS[4], 0, ARGV[1])
 return { 'ok', tostring(total + 1),
-  tostring(redis.call('EXISTS', KEYS[8])) }
+  tostring(redis.call('EXISTS', KEYS[7])) }
 `;
-/** KEYS: snapshot. ARGV: upToIndex, json. Guarded: never move backward. */
-const PUT_SNAPSHOT_LUA = `
-local cur = redis.call('GET', KEYS[1])
-if cur and tonumber(cjson.decode(cur)['index']) >= tonumber(ARGV[1]) then
-  return 0
+/**
+* KEYS: head, history, event counter, event meta, pin counts.
+* ARGV: nowMs, event pin key prefix, write count, then per write:
+* index, snapshot JSON, pin count, pin event indexes.
+*/
+const PUT_SNAPSHOTS_LUA = `
+local total = tonumber(redis.call('GET', KEYS[3]) or '0')
+local writes = {}
+local offset = 4
+for i = 1, tonumber(ARGV[3]) do
+  local index = tonumber(ARGV[offset])
+  local snapshot = ARGV[offset + 1]
+  local pin_count = tonumber(ARGV[offset + 2])
+  local ref = cjson.encode({ KEYS[2], tostring(index) })
+  for p = 1, pin_count do
+    local event_index = tonumber(ARGV[offset + 2 + p])
+    if event_index >= 1 and event_index <= total and
+       redis.call('HEXISTS', KEYS[4], tostring(event_index) .. ':p') == 0 and
+       redis.call('HEXISTS', KEYS[4], tostring(event_index) .. ':f') == 0 then
+      local pin_key = ARGV[2] .. tostring(event_index)
+      if redis.call('SADD', pin_key, ref) == 1 then
+        redis.call('HINCRBY', KEYS[5], ref, 1)
+      end
+    end
+  end
+  writes[#writes + 1] = { index = index, snapshot = snapshot, ref = ref }
+  offset = offset + 3 + pin_count
+end
+
+local head = redis.call('GET', KEYS[1])
+local head_index = nil
+if head then head_index = tonumber(cjson.decode(head)['index']) end
+local latest = writes[#writes]
+local writes_head = not head_index or latest.index >= head_index
+local advances = not head_index or latest.index > head_index
+local final_head_index = advances and latest.index or head_index
+
+if advances and head and tonumber(redis.call('HGET', KEYS[5], cjson.encode({ KEYS[2], tostring(head_index) })) or '0') > 0 then
+  redis.call('ZREMRANGEBYSCORE', KEYS[2], head_index, head_index)
+  redis.call('ZADD', KEYS[2], head_index, head)
+end
+
+for _, write in ipairs(writes) do
+  if write.index < final_head_index then
+    redis.call('ZREMRANGEBYSCORE', KEYS[2], write.index, write.index)
+    if tonumber(redis.call('HGET', KEYS[5], write.ref) or '0') > 0 then
+      redis.call('ZADD', KEYS[2], write.index, write.snapshot)
+    end
+  end
+end
+
+if writes_head then
+  redis.call('SET', KEYS[1], latest.snapshot)
+  redis.call('ZREMRANGEBYSCORE', KEYS[2], latest.index, latest.index)
 end
-redis.call('SET', KEYS[1], ARGV[2])
 return 1
 `;
 /**
@@ -426,11 +504,26 @@ for i = 1, #rows, 2 do
 end
 return live
 `;
-/** KEYS: snapshot, event counter. Returns one atomic cache-plus-frontier read. */
+/**
+* KEYS: head, history, event counter. ARGV: snapshot frontier or ''.
+* Returns one atomic multiversion-cache-plus-log-frontier read.
+*/
 const READ_STATE_LUA = `
-local snapshot = redis.call('GET', KEYS[1])
-local frontier = redis.call('GET', KEYS[2]) or '0'
-return { snapshot or '', frontier }
+local head = redis.call('GET', KEYS[1])
+local cap = ARGV[1]
+local snapshot = nil
+if head and (cap == '' or tonumber(cjson.decode(head)['index']) <= tonumber(cap)) then
+  snapshot = head
+end
+local upper = cap == '' and '+inf' or cap
+local historical = redis.call('ZREVRANGEBYSCORE', KEYS[2], upper, '-inf', 'LIMIT', 0, 1)
+if #historical > 0 then
+  if not snapshot or tonumber(cjson.decode(historical[1])['index']) > tonumber(cjson.decode(snapshot)['index']) then
+    snapshot = historical[1]
+  end
+end
+local frontier = redis.call('GET', KEYS[3]) or '0'
+return { head or '', snapshot or '', frontier }
 `;
 const fieldMap = (fields) => {
 	const map = {};
@@ -465,7 +558,6 @@ const toEvent = (sessionId, entry) => {
 	};
 };
 const json = (value) => JSON.stringify(value) ?? "null";
-const escapeGlob = (value) => value.replaceAll("\\", "\\\\").replaceAll("*", "\\*").replaceAll("?", "\\?").replaceAll("[", "\\[").replaceAll("]", "\\]");
 const toCause = (raw) => {
 	if (raw === "" || raw === void 0) return null;
 	const value = JSON.parse(raw);
@@ -535,10 +627,13 @@ function createRedisStoreCore(options) {
 	const pendingKey = (s) => `${prefix}:${s}:pending`;
 	const readyKey = (s) => `${prefix}:${s}:ready`;
 	const snapKey = (s, r) => `${prefix}:${s}:snap:${r}`;
+	const snapHistoryKey = (s, r) => `${prefix}:${s}:snap-history:${r}`;
+	const snapshotEventPinsKey = (s, index) => `${prefix}:${s}:snapshot-pins:${index}`;
+	const snapshotEventPinsPrefix = (s) => `${prefix}:${s}:snapshot-pins:`;
+	const snapshotPinCountsKey = (s) => `${prefix}:${s}:snapshot-pin-counts`;
 	const watchedKey = (s) => `${prefix}:${s}:watched`;
 	const presenceKey = (s) => `${prefix}:${s}:presence`;
 	const idsKey = `${prefix}:ids`;
-	const sessionsKey = `${prefix}:sessions`;
 	const evalScript = (script, keys, args) => call("EVAL", script, keys.length, ...keys, ...args);
 	const readFrontier = async (sessionId) => {
 		const frontier = Number(await call("GET", countKey(sessionId)) ?? 0);
@@ -658,7 +753,6 @@ function createRedisStoreCore(options) {
 					storeKey(sessionId),
 					countKey(sessionId),
 					idsKey,
-					sessionsKey,
 					metaKey(sessionId),
 					pendingKey(sessionId),
 					readyKey(sessionId),
@@ -767,11 +861,12 @@ function createRedisStoreCore(options) {
 					storeKey(sessionId),
 					countKey(sessionId),
 					idsKey,
-					sessionsKey,
 					metaKey(sessionId),
 					pendingKey(sessionId),
 					readyKey(sessionId),
-					watchedKey(sessionId)
+					watchedKey(sessionId),
+					snapshotEventPinsKey(sessionId, index),
+					snapshotPinCountsKey(sessionId)
 				], [
 					sessionId,
 					now,
@@ -848,7 +943,9 @@ function createRedisStoreCore(options) {
 					countKey(sessionId),
 					metaKey(sessionId),
 					pendingKey(sessionId),
-					readyKey(sessionId)
+					readyKey(sessionId),
+					snapshotEventPinsKey(sessionId, index),
+					snapshotPinCountsKey(sessionId)
 				], [
 					index,
 					attempt,
@@ -864,30 +961,65 @@ function createRedisStoreCore(options) {
 				};
 			});
 		},
-		async readState(sessionId, reducerName) {
+		async readState(sessionId, reducerName, stateOptions) {
 			return wrap(async () => {
-				const reply = await evalScript(READ_STATE_LUA, [snapKey(sessionId, reducerName), countKey(sessionId)], []);
-				const raw = reply[0];
+				const reply = await evalScript(READ_STATE_LUA, [
+					snapKey(sessionId, reducerName),
+					snapHistoryKey(sessionId, reducerName),
+					countKey(sessionId)
+				], [stateOptions?.snapshotThroughIndex ?? stateOptions?.throughIndex ?? ""]);
+				const rawHead = reply[0];
+				const raw = reply[1];
+				const head = rawHead === "" ? null : JSON.parse(rawHead);
 				const parsed = raw === "" ? null : JSON.parse(raw);
-				const frontier = Number(reply[1]);
-				if (!Number.isSafeInteger(frontier) || frontier < 0 || parsed !== null && (!Number.isSafeInteger(parsed.index) || parsed.index < 0)) throw new A2Error("STORE_UNAVAILABLE", `redis state frontier for session '${sessionId}' is invalid`);
-				const events = await readEventRange(sessionId, parsed?.index ?? 0, frontier);
+				const currentFrontier = Number(reply[2]);
+				if (!Number.isSafeInteger(currentFrontier) || currentFrontier < 0 || head !== null && (!Number.isSafeInteger(head.index) || head.index < 0) || parsed !== null && (!Number.isSafeInteger(parsed.index) || parsed.index < 0)) throw new A2Error("STORE_UNAVAILABLE", `redis state frontier for session '${sessionId}' is invalid`);
+				const frontier = Math.min(currentFrontier, stateOptions?.throughIndex ?? currentFrontier);
+				const snapshot = parsed;
+				const events = await readEventRange(sessionId, snapshot?.index ?? 0, frontier);
 				return {
-					snapshot: parsed ? {
-						index: parsed.index,
-						state: parsed.state
+					headIndex: head?.index ?? null,
+					snapshot: snapshot ? {
+						index: snapshot.index,
+						state: snapshot.state
 					} : null,
 					events
 				};
 			});
 		},
-		async putSnapshot(sessionId, reducerName, index, state) {
+		async putSnapshots(sessionId, reducerName, writes) {
+			const byIndex = /* @__PURE__ */ new Map();
+			for (const write of writes) {
+				const existing = byIndex.get(write.index);
+				if (existing) {
+					existing.state = write.state;
+					for (const eventIndex of write.pinEventIndexes ?? []) existing.pinEventIndexes.add(eventIndex);
+				} else byIndex.set(write.index, {
+					index: write.index,
+					state: write.state,
+					pinEventIndexes: new Set(write.pinEventIndexes ?? [])
+				});
+			}
+			const normalized = [...byIndex.values()].toSorted((a, b) => a.index - b.index);
+			if (normalized.length === 0) return;
 			await wrap(async () => {
-				await evalScript(PUT_SNAPSHOT_LUA, [snapKey(sessionId, reducerName)], [index, json({
-					index,
-					state,
+				const args = [
+					clock.now().getTime(),
+					snapshotEventPinsPrefix(sessionId),
+					normalized.length
+				];
+				for (const write of normalized) args.push(write.index, json({
+					index: write.index,
+					state: write.state,
 					updatedAt: clock.now().getTime()
-				})]);
+				}), write.pinEventIndexes.size, ...write.pinEventIndexes);
+				await evalScript(PUT_SNAPSHOTS_LUA, [
+					snapKey(sessionId, reducerName),
+					snapHistoryKey(sessionId, reducerName),
+					countKey(sessionId),
+					metaKey(sessionId),
+					snapshotPinCountsKey(sessionId)
+				], args);
 			});
 		},
 		presence: {
@@ -942,86 +1074,6 @@ function createRedisStoreCore(options) {
 				});
 			}
 		},
-		inspect: {
-			async listSessions(inspectionOptions) {
-				return wrap(async () => {
-					const minimum = inspectionOptions.cursor === void 0 ? `[${inspectionOptions.prefix}` : `(${inspectionOptions.cursor}`;
-					const candidates = await call("ZRANGEBYLEX", sessionsKey, minimum, "+", "LIMIT", 0, inspectionOptions.limit + 1);
-					const sessionIds = candidates.filter((id) => id.startsWith(inspectionOptions.prefix)).slice(0, inspectionOptions.limit);
-					return {
-						sessions: (await Promise.all(sessionIds.map(async (sessionId) => {
-							const rows = await readRange(sessionId, 0);
-							const first = rows[0];
-							let updatedAt = first.createdAt;
-							let pendingCount = 0;
-							let failedCount = 0;
-							let attemptCount = 0;
-							let failureCount = 0;
-							for (const row of rows) {
-								attemptCount += row.attemptCount;
-								failureCount += row.failureCount;
-								if (row.processedAt === null && row.failedAt === null) pendingCount += 1;
-								if (row.failedAt !== null) failedCount += 1;
-								for (const timestamp of [
-									row.createdAt,
-									row.firstClaimedAt,
-									row.lastClaimedAt,
-									row.lastFailedAt,
-									row.processedAt,
-									row.failedAt
-								]) if (timestamp && timestamp > updatedAt) updatedAt = timestamp;
-							}
-							return {
-								sessionId,
-								eventCount: rows.length,
-								pendingCount,
-								failedCount,
-								attemptCount,
-								failureCount,
-								firstEventAt: first.createdAt,
-								updatedAt
-							};
-						}))).toSorted((a, b) => a.sessionId.localeCompare(b.sessionId)),
-						cursor: candidates.length > inspectionOptions.limit && candidates[inspectionOptions.limit]?.startsWith(inspectionOptions.prefix) ? sessionIds.at(-1) ?? null : null
-					};
-				});
-			},
-			async readEvents(sessionId, pageOptions) {
-				return wrap(async () => {
-					const currentFrontier = await readFrontier(sessionId);
-					const throughIndex = Math.min(pageOptions.throughIndex ?? currentFrontier, currentFrontier);
-					const events = await readRangePage(sessionId, pageOptions.afterIndex, throughIndex, pageOptions.limit);
-					if (throughIndex > pageOptions.afterIndex && events.length === 0) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' ended before index ${throughIndex}`);
-					for (let position = 0; position < events.length; position += 1) if (events[position].index !== pageOptions.afterIndex + position + 1) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' is not contiguous`);
-					return {
-						events,
-						throughIndex
-					};
-				});
-			},
-			async listSnapshots(sessionId) {
-				return wrap(async () => {
-					const start = `${prefix}:${sessionId}:snap:`;
-					let cursor = "0";
-					const keys = [];
-					do {
-						const reply = await call("SCAN", cursor, "MATCH", `${escapeGlob(start)}*`, "COUNT", 100);
-						cursor = reply[0];
-						keys.push(...reply[1].filter((key) => key.startsWith(start)));
-					} while (cursor !== "0");
-					return (await Promise.all(keys.map(async (key) => {
-						const raw = await call("GET", key);
-						if (raw === null) return null;
-						const parsed = JSON.parse(raw);
-						return {
-							reducerName: key.slice(start.length),
-							index: parsed.index,
-							updatedAt: new Date(parsed.updatedAt ?? 0)
-						};
-					}))).filter((snapshot) => snapshot !== null).toSorted((a, b) => a.reducerName.localeCompare(b.reducerName));
-				});
-			}
-		},
 		async readRange(sessionId, afterIndex, throughIndex) {
 			return wrap(() => readRange(sessionId, afterIndex, throughIndex));
 		},
@@ -1038,4 +1090,4 @@ function createRedisStoreCore(options) {
 //#endregion
 export { createRedisStoreCore as t };
 
-//# sourceMappingURL=store-redis-core-BFLwz0Wj.js.map
+//# sourceMappingURL=store-redis-core-DT01r4GZ.js.map