experimental-a2 0.3.0 → 0.4.0

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

@@ -1,31 +1,17 @@
-import { t as A2Error } from "./errors-BJRMd-h6.js";
-import { t as idempotentReplay } from "./idempotent-replay-BMyHrP0L.js";
-//#region src/log-redis-core.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;
 /**
-* The shared Redis log core — every operation except `stream` and
-* `close`, expressed over one injected `call` function so both
-* transports reuse it: `log-redis` (Redis protocol via `ioredis`) and
-* `log-redis-http` (provider REST APIs).
-*
-* 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.
-* 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. Cluster mode is out: the
-* atomic scripts span keys.
-*/
-/**
-* KEYS: log stream, counter, global id hash, session index, metadata,
+* 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, watched] |
 * ['dup', hasPending, ...indexes] | ['partial', count] |
-* ['foreign', eventId].
+* ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx].
 */
 const APPEND_LUA = `
 local function lane_field(lane, suffix)
@@ -67,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]
@@ -152,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 = `
@@ -202,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, watched.
+* 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.
 */
@@ -360,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]);
@@ -445,28 +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 createRedisLogCore(options) {
+function createRedisStoreCore(options) {
 	const { call, clock, notify } = options;
 	const generateId = options.ids;
 	const prefix = options.keyPrefix;
-	const logKey = (s) => `${prefix}:${s}:log`;
+	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 evalScript = (script, keys, args) => call("EVAL", script, keys.length, ...keys, ...args);
-	/** XRANGE + meta merge — the raw read both `read` and dup-returns use. */
-	const readRange = async (sessionId, afterIndex) => {
-		const entries = await call("XRANGE", logKey(sessionId), `${afterIndex + 1}-0`, "+");
+	const readFrontier = async (sessionId) => {
+		const frontier = Number(await call("GET", countKey(sessionId)) ?? 0);
+		if (!Number.isSafeInteger(frontier) || frontier < 0) throw new A2Error("STORE_UNAVAILABLE", `redis event count for session '${sessionId}' is invalid`);
+		return frontier;
+	};
+	const readRangePage = async (sessionId, afterIndex, throughIndex, limit) => {
+		if (throughIndex <= afterIndex) return [];
+		const entries = await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, `${throughIndex}-0`, "COUNT", limit);
 		if (entries.length === 0) return [];
-		const meta = fieldMap(await 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;
@@ -486,7 +578,7 @@ function createRedisLogCore(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),
@@ -500,6 +592,41 @@ function createRedisLogCore(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 () => {
@@ -528,7 +655,7 @@ function createRedisLogCore(options) {
 					])
 				];
 				const reply = await evalScript(APPEND_LUA, [
-					logKey(sessionId),
+					storeKey(sessionId),
 					countKey(sessionId),
 					idsKey,
 					sessionsKey,
@@ -543,6 +670,8 @@ function createRedisLogCore(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";
@@ -586,7 +715,7 @@ function createRedisLogCore(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 }) {
@@ -595,7 +724,7 @@ function createRedisLogCore(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),
@@ -610,17 +739,23 @@ function createRedisLogCore(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 }) {
@@ -629,7 +764,7 @@ function createRedisLogCore(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,
@@ -731,15 +866,18 @@ function createRedisLogCore(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
 				};
 			});
 		},
@@ -752,6 +890,58 @@ function createRedisLogCore(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 () => {
@@ -796,6 +986,19 @@ function createRedisLogCore(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 start = `${prefix}:${sessionId}:snap:`;
@@ -819,12 +1022,12 @@ function createRedisLogCore(options) {
 				});
 			}
 		},
-		async readRange(sessionId, afterIndex) {
-			return wrap(() => readRange(sessionId, afterIndex));
+		async readRange(sessionId, afterIndex, throughIndex) {
+			return wrap(() => readRange(sessionId, afterIndex, throughIndex));
 		},
 		async readEvents(sessionId, afterIndex) {
 			return wrap(async () => {
-				return (await call("XRANGE", logKey(sessionId), `${afterIndex + 1}-0`, "+")).map((entry) => toEvent(sessionId, entry));
+				return (await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, "+")).map((entry) => toEvent(sessionId, entry));
 			});
 		},
 		async markWatched(sessionId, ttlMs) {
@@ -833,4 +1036,4 @@ function createRedisLogCore(options) {
 	};
 }
 //#endregion
-export { createRedisLogCore as t };
+export { createRedisStoreCore as t };

package/dist/{log-redis-http.d.ts → store-redis-http.d.ts}

@@ -1,6 +1,6 @@
-import { c as IdSource, i as Clock, t as A2Log } from "./log-ldf5g8Cx.js";
-//#region src/log-redis-http.d.ts
-type RedisHttpLogOptions = {
+import { c as IdSource, i as Clock, t as A2Store } from "./store-C3sNAaBT.js";
+//#region src/store-redis-http.d.ts
+type RedisHttpStoreOptions = {
   /** REST endpoint, e.g. `process.env.UPSTASH_REDIS_REST_URL`. */
   url: string;
   /** Bearer token, e.g. `process.env.UPSTASH_REDIS_REST_TOKEN`. */
@@ -12,10 +12,10 @@ type RedisHttpLogOptions = {
   /** Injectable id source for generated event ids. */
   ids?: IdSource;
 };
-type RedisHttpLog = A2Log & {
-  /** Nothing to disconnect; present so callers can treat logs uniformly. */
+type RedisHttpStore = A2Store & {
+  /** Nothing to disconnect; present so callers can treat stores uniformly. */
   close(): Promise<void>;
 };
-declare function redisHttp(options: RedisHttpLogOptions): RedisHttpLog;
+declare function redisHttp(options: RedisHttpStoreOptions): RedisHttpStore;
 //#endregion
-export { RedisHttpLog, RedisHttpLogOptions, redisHttp };
+export { RedisHttpStore, RedisHttpStoreOptions, redisHttp };

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

@@ -1,19 +1,21 @@
-import { t as A2Error } from "./errors-BJRMd-h6.js";
-import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
-import { n as pollingStream } from "./log-polling-DZ1MiKLg.js";
-import { t as createRedisLogCore } from "./log-redis-core-CyJ5L8yR.js";
-//#region src/log-redis-http.ts
+import { t as A2Error } from "./errors-BQuJpe82.js";
+import { n as pollingStream } from "./store-polling-DgrrAE3d.js";
+import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS.js";
+import { t as createRedisStoreCore } from "./store-redis-core-DWqx3F47.js";
+//#region src/store-redis-http.ts
 /**
-* experimental-a2/log-redis-http — the same Redis Streams log over a
+* experimental-a2/store-redis-http — the same Redis Streams store over a
 * provider REST API (Upstash-shaped: POST one command as a JSON array,
 * receive `{ result }` or `{ error }`). The storage semantics live in
-* log-redis-core.ts, shared with experimental-a2/log-redis.
+* store-redis-core.ts, shared with experimental-a2/store-redis.
 *
 * Fully connectionless: every command is one `fetch`, so it works
 * where a Redis-protocol connection cannot exist or cannot be spared.
 * Without a connection there is no push and no pub/sub, so `stream()`
 * is the shared activity-adaptive poll loop (25ms while events flow,
-* backing off to a 250ms idle ceiling). No peer dependencies.
+* backing off to a 250ms idle ceiling), and presence is the degraded
+* tier: `set`/`read` from the shared core, no `subscribe`. No peer
+* dependencies.
 */
 function redisHttp(options) {
 	if (!options.url || !options.token) throw new TypeError("redisHttp() needs a url and a token");
@@ -30,13 +32,13 @@ function redisHttp(options) {
 				body: JSON.stringify([command, ...args.map(String)])
 			});
 		} catch (err) {
-			throw new A2Error("LOG_UNAVAILABLE", "redis rest request failed", { cause: err });
+			throw new A2Error("STORE_UNAVAILABLE", "redis rest request failed", { cause: err });
 		}
 		const body = await response.json().catch(() => null);
-		if (body === null || !response.ok || body.error !== void 0) throw new A2Error("LOG_UNAVAILABLE", `redis rest command failed: ${body?.error ?? `status ${response.status}`}`);
+		if (body === null || !response.ok || body.error !== void 0) throw new A2Error("STORE_UNAVAILABLE", `redis rest command failed: ${body?.error ?? `status ${response.status}`}`);
 		return body.result;
 	};
-	const core = createRedisLogCore({
+	const core = createRedisStoreCore({
 		call,
 		clock: options.clock ?? SYSTEM_CLOCK,
 		ids: options.ids ?? RANDOM_IDS,
@@ -51,9 +53,15 @@ function redisHttp(options) {
 		failAttempt: core.failAttempt,
 		readState: core.readState,
 		putSnapshot: core.putSnapshot,
+		presence: {
+			async set(ns, participant, values, meta) {
+				await core.presence.set(ns, participant, values, meta);
+			},
+			read: core.presence.read
+		},
 		inspect: core.inspect,
 		stream(sessionId, opts) {
-			return pollingStream((afterIndex) => core.readRange(sessionId, afterIndex), opts?.startAt !== void 0 ? { startAt: opts.startAt } : {});
+			return pollingStream((afterIndex) => core.readRange(sessionId, afterIndex), opts?.startAfter !== void 0 ? { startAfter: opts.startAfter } : {});
 		},
 		async close() {}
 	};

package/dist/{log-redis.d.ts → store-redis.d.ts}

@@ -1,5 +1,5 @@
-import { c as IdSource, i as Clock, t as A2Log } from "./log-ldf5g8Cx.js";
-//#region src/log-redis.d.ts
+import { c as IdSource, i as Clock, t as A2Store } from "./store-C3sNAaBT.js";
+//#region src/store-redis.d.ts
 /**
  * The minimal client this backend needs — `ioredis` matches it
  * structurally. `call` issues any command; `duplicate` opens the one
@@ -16,7 +16,7 @@ type RedisConnection = {
   on(event: "message", listener: (channel: string, message: string) => void): unknown;
   disconnect(): void;
 };
-type RedisLogOptions = {
+type RedisStoreOptions = {
   /** Creates an `ioredis` client lazily (optional peer dep `ioredis`). */
   url?: string | undefined;
   /** Bring your own client — anything `call`/`duplicate`/`on`/`disconnect`. */
@@ -28,10 +28,10 @@ type RedisLogOptions = {
   /** Injectable id source for generated event ids. */
   ids?: IdSource;
 };
-type RedisLog = A2Log & {
+type RedisStore = A2Store & {
   /** Disconnect the command client and the shared subscriber. */
   close(): Promise<void>;
 };
-declare function redis(options?: RedisLogOptions): RedisLog;
+declare function redis(options?: RedisStoreOptions): RedisStore;
 //#endregion
-export { RedisConnection, RedisLog, RedisLogOptions, redis };
+export { RedisConnection, RedisStore, RedisStoreOptions, redis };