experimental-a2 0.10.0 → 0.12.0

package/dist/store-postgres.js

@@ -1,9 +1,482 @@
 import { t as A2Error } from "./errors-DCk6ch5n.js";
-import { n as pollingStream } from "./store-polling-6DW7F1DT.js";
+import { h as nullProtoRecord, r as NOTIFY_TIMINGS } from "./internal-Dq2qYxou.js";
+import { n as pollingStream, t as defaultSleep } from "./store-polling-CmxUbV93.js";
+import { r as platformWaitUntil } from "./platform-B4TnJtWu.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { t as idempotentReplay } from "./idempotent-replay-DVOlyYbx.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS.js";
 import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
+import { t as pollPresence } from "./store-presence-polling-C7-XZyW9.js";
+import { createHash } from "node:crypto";
+//#region src/postgres-notifications.ts
+const postgresNotificationChannel = ({ kind, sessionId }) => `a2_${kind}_${createHash("md5").update(sessionId).digest("hex")}`;
+function postgresNotifications(createConnection) {
+	const channels = /* @__PURE__ */ new Map();
+	const ending = /* @__PURE__ */ new Set();
+	const end = (connection) => {
+		if (!connection) return;
+		const pending = connection.end().catch(() => {}).finally(() => {
+			ending.delete(pending);
+		});
+		ending.add(pending);
+	};
+	let current;
+	let task;
+	let retry;
+	let delay = 100;
+	let connectedAt = 0;
+	let closed = false;
+	const queues = /* @__PURE__ */ new WeakMap();
+	const query = ({ connection, text }) => {
+		const result = (queues.get(connection) ?? Promise.resolve()).then(() => {
+			if (current !== connection) throw new Error("Postgres listener disconnected");
+			return connection.query(text);
+		});
+		queues.set(connection, result.catch(() => {}));
+		return result;
+	};
+	const fail = ({ connection, error }) => {
+		if (connection !== current) return;
+		current = void 0;
+		end(connection);
+		for (const entry of channels.values()) {
+			entry.listening = false;
+			for (const watcher of entry.watchers) watcher.reject(error);
+		}
+		if (closed || channels.size === 0 || retry) return;
+		if (Date.now() - connectedAt >= NOTIFY_TIMINGS.safetyReadMs) delay = 100;
+		retry = defaultSleep(delay);
+		delay = Math.min(delay * 2, NOTIFY_TIMINGS.safetyReadMs);
+		retry.promise.then(() => {
+			retry = void 0;
+			reconcile();
+		});
+	};
+	const reconcile = () => {
+		if (closed || task || retry || channels.size === 0) return;
+		let attempt;
+		task = (async () => {
+			if (!current) {
+				connectedAt = Date.now();
+				const connection = await createConnection();
+				if (closed || channels.size === 0) {
+					await connection.end();
+					return;
+				}
+				current = connection;
+				attempt = connection;
+				connectedAt = Date.now();
+				connection.onNotification(({ channel, payload }) => {
+					if (current !== connection) return;
+					for (const watcher of channels.get(channel)?.watchers ?? []) watcher.notify(payload ?? "");
+				});
+				connection.onError((error) => fail({
+					connection,
+					error
+				}));
+				connection.onEnd(() => fail({
+					connection,
+					error: /* @__PURE__ */ new Error("Postgres listener disconnected")
+				}));
+				await connection.connect();
+				if (current !== connection) return;
+			}
+			const connection = current;
+			attempt = connection;
+			for (const [channel, entry] of channels) {
+				if (entry.listening) continue;
+				entry.listening = true;
+				entry.ready = query({
+					connection,
+					text: `LISTEN "${channel.replaceAll("\"", "\"\"")}"`
+				});
+				await entry.ready;
+				if (current !== connection) return;
+				for (const watcher of entry.watchers) {
+					watcher.resolve();
+					watcher.notify("");
+				}
+			}
+		})().catch((error) => {
+			if (attempt === current) fail({
+				connection: attempt,
+				error
+			});
+		}).finally(() => {
+			task = void 0;
+			if ([...channels.values()].some((entry) => !entry.listening)) reconcile();
+		});
+	};
+	return {
+		watch({ channel, notify }) {
+			let resolve;
+			let reject;
+			const ready = new Promise((yes, no) => {
+				resolve = yes;
+				reject = no;
+			});
+			const watcher = {
+				notify,
+				resolve,
+				reject
+			};
+			let entry = channels.get(channel);
+			if (!entry) {
+				entry = {
+					listening: false,
+					watchers: /* @__PURE__ */ new Set()
+				};
+				channels.set(channel, entry);
+			}
+			entry.watchers.add(watcher);
+			if (entry.listening) entry.ready?.then(resolve, reject);
+			reconcile();
+			let stopped = false;
+			return {
+				ready,
+				stop() {
+					if (stopped) return;
+					stopped = true;
+					resolve();
+					entry.watchers.delete(watcher);
+					if (entry.watchers.size > 0) return;
+					channels.delete(channel);
+					if (channels.size === 0) {
+						retry?.cancel();
+						const connection = current;
+						current = void 0;
+						end(connection);
+					} else if (entry.listening) {
+						const connection = current;
+						if (connection) query({
+							connection,
+							text: `UNLISTEN "${channel.replaceAll("\"", "\"\"")}"`
+						}).catch((error) => fail({
+							connection,
+							error
+						}));
+					}
+				}
+			};
+		},
+		async close() {
+			closed = true;
+			retry?.cancel();
+			for (const entry of channels.values()) for (const watcher of entry.watchers) watcher.resolve();
+			channels.clear();
+			const connection = current;
+			current = void 0;
+			end(connection);
+			await Promise.all(ending);
+		}
+	};
+}
+const POSTGRES_NOTIFICATIONS_SQL = `
+create or replace function a2_notify_events() returns trigger language plpgsql as $$
+begin
+  perform pg_notify('a2_events_' || md5(new.session_id), '');
+  return null;
+end $$;
+create or replace function a2_notify_presence() returns trigger language plpgsql as $$
+begin
+  perform pg_notify('a2_presence_' || md5(case when TG_OP = 'DELETE' then old.ns else new.ns end),
+    coalesce(current_setting('a2.presence_source', true), ''));
+  return null;
+end $$;
+do $$ begin
+  if not exists (select 1 from pg_trigger where tgname = 'a2_notify_events' and tgrelid = 'a2_events'::regclass) then
+    create trigger a2_notify_events after insert on a2_events for each row execute function a2_notify_events();
+  end if;
+  if not exists (select 1 from pg_trigger where tgname = 'a2_notify_presence' and tgrelid = 'a2_presence'::regclass) then
+    create trigger a2_notify_presence after insert or update or delete on a2_presence for each row execute function a2_notify_presence();
+  end if;
+end $$;
+`;
+//#endregion
+//#region src/postgres-notification-scope.ts
+const failure = (error) => error instanceof A2Error ? error : new A2Error("STORE_UNAVAILABLE", "Postgres subscription failed", { cause: error });
+function postgresNotificationScope(load) {
+	const state = {
+		shared: retryableLazy(load),
+		stops: /* @__PURE__ */ new Set(),
+		closed: false
+	};
+	const scope = {
+		watch(options) {
+			let stopped = false;
+			let cancel;
+			const cancelled = new Promise((resolve) => {
+				cancel = resolve;
+			});
+			let subscription;
+			const stop = () => {
+				stopped = true;
+				cancel();
+				subscription?.stop();
+				state.stops.delete(stop);
+			};
+			state.stops.add(stop);
+			return {
+				ready: Promise.race([cancelled, state.shared.get().then(async ({ value }) => {
+					if (stopped || state.closed) return;
+					subscription = value.watch(options);
+					await subscription.ready;
+				})]).catch((error) => {
+					if (!stopped && !state.closed) throw failure(error);
+				}),
+				stop
+			};
+		},
+		stream({ channel, read, startAfter }) {
+			return { [Symbol.asyncIterator]() {
+				let stopped = false;
+				let after = startAfter;
+				let buffer = [];
+				let version = 0;
+				let waiting;
+				let lease;
+				const stop = () => {
+					stopped = true;
+					waiting?.cancel();
+					lease?.stop();
+					state.stops.delete(stop);
+				};
+				state.stops.add(stop);
+				return {
+					async next() {
+						try {
+							if (stopped || state.closed) return {
+								done: true,
+								value: void 0
+							};
+							lease ??= scope.watch({
+								channel,
+								notify: () => {
+									version += 1;
+									waiting?.cancel();
+								}
+							});
+							await lease.ready;
+							for (;;) {
+								if (stopped || state.closed) return {
+									done: true,
+									value: void 0
+								};
+								const row = buffer.shift();
+								if (row) {
+									after = row.index;
+									return {
+										done: false,
+										value: row
+									};
+								}
+								const before = version;
+								buffer = await read(after);
+								if (stopped || state.closed) return {
+									done: true,
+									value: void 0
+								};
+								if (buffer.length || before !== version) continue;
+								waiting = defaultSleep(NOTIFY_TIMINGS.safetyReadMs);
+								await waiting.promise;
+							}
+						} catch (error) {
+							if (stopped || state.closed) return {
+								done: true,
+								value: void 0
+							};
+							stop();
+							throw failure(error);
+						}
+					},
+					async return() {
+						stop();
+						return {
+							done: true,
+							value: void 0
+						};
+					}
+				};
+			} };
+		},
+		async close() {
+			if (state.closed) return;
+			state.closed = true;
+			for (const stop of state.stops) stop();
+			await (await state.shared.peek()?.catch(() => void 0))?.release();
+		}
+	};
+	return scope;
+}
+//#endregion
+//#region src/postgres-pool.ts
+function postgresPoolClient(pool) {
+	let timer;
+	let resolve;
+	const finish = () => {
+		clearTimeout(timer);
+		timer = void 0;
+		resolve?.();
+		resolve = void 0;
+	};
+	const keepAlive = () => {
+		const idleTimeout = pool.options.idleTimeoutMillis;
+		if (pool.ending || pool.idleCount === 0 || typeof idleTimeout !== "number" || !Number.isFinite(idleTimeout) || idleTimeout <= 0) return;
+		finish();
+		const pending = new Promise((done) => {
+			resolve = done;
+			timer = setTimeout(finish, idleTimeout + 100);
+			timer.unref();
+		});
+		platformWaitUntil(pending);
+	};
+	pool.on("remove", () => {
+		if (pool.totalCount === 0) finish();
+	});
+	return {
+		async query(text, values) {
+			try {
+				return await pool.query(text, values);
+			} finally {
+				keepAlive();
+			}
+		},
+		async connect() {
+			const client = await pool.connect();
+			return {
+				query: (text, values) => client.query(text, values),
+				release() {
+					try {
+						client.release();
+					} finally {
+						keepAlive();
+					}
+				}
+			};
+		},
+		async end() {
+			try {
+				await pool.end();
+			} finally {
+				finish();
+			}
+		}
+	};
+}
+//#endregion
+//#region src/postgres-resources.ts
+const registryKey = Symbol.for("experimental-a2.postgres-resources.v3");
+const registry = () => {
+	let value = Reflect.get(globalThis, registryKey);
+	if (!value) {
+		value = {
+			pools: /* @__PURE__ */ new Map(),
+			injected: /* @__PURE__ */ new WeakMap(),
+			listeners: /* @__PURE__ */ new Map(),
+			identities: /* @__PURE__ */ new WeakMap(),
+			nextIdentity: 0
+		};
+		Reflect.set(globalThis, registryKey, value);
+	}
+	return value;
+};
+const acquire = ({ cache, key, create }) => {
+	let entry = cache.get(key);
+	if (!entry) {
+		entry = {
+			value: create(),
+			refs: 0
+		};
+		cache.set(key, entry);
+	}
+	entry.refs += 1;
+	const held = entry;
+	let released = false;
+	return {
+		value: entry.value,
+		async release() {
+			if (released) return;
+			released = true;
+			held.refs -= 1;
+			if (held.refs !== 0) return;
+			if (cache.get(key) === held) cache.delete(key);
+			await held.value.close();
+		}
+	};
+};
+function postgresConnectionKey({ connectionString, defaults }) {
+	const shared = registry();
+	const visited = /* @__PURE__ */ new Set();
+	const identity = (value) => {
+		let id = shared.identities.get(value);
+		if (id === void 0) {
+			id = ++shared.nextIdentity;
+			shared.identities.set(value, id);
+		}
+		return id;
+	};
+	const encode = (value) => {
+		if (typeof value === "function") return ["reference", identity(value)];
+		if (value === null || typeof value !== "object") return [typeof value, String(value)];
+		if (Buffer.isBuffer(value)) return ["buffer", value.toString("base64")];
+		const prototype = Object.getPrototypeOf(value);
+		if (visited.has(value) || prototype !== Object.prototype && prototype !== null && !Array.isArray(value)) return ["reference", identity(value)];
+		visited.add(value);
+		const result = [Array.isArray(value) ? "array" : "object", Object.getOwnPropertyNames(value).toSorted().map((key) => [key, encode(Reflect.get(value, key))])];
+		visited.delete(value);
+		return result;
+	};
+	const environment = Object.keys(process.env).filter((key) => key.startsWith("PG")).toSorted().map((key) => [key, process.env[key]]);
+	return createHash("sha256").update(JSON.stringify([
+		connectionString,
+		environment,
+		encode(defaults)
+	])).digest("hex");
+}
+const queries = (raw) => {
+	let pending = Promise.resolve();
+	const schemas = /* @__PURE__ */ new Map();
+	const exclusive = (fn) => {
+		const result = pending.then(fn);
+		pending = result.catch(() => {});
+		return result;
+	};
+	return {
+		raw,
+		client: raw.connect ? raw : { query: (text, values) => exclusive(() => raw.query(text, values)) },
+		exclusive,
+		initialize({ schema, run }) {
+			const existing = schemas.get(schema);
+			if (existing) return existing;
+			const attempt = run();
+			schemas.set(schema, attempt);
+			attempt.catch(() => {
+				if (schemas.get(schema) === attempt) schemas.delete(schema);
+			});
+			return attempt;
+		},
+		async close() {
+			await pending;
+			await raw.end?.();
+		}
+	};
+};
+const sharePostgresPool = ({ key, create }) => acquire({
+	cache: registry().pools,
+	key,
+	create: () => queries(create())
+});
+const sharePostgresClient = (client) => acquire({
+	cache: registry().injected,
+	key: client,
+	create: () => queries(client)
+});
+const sharePostgresListener = ({ key, create }) => acquire({
+	cache: registry().listeners,
+	key,
+	create
+});
+//#endregion
 //#region src/store-postgres.ts
 /**
 * experimental-a2/store-postgres — postgres store backend (the production path).
@@ -17,9 +490,8 @@ import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
 *
 * Semantics mirror the sqlite backend: `index` is stored as `idx`,
 * timestamps are epoch milliseconds written from the injected clock —
-* never SQL `now()` — and `stream()` is a poll loop. (A LISTEN/NOTIFY
-* upgrade can land later without any API change; callers never branch
-* on the transport.) Appends serialize per session via
+* never SQL `now()`. Streams poll by default; an optional direct
+* connection enables LISTEN/NOTIFY for events and presence. Appends serialize per session via
 * `pg_advisory_xact_lock`, so concurrent writers can't race the index
 * assignment.
 */
@@ -155,16 +627,17 @@ const wrap = async (fn) => {
 	}
 };
 const jsonb = (value) => JSON.stringify(value) ?? "null";
-const initializeSchema = async (client) => {
+const initializeSchema = async ({ client, listen }) => {
+	const schema = SCHEMA + (listen ? POSTGRES_NOTIFICATIONS_SQL : "");
 	if (!client.connect) {
-		await client.query(SCHEMA);
+		await client.query(schema);
 		return;
 	}
 	const conn = await client.connect();
 	try {
 		await conn.query("begin");
 		await conn.query("select pg_advisory_xact_lock(hashtext('a2:postgres:schema'))");
-		await conn.query(SCHEMA);
+		await conn.query(schema);
 		await conn.query("commit");
 	} catch (err) {
 		await conn.query("rollback").catch(() => {});
@@ -173,28 +646,99 @@ const initializeSchema = async (client) => {
 		conn.release();
 	}
 };
+const loadPg = async () => import("pg").catch(() => {
+	throw new A2Error("STORE_NOT_CONFIGURED", "Postgres connections created by A2 require the optional 'pg' package");
+});
+const createListener = ({ pg, connectionString }) => postgresNotifications(async () => {
+	const listener = new pg.default.Client({
+		connectionString,
+		application_name: "a2-listener",
+		connectionTimeoutMillis: 1e4
+	});
+	return {
+		connect: () => listener.connect(),
+		query: (text) => listener.query(text),
+		end: () => listener.end(),
+		onNotification: (callback) => {
+			listener.on("notification", callback);
+		},
+		onError: (callback) => {
+			listener.on("error", callback);
+		},
+		onEnd: (callback) => {
+			listener.on("end", callback);
+		}
+	};
+});
 function postgres(options = {}) {
 	const clock = options.clock ?? SYSTEM_CLOCK;
 	const generateId = options.ids ?? RANDOM_IDS;
+	const instanceId = crypto.randomUUID();
+	let closed = false;
+	if (options.listenConnectionString === "") throw new TypeError("listenConnectionString must be a direct Postgres connection string");
 	if (!options.client && !options.connectionString) throw new TypeError("postgres() needs a connectionString or an injected client");
+	const injected = options.client ? sharePostgresClient(options.client) : void 0;
 	const connection = retryableLazy(async () => {
-		let owned = null;
+		let lease = injected;
+		if (!lease) {
+			const pg = await loadPg();
+			const connectionString = options.connectionString;
+			const key = postgresConnectionKey({
+				connectionString,
+				defaults: pg.default.defaults
+			});
+			lease = sharePostgresPool({
+				key,
+				create: () => {
+					const pool = new pg.default.Pool({ connectionString });
+					pool.on("error", () => {});
+					return postgresPoolClient(pool);
+				}
+			});
+		}
 		try {
-			let c = options.client;
-			if (!c) {
-				c = new (await (import("pg").catch(() => {
-					throw new A2Error("STORE_NOT_CONFIGURED", "experimental-a2/store-postgres with a connectionString needs the 'pg' package (optional peer dependency) — install it, or inject a client");
-				}))).default.Pool({ connectionString: options.connectionString });
-				owned = c;
-			}
-			await initializeSchema(c);
-			return c;
-		} catch (err) {
-			if (owned?.end) await owned.end().catch(() => {});
-			throw err;
+			const listen = Boolean(options.listenConnectionString);
+			const resource = lease.value;
+			if (injected) await initializeSchema({
+				client: resource.client,
+				listen
+			});
+			else await resource.initialize({
+				schema: SCHEMA + (listen ? POSTGRES_NOTIFICATIONS_SQL : ""),
+				run: () => initializeSchema({
+					client: resource.client,
+					listen
+				})
+			});
+			return lease;
+		} catch (error) {
+			if (!injected) await lease.release().catch(() => {});
+			throw error;
 		}
 	});
-	const client = connection.get;
+	const client = async () => {
+		if (closed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+		const lease = await connection.get();
+		if (closed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+		return lease.value.client;
+	};
+	const notifications = options.listenConnectionString ? postgresNotificationScope(async () => {
+		await client();
+		const pg = await loadPg();
+		const connectionString = options.listenConnectionString;
+		const key = postgresConnectionKey({
+			connectionString,
+			defaults: pg.default.defaults
+		});
+		return sharePostgresListener({
+			key,
+			create: () => createListener({
+				pg,
+				connectionString
+			})
+		});
+	}) : void 0;
+	const presenceSubscriptions = /* @__PURE__ */ new Map();
 	const readStateBatch = async (requests, reducerName) => {
 		if (requests.length === 0) return [];
 		const c = await client();
@@ -279,13 +823,13 @@ function postgres(options = {}) {
 		}
 		return reads;
 	};
-	let mutex = Promise.resolve();
+	const begin = notifications ? `begin; set local a2.presence_source = '${instanceId}'` : "begin";
 	const withTx = async (fn) => {
 		const c = await client();
 		if (c.connect) {
 			const conn = await c.connect();
 			try {
-				await conn.query("begin");
+				await conn.query(begin);
 				const result = await fn((text, values) => conn.query(text, values));
 				await conn.query("commit");
 				return result;
@@ -296,21 +840,21 @@ function postgres(options = {}) {
 				conn.release();
 			}
 		}
-		const run = mutex.then(async () => {
-			await c.query("begin");
+		const resource = (await connection.get()).value;
+		return resource.exclusive(async () => {
+			const raw = resource.raw;
+			await raw.query(begin);
 			try {
-				const result = await fn((text, values) => c.query(text, values));
-				await c.query("commit");
+				const result = await fn((text, values) => raw.query(text, values));
+				await raw.query("commit");
 				return result;
 			} catch (err) {
-				await c.query("rollback").catch(() => {});
+				await raw.query("rollback").catch(() => {});
 				throw err;
 			}
 		});
-		mutex = run.catch(() => {});
-		return run;
 	};
-	return {
+	const store = {
 		async append(sessionId, events) {
 			if (events.length === 0) return wrap(async () => {
 				const { rows } = await (await client()).query(`select exists(
@@ -838,17 +1382,18 @@ function postgres(options = {}) {
 				const entries = Object.entries(values);
 				if (entries.length === 0) return;
 				await wrap(async () => {
-					const c = await client();
 					const atMs = meta.at.getTime();
 					const expiresAtMs = clock.now().getTime() + meta.ttlMs;
-					for (const [field, value] of entries) await (value === null ? c.query(`delete from a2_presence
+					const applied = nullProtoRecord();
+					const write = async (query) => {
+						for (const [field, value] of entries) if ((await (value === null ? query(`delete from a2_presence
                     where ns = $1 and participant = $2 and field = $3
-                      and at <= $4`, [
-						ns,
-						participant,
-						field,
-						atMs
-					]) : c.query(`insert into a2_presence
+                      and at <= $4${notifications ? " returning field" : ""}`, [
+							ns,
+							participant,
+							field,
+							atMs
+						]) : query(`insert into a2_presence
                      (ns, participant, field, value, seen, at, expires_at)
                    values ($1, $2, $3, $4::jsonb, $5, $6, $7)
                    on conflict (ns, participant, field) do update set
@@ -856,15 +1401,32 @@ function postgres(options = {}) {
                      seen = excluded.seen,
                      at = excluded.at,
                      expires_at = excluded.expires_at
-                   where a2_presence.at <= excluded.at`, [
-						ns,
-						participant,
-						field,
-						jsonb(value),
-						meta.seen,
-						atMs,
-						expiresAtMs
-					]));
+                   where a2_presence.at <= excluded.at${notifications ? " returning field" : ""}`, [
+							ns,
+							participant,
+							field,
+							jsonb(value),
+							meta.seen,
+							atMs,
+							expiresAtMs
+						]))).rows.length) applied[field] = structuredClone(value);
+					};
+					if (notifications) await withTx(write);
+					else {
+						const c = await client();
+						await write((text, parameters) => c.query(text, parameters));
+					}
+					if (Object.keys(applied).length) {
+						const patch = {
+							participant,
+							values: applied,
+							seen: meta.seen,
+							at: new Date(atMs)
+						};
+						const subscription = presenceSubscriptions.get(ns);
+						subscription?.poll.update(patch);
+						for (const listener of subscription?.listeners ?? []) listener(patch);
+					}
 				});
 			},
 			async read(ns) {
@@ -892,17 +1454,103 @@ function postgres(options = {}) {
 		},
 		stream(sessionId, opts) {
 			const readAfter = (afterIndex) => wrap(async () => {
-				const { rows } = await (await client()).query("select * from a2_events where session_id = $1 and idx > $2 order by idx", [sessionId, afterIndex]);
-				return rows.map(toStored);
+				const { rows } = await (await client()).query(`select session_id, idx, event_type, payload, event_id, created_at
+               from a2_events
+              where session_id = $1 and idx > $2
+              order by idx`, [sessionId, afterIndex]);
+				return rows.map(toEvent);
+			});
+			if (notifications) return notifications.stream({
+				channel: postgresNotificationChannel({
+					kind: "events",
+					sessionId
+				}),
+				read: readAfter,
+				startAfter: opts?.startAfter ?? 0
 			});
 			return pollingStream(readAfter, opts?.startAfter !== void 0 ? { startAfter: opts.startAfter } : {});
 		},
 		async close() {
-			const current = connection.peek();
-			if (!current) return;
-			await (await current).end?.();
+			if (closed) return;
+			closed = true;
+			for (const subscription of presenceSubscriptions.values()) subscription.stop();
+			presenceSubscriptions.clear();
+			await notifications?.close();
+			const lease = await connection.peek()?.catch(() => void 0);
+			await (injected ?? lease)?.release();
 		}
 	};
+	if (notifications) {
+		const presence = store.presence;
+		const read = presence.read;
+		presence.read = async (ns) => {
+			const subscription = presenceSubscriptions.get(ns);
+			await subscription?.ready;
+			await subscription?.poll.ready;
+			return read(ns);
+		};
+		presence.subscribe = (ns, onPatch) => {
+			if (closed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+			let subscription = presenceSubscriptions.get(ns);
+			if (!subscription) {
+				const listeners = /* @__PURE__ */ new Set();
+				let dirty = false;
+				let ended = false;
+				let waiting;
+				const lease = notifications.watch({
+					channel: postgresNotificationChannel({
+						kind: "presence",
+						sessionId: ns
+					}),
+					notify: (source) => {
+						if (source === instanceId) return;
+						dirty = true;
+						waiting?.cancel();
+					}
+				});
+				const poll = pollPresence({
+					read: async () => {
+						await lease.ready;
+						if (ended || closed) return [];
+						dirty = false;
+						return read(ns);
+					},
+					deliver: (patch) => {
+						for (const listener of listeners) listener(patch);
+					},
+					sleep: () => {
+						waiting = defaultSleep(dirty ? 0 : NOTIFY_TIMINGS.safetyReadMs);
+						return waiting;
+					}
+				});
+				lease.ready.catch(() => poll.stop());
+				subscription = {
+					listeners,
+					ready: lease.ready,
+					poll,
+					stop() {
+						ended = true;
+						poll.stop();
+						lease.stop();
+						waiting?.cancel();
+					}
+				};
+				presenceSubscriptions.set(ns, subscription);
+			}
+			subscription.listeners.add(onPatch);
+			let stopped = false;
+			return () => {
+				if (stopped) return;
+				stopped = true;
+				subscription.listeners.delete(onPatch);
+				if (subscription.listeners.size === 0) {
+					presenceSubscriptions.delete(ns);
+					subscription.stop();
+				}
+			};
+		};
+	}
+	return store;
 }
 //#endregion
 export { postgres };