experimental-a2 0.10.0 → 0.12.0

package/dist/{store-redis-core-z-ykbyMg.js → store-redis-notify-BUCyXOn0.js}

@@ -1,15 +1,112 @@
 import { t as A2Error } from "./errors-DCk6ch5n.js";
-import { h as nullProtoRecord } from "./internal-DRXJ56EI.js";
+import { h as nullProtoRecord, r as NOTIFY_TIMINGS } from "./internal-Dq2qYxou.js";
+import { i as streamActivities, n as pollingStream, r as createStreamActivity, t as defaultSleep } from "./store-polling-CmxUbV93.js";
 import { t as idempotentReplay } from "./idempotent-replay-DVOlyYbx.js";
 import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
+import { t as pollPresence } from "./store-presence-polling-C7-XZyW9.js";
+//#region src/presence-recovery.ts
+const key = ({ participant, field }) => JSON.stringify([participant, field]);
+function presenceRecovery({ read, deliver, isActive }) {
+	const fields = /* @__PURE__ */ new Map();
+	const reading = /* @__PURE__ */ new Set();
+	let generation = 0;
+	let latest;
+	const remember = ({ participant, field, seen, at }) => {
+		const id = key({
+			participant,
+			field
+		});
+		const previous = fields.get(id);
+		if (!previous || previous.at.getTime() < at.getTime() || previous.at.getTime() === at.getTime() && previous.seen !== seen) fields.set(id, {
+			participant,
+			field,
+			seen,
+			at
+		});
+	};
+	const snapshot = async ({ reconcile }) => {
+		const run = generation;
+		const before = new Map(fields);
+		const changed = /* @__PURE__ */ new Set();
+		reading.add(changed);
+		try {
+			const rows = await read();
+			if (!isActive()) return rows;
+			if (run !== generation) return latest;
+			const live = /* @__PURE__ */ new Set();
+			for (const row of rows) {
+				const id = key(row);
+				live.add(id);
+				if (changed.has(id)) continue;
+				remember(row);
+				if (reconcile) deliver({
+					participant: row.participant,
+					values: { [row.field]: row.value },
+					seen: row.seen,
+					at: row.at
+				});
+			}
+			if (reconcile) for (const [id, prior] of before) {
+				if (live.has(id) || changed.has(id) || fields.get(id) !== prior) continue;
+				fields.delete(id);
+				deliver({
+					participant: prior.participant,
+					values: { [prior.field]: null },
+					seen: prior.seen,
+					at: prior.at
+				});
+			}
+			return rows;
+		} finally {
+			reading.delete(changed);
+			if (reading.size === 0) latest = void 0;
+		}
+	};
+	return {
+		async read() {
+			let pending = latest;
+			while (pending) {
+				await pending;
+				if (latest === pending) break;
+				pending = latest;
+			}
+			return snapshot({ reconcile: false });
+		},
+		async reconnect() {
+			generation += 1;
+			latest = snapshot({ reconcile: true });
+			await latest;
+		},
+		update(patch) {
+			for (const [field, value] of Object.entries(patch.values)) {
+				if (value === void 0) continue;
+				const id = key({
+					participant: patch.participant,
+					field
+				});
+				const previous = fields.get(id);
+				if (previous && previous.at.getTime() > patch.at.getTime()) continue;
+				for (const changed of reading) changed.add(id);
+				if (value === null) fields.delete(id);
+				else remember({
+					participant: patch.participant,
+					field,
+					seen: patch.seen,
+					at: patch.at
+				});
+			}
+		}
+	};
+}
+//#endregion
 //#region src/store-redis-core.ts
 const READ_PAGE_SIZE = 256;
 /**
 * 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] |
+* id, type, payloadJson, causeJson, lane, settled; finally notify channel.
+* Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
 * ['dup', hasPending, ...indexes] | ['partial', count] |
 * ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx].
 */
@@ -90,8 +187,10 @@ for i = 1, n do
 end
 redis.call('SET', KEYS[2], tostring(base + n))
 has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
-return { 'ok', tostring(base + 1), has_pending,
-  tostring(redis.call('EXISTS', KEYS[7])) }
+if redis.call('EXISTS', KEYS[7]) == 1 then
+  redis.pcall('PUBLISH', ARGV[4 + n * 6], tostring(base + n))
+end
+return { 'ok', tostring(base + 1), has_pending }
 `;
 /**
 * KEYS: counter, meta, pending, ready, event snapshot pins, snapshot pin counts.
@@ -258,7 +357,7 @@ return result
 * 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.
+* id, type, payloadJson, lane, settled; finally notify channel.
 */
 const COMPLETE_ATTEMPT_LUA = `
 local function release_snapshot_pins()
@@ -393,8 +492,10 @@ for i = 1, n do
   end
 end
 redis.call('SET', KEYS[2], tostring(total + n))
-return { 'ok', tostring(total + 1),
-  tostring(redis.call('EXISTS', KEYS[7])) }
+if n > 0 and redis.call('EXISTS', KEYS[7]) == 1 then
+  redis.pcall('PUBLISH', ARGV[6 + n * 5], tostring(total + n))
+end
+return { 'ok', tostring(total + 1) }
 `;
 /**
 * KEYS: head, history, event counter, event meta, pin counts.
@@ -455,7 +556,9 @@ return 1
 `;
 /**
 * KEYS: presence hash. ARGV: atMs, ttlMs, n, then per entry:
-* hashField, valueJson ('' deletes). Field-wise LWW by the sender's
+* hashField, valueJson ('' deletes), patchFieldJson; finally channel and
+* message prefix. Wire fragments stay JSON text to preserve arrays
+* and numeric precision through Lua. Field-wise LWW by the sender's
 * `at`: a stored entry with a strictly newer stamp survives; ties go
 * to the incoming write (memory-tier parity). Returns the applied
 * 1-based entry positions. The whole-key PEXPIRE is the coarse bound,
@@ -467,9 +570,11 @@ return 1
 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 published = {}
+local n = tonumber(ARGV[3])
+for i = 1, n do
+  local field = ARGV[3 + (i - 1) * 3 + 1]
+  local value = ARGV[3 + (i - 1) * 3 + 2]
   local existing = redis.call('HGET', KEYS[1], field)
   if not existing or tonumber(cjson.decode(existing)['a']) <= at then
     if value == '' then
@@ -478,9 +583,13 @@ for i = 1, tonumber(ARGV[3]) do
       redis.call('HSET', KEYS[1], field, value)
     end
     applied[#applied + 1] = tostring(i)
+    published[#published + 1] = ARGV[3 + (i - 1) * 3 + 3]
   end
 end
-if #applied > 0 then redis.call('PEXPIRE', KEYS[1], ARGV[2]) end
+if #applied > 0 then
+  redis.call('PEXPIRE', KEYS[1], ARGV[2])
+  redis.pcall('PUBLISH', ARGV[4 + n * 3], ARGV[5 + n * 3] .. table.concat(published, ',') .. '}}')
+end
 return applied
 `;
 /**
@@ -618,7 +727,7 @@ const wrap = async (fn) => {
 	}
 };
 function createRedisStoreCore(options) {
-	const { call, clock, notify } = options;
+	const { call, clock } = options;
 	const generateId = options.ids;
 	const prefix = options.keyPrefix;
 	const storeKey = (s) => `${prefix}:${s}:log`;
@@ -747,7 +856,8 @@ function createRedisStoreCore(options) {
 						e.cause ? json(e.cause) : "",
 						e.lane ?? "",
 						e.settled ? "1" : "0"
-					])
+					]),
+					`${prefix}:${sessionId}:notify`
 				];
 				const reply = await evalScript(APPEND_LUA, [
 					storeKey(sessionId),
@@ -778,7 +888,6 @@ function createRedisStoreCore(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,
@@ -879,7 +988,8 @@ function createRedisStoreCore(options) {
 						json(event.payload),
 						event.lane ?? "",
 						event.settled === true ? "1" : "0"
-					])
+					]),
+					`${prefix}:${sessionId}:notify`
 				]);
 				const outcome = reply[0];
 				if (outcome === "missing") throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
@@ -891,7 +1001,6 @@ function createRedisStoreCore(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) => ({
@@ -1033,12 +1142,23 @@ function createRedisStoreCore(options) {
 						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
-						})])
+						...entries.flatMap(([field, value]) => [
+							JSON.stringify([participant, field]),
+							value === null ? "" : json({
+								v: value,
+								s: meta.seen,
+								a: atMs,
+								e: expiresAtMs
+							}),
+							`${json(field)}:${json(value)}`
+						]),
+						presenceKey(ns),
+						`${json({
+							src: options.presenceSource,
+							participant,
+							seen: meta.seen,
+							at: atMs
+						}).slice(0, -1)},"values":{`
 					]);
 					if (applied.length === 0) return null;
 					const appliedValues = nullProtoRecord();
@@ -1079,7 +1199,7 @@ function createRedisStoreCore(options) {
 		},
 		async readEvents(sessionId, afterIndex) {
 			return wrap(async () => {
-				return (await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, "+")).map((entry) => toEvent(sessionId, entry));
+				return (await call("XRANGE", storeKey(sessionId), `${afterIndex + 1}-0`, "+", "COUNT", READ_PAGE_SIZE)).map((entry) => toEvent(sessionId, entry));
 			});
 		},
 		async markWatched(sessionId, ttlMs) {
@@ -1088,6 +1208,350 @@ function createRedisStoreCore(options) {
 	};
 }
 //#endregion
-export { createRedisStoreCore as t };
+//#region src/store-redis-notify.ts
+function createRedisNotifyStore(options) {
+	const { client, clock, ids, keyPrefix: prefix } = options;
+	const notifyChannel = (sessionId) => `${prefix}:${sessionId}:notify`;
+	const presenceChannel = (ns) => `${prefix}:${ns}:presence`;
+	const instanceId = crypto.randomUUID();
+	const core = createRedisStoreCore({
+		call: async (command, ...args) => {
+			return (await client()).call(command, ...args);
+		},
+		clock,
+		ids,
+		keyPrefix: prefix,
+		presenceSource: instanceId
+	});
+	let severed = false;
+	let subscriber = null;
+	/** channel → parked-feed wake-ups, armed before each catch-up read. */
+	const wakers = /* @__PURE__ */ new Map();
+	/** channel → refcounted subscription held for each live iterator. */
+	const subscriptions = /* @__PURE__ */ new Map();
+	/**
+	* channel → last presence-marker refresh, throttling the SET.
+	* Deliberately real time (`Date.now()`), not the injected clock:
+	* the marker's PX expiry runs on server real time, and the throttle
+	* must tick with the TTL it refreshes or time-traveling tests would
+	* desync the two. Process-local and never stored, so the injected
+	* clock's every-stored-timestamp pledge is untouched.
+	*/
+	const watched = /* @__PURE__ */ new Map();
+	const presenceSubscriptions = /* @__PURE__ */ new Map();
+	const pollingStreams = /* @__PURE__ */ new Set();
+	options.onReconnect?.((channel) => {
+		for (const wake of wakers.get(channel) ?? []) wake();
+		presenceSubscriptions.get(channel)?.recovery?.reconnect().catch(() => {});
+	});
+	const deliverRemotePresence = ({ subscription, message }) => {
+		let parsed;
+		try {
+			parsed = JSON.parse(message);
+		} catch {
+			return;
+		}
+		if (parsed.src === instanceId) return;
+		const patch = {
+			participant: parsed.participant,
+			values: parsed.values,
+			seen: parsed.seen,
+			at: new Date(parsed.at)
+		};
+		subscription.recovery?.update(patch);
+		for (const listener of subscription.listeners) listener(patch);
+	};
+	const getSubscriber = () => {
+		subscriber ??= (async () => {
+			const conn = (await client()).duplicate();
+			conn.on("message", (channel, message) => {
+				const set = wakers.get(channel);
+				if (set) for (const wake of set) wake();
+				const subscription = presenceSubscriptions.get(channel);
+				if (subscription) deliverRemotePresence({
+					subscription,
+					message
+				});
+			});
+			return conn;
+		})();
+		return subscriber;
+	};
+	/**
+	* The subscriber, gated on connection readiness — for channel
+	* commands only (`close` uses the ungated promise, so it can never
+	* hang on an unreachable server). SUBSCRIBE carries redis's
+	* ok-loading flag, so ioredis writes it mid-handshake, ahead of the
+	* ready check's INFO — which then finds the connection already in
+	* subscriber mode and fails the check (a spurious error event plus
+	* a reconnect). ECHO has no such flag: it resolves only once the
+	* connection is ready, so every channel command chained behind it
+	* lands after the check.
+	*/
+	let subscriberGate = null;
+	const gatedSubscriber = () => {
+		subscriberGate ??= getSubscriber().then(async (conn) => {
+			await conn.call("echo", "ready");
+			return conn;
+		});
+		return subscriberGate;
+	};
+	const acquireChannel = async (channel) => {
+		const existing = subscriptions.get(channel);
+		if (existing) {
+			existing.refs += 1;
+			try {
+				await existing.ready;
+			} catch (err) {
+				existing.refs -= 1;
+				throw err;
+			}
+			return;
+		}
+		const lease = {
+			refs: 1,
+			ready: gatedSubscriber().then(async (conn) => {
+				await conn.call("subscribe", channel);
+				if (subscriptions.get(channel) !== lease || severed) return;
+				const presence = presenceSubscriptions.get(channel);
+				if (options.polling?.() && presence) {
+					presence.recovery = void 0;
+					const ns = channel.slice(prefix.length + 1, -9);
+					presence.poll = pollPresence({
+						read: () => core.presence.read(ns),
+						deliver: (patch) => {
+							for (const listener of presence.listeners) listener(patch);
+						}
+					});
+					await presence.poll.ready;
+				}
+			})
+		};
+		subscriptions.set(channel, lease);
+		try {
+			await lease.ready;
+		} catch (err) {
+			if (subscriptions.get(channel) === lease) {
+				subscriptions.delete(channel);
+				const presence = presenceSubscriptions.get(channel);
+				presence?.poll?.stop();
+				if (presence) presence.poll = void 0;
+			}
+			throw err;
+		}
+	};
+	const releaseChannel = (channel) => {
+		const lease = subscriptions.get(channel);
+		if (!lease) return;
+		lease.refs -= 1;
+		if (lease.refs > 0) return;
+		subscriptions.delete(channel);
+		watched.delete(channel);
+		gatedSubscriber().then((conn) => conn.call("unsubscribe", channel)).catch(() => {});
+	};
+	const armWaker = (channel) => {
+		let wake;
+		const wakeup = new Promise((resolve) => {
+			wake = resolve;
+		});
+		let set = wakers.get(channel);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			wakers.set(channel, set);
+		}
+		set.add(wake);
+		return {
+			wakeup,
+			wake,
+			disarm: () => {
+				set.delete(wake);
+				if (set.size === 0) wakers.delete(channel);
+			}
+		};
+	};
+	return {
+		append: core.append,
+		read: core.read,
+		claimAvailable: core.claimAvailable,
+		renewClaims: core.renewClaims,
+		completeAttempt: core.completeAttempt,
+		failAttempt: core.failAttempt,
+		readState: core.readState,
+		putSnapshots: core.putSnapshots,
+		presence: {
+			async set(ns, participant, values, meta) {
+				const patch = await core.presence.set(ns, participant, values, meta);
+				if (!patch) return;
+				const channel = presenceChannel(ns);
+				const subscription = presenceSubscriptions.get(channel);
+				if (subscription) {
+					subscription.poll?.update(patch);
+					subscription.recovery?.update(patch);
+					for (const listener of subscription.listeners) listener(patch);
+				}
+			},
+			async read(ns) {
+				const channel = presenceChannel(ns);
+				await subscriptions.get(channel)?.ready;
+				return presenceSubscriptions.get(channel)?.recovery?.read() ?? core.presence.read(ns);
+			},
+			subscribe(ns, onPatch) {
+				const channel = presenceChannel(ns);
+				let subscription = presenceSubscriptions.get(channel);
+				if (!subscription) {
+					subscription = { listeners: /* @__PURE__ */ new Set() };
+					presenceSubscriptions.set(channel, subscription);
+					if (options.onReconnect && !options.polling?.()) {
+						const current = subscription;
+						subscription.recovery = presenceRecovery({
+							read: () => core.presence.read(ns),
+							deliver: (patch) => {
+								for (const listener of current.listeners) listener(patch);
+							},
+							isActive: () => !severed && presenceSubscriptions.get(channel) === current
+						});
+					}
+				}
+				subscription.listeners.add(onPatch);
+				acquireChannel(channel).catch(() => {});
+				let stopped = false;
+				return () => {
+					if (stopped) return;
+					stopped = true;
+					subscription.listeners.delete(onPatch);
+					if (subscription.listeners.size === 0) {
+						subscription.poll?.stop();
+						presenceSubscriptions.delete(channel);
+					}
+					releaseChannel(channel);
+				};
+			}
+		},
+		stream(sessionId, opts) {
+			const startAfter = opts?.startAfter ?? 0;
+			const channel = notifyChannel(sessionId);
+			return { [Symbol.asyncIterator]() {
+				let last = startAfter;
+				let buffer = [];
+				let closed = false;
+				let subscribed = false;
+				let pending = null;
+				let interrupt = null;
+				let poller;
+				let stopActivity;
+				const activity = createStreamActivity(() => {
+					if (poller) streamActivities.get(poller)?.activate();
+				});
+				const release = () => {
+					stopActivity?.();
+					if (poller) {
+						poller.return?.();
+						pollingStreams.delete(poller);
+					}
+					if (!subscribed) return;
+					subscribed = false;
+					releaseChannel(channel);
+				};
+				const iterator = {
+					async next() {
+						for (;;) {
+							if (closed) {
+								release();
+								return {
+									value: void 0,
+									done: true
+								};
+							}
+							const row = buffer.shift();
+							if (row) {
+								last = row.index;
+								return {
+									value: row,
+									done: false
+								};
+							}
+							if (severed) {
+								release();
+								throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+							}
+							const waker = armWaker(channel);
+							interrupt = waker.wake;
+							try {
+								if (!subscribed) {
+									subscribed = true;
+									await acquireChannel(channel);
+									if (closed || severed) continue;
+								}
+								if (options.polling?.()) {
+									if (!poller) {
+										poller = pollingStream((after) => core.readEvents(sessionId, after), { startAfter: last })[Symbol.asyncIterator]();
+										pollingStreams.add(poller);
+										stopActivity = streamActivities.get(poller)?.subscribe(activity.setIdle);
+									}
+									const result = await poller.next();
+									if (!result.done) presenceSubscriptions.get(presenceChannel(sessionId))?.poll?.wake();
+									if (severed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+									return result;
+								}
+								let marker = watched.get(channel);
+								if (!marker || Date.now() - marker.at >= NOTIFY_TIMINGS.safetyReadMs) {
+									marker = {
+										at: Date.now(),
+										ready: core.markWatched(sessionId, NOTIFY_TIMINGS.safetyReadMs * 3)
+									};
+									watched.set(channel, marker);
+								}
+								await marker.ready;
+								if (closed || severed) continue;
+								buffer = await core.readEvents(sessionId, last);
+								if (buffer.length === 0 && !closed && !severed) {
+									pending = defaultSleep(NOTIFY_TIMINGS.safetyReadMs);
+									await Promise.race([waker.wakeup, pending.promise]);
+									pending.cancel();
+									pending = null;
+								}
+							} catch (err) {
+								release();
+								if (closed) return {
+									value: void 0,
+									done: true
+								};
+								if (err instanceof A2Error) throw err;
+								throw new A2Error("STORE_UNAVAILABLE", "redis store operation failed", { cause: err });
+							} finally {
+								waker.disarm();
+								interrupt = null;
+							}
+						}
+					},
+					async return() {
+						closed = true;
+						pending?.cancel();
+						interrupt?.();
+						release();
+						return {
+							value: void 0,
+							done: true
+						};
+					}
+				};
+				streamActivities.set(iterator, activity);
+				return iterator;
+			} };
+		},
+		async close() {
+			severed = true;
+			for (const subscription of presenceSubscriptions.values()) subscription.poll?.stop();
+			presenceSubscriptions.clear();
+			for (const poller of pollingStreams) poller.return?.();
+			pollingStreams.clear();
+			for (const set of wakers.values()) for (const wake of set) wake();
+			if (subscriber) (await subscriber.catch(() => null))?.disconnect();
+			await options.closeClient();
+		}
+	};
+}
+//#endregion
+export { createRedisNotifyStore as t };
 
-//# sourceMappingURL=store-redis-core-z-ykbyMg.js.map
+//# sourceMappingURL=store-redis-notify-BUCyXOn0.js.map