@agimon-ai/po-session 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/{sessionDelivery-CkuX6jlw.cjs → sessionDelivery-CGWuQyLV.cjs}

@@ -23,19 +23,21 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let _agimon_ai_po_core_backgroundWork = require("@agimon-ai/po-core/backgroundWork");
 let typebox_value = require("typebox/value");
 let node_crypto = require("node:crypto");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs, 1);
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
-let node_sqlite = require("node:sqlite");
+let _agimon_ai_po_core_platform = require("@agimon-ai/po-core/platform");
 let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_sqlite = require("node:sqlite");
+let node_timers = require("node:timers");
 //#region src/services/backgroundWorkService/index.ts
 /** Creates the generation-bound, pull-based coordinator shared by session extensions. */
 function createBackgroundWorkService(ctx) {
 	const registrations = /* @__PURE__ */ new Map();
-	const generation = `doom-background-work:${crypto.randomUUID()}`;
+	const generation = `po-background-work:${crypto.randomUUID()}`;
 	const changed = (provider, providerGeneration, kind) => {
-		ctx.emit(_agimon_ai_po_core_backgroundWork.DOOM_BACKGROUND_WORK_CHANGED_EVENT, {
+		ctx.emit(_agimon_ai_po_core_backgroundWork.PO_BACKGROUND_WORK_CHANGED_EVENT, {
 			provider,
 			generation: providerGeneration,
 			kind
@@ -99,11 +101,8 @@ function createBackgroundWorkService(ctx) {
 }
 /** Installs one coordinator in the current session service context. */
 function provideBackgroundWorkService(context) {
-	context.provide(_agimon_ai_po_core_backgroundWork.DOOM_BACKGROUND_WORK_SERVICE, createBackgroundWorkService(context));
+	context.provide(_agimon_ai_po_core_backgroundWork.PO_BACKGROUND_WORK_SERVICE, createBackgroundWorkService(context));
 }
-//#endregion
-//#region src/services/peerTransport/index.ts
-const PEER_CONFIG_VERSION = 1;
 const PEER_CONFIG_FILE = "peers.json";
 const PEER_ROUTE = "/api/plugins/session-peer/inbox";
 const PEER_HEADER = "x-po-session-peer";
@@ -111,7 +110,8 @@ const TIMESTAMP_HEADER = "x-po-session-timestamp";
 const SIGNATURE_HEADER = "x-po-session-signature";
 const MAX_CLOCK_SKEW_MS = 3e5;
 const MAX_REPLAY_ENTRIES = 1e4;
-const REPLAY_DATABASE_FILE = "peer-replay.sqlite";
+/** File the replay guard database lives in, beside the peer config. */
+const PEER_REPLAY_DATABASE_FILE = "peer-replay.sqlite";
 function validId(value) {
 	return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value);
 }
@@ -140,29 +140,144 @@ function peerOf(value) {
 function sessionPeerConfigPath(homeDirectory) {
 	return node_path.default.join((0, _agimon_ai_po_core_piSettings.poHomeDirectory)(homeDirectory), "session", PEER_CONFIG_FILE);
 }
-/** Reads operator-provisioned peers. Invalid or unreadable config fails closed. */
-function readSessionPeerConfig(homeDirectory) {
+/** Group or other permission bits on the peer config make it untrusted. */
+function peerConfigModeIsPrivate(mode) {
+	return (mode & 63) === 0;
+}
+/** Validates peer config text. Invalid config fails closed. */
+function parseSessionPeerConfig(text) {
 	let parsed;
 	try {
-		const file = sessionPeerConfigPath(homeDirectory);
-		if ((node_fs.default.statSync(file).mode & 63) !== 0) return void 0;
-		parsed = JSON.parse(node_fs.default.readFileSync(file, "utf8"));
+		parsed = JSON.parse(text);
 	} catch {
 		return;
 	}
 	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
 	const record = parsed;
-	if (record.version !== PEER_CONFIG_VERSION || !validId(record.hostId) || !Array.isArray(record.peers)) return void 0;
+	if (record.version !== 1 || !validId(record.hostId) || !Array.isArray(record.peers)) return void 0;
 	const peers = record.peers.map(peerOf);
 	if (peers.some((peer) => peer === void 0)) return void 0;
 	const resolved = peers;
 	if (new Set(resolved.map((peer) => peer.hostId)).size !== resolved.length || resolved.some((peer) => peer.hostId === record.hostId)) return void 0;
 	return {
-		version: PEER_CONFIG_VERSION,
+		version: 1,
 		hostId: record.hostId,
 		peers: resolved
 	};
 }
+/** Replay guard SQL shared by the async guard and the Node-only sync shim. */
+const PEER_REPLAY_SQL = Object.freeze({
+	schema: `
+    CREATE TABLE IF NOT EXISTS peer_request_replays (
+      signature TEXT PRIMARY KEY,
+      expires_at INTEGER NOT NULL
+    );
+  `,
+	removeExpired: "DELETE FROM peer_request_replays WHERE expires_at < ?",
+	insert: "INSERT OR IGNORE INTO peer_request_replays (signature, expires_at) VALUES (?, ?)",
+	insertReturning: "INSERT OR IGNORE INTO peer_request_replays (signature, expires_at) VALUES (?, ?) RETURNING signature",
+	count: "SELECT COUNT(*) AS count FROM peer_request_replays",
+	trim: `
+    DELETE FROM peer_request_replays
+    WHERE signature IN (
+      SELECT signature FROM peer_request_replays ORDER BY expires_at ASC, signature ASC LIMIT ?
+    )
+  `
+});
+function peerRequestSignature(request) {
+	return request.headers.get(SIGNATURE_HEADER);
+}
+function peerReplayExpiry(now) {
+	return now + MAX_CLOCK_SKEW_MS;
+}
+function peerReplayOverflow(total) {
+	return total > MAX_REPLAY_ENTRIES ? total - MAX_REPLAY_ENTRIES : 0;
+}
+//#endregion
+//#region src/services/peerTransport/sync.ts
+/**
+* Reads operator-provisioned peers. Invalid or unreadable config fails closed.
+*
+* @deprecated Node-only sync shim; use readSessionPeerConfigAsync. Removed in M2.
+*/
+function readSessionPeerConfig(homeDirectory) {
+	let text;
+	try {
+		const file = sessionPeerConfigPath(homeDirectory);
+		if (!peerConfigModeIsPrivate(node_fs.default.statSync(file).mode)) return void 0;
+		text = node_fs.default.readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+	return parseSessionPeerConfig(text);
+}
+/**
+* Persists accepted peer signatures so a valid request cannot be replayed within its clock-skew window.
+*
+* @deprecated Node-only sync shim; use createPeerReplayGuardAsync. Removed in M2.
+*/
+function createPeerReplayGuard(homeDirectory) {
+	const directory = node_path.default.dirname(sessionPeerConfigPath(homeDirectory));
+	node_fs.default.mkdirSync(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const database = new node_sqlite.DatabaseSync(node_path.default.join(directory, PEER_REPLAY_DATABASE_FILE));
+	database.exec(`PRAGMA journal_mode = WAL;${PEER_REPLAY_SQL.schema}`);
+	const removeExpired = database.prepare(PEER_REPLAY_SQL.removeExpired);
+	const insert = database.prepare(PEER_REPLAY_SQL.insert);
+	const count = database.prepare(PEER_REPLAY_SQL.count);
+	const trim = database.prepare(PEER_REPLAY_SQL.trim);
+	return {
+		admit(request, now = Date.now()) {
+			const supplied = peerRequestSignature(request);
+			if (!supplied) return false;
+			database.exec("BEGIN IMMEDIATE");
+			try {
+				removeExpired.run(now);
+				const accepted = insert.run(supplied, peerReplayExpiry(now)).changes === 1;
+				const overflow = peerReplayOverflow(Number(count.get().count));
+				if (overflow > 0) trim.run(overflow);
+				database.exec("COMMIT");
+				return accepted;
+			} catch (cause) {
+				database.exec("ROLLBACK");
+				throw cause;
+			}
+		},
+		close: () => database.close()
+	};
+}
+//#endregion
+//#region src/services/peerTransport/index.ts
+/** Reads operator-provisioned peers. Invalid or unreadable config fails closed. */
+async function readSessionPeerConfigAsync(fs, homeDirectory, context) {
+	try {
+		const file = sessionPeerConfigPath(homeDirectory);
+		const mode = await _agimon_ai_po_core_platform.nodeHost.fileMode(file);
+		if (mode !== void 0 && !peerConfigModeIsPrivate(mode)) return void 0;
+		const text = await (0, _agimon_ai_po_core_platform.readTextIfExists)(fs, file, context);
+		return text === void 0 ? void 0 : parseSessionPeerConfig(text);
+	} catch {
+		return;
+	}
+}
+/**
+* Creates a directory tree, giving each directory it creates owner-only access, the way
+* `mkdirSync(directory, { recursive: true, mode: 0o700 })` does. Existing directories keep their mode.
+*/
+async function ensurePrivateDirectory(fs, directory, context) {
+	const missing = [];
+	for (let current = node_path.default.resolve(directory); !(0, _agimon_ai_po_core_platform.getOrThrow)(await fs.exists(current, context));) {
+		missing.unshift(current);
+		const parent = node_path.default.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	if (missing.length === 0) return;
+	(0, _agimon_ai_po_core_platform.getOrThrow)(await fs.createDir(directory, { recursive: true }, context));
+	for (const created of missing) await _agimon_ai_po_core_platform.nodeHost.setMode(created, 448);
+}
 /** `peer/<host-id>/<session-id>` is the only remote target spelling. */
 function parseRemoteSessionReference(value) {
 	const match = /^peer\/([^/]+)\/([^/]+)$/u.exec(value);
@@ -189,46 +304,24 @@ function peerRequestHeaders(sourceHostId, peer, method, pathname, body, now = Da
 		[SIGNATURE_HEADER]: signature(peer.secret, method, pathname, timestamp, body)
 	});
 }
-/** Persists accepted peer signatures so a valid request cannot be replayed within its clock-skew window. */
-function createPeerReplayGuard(homeDirectory) {
-	const directory = node_path.default.dirname(sessionPeerConfigPath(homeDirectory));
-	node_fs.default.mkdirSync(directory, {
-		recursive: true,
-		mode: 448
-	});
-	const database = new node_sqlite.DatabaseSync(node_path.default.join(directory, REPLAY_DATABASE_FILE));
-	database.exec(`
-    PRAGMA journal_mode = WAL;
-    CREATE TABLE IF NOT EXISTS peer_request_replays (
-      signature TEXT PRIMARY KEY,
-      expires_at INTEGER NOT NULL
-    );
-  `);
-	const removeExpired = database.prepare("DELETE FROM peer_request_replays WHERE expires_at < ?");
-	const insert = database.prepare("INSERT OR IGNORE INTO peer_request_replays (signature, expires_at) VALUES (?, ?)");
-	const count = database.prepare("SELECT COUNT(*) AS count FROM peer_request_replays");
-	const trim = database.prepare(`
-    DELETE FROM peer_request_replays
-    WHERE signature IN (
-      SELECT signature FROM peer_request_replays ORDER BY expires_at ASC, signature ASC LIMIT ?
-    )
-  `);
+/**
+* Persists accepted peer signatures so a valid request cannot be replayed within its clock-skew window.
+* Takes over the database and closes it in `close()`.
+*/
+async function createPeerReplayGuardAsync(database) {
+	await database.exec(PEER_REPLAY_SQL.schema);
 	return {
-		admit(request, now = Date.now()) {
-			const supplied = request.headers.get(SIGNATURE_HEADER);
+		async admit(request, now = Date.now()) {
+			const supplied = peerRequestSignature(request);
 			if (!supplied) return false;
-			database.exec("BEGIN IMMEDIATE");
-			try {
-				removeExpired.run(now);
-				const accepted = insert.run(supplied, now + MAX_CLOCK_SKEW_MS).changes === 1;
-				const total = Number(count.get().count);
-				if (total > MAX_REPLAY_ENTRIES) trim.run(total - MAX_REPLAY_ENTRIES);
-				database.exec("COMMIT");
+			return database.transaction(async (transaction) => {
+				await transaction.run(PEER_REPLAY_SQL.removeExpired, now);
+				const accepted = await transaction.get(PEER_REPLAY_SQL.insertReturning, supplied, peerReplayExpiry(now)) !== void 0;
+				const row = await transaction.get(PEER_REPLAY_SQL.count);
+				const overflow = peerReplayOverflow(Number(row?.count ?? 0));
+				if (overflow > 0) await transaction.run(PEER_REPLAY_SQL.trim, overflow);
 				return accepted;
-			} catch (cause) {
-				database.exec("ROLLBACK");
-				throw cause;
-			}
+			});
 		},
 		close: () => database.close()
 	};
@@ -239,7 +332,7 @@ function verifyPeerRequest(config, request, body, now = Date.now()) {
 	const supplied = request.headers.get(SIGNATURE_HEADER);
 	if (!hostId || !timestamp || !supplied || !/^\d{1,16}$/u.test(timestamp)) return void 0;
 	const sentAt = Number(timestamp);
-	if (!Number.isSafeInteger(sentAt) || Math.abs(now - sentAt) > MAX_CLOCK_SKEW_MS) return void 0;
+	if (!Number.isSafeInteger(sentAt) || Math.abs(now - sentAt) > 3e5) return void 0;
 	const peer = config.peers.find((candidate) => candidate.hostId === hostId);
 	if (!peer) return void 0;
 	const expected = Buffer.from(signature(peer.secret, request.method, new URL(request.url).pathname, timestamp, body));
@@ -261,7 +354,7 @@ function parseSessionPeerEnvelope(value) {
 }
 /** Adds asynchronous tunnel publication to a host-bound local communication endpoint. */
 function createPeerCommunication(options) {
-	const config = readSessionPeerConfig(options.homeDirectory);
+	const config = options.config;
 	const send = options.fetch ?? fetch;
 	return {
 		sessionId: options.local.sessionId,
@@ -329,19 +422,26 @@ function createSessionDirectory(options) {
 	const observations = /* @__PURE__ */ new Map();
 	const snapshotRequired = /* @__PURE__ */ new Set();
 	const subscribers = /* @__PURE__ */ new Set();
-	const discover = (callerReference, allowedReferences) => {
+	const discover = async (callerReference, allowedReferences) => {
 		const result = [];
-		for (const observation of observations.values()) {
+		for (const observation of Array.from(observations.values())) {
 			const reference = keyOf(observation);
 			if (allowedReferences && !allowedReferences.has(reference)) continue;
-			const grant = options.authorizeDiscovery(callerReference, observation);
+			const grant = await options.authorizeDiscovery(callerReference, observation);
 			if (!grant) continue;
 			result.push(publicEntry(observation, now(), grant.label ?? observation.label, grant.capabilities));
 		}
 		return result.sort((left, right) => left.reference.localeCompare(right.reference));
 	};
+	const push = (subscriber) => {
+		subscriber.queue = subscriber.queue.then(async () => {
+			if (!subscribers.has(subscriber)) return;
+			const sessions = await discover(subscriber.callerReference);
+			if (subscribers.has(subscriber)) subscriber.listener(sessions);
+		}).catch(() => void 0);
+	};
 	const notify = () => {
-		for (const subscriber of subscribers) subscriber.listener(discover(subscriber.callerReference));
+		for (const subscriber of subscribers) push(subscriber);
 	};
 	return {
 		observe(observation) {
@@ -390,17 +490,18 @@ function createSessionDirectory(options) {
 			notify();
 		},
 		discover,
-		resolveDeliveryTarget(callerReference, reference) {
+		async resolveDeliveryTarget(callerReference, reference) {
 			const observation = observations.get(reference);
-			return observation && options.authorizeDiscovery(callerReference, observation) ? observation.deliveryTarget : void 0;
+			return observation && await options.authorizeDiscovery(callerReference, observation) ? observation.deliveryTarget : void 0;
 		},
 		subscribe(callerReference, listener) {
 			const subscriber = {
 				callerReference,
-				listener
+				listener,
+				queue: Promise.resolve()
 			};
 			subscribers.add(subscriber);
-			listener(discover(callerReference));
+			push(subscriber);
 			return () => subscribers.delete(subscriber);
 		}
 	};
@@ -423,100 +524,96 @@ function validateGroupId(value) {
 function validateReference(value) {
 	if (!REFERENCE_PATTERN.test(value)) throw new TypeError(`Session group member '${value}' is not a qualified reference.`);
 }
+const SCHEMA$1 = `
+  CREATE TABLE IF NOT EXISTS session_groups (
+    group_id TEXT PRIMARY KEY,
+    owner_authority TEXT NOT NULL,
+    revision INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS session_group_members (
+    group_id TEXT NOT NULL REFERENCES session_groups(group_id) ON DELETE CASCADE,
+    member_reference TEXT NOT NULL,
+    PRIMARY KEY (group_id, member_reference)
+  );
+`;
+async function readGroup(database, groupId) {
+	const row = await database.get("SELECT * FROM session_groups WHERE group_id = ?", groupId);
+	if (!row) return void 0;
+	const members = await database.all("SELECT member_reference FROM session_group_members WHERE group_id = ? ORDER BY member_reference", groupId);
+	return Object.freeze({
+		id: row.group_id,
+		ownerAuthority: row.owner_authority,
+		revision: Number(row.revision),
+		members: Object.freeze(members.map((member) => member.member_reference))
+	});
+}
 /** Opens a revisioned SQLite registry for communication-only group membership. */
-function createSessionGroupStore(options) {
-	const database = new node_sqlite.DatabaseSync(options.databasePath);
-	database.exec(`
-    PRAGMA journal_mode = WAL;
-    PRAGMA foreign_keys = ON;
-    CREATE TABLE IF NOT EXISTS session_groups (
-      group_id TEXT PRIMARY KEY,
-      owner_authority TEXT NOT NULL,
-      revision INTEGER NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS session_group_members (
-      group_id TEXT NOT NULL REFERENCES session_groups(group_id) ON DELETE CASCADE,
-      member_reference TEXT NOT NULL,
-      PRIMARY KEY (group_id, member_reference)
-    );
-  `);
-	const read = (groupId) => {
-		const row = database.prepare("SELECT * FROM session_groups WHERE group_id = ?").get(groupId);
-		if (!row) return void 0;
-		const members = database.prepare("SELECT member_reference FROM session_group_members WHERE group_id = ? ORDER BY member_reference").all(groupId);
-		return Object.freeze({
-			id: row.group_id,
-			ownerAuthority: row.owner_authority,
-			revision: row.revision,
-			members: Object.freeze(members.map((member) => member.member_reference))
-		});
-	};
-	const enroll = (groupId, members) => {
-		const insert = database.prepare("INSERT OR IGNORE INTO session_group_members (group_id, member_reference) VALUES (?, ?)");
+async function createSessionGroupStore(options) {
+	const { database } = options;
+	try {
+		await database.exec("PRAGMA foreign_keys = ON");
+	} catch {}
+	await database.exec(SCHEMA$1);
+	const enroll = async (transaction, groupId, members) => {
 		for (const member of new Set(members)) {
 			validateReference(member);
 			if (options.validateEnrollment?.(groupId, member) === false) throw new Error(`Session group enrollment policy rejected '${member}'.`);
-			insert.run(groupId, member);
+			await transaction.run("INSERT OR IGNORE INTO session_group_members (group_id, member_reference) VALUES (?, ?)", groupId, member);
 		}
 	};
 	return {
-		create(groupId, ownerAuthority, members) {
+		async create(groupId, ownerAuthority, members) {
 			validateGroupId(groupId);
 			if (!ownerAuthority.trim()) throw new TypeError("Session group owner authority is required.");
-			database.exec("BEGIN IMMEDIATE");
-			try {
-				database.prepare("INSERT INTO session_groups (group_id, owner_authority, revision) VALUES (?, ?, 1)").run(groupId, ownerAuthority);
-				enroll(groupId, members);
-				database.exec("COMMIT");
-			} catch (cause) {
-				database.exec("ROLLBACK");
-				throw cause;
-			}
-			return read(groupId);
+			return database.transaction(async (transaction) => {
+				await transaction.run("INSERT INTO session_groups (group_id, owner_authority, revision) VALUES (?, ?, 1)", groupId, ownerAuthority);
+				await enroll(transaction, groupId, members);
+				return await readGroup(transaction, groupId);
+			});
 		},
-		mutate(mutation) {
-			database.exec("BEGIN IMMEDIATE");
-			try {
-				const current = read(mutation.groupId);
+		async mutate(mutation) {
+			return database.transaction(async (transaction) => {
+				const current = await readGroup(transaction, mutation.groupId);
 				if (!current) throw new Error(`Session group '${mutation.groupId}' does not exist.`);
 				if (mutation.authority !== current.ownerAuthority && options.authorizeManagement?.(mutation.authority, current) !== true) throw new Error(`Authority '${mutation.authority}' cannot manage Session group '${mutation.groupId}'.`);
 				if (mutation.expectedRevision !== current.revision) throw new SessionGroupRevisionError(mutation.groupId, mutation.expectedRevision, current.revision);
-				enroll(mutation.groupId, mutation.add ?? []);
-				const remove = database.prepare("DELETE FROM session_group_members WHERE group_id = ? AND member_reference = ?");
+				await enroll(transaction, mutation.groupId, mutation.add ?? []);
 				for (const member of new Set(mutation.remove ?? [])) {
 					validateReference(member);
-					remove.run(mutation.groupId, member);
+					await transaction.run("DELETE FROM session_group_members WHERE group_id = ? AND member_reference = ?", mutation.groupId, member);
 				}
-				database.prepare("UPDATE session_groups SET revision = revision + 1 WHERE group_id = ? AND revision = ?").run(mutation.groupId, current.revision);
-				database.exec("COMMIT");
-			} catch (cause) {
-				database.exec("ROLLBACK");
-				throw cause;
-			}
-			return read(mutation.groupId);
+				await transaction.run("UPDATE session_groups SET revision = revision + 1 WHERE group_id = ? AND revision = ?", mutation.groupId, current.revision);
+				return await readGroup(transaction, mutation.groupId);
+			});
 		},
-		get: read,
-		groupsFor(memberReference) {
+		get: (groupId) => readGroup(database, groupId),
+		async groupsFor(memberReference) {
 			validateReference(memberReference);
-			return database.prepare(`SELECT g.group_id FROM session_groups g
-           INNER JOIN session_group_members m ON m.group_id = g.group_id
-           WHERE m.member_reference = ? ORDER BY g.group_id`).all(memberReference).map((row) => read(row.group_id));
+			const rows = await database.all(`SELECT g.group_id FROM session_groups g
+         INNER JOIN session_group_members m ON m.group_id = g.group_id
+         WHERE m.member_reference = ? ORDER BY g.group_id`, memberReference);
+			const groups = [];
+			for (const row of rows) {
+				const group = await readGroup(database, row.group_id);
+				if (group) groups.push(group);
+			}
+			return groups;
 		},
-		canMessage(groupId, sourceReference, targetReference) {
+		async canMessage(groupId, sourceReference, targetReference) {
 			validateReference(sourceReference);
 			validateReference(targetReference);
-			const row = database.prepare(`SELECT COUNT(*) AS count FROM session_group_members
-           WHERE group_id = ? AND member_reference IN (?, ?)`).get(groupId, sourceReference, targetReference);
-			return Number(row.count) === (sourceReference === targetReference ? 1 : 2);
+			const row = await database.get(`SELECT COUNT(*) AS count FROM session_group_members
+         WHERE group_id = ? AND member_reference IN (?, ?)`, groupId, sourceReference, targetReference);
+			return Number(row?.count ?? 0) === (sourceReference === targetReference ? 1 : 2);
 		},
 		close: () => database.close()
 	};
 }
 //#endregion
 //#region src/services/sessionIntercom/type.ts
-const DOOM_SESSION_INTERCOM_SERVICE = "doom/session-intercom";
+const PO_SESSION_INTERCOM_SERVICE = "po/session-intercom";
 function readSessionIntercom(context) {
-	return context.get(DOOM_SESSION_INTERCOM_SERVICE);
+	return context.get(PO_SESSION_INTERCOM_SERVICE);
 }
 function requireSessionIntercom(context) {
 	const service = readSessionIntercom(context);
@@ -527,9 +624,9 @@ function requireSessionIntercom(context) {
 //#region src/services/sessionIntercom/index.ts
 const MESSAGE_KIND = "session-message";
 const REPORT_KIND = "session-report";
-function metadataFor(options, request, reportStatus) {
-	const group = options.groups.get(request.groupId);
-	if (!group || !options.groups.canMessage(request.groupId, options.selfReference, request.targetReference)) throw new Error(`Session group '${request.groupId}' does not authorize this message.`);
+async function metadataFor(options, request, reportStatus) {
+	const group = await options.groups.get(request.groupId);
+	if (!group || !await options.groups.canMessage(request.groupId, options.selfReference, request.targetReference)) throw new Error(`Session group '${request.groupId}' does not authorize this message.`);
 	return {
 		sourceReference: options.selfReference,
 		targetReference: request.targetReference,
@@ -539,12 +636,21 @@ function metadataFor(options, request, reportStatus) {
 		...reportStatus === void 0 ? {} : { reportStatus }
 	};
 }
+/** The group IDs, among those given, whose current membership includes this session. */
+async function groupMembership(options, groupIds) {
+	const memberOf = /* @__PURE__ */ new Set();
+	for (const groupId of new Set(groupIds)) {
+		if (groupId === void 0) continue;
+		if ((await options.groups.get(groupId))?.members.includes(options.selfReference) === true) memberOf.add(groupId);
+	}
+	return memberOf;
+}
 /** Agent-facing intercom operations. A composition may acquire this service without gaining session controls. */
 function createSessionIntercom(options) {
 	const deliver = async (request, kind, status) => {
-		const recipientKey = options.directory.resolveDeliveryTarget(options.selfReference, request.targetReference);
+		const recipientKey = await options.directory.resolveDeliveryTarget(options.selfReference, request.targetReference);
 		if (!recipientKey) throw new Error(`Session '${request.targetReference}' is not discoverable.`);
-		const metadata = metadataFor(options, request, status);
+		const metadata = await metadataFor(options, request, status);
 		return options.delivery.deliver({
 			...request.deliveryId === void 0 ? {} : { deliveryId: request.deliveryId },
 			recipientKey,
@@ -554,16 +660,18 @@ function createSessionIntercom(options) {
 		});
 	};
 	return Object.freeze({
-		discover() {
-			const members = new Set(options.groups.groupsFor(options.selfReference).flatMap((group) => group.members).filter((reference) => reference !== options.selfReference));
+		async discover() {
+			const members = new Set((await options.groups.groupsFor(options.selfReference)).flatMap((group) => group.members).filter((reference) => reference !== options.selfReference));
 			return options.directory.discover(options.selfReference, members);
 		},
 		send: (request) => deliver(request, MESSAGE_KIND),
 		report: (request) => deliver(request, REPORT_KIND, request.status),
-		messages() {
-			return options.delivery.inbox().filter((entry) => entry.kind === MESSAGE_KIND || entry.kind === REPORT_KIND).filter((entry) => {
+		async messages() {
+			const entries = (await options.delivery.inbox()).filter((entry) => entry.kind === MESSAGE_KIND || entry.kind === REPORT_KIND);
+			const memberOf = await groupMembership(options, entries.map((entry) => entry.metadata.groupId));
+			return entries.filter((entry) => {
 				const groupId = entry.metadata.groupId;
-				return groupId !== void 0 && options.groups.get(groupId)?.members.includes(options.selfReference) === true;
+				return groupId !== void 0 && memberOf.has(groupId);
 			}).flatMap((entry) => {
 				const sourceReference = entry.metadata.sourceReference;
 				const targetReference = entry.metadata.targetReference;
@@ -583,38 +691,38 @@ function createSessionIntercom(options) {
 				}];
 			});
 		},
-		delivery(deliveryId) {
-			const entry = options.delivery.outbox(deliveryId);
+		async delivery(deliveryId) {
+			const entry = await options.delivery.outbox(deliveryId);
 			const groupId = entry?.metadata.groupId;
-			return entry && groupId !== void 0 && options.groups.get(groupId)?.members.includes(options.selfReference) === true ? entry : void 0;
+			return entry && groupId !== void 0 && (await groupMembership(options, [groupId])).has(groupId) ? entry : void 0;
 		}
 	});
 }
 /** Builds the dynamic delivery check used before every send, retry, and recipient acceptance. */
 function createSessionGroupDeliveryAuthorizer(options) {
-	return (peerKey, metadata) => {
+	return async (peerKey, metadata) => {
 		const sourceReference = metadata?.sourceReference;
 		const targetReference = metadata?.targetReference;
 		const groupId = metadata?.groupId;
 		if (sourceReference && targetReference && groupId) {
 			const peerReference = options.peerReference(peerKey);
 			if (!peerReference) return false;
-			return (sourceReference === options.selfReference && targetReference === peerReference || targetReference === options.selfReference && sourceReference === peerReference) && options.groups.canMessage(groupId, sourceReference, targetReference);
+			return (sourceReference === options.selfReference && targetReference === peerReference || targetReference === options.selfReference && sourceReference === peerReference) && await options.groups.canMessage(groupId, sourceReference, targetReference);
 		}
-		return options.fallback?.(peerKey, metadata) === true;
+		return await options.fallback?.(peerKey, metadata) === true;
 	};
 }
 //#endregion
 //#region src/services/sessionDelivery/type.ts
-const DOOM_SESSION_DELIVERY_SERVICE = "doom/session-delivery";
+const PO_SESSION_DELIVERY_SERVICE = "po/session-delivery";
 /** Reads the currently active provider each time, without retaining a stale binding. */
-function readDoomSessionDelivery(context) {
-	return context.get(DOOM_SESSION_DELIVERY_SERVICE);
+function readPoSessionDelivery(context) {
+	return context.get(PO_SESSION_DELIVERY_SERVICE);
 }
 //#endregion
 //#region src/services/sessionDelivery/index.ts
-const DELIVERY_EVENT = "doom/session-delivery/envelope";
-const ACK_EVENT = "doom/session-delivery/ack";
+const DELIVERY_EVENT = "po/session-delivery/envelope";
+const ACK_EVENT = "po/session-delivery/ack";
 const DEFAULT_DELIVERY = "prompt";
 const INBOX_STATES = /* @__PURE__ */ new Set([
 	"accepted",
@@ -665,112 +773,127 @@ function matchesMetadata(entry, query) {
 function sameMetadata(left, right) {
 	return matchesMetadata(left, right) && matchesMetadata(right, left);
 }
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS session_delivery_outbox (
+    delivery_id TEXT PRIMARY KEY,
+    recipient_key TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    prompt TEXT NOT NULL,
+    delivery_mode TEXT NOT NULL,
+    metadata_json TEXT NOT NULL,
+    state TEXT NOT NULL,
+    recipient_state TEXT,
+    created_at INTEGER NOT NULL,
+    acknowledged_at INTEGER
+  );
+  CREATE TABLE IF NOT EXISTS session_delivery_inbox (
+    delivery_id TEXT PRIMARY KEY,
+    sender_key TEXT NOT NULL,
+    recipient_key TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    prompt TEXT NOT NULL,
+    delivery_mode TEXT NOT NULL,
+    metadata_json TEXT NOT NULL,
+    state TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    consumed_at INTEGER
+  );
+`;
+const SET_INBOX_STATE = "UPDATE session_delivery_inbox SET state = ?, updated_at = ? WHERE delivery_id = ?";
+const UNSETTLED_OUTBOX = "(recipient_state IS NULL OR recipient_state NOT IN ('admitted', 'recovery_required'))";
 /** Opens and starts one durable delivery endpoint. */
-function createSessionDeliveryService(options) {
+async function createSessionDeliveryService(options) {
 	if (!options.recipientKey.trim() || options.recipientKey !== options.recipientKey.trim()) throw new TypeError("Session delivery requires a trimmed, non-empty recipient key.");
-	const database = new node_sqlite.DatabaseSync(options.databasePath);
-	database.exec(`
-    PRAGMA journal_mode = WAL;
-    CREATE TABLE IF NOT EXISTS session_delivery_outbox (
-      delivery_id TEXT PRIMARY KEY,
-      recipient_key TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      prompt TEXT NOT NULL,
-      delivery_mode TEXT NOT NULL,
-      metadata_json TEXT NOT NULL,
-      state TEXT NOT NULL,
-      recipient_state TEXT,
-      created_at INTEGER NOT NULL,
-      acknowledged_at INTEGER
-    );
-    CREATE TABLE IF NOT EXISTS session_delivery_inbox (
-      delivery_id TEXT PRIMARY KEY,
-      sender_key TEXT NOT NULL,
-      recipient_key TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      prompt TEXT NOT NULL,
-      delivery_mode TEXT NOT NULL,
-      metadata_json TEXT NOT NULL,
-      state TEXT NOT NULL,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      consumed_at INTEGER
-    );
-  `);
-	database.prepare("UPDATE session_delivery_inbox SET state = 'recovery_required', updated_at = ? WHERE state = 'admitting'").run(Date.now());
+	const database = options.database;
+	try {
+		await database.exec(SCHEMA);
+		await database.run("UPDATE session_delivery_inbox SET state = 'accepted', updated_at = ? WHERE state = 'admitting'", Date.now());
+	} catch (error) {
+		await database.close();
+		throw error;
+	}
 	let closed = false;
 	const scheduled = /* @__PURE__ */ new Set();
 	let admissionQueue = Promise.resolve();
+	const pending = /* @__PURE__ */ new Set();
+	/** Tracks fire-and-forget work so close() can wait for it before the database closes. */
+	const track = (work) => {
+		const settled = work.catch(() => void 0);
+		pending.add(settled);
+		settled.finally(() => pending.delete(settled));
+	};
+	const authorized = async (peerKey, metadata) => await options.authorizePeer(peerKey, metadata) === true;
 	const publishAck = (deliveryId, senderKey, state) => {
 		options.communication.publish(senderKey, ACK_EVENT, {
 			deliveryId,
 			state
 		});
 	};
-	const readInboxRow = (deliveryId) => database.prepare("SELECT * FROM session_delivery_inbox WHERE delivery_id = ?").get(deliveryId);
+	const readInboxRow = (deliveryId) => database.get("SELECT * FROM session_delivery_inbox WHERE delivery_id = ?", deliveryId);
 	const scheduleAdmission = (deliveryId) => {
 		if (closed || scheduled.has(deliveryId)) return;
 		scheduled.add(deliveryId);
 		admissionQueue = admissionQueue.then(async () => {
 			try {
 				if (closed) return;
-				const row = readInboxRow(deliveryId);
-				if (!row || row.state !== "accepted") return;
-				database.prepare("UPDATE session_delivery_inbox SET state = 'admitting', updated_at = ? WHERE delivery_id = ?").run(Date.now(), deliveryId);
+				const row = await database.get("UPDATE session_delivery_inbox SET state = 'admitting', updated_at = ? WHERE delivery_id = ? AND state = 'accepted' RETURNING *", Date.now(), deliveryId);
+				if (!row) return;
 				publishAck(deliveryId, row.sender_key, "admitting");
 				try {
-					await options.admitPrompt(row.prompt, row.delivery_mode);
+					await options.admitPrompt(row.prompt, row.delivery_mode, deliveryId);
 				} catch {
-					database.prepare("UPDATE session_delivery_inbox SET state = 'recovery_required', updated_at = ? WHERE delivery_id = ?").run(Date.now(), deliveryId);
+					await database.run(SET_INBOX_STATE, "recovery_required", Date.now(), deliveryId);
 					publishAck(deliveryId, row.sender_key, "recovery_required");
 					return;
 				}
-				database.prepare("UPDATE session_delivery_inbox SET state = 'admitted', updated_at = ? WHERE delivery_id = ?").run(Date.now(), deliveryId);
+				await database.run(SET_INBOX_STATE, "admitted", Date.now(), deliveryId);
 				publishAck(deliveryId, row.sender_key, "admitted");
 			} finally {
 				scheduled.delete(deliveryId);
 			}
-		}).catch(() => {
+		}).catch(async () => {
 			scheduled.delete(deliveryId);
 			try {
-				const row = readInboxRow(deliveryId);
+				const row = await readInboxRow(deliveryId);
 				if (row?.state !== "admitting") return;
-				database.prepare("UPDATE session_delivery_inbox SET state = 'recovery_required', updated_at = ? WHERE delivery_id = ?").run(Date.now(), deliveryId);
+				await database.run(SET_INBOX_STATE, "recovery_required", Date.now(), deliveryId);
 				try {
 					publishAck(deliveryId, row.sender_key, "recovery_required");
 				} catch {}
 			} catch {}
 		});
 	};
-	const receiveEnvelope = (senderKey, value) => {
+	const receiveEnvelope = async (senderKey, value) => {
 		if (closed) return void 0;
 		const envelope = envelopeOf(value);
-		if (!envelope || !options.authorizePeer(senderKey, envelope.metadata)) return void 0;
-		database.prepare(`INSERT OR IGNORE INTO session_delivery_inbox
-         (delivery_id, sender_key, recipient_key, kind, prompt, delivery_mode, metadata_json, state, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, 'accepted', ?, ?)`).run(envelope.deliveryId, senderKey, options.recipientKey, envelope.kind, envelope.prompt, envelope.delivery, JSON.stringify(envelope.metadata), Date.now(), Date.now());
-		const current = readInboxRow(envelope.deliveryId);
+		if (!envelope || !await authorized(senderKey, envelope.metadata) || closed) return void 0;
+		await database.run(`INSERT OR IGNORE INTO session_delivery_inbox
+       (delivery_id, sender_key, recipient_key, kind, prompt, delivery_mode, metadata_json, state, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 'accepted', ?, ?)`, envelope.deliveryId, senderKey, options.recipientKey, envelope.kind, envelope.prompt, envelope.delivery, JSON.stringify(envelope.metadata), Date.now(), Date.now());
+		const current = await readInboxRow(envelope.deliveryId);
 		if (!current) return void 0;
 		if (!(current.sender_key === senderKey && current.recipient_key === options.recipientKey && current.kind === envelope.kind && current.prompt === envelope.prompt && current.delivery_mode === envelope.delivery && sameMetadata(JSON.parse(current.metadata_json), envelope.metadata))) return void 0;
 		publishAck(envelope.deliveryId, current.sender_key, current.state);
 		if (current.state === "accepted") scheduleAdmission(envelope.deliveryId);
 		return current.state;
 	};
-	const receiveAck = (recipientKey, value) => {
+	const receiveAck = async (recipientKey, value) => {
 		const ack = ackOf(value);
 		if (closed || !ack) return;
-		database.prepare(`UPDATE session_delivery_outbox
-         SET state = 'acknowledged', recipient_state = ?, acknowledged_at = ?
-         WHERE delivery_id = ? AND recipient_key = ?
-           AND (recipient_state IS NULL
-             OR (recipient_state = 'accepted' AND ? != 'accepted')
-             OR (recipient_state = 'admitting' AND ? IN ('admitted', 'recovery_required')))`).run(ack.state, Date.now(), ack.deliveryId, recipientKey, ack.state, ack.state);
+		await database.run(`UPDATE session_delivery_outbox
+       SET state = 'acknowledged', recipient_state = ?, acknowledged_at = ?
+       WHERE delivery_id = ? AND recipient_key = ?
+         AND (recipient_state IS NULL
+           OR (recipient_state = 'accepted' AND ? != 'accepted')
+           OR (recipient_state = 'admitting' AND ? IN ('admitted', 'recovery_required')))`, ack.state, Date.now(), ack.deliveryId, recipientKey, ack.state, ack.state);
 	};
-	const publishOutbox = (deliveryId) => {
-		const row = database.prepare("SELECT * FROM session_delivery_outbox WHERE delivery_id = ? AND (recipient_state IS NULL OR recipient_state NOT IN ('admitted', 'recovery_required'))").get(deliveryId);
+	const publishOutbox = async (deliveryId) => {
+		if (closed) return;
+		const row = await database.get(`SELECT * FROM session_delivery_outbox WHERE delivery_id = ? AND ${UNSETTLED_OUTBOX}`, deliveryId);
 		if (!row) return;
 		const metadata = JSON.parse(row.metadata_json);
-		if (!options.authorizePeer(row.recipient_key, metadata)) return;
+		if (!await authorized(row.recipient_key, metadata) || closed) return;
 		options.communication.publish(row.recipient_key, DELIVERY_EVENT, {
 			deliveryId: row.delivery_id,
 			kind: row.kind,
@@ -779,20 +902,47 @@ function createSessionDeliveryService(options) {
 			metadata
 		});
 	};
-	const publishQueued = (recipientKey) => {
-		for (const row of database.prepare("SELECT delivery_id FROM session_delivery_outbox WHERE recipient_key = ? AND (recipient_state IS NULL OR recipient_state NOT IN ('admitted', 'recovery_required'))").all(recipientKey)) publishOutbox(row.delivery_id);
+	const publishQueued = async (recipientKey) => {
+		if (closed) return;
+		for (const row of await database.all(`SELECT delivery_id FROM session_delivery_outbox WHERE recipient_key = ? AND ${UNSETTLED_OUTBOX}`, recipientKey)) await publishOutbox(row.delivery_id);
+	};
+	let retryTimer;
+	const startRetry = () => {
+		if (closed || retryTimer) return;
+		retryTimer = (0, node_timers.setInterval)(() => track(publishAllQueued()), 1e3);
+		retryTimer.unref?.();
+	};
+	const stopRetry = () => {
+		if (retryTimer) (0, node_timers.clearInterval)(retryTimer);
+		retryTimer = void 0;
 	};
+	let retrying;
 	const publishAllQueued = () => {
-		for (const row of database.prepare("SELECT delivery_id FROM session_delivery_outbox WHERE recipient_state IS NULL OR recipient_state NOT IN ('admitted', 'recovery_required')").all()) publishOutbox(row.delivery_id);
+		retrying ??= (async () => {
+			try {
+				if (closed) return;
+				const rows = await database.all(`SELECT delivery_id FROM session_delivery_outbox WHERE ${UNSETTLED_OUTBOX}`);
+				if (rows.length === 0) stopRetry();
+				else startRetry();
+				for (const row of rows) await publishOutbox(row.delivery_id);
+			} finally {
+				retrying = void 0;
+			}
+		})();
+		return retrying;
 	};
-	const releaseEnvelope = options.communication.subscribe(DELIVERY_EVENT, receiveEnvelope);
-	const releaseAck = options.communication.subscribe(ACK_EVENT, receiveAck);
-	const releaseReady = options.communication.onPeerReady(publishQueued);
-	for (const row of database.prepare("SELECT delivery_id, sender_key FROM session_delivery_inbox WHERE state = 'recovery_required'").all()) publishAck(row.delivery_id, row.sender_key, "recovery_required");
-	for (const row of database.prepare("SELECT delivery_id FROM session_delivery_inbox WHERE state = 'accepted'").all()) scheduleAdmission(row.delivery_id);
-	publishAllQueued();
-	const retryTimer = setInterval(publishAllQueued, 1e3);
-	retryTimer.unref();
+	const releaseEnvelope = options.communication.subscribe(DELIVERY_EVENT, (senderKey, payload) => {
+		track(receiveEnvelope(senderKey, payload));
+	});
+	const releaseAck = options.communication.subscribe(ACK_EVENT, (recipientKey, payload) => {
+		track(receiveAck(recipientKey, payload));
+	});
+	const releaseReady = options.communication.onPeerReady((recipientKey) => {
+		track(publishQueued(recipientKey));
+	});
+	for (const row of await database.all("SELECT delivery_id, sender_key FROM session_delivery_inbox WHERE state = 'recovery_required'")) publishAck(row.delivery_id, row.sender_key, "recovery_required");
+	for (const row of await database.all("SELECT delivery_id FROM session_delivery_inbox WHERE state = 'accepted'")) scheduleAdmission(row.delivery_id);
+	track(publishAllQueued());
 	return Object.freeze({
 		recipientKey: options.recipientKey,
 		async deliver(request) {
@@ -800,36 +950,38 @@ function createSessionDeliveryService(options) {
 			const deliveryId = request.deliveryId ?? crypto.randomUUID();
 			const mode = request.delivery ?? DEFAULT_DELIVERY;
 			if (!deliveryId.trim() || !request.recipientKey.trim() || !request.kind.trim() || !isMode(mode)) throw new TypeError("Delivery id, recipient key, kind, and mode must be valid.");
-			if (!options.authorizePeer(request.recipientKey, request.metadata)) throw new Error(`Session '${request.recipientKey}' is not an authorized communication peer.`);
+			if (!await authorized(request.recipientKey, request.metadata)) throw new Error(`Session '${request.recipientKey}' is not an authorized communication peer.`);
+			if (closed) throw new Error("Session delivery service is closed.");
 			const metadata = normalizedMetadata(request.metadata);
-			database.prepare(`INSERT OR IGNORE INTO session_delivery_outbox
-           (delivery_id, recipient_key, kind, prompt, delivery_mode, metadata_json, state, created_at)
-           VALUES (?, ?, ?, ?, ?, ?, 'queued', ?)`).run(deliveryId, request.recipientKey, request.kind, request.prompt, mode, JSON.stringify(metadata), Date.now());
-			const current = database.prepare("SELECT * FROM session_delivery_outbox WHERE delivery_id = ?").get(deliveryId);
+			await database.run(`INSERT OR IGNORE INTO session_delivery_outbox
+         (delivery_id, recipient_key, kind, prompt, delivery_mode, metadata_json, state, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, 'queued', ?)`, deliveryId, request.recipientKey, request.kind, request.prompt, mode, JSON.stringify(metadata), Date.now());
+			const current = await database.get("SELECT * FROM session_delivery_outbox WHERE delivery_id = ?", deliveryId);
 			if (!current || current.recipient_key !== request.recipientKey || current.kind !== request.kind || current.prompt !== request.prompt || current.delivery_mode !== mode || !sameMetadata(JSON.parse(current.metadata_json), metadata)) throw new TypeError(`Delivery id '${deliveryId}' is already bound to another envelope.`);
-			publishOutbox(deliveryId);
+			startRetry();
+			await publishOutbox(deliveryId);
 			return { deliveryId };
 		},
 		async waitForAdmission(deliveryId, timeoutMs = 5e3) {
 			const deadline = Date.now() + Math.max(0, timeoutMs);
 			let state;
 			do {
-				state = database.prepare("SELECT recipient_state FROM session_delivery_outbox WHERE delivery_id = ?").get(deliveryId)?.recipient_state ?? void 0;
+				state = (await database.get("SELECT recipient_state FROM session_delivery_outbox WHERE delivery_id = ?", deliveryId))?.recipient_state ?? void 0;
 				if (state === "admitted" || state === "recovery_required") return state;
 				if (Date.now() >= deadline) return state;
-				await new Promise((resolve) => setTimeout(resolve, Math.min(10, deadline - Date.now())));
+				await new Promise((resolve) => (0, node_timers.setTimeout)(resolve, Math.min(10, deadline - Date.now())));
 			} while (!closed);
 			return state;
 		},
-		receive(senderKey, kind, payload) {
+		async receive(senderKey, kind, payload) {
 			if (kind === DELIVERY_EVENT) return receiveEnvelope(senderKey, payload);
 			if (kind === ACK_EVENT) {
-				receiveAck(senderKey, payload);
+				await receiveAck(senderKey, payload);
 				return "accepted";
 			}
 		},
-		inbox(query = {}) {
-			return database.prepare("SELECT * FROM session_delivery_inbox ORDER BY created_at, delivery_id").all().map((row) => {
+		async inbox(query = {}) {
+			return (await database.all("SELECT * FROM session_delivery_inbox ORDER BY created_at, delivery_id")).map((row) => {
 				const metadata = JSON.parse(row.metadata_json);
 				return {
 					deliveryId: row.delivery_id,
@@ -844,11 +996,11 @@ function createSessionDeliveryService(options) {
 				};
 			}).filter((entry) => (query.kind === void 0 || entry.kind === query.kind) && (query.state === void 0 || entry.state === query.state) && (query.consumed === void 0 || entry.consumed === query.consumed) && matchesMetadata(entry.metadata, query.metadata));
 		},
-		consume(deliveryId) {
-			return database.prepare("UPDATE session_delivery_inbox SET consumed_at = ? WHERE delivery_id = ? AND state IN ('admitted', 'recovery_required') AND consumed_at IS NULL").run(Date.now(), deliveryId).changes === 1;
+		async consume(deliveryId) {
+			return await database.get("UPDATE session_delivery_inbox SET consumed_at = ? WHERE delivery_id = ? AND state IN ('admitted', 'recovery_required') AND consumed_at IS NULL RETURNING delivery_id", Date.now(), deliveryId) !== void 0;
 		},
-		outbox(deliveryId) {
-			const row = database.prepare("SELECT delivery_id, recipient_key, kind, metadata_json, state, recipient_state FROM session_delivery_outbox WHERE delivery_id = ?").get(deliveryId);
+		async outbox(deliveryId) {
+			const row = await database.get("SELECT delivery_id, recipient_key, kind, metadata_json, state, recipient_state FROM session_delivery_outbox WHERE delivery_id = ?", deliveryId);
 			if (!row) return void 0;
 			return {
 				deliveryId: row.delivery_id,
@@ -862,14 +1014,15 @@ function createSessionDeliveryService(options) {
 		async close() {
 			if (closed) return;
 			closed = true;
-			clearInterval(retryTimer);
+			stopRetry();
 			releaseEnvelope();
 			releaseAck();
 			releaseReady();
 			try {
 				await admissionQueue;
+				await Promise.all(pending);
 			} finally {
-				database.close();
+				await database.close();
 			}
 		}
 	});
@@ -881,9 +1034,9 @@ function createSessionDeliveryService(options) {
 * `ctx.get` is strict and hides an implementation while its providing fiber is
 * LOADING, which is the whole of that fiber's own callback.
 */
-function provideSessionDeliveryService(context, options) {
-	const service = createSessionDeliveryService(options);
-	const unprovide = context.provide(DOOM_SESSION_DELIVERY_SERVICE, service);
+async function provideSessionDeliveryService(context, options) {
+	const service = await createSessionDeliveryService(options);
+	const unprovide = context.provide(PO_SESSION_DELIVERY_SERVICE, service);
 	context.effect(() => () => service.close(), "session delivery database");
 	return {
 		service,
@@ -894,16 +1047,22 @@ function provideSessionDeliveryService(context, options) {
 	};
 }
 //#endregion
-Object.defineProperty(exports, "DOOM_SESSION_DELIVERY_SERVICE", {
+Object.defineProperty(exports, "PEER_REPLAY_DATABASE_FILE", {
+	enumerable: true,
+	get: function() {
+		return PEER_REPLAY_DATABASE_FILE;
+	}
+});
+Object.defineProperty(exports, "PO_SESSION_DELIVERY_SERVICE", {
 	enumerable: true,
 	get: function() {
-		return DOOM_SESSION_DELIVERY_SERVICE;
+		return PO_SESSION_DELIVERY_SERVICE;
 	}
 });
-Object.defineProperty(exports, "DOOM_SESSION_INTERCOM_SERVICE", {
+Object.defineProperty(exports, "PO_SESSION_INTERCOM_SERVICE", {
 	enumerable: true,
 	get: function() {
-		return DOOM_SESSION_INTERCOM_SERVICE;
+		return PO_SESSION_INTERCOM_SERVICE;
 	}
 });
 Object.defineProperty(exports, "SessionGroupRevisionError", {
@@ -936,6 +1095,12 @@ Object.defineProperty(exports, "createPeerReplayGuard", {
 		return createPeerReplayGuard;
 	}
 });
+Object.defineProperty(exports, "createPeerReplayGuardAsync", {
+	enumerable: true,
+	get: function() {
+		return createPeerReplayGuardAsync;
+	}
+});
 Object.defineProperty(exports, "createSessionDeliveryService", {
 	enumerable: true,
 	get: function() {
@@ -966,6 +1131,12 @@ Object.defineProperty(exports, "createSessionIntercom", {
 		return createSessionIntercom;
 	}
 });
+Object.defineProperty(exports, "ensurePrivateDirectory", {
+	enumerable: true,
+	get: function() {
+		return ensurePrivateDirectory;
+	}
+});
 Object.defineProperty(exports, "parseRemoteSessionReference", {
 	enumerable: true,
 	get: function() {
@@ -1002,10 +1173,10 @@ Object.defineProperty(exports, "provideSessionDeliveryService", {
 		return provideSessionDeliveryService;
 	}
 });
-Object.defineProperty(exports, "readDoomSessionDelivery", {
+Object.defineProperty(exports, "readPoSessionDelivery", {
 	enumerable: true,
 	get: function() {
-		return readDoomSessionDelivery;
+		return readPoSessionDelivery;
 	}
 });
 Object.defineProperty(exports, "readSessionIntercom", {
@@ -1020,6 +1191,12 @@ Object.defineProperty(exports, "readSessionPeerConfig", {
 		return readSessionPeerConfig;
 	}
 });
+Object.defineProperty(exports, "readSessionPeerConfigAsync", {
+	enumerable: true,
+	get: function() {
+		return readSessionPeerConfigAsync;
+	}
+});
 Object.defineProperty(exports, "requireSessionIntercom", {
 	enumerable: true,
 	get: function() {
@@ -1039,4 +1216,4 @@ Object.defineProperty(exports, "verifyPeerRequest", {
 	}
 });
 
-//# sourceMappingURL=sessionDelivery-CkuX6jlw.cjs.map
+//# sourceMappingURL=sessionDelivery-CGWuQyLV.cjs.map