experimental-a2 0.2.0 → 0.4.0

package/dist/{log-redis.js → store-redis-core-DWqx3F47.js}

@@ -1,37 +1,17 @@
-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
+import { t as A2Error } from "./errors-BQuJpe82.js";
+import { g as nullProtoRecord } from "./internal-aEotMzu_.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;
 /**
-* 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
-* `XREAD BLOCK` is a true blocking live feed — no polling anywhere.
-* Mutable drain/failure bookkeeping lives in a side hash (stream
-* entries are immutable); every write path is one atomic Lua script.
-* The conformance suite in test/conformance is the executable
-* contract, run against a real spawned `redis-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).
-* Cluster mode is out: the atomic scripts span keys. `ioredis` is an
-* optional peer dependency; pass `url`, or inject any client exposing
-* `call`/`duplicate`/`disconnect`.
-*/
-/** 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, metadata, pending, ready.
+* KEYS: store stream, counter, global id hash, session index, metadata,
+* pending, ready, watched.
 * ARGV: sessionId, nowMs, n, then per event:
 * id, type, payloadJson, causeJson, lane, settled.
-* Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
+* Returns ['empty', hasPending] | ['ok', firstIndex, hasPending, watched] |
 * ['dup', hasPending, ...indexes] | ['partial', count] |
-* ['foreign', eventId].
+* ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx].
 */
 const APPEND_LUA = `
 local function lane_field(lane, suffix)
@@ -73,6 +53,22 @@ if #dups == n then
   return res
 end
 if #dups > 0 then return { 'partial', tostring(#dups) } end
+for i = 1, n do
+  local cause = ARGV[3 + (i - 1) * 6 + 4]
+  if cause ~= '' then
+    local parsed = cjson.decode(cause)
+    local pidx = tonumber(parsed.index)
+    if pidx < 1 or pidx > base then
+      return { 'no_parent', tostring(parsed.index) }
+    end
+    local field = tostring(pidx)
+    local dispatches = tonumber(redis.call('HGET', KEYS[5], field .. ':d') or '0')
+    if dispatches ~= tonumber(parsed.attempt) or
+       redis.call('HEXISTS', KEYS[5], field .. ':f') == 1 then
+      return { 'superseded', field }
+    end
+  end
+end
 for i = 1, n do
   local id = ARGV[3 + (i - 1) * 6 + 1]
   local typ = ARGV[3 + (i - 1) * 6 + 2]
@@ -95,7 +91,8 @@ 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'
-return { 'ok', tostring(base + 1), has_pending }
+return { 'ok', tostring(base + 1), has_pending,
+  tostring(redis.call('EXISTS', KEYS[8])) }
 `;
 /** KEYS: counter, meta, pending, ready. ARGV: idx, attempt, error, maxFailures, nowMs. */
 const FAIL_ATTEMPT_LUA = `
@@ -157,7 +154,7 @@ end
 return { 'failed', tostring(failures) }
 `;
 /**
-* KEYS: log, counter, meta, pending, ready.
+* KEYS: store, counter, meta, pending, ready.
 * ARGV: holder, nowMs, expiresAtMs, excludedCount, excluded indexes.
 */
 const CLAIM_AVAILABLE_LUA = `
@@ -207,29 +204,42 @@ if retry_at then return { 'busy', tostring(retry_at) } end
 return { 'settled' }
 `;
 /**
-* KEYS: counter, meta. ARGV: holder, nowMs, expiresAtMs, n, indexes.
+* KEYS: counter, meta.
+* ARGV: holder, nowMs, expiresAtMs, n, then per claim: index, attempt.
+* Returns [renewedCount, ...renewed, ...superseded].
 */
 const RENEW_CLAIMS_LUA = `
 local total = tonumber(redis.call('GET', KEYS[1]) or '0')
 local renewed = {}
+local superseded = {}
 for i = 1, tonumber(ARGV[4]) do
-  local field = ARGV[4 + i]
+  local field = ARGV[4 + (i - 1) * 2 + 1]
+  local attempt = tonumber(ARGV[4 + (i - 1) * 2 + 2])
   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
+  if idx >= 1 and idx <= total then
+    local dispatches = tonumber(redis.call('HGET', KEYS[2], field .. ':d') or '0')
+    if dispatches > attempt then
+      superseded[#superseded + 1] = field
+    else
+      local expires = tonumber(redis.call('HGET', KEYS[2], field .. ':ce') or '0')
+      if tonumber(ARGV[3]) > tonumber(ARGV[2]) and
+         redis.call('HEXISTS', KEYS[2], field .. ':p') == 0 and
+         redis.call('HEXISTS', KEYS[2], field .. ':f') == 0 and
+         redis.call('HGET', KEYS[2], field .. ':ch') == ARGV[1] and
+         expires > tonumber(ARGV[2]) then
+        redis.call('HSET', KEYS[2], field .. ':ce', ARGV[3])
+        renewed[#renewed + 1] = field
+      end
+    end
   end
 end
-return renewed
+local result = { tostring(#renewed) }
+for i = 1, #renewed do result[#result + 1] = renewed[i] end
+for i = 1, #superseded do result[#result + 1] = superseded[i] end
+return result
 `;
 /**
-* KEYS: log, counter, ids, session index, meta, pending, ready.
+* KEYS: store, counter, ids, session index, meta, pending, ready, watched.
 * ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
 * id, type, payloadJson, lane, settled.
 */
@@ -353,7 +363,8 @@ for i = 1, n do
 end
 redis.call('SET', KEYS[2], tostring(total + n))
 redis.call('ZADD', KEYS[4], 0, ARGV[1])
-return { 'ok', tostring(total + 1) }
+return { 'ok', tostring(total + 1),
+  tostring(redis.call('EXISTS', KEYS[8])) }
 `;
 /** KEYS: snapshot. ARGV: upToIndex, json. Guarded: never move backward. */
 const PUT_SNAPSHOT_LUA = `
@@ -364,21 +375,83 @@ end
 redis.call('SET', KEYS[1], ARGV[2])
 return 1
 `;
-/** KEYS: snapshot, log stream. Returns one atomic cache-plus-tail read. */
+/**
+* KEYS: presence hash. ARGV: atMs, ttlMs, n, then per entry:
+* hashField, valueJson ('' deletes). Field-wise LWW by the sender's
+* `at`: a stored entry with a strictly newer stamp survives; ties go
+* to the incoming write (memory-tier parity). Returns the applied
+* 1-based entry positions. The whole-key PEXPIRE is the coarse bound,
+* sound because core sends one uniform ttlMs; the per-entry `e` stamp
+* is the fine bound (the injected storage clock at the applied set
+* plus ttlMs — never the sender stamp), pruned on read against the
+* same clock.
+*/
+const PRESENCE_SET_LUA = `
+local at = tonumber(ARGV[1])
+local applied = {}
+for i = 1, tonumber(ARGV[3]) do
+  local field = ARGV[3 + (i - 1) * 2 + 1]
+  local value = ARGV[3 + (i - 1) * 2 + 2]
+  local existing = redis.call('HGET', KEYS[1], field)
+  if not existing or tonumber(cjson.decode(existing)['a']) <= at then
+    if value == '' then
+      redis.call('HDEL', KEYS[1], field)
+    else
+      redis.call('HSET', KEYS[1], field, value)
+    end
+    applied[#applied + 1] = tostring(i)
+  end
+end
+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.
+*/
+const PRESENCE_READ_LUA = `
+local now = tonumber(ARGV[1])
+local rows = redis.call('HGETALL', KEYS[1])
+local live = {}
+for i = 1, #rows, 2 do
+  if tonumber(cjson.decode(rows[i + 1])['e']) <= now then
+    redis.call('HDEL', KEYS[1], rows[i])
+  else
+    live[#live + 1] = rows[i]
+    live[#live + 1] = rows[i + 1]
+  end
+end
+return live
+`;
+/** KEYS: snapshot, event counter. Returns one atomic cache-plus-frontier read. */
 const READ_STATE_LUA = `
 local snapshot = redis.call('GET', KEYS[1])
-local after = 0
-if snapshot then
-  after = tonumber(cjson.decode(snapshot)['index'])
-end
-local events = redis.call('XRANGE', KEYS[2], tostring(after + 1) .. '-0', '+')
-return { snapshot or '', events }
+local frontier = redis.call('GET', KEYS[2]) or '0'
+return { snapshot or '', frontier }
 `;
 const fieldMap = (fields) => {
 	const map = {};
 	for (let i = 0; i + 1 < fields.length; i += 2) map[fields[i]] = fields[i + 1];
 	return map;
 };
+const STORED_EVENT_META_SUFFIXES = [
+	"p",
+	"pa",
+	"ri",
+	"ch",
+	"ce",
+	"f",
+	"fc",
+	"lc",
+	"lf",
+	"lfa",
+	"d",
+	"a",
+	"e"
+];
 const entryIndex = (entryId) => Number(entryId.slice(0, entryId.indexOf("-")));
 const toEvent = (sessionId, entry) => {
 	const fields = fieldMap(entry[1]);
@@ -449,40 +522,43 @@ const wrap = async (fn) => {
 		return await fn();
 	} catch (err) {
 		if (err instanceof A2Error || err instanceof TypeError) throw err;
-		throw new A2Error("LOG_UNAVAILABLE", "redis log operation failed", { cause: err });
+		throw new A2Error("STORE_UNAVAILABLE", "redis store operation failed", { cause: err });
 	}
 };
-function redis(options = {}) {
-	const clock = options.clock ?? SYSTEM_CLOCK;
-	const generateId = options.ids ?? RANDOM_IDS;
-	const prefix = options.keyPrefix ?? "a2";
-	if (!options.client && !options.url) throw new TypeError("redis() needs a url or an injected client");
-	const logKey = (s) => `${prefix}:${s}:log`;
+function createRedisStoreCore(options) {
+	const { call, clock, notify } = options;
+	const generateId = options.ids;
+	const prefix = options.keyPrefix;
+	const storeKey = (s) => `${prefix}:${s}:log`;
 	const countKey = (s) => `${prefix}:${s}:count`;
 	const metaKey = (s) => `${prefix}:${s}:meta`;
 	const pendingKey = (s) => `${prefix}:${s}:pending`;
 	const readyKey = (s) => `${prefix}:${s}:ready`;
 	const snapKey = (s, r) => `${prefix}:${s}:snap:${r}`;
+	const watchedKey = (s) => `${prefix}:${s}:watched`;
+	const presenceKey = (s) => `${prefix}:${s}:presence`;
 	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", "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;
-	const evalScript = async (script, keys, args) => {
-		return (await client()).call("EVAL", script, keys.length, ...keys, ...args);
+	const evalScript = (script, keys, args) => call("EVAL", script, keys.length, ...keys, ...args);
+	const readFrontier = async (sessionId) => {
+		const frontier = Number(await call("GET", countKey(sessionId)) ?? 0);
+		if (!Number.isSafeInteger(frontier) || frontier < 0) throw new A2Error("STORE_UNAVAILABLE", `redis event count for session '${sessionId}' is invalid`);
+		return frontier;
 	};
-	/** Every live-feed connection, so close() can sever them. */
-	const streamConnections = /* @__PURE__ */ new Set();
-	/** XRANGE + meta merge — the raw read both `read` and dup-returns use. */
-	const readRange = async (sessionId, afterIndex) => {
-		const c = await client();
-		const entries = await c.call("XRANGE", logKey(sessionId), `${afterIndex + 1}-0`, "+");
+	const readRangePage = async (sessionId, afterIndex, throughIndex, limit) => {
+		if (throughIndex <= afterIndex) return [];
+		const entries = await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, `${throughIndex}-0`, "COUNT", limit);
 		if (entries.length === 0) return [];
-		const meta = fieldMap(await c.call("HGETALL", metaKey(sessionId)) ?? []);
+		const metaFields = entries.flatMap((entry) => {
+			const index = entryIndex(entry[0]);
+			return STORED_EVENT_META_SUFFIXES.map((suffix) => `${index}:${suffix}`);
+		});
+		const metaValues = await call("HMGET", metaKey(sessionId), ...metaFields) ?? [];
+		const meta = {};
+		for (let i = 0; i < metaFields.length; i += 1) {
+			const value = metaValues[i];
+			if (value !== null && value !== void 0) meta[metaFields[i]] = value;
+		}
 		return entries.map((entry) => {
 			const event = toEvent(sessionId, entry);
 			const idx = event.index;
@@ -502,7 +578,7 @@ function redis(options = {}) {
 				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),
+				returnedEventIds: returnedEventIds === void 0 ? null : decodeReturnedEventIds(returnedEventIds),
 				firstClaimedAt: firstClaimedAt === void 0 ? null : new Date(Number(firstClaimedAt)),
 				lastClaimedAt: lastClaimedAt === void 0 ? null : new Date(Number(lastClaimedAt)),
 				attemptCount: Number(meta[`${idx}:d`] ?? 0),
@@ -516,6 +592,41 @@ function redis(options = {}) {
 			});
 		});
 	};
+	const readEventRange = async (sessionId, afterIndex, throughIndex) => {
+		if (throughIndex <= afterIndex) return [];
+		const events = [];
+		let nextIndex = afterIndex + 1;
+		while (nextIndex <= throughIndex) {
+			const entries = await call("XRANGE", storeKey(sessionId), `${nextIndex}-0`, `${throughIndex}-0`, "COUNT", READ_PAGE_SIZE);
+			if (entries.length === 0) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' ended before index ${throughIndex}`);
+			for (let position = 0; position < entries.length; position += 1) {
+				const index = entryIndex(entries[position][0]);
+				if (index !== nextIndex + position || index > throughIndex) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' is not contiguous`);
+			}
+			events.push(...entries.map((entry) => toEvent(sessionId, entry)));
+			nextIndex = events.at(-1).index + 1;
+		}
+		return events;
+	};
+	/** Bounded XRANGE pages restore the full-read contract on capped providers. */
+	const readRange = async (sessionId, afterIndex, throughIndex) => {
+		if (throughIndex !== void 0 && throughIndex <= afterIndex) return [];
+		const currentFrontier = await readFrontier(sessionId);
+		const frontier = Math.min(throughIndex ?? currentFrontier, currentFrontier);
+		if (frontier <= afterIndex) return [];
+		const rows = [];
+		let nextIndex = afterIndex + 1;
+		while (nextIndex <= frontier) {
+			const page = await readRangePage(sessionId, nextIndex - 1, frontier, READ_PAGE_SIZE);
+			if (page.length === 0) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' ended before index ${frontier}`);
+			for (let position = 0; position < page.length; position += 1) if (page[position].index !== nextIndex + position) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' is not contiguous`);
+			const lastIndex = page.at(-1).index;
+			if (lastIndex < nextIndex || lastIndex > frontier) throw new A2Error("STORE_UNAVAILABLE", `redis event range for session '${sessionId}' did not advance`);
+			rows.push(...page);
+			nextIndex = lastIndex + 1;
+		}
+		return rows;
+	};
 	return {
 		async append(sessionId, events) {
 			return wrap(async () => {
@@ -544,13 +655,14 @@ function redis(options = {}) {
 					])
 				];
 				const reply = await evalScript(APPEND_LUA, [
-					logKey(sessionId),
+					storeKey(sessionId),
 					countKey(sessionId),
 					idsKey,
 					sessionsKey,
 					metaKey(sessionId),
 					pendingKey(sessionId),
-					readyKey(sessionId)
+					readyKey(sessionId),
+					watchedKey(sessionId)
 				], args);
 				const [verdict] = reply;
 				if (verdict === "empty") return {
@@ -558,6 +670,8 @@ function redis(options = {}) {
 					hasPending: reply[1] === "1"
 				};
 				if (verdict === "foreign") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${reply[1]}' already exists in another session`);
+				if (verdict === "no_parent") throw new TypeError(`no event at index ${reply[1]} in session '${sessionId}'`);
+				if (verdict === "superseded") throw new A2Error("SUPERSEDED_ATTEMPT", `a newer attempt owns event ${reply[1]} in session '${sessionId}'`);
 				if (verdict === "partial") throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${reply[1]} already-appended and ${events.length - Number(reply[1])} fresh events`);
 				if (verdict === "dup") {
 					const hasPending = reply[1] === "1";
@@ -570,6 +684,7 @@ function redis(options = {}) {
 					};
 				}
 				const base = Number(reply[1]) - 1;
+				if (reply[3] === "1") notify?.(sessionId, base + withIds.length);
 				return {
 					events: withIds.map((e, i) => ({
 						id: e.id,
@@ -600,7 +715,7 @@ function redis(options = {}) {
 		},
 		async read(sessionId, opts) {
 			return wrap(async () => {
-				return await readRange(sessionId, opts?.afterIndex ?? 0);
+				return await readRange(sessionId, opts?.afterIndex ?? 0, opts?.throughIndex);
 			});
 		},
 		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes }) {
@@ -609,7 +724,7 @@ function redis(options = {}) {
 				const expiresAt = expiresAtMs ?? now + ttlMs;
 				const excluded = excludeIndexes ?? [];
 				const reply = await evalScript(CLAIM_AVAILABLE_LUA, [
-					logKey(sessionId),
+					storeKey(sessionId),
 					countKey(sessionId),
 					metaKey(sessionId),
 					pendingKey(sessionId),
@@ -624,17 +739,23 @@ function redis(options = {}) {
 				return toClaimAvailableResult(sessionId, reply);
 			});
 		},
-		async renewClaims({ sessionId, holder, indexes, ttlMs, expiresAtMs }) {
+		async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
 			return wrap(async () => {
 				const now = clock.now().getTime();
 				const expiresAt = expiresAtMs ?? now + ttlMs;
-				return (await evalScript(RENEW_CLAIMS_LUA, [countKey(sessionId), metaKey(sessionId)], [
+				const reply = await evalScript(RENEW_CLAIMS_LUA, [countKey(sessionId), metaKey(sessionId)], [
 					holder,
 					now,
 					expiresAt,
-					indexes.length,
-					...indexes
-				])).map(Number);
+					claims.length,
+					...claims.flatMap((claim) => [claim.index, claim.attempt])
+				]);
+				const renewedCount = Number(reply[0]);
+				const values = reply.slice(1).map(Number);
+				return {
+					renewed: values.slice(0, renewedCount).toSorted((a, b) => a - b),
+					superseded: values.slice(renewedCount).toSorted((a, b) => a - b)
+				};
 			});
 		},
 		async completeAttempt({ sessionId, index, attempt, events }) {
@@ -643,13 +764,14 @@ function redis(options = {}) {
 				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),
+					storeKey(sessionId),
 					countKey(sessionId),
 					idsKey,
 					sessionsKey,
 					metaKey(sessionId),
 					pendingKey(sessionId),
-					readyKey(sessionId)
+					readyKey(sessionId),
+					watchedKey(sessionId)
 				], [
 					sessionId,
 					now,
@@ -674,6 +796,7 @@ function redis(options = {}) {
 				};
 				if (outcome === "ok") {
 					const base = Number(reply[1]) - 1;
+					if (events.length > 0 && reply[2] === "1") notify?.(sessionId, base + events.length);
 					return {
 						outcome: "completed",
 						events: events.map((event, i) => ({
@@ -743,15 +866,18 @@ function redis(options = {}) {
 		},
 		async readState(sessionId, reducerName) {
 			return wrap(async () => {
-				const reply = await evalScript(READ_STATE_LUA, [snapKey(sessionId, reducerName), logKey(sessionId)], []);
+				const reply = await evalScript(READ_STATE_LUA, [snapKey(sessionId, reducerName), countKey(sessionId)], []);
 				const raw = reply[0];
 				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);
 				return {
 					snapshot: parsed ? {
 						index: parsed.index,
 						state: parsed.state
 					} : null,
-					events: reply[1].map((entry) => toEvent(sessionId, entry))
+					events
 				};
 			});
 		},
@@ -764,12 +890,63 @@ function redis(options = {}) {
 				})]);
 			});
 		},
+		presence: {
+			async set(ns, participant, values, meta) {
+				return wrap(async () => {
+					const entries = Object.entries(values);
+					if (entries.length === 0) return null;
+					const atMs = meta.at.getTime();
+					const expiresAtMs = clock.now().getTime() + meta.ttlMs;
+					const applied = await evalScript(PRESENCE_SET_LUA, [presenceKey(ns)], [
+						atMs,
+						meta.ttlMs,
+						entries.length,
+						...entries.flatMap(([field, value]) => [JSON.stringify([participant, field]), value === null ? "" : json({
+							v: value,
+							s: meta.seen,
+							a: atMs,
+							e: expiresAtMs
+						})])
+					]);
+					if (applied.length === 0) return null;
+					const appliedValues = nullProtoRecord();
+					for (const position of applied) {
+						const [field, value] = entries[Number(position) - 1];
+						appliedValues[field] = structuredClone(value);
+					}
+					return {
+						participant,
+						values: appliedValues,
+						seen: meta.seen,
+						at: new Date(atMs)
+					};
+				});
+			},
+			async read(ns) {
+				return wrap(async () => {
+					const reply = await evalScript(PRESENCE_READ_LUA, [presenceKey(ns)], [clock.now().getTime()]);
+					const rows = [];
+					for (let i = 0; i + 1 < reply.length; i += 2) {
+						const [participant, field] = JSON.parse(reply[i]);
+						const entry = JSON.parse(reply[i + 1]);
+						rows.push({
+							participant,
+							field,
+							value: entry.v,
+							seen: entry.s,
+							at: new Date(entry.a),
+							expiresAt: new Date(entry.e)
+						});
+					}
+					return rows;
+				});
+			}
+		},
 		inspect: {
 			async listSessions(inspectionOptions) {
 				return wrap(async () => {
-					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);
+					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) => {
@@ -809,19 +986,31 @@ function redis(options = {}) {
 					};
 				});
 			},
+			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 c = await client();
 					const start = `${prefix}:${sessionId}:snap:`;
 					let cursor = "0";
 					const keys = [];
 					do {
-						const reply = await c.call("SCAN", cursor, "MATCH", `${escapeGlob(start)}*`, "COUNT", 100);
+						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 c.call("GET", key);
+						const raw = await call("GET", key);
 						if (raw === null) return null;
 						const parsed = JSON.parse(raw);
 						return {
@@ -833,69 +1022,18 @@ function redis(options = {}) {
 				});
 			}
 		},
-		stream(sessionId, opts) {
-			const startAt = opts?.startAt ?? 0;
-			return { [Symbol.asyncIterator]() {
-				let last = startAt;
-				let buffer = [];
-				let closed = false;
-				let conn = null;
-				return {
-					async next() {
-						for (;;) {
-							if (closed) return {
-								value: void 0,
-								done: true
-							};
-							const row = buffer.shift();
-							if (row) {
-								last = row.index;
-								return {
-									value: row,
-									done: false
-								};
-							}
-							if (!conn) {
-								conn = (await client()).duplicate();
-								streamConnections.add(conn);
-							}
-							let reply;
-							try {
-								reply = await conn.call("XREAD", "BLOCK", XREAD_BLOCK_MS, "STREAMS", logKey(sessionId), `${last}-0`);
-							} catch (err) {
-								if (closed) return {
-									value: void 0,
-									done: true
-								};
-								throw new A2Error("LOG_UNAVAILABLE", "redis log operation failed", { cause: err });
-							}
-							if (reply === null) continue;
-							const [[, entries]] = reply;
-							buffer = entries.map((entry) => toEvent(sessionId, entry));
-						}
-					},
-					async return() {
-						closed = true;
-						if (conn) {
-							streamConnections.delete(conn);
-							conn.disconnect();
-						}
-						return {
-							value: void 0,
-							done: true
-						};
-					}
-				};
-			} };
+		async readRange(sessionId, afterIndex, throughIndex) {
+			return wrap(() => readRange(sessionId, afterIndex, throughIndex));
+		},
+		async readEvents(sessionId, afterIndex) {
+			return wrap(async () => {
+				return (await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, "+")).map((entry) => toEvent(sessionId, entry));
+			});
 		},
-		async close() {
-			for (const conn of streamConnections) conn.disconnect();
-			streamConnections.clear();
-			const current = connection.peek();
-			if (!current) return;
-			(await current).disconnect();
+		async markWatched(sessionId, ttlMs) {
+			await wrap(() => call("SET", watchedKey(sessionId), "1", "PX", ttlMs));
 		}
 	};
 }
 //#endregion
-export { redis };
+export { createRedisStoreCore as t };