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

package/dist/{sessionDelivery-DpLWlaum.mjs → sessionDelivery-4svjzWUW.mjs}

@@ -1,17 +1,19 @@
-import { BackgroundProviderWorkItemSchema, DOOM_BACKGROUND_WORK_CHANGED_EVENT, DOOM_BACKGROUND_WORK_SERVICE } from "@agimon-ai/po-core/backgroundWork";
+import { BackgroundProviderWorkItemSchema, PO_BACKGROUND_WORK_CHANGED_EVENT, PO_BACKGROUND_WORK_SERVICE } from "@agimon-ai/po-core/backgroundWork";
 import { Check } from "typebox/value";
 import { createHash, createHmac, timingSafeEqual } from "node:crypto";
-import fs from "node:fs";
 import path from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { getOrThrow, nodeHost, readTextIfExists } from "@agimon-ai/po-core/platform";
 import { poHomeDirectory } from "@agimon-ai/po-core/piSettings";
+import fs from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { clearInterval, setInterval, setTimeout } from "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(DOOM_BACKGROUND_WORK_CHANGED_EVENT, {
+		ctx.emit(PO_BACKGROUND_WORK_CHANGED_EVENT, {
 			provider,
 			generation: providerGeneration,
 			kind
@@ -75,11 +77,8 @@ function createBackgroundWorkService(ctx) {
 }
 /** Installs one coordinator in the current session service context. */
 function provideBackgroundWorkService(context) {
-	context.provide(DOOM_BACKGROUND_WORK_SERVICE, createBackgroundWorkService(context));
+	context.provide(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";
@@ -87,7 +86,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);
 }
@@ -116,29 +116,144 @@ function peerOf(value) {
 function sessionPeerConfigPath(homeDirectory) {
 	return path.join(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 ((fs.statSync(file).mode & 63) !== 0) return void 0;
-		parsed = JSON.parse(fs.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(fs.statSync(file).mode)) return void 0;
+		text = fs.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 = path.dirname(sessionPeerConfigPath(homeDirectory));
+	fs.mkdirSync(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const database = new DatabaseSync(path.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 nodeHost.fileMode(file);
+		if (mode !== void 0 && !peerConfigModeIsPrivate(mode)) return void 0;
+		const text = await 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 = path.resolve(directory); !getOrThrow(await fs.exists(current, context));) {
+		missing.unshift(current);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	if (missing.length === 0) return;
+	getOrThrow(await fs.createDir(directory, { recursive: true }, context));
+	for (const created of missing) await nodeHost.setMode(created, 448);
+}
 /** `peer/<host-id>/<session-id>` is the only remote target spelling. */
 function parseRemoteSessionReference(value) {
 	const match = /^peer\/([^/]+)\/([^/]+)$/u.exec(value);
@@ -165,46 +280,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 = path.dirname(sessionPeerConfigPath(homeDirectory));
-	fs.mkdirSync(directory, {
-		recursive: true,
-		mode: 448
-	});
-	const database = new DatabaseSync(path.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()
 	};
@@ -215,7 +308,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));
@@ -237,7 +330,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,
@@ -305,19 +398,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) {
@@ -366,17 +466,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);
 		}
 	};
@@ -399,100 +500,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 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);
@@ -503,9 +600,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,
@@ -515,12 +612,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,
@@ -530,16 +636,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;
@@ -559,38 +667,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",
@@ -641,112 +749,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 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,
@@ -755,20 +878,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 = setInterval(() => track(publishAllQueued()), 1e3);
+		retryTimer.unref?.();
+	};
+	const stopRetry = () => {
+		if (retryTimer) 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) {
@@ -776,36 +926,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())));
 			} 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,
@@ -820,11 +972,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,
@@ -838,14 +990,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();
 			}
 		}
 	});
@@ -857,9 +1010,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,
@@ -870,6 +1023,6 @@ function provideSessionDeliveryService(context, options) {
 	};
 }
 //#endregion
-export { provideBackgroundWorkService as C, createBackgroundWorkService as S, peerRequestHeaders as _, createSessionGroupDeliveryAuthorizer as a, sessionPeerConfigPath as b, readSessionIntercom as c, SessionGroupRevisionError as d, createSessionDirectory as f, parseSessionPeerEnvelope as g, parseRemoteSessionReference as h, readDoomSessionDelivery as i, requireSessionIntercom as l, createPeerReplayGuard as m, provideSessionDeliveryService as n, createSessionIntercom as o, createPeerCommunication as p, DOOM_SESSION_DELIVERY_SERVICE as r, DOOM_SESSION_INTERCOM_SERVICE as s, createSessionDeliveryService as t, createSessionGroupStore as u, peerSessionReference as v, verifyPeerRequest as x, readSessionPeerConfig as y };
+export { readSessionPeerConfig as C, provideBackgroundWorkService as D, createBackgroundWorkService as E, createPeerReplayGuard as S, sessionPeerConfigPath as T, parseSessionPeerEnvelope as _, createSessionGroupDeliveryAuthorizer as a, readSessionPeerConfigAsync as b, readSessionIntercom as c, SessionGroupRevisionError as d, createSessionDirectory as f, parseRemoteSessionReference as g, ensurePrivateDirectory as h, readPoSessionDelivery as i, requireSessionIntercom as l, createPeerReplayGuardAsync as m, provideSessionDeliveryService as n, createSessionIntercom as o, createPeerCommunication as p, PO_SESSION_DELIVERY_SERVICE as r, PO_SESSION_INTERCOM_SERVICE as s, createSessionDeliveryService as t, createSessionGroupStore as u, peerRequestHeaders as v, PEER_REPLAY_DATABASE_FILE as w, verifyPeerRequest as x, peerSessionReference as y };
 
-//# sourceMappingURL=sessionDelivery-DpLWlaum.mjs.map
+//# sourceMappingURL=sessionDelivery-4svjzWUW.mjs.map