@bastani/atomic 0.9.39-alpha.2 → 0.9.40-alpha.1

package/dist/builtin/intercom/broker/client.ts

@@ -22,11 +22,14 @@ import { isMessage, isSessionInfo } from "./client-message-validation.js";
 import { normalizeGroups } from "../group.js";
 import { IntercomClientDisconnectedError } from "../recoverable-disconnect.js";
 import { IntercomLiveRouteRefusedError, isLiveWorkflowStageRouteRefusalCode } from "../live-route-refusal.js";
+import { SEND_RESPONSE_TIMEOUT_MS } from "../retry-policy.js";
 
 const BROKER_SOCKET = getBrokerSocketPath();
 const GROUP_REQUEST_TIMEOUT_MS = 5000;
 const PRESENCE_ACK_TIMEOUT_MS = 5000;
-
+const RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS = 5000;
+/** Extra wait past a broker hold, so the broker's own outcome for a held send always arrives first (#3760). */
+const HELD_SEND_GRACE_MS = 5000;
 
 export interface SendOptions {
   text: string;
@@ -41,10 +44,17 @@ export interface SendOptions {
   requirePendingReply?: true;
   /** An explicit reply selector must resolve to this frozen recipient, never a namesake. */
   expectedRecipientId?: string;
-  /** Broker-authorized identity for a canonical-path ask, delivered before its recipient can reply. */
+  /** Broker-authorized recipient identity for an ask, delivered before its recipient can reply. */
   onReplyTarget?: (sessionId: string) => void;
 }
 
+export interface IntercomClientOptions {
+	/** Intercom session id held before a restart or reconnect; the broker grants it only when it is free (#3760). */
+	readonly preferredSessionId?: string;
+	/** #3761: this client confirms each received message with `acknowledgeReceived` once it has saved it. */
+	readonly acknowledgesReceipt?: true;
+}
+
 export interface SendResult {
   id: string;
   delivered: boolean;
@@ -152,6 +162,10 @@ function isWorkflowStageRosterEntries(value: unknown): value is WorkflowStageRos
 
 export class IntercomClient extends EventEmitter {
 	private readonly returnAddress: string;
+	private readonly preferredSessionId: string | undefined;
+	private readonly acknowledgesReceipt: boolean;
+	/** #3761: the broker of the current registration echoed `acknowledgesReceipt`, so it understands `received`. */
+	private brokerAcknowledgesReceipt = false;
   private socket: net.Socket | null = null;
   private _sessionId: string | null = null;
   private _supervisorSessionId: string | null = null;
@@ -174,13 +188,16 @@ export class IntercomClient extends EventEmitter {
     resolve: (authorization: SupervisorAuthorization) => void;
     reject: (error: Error) => void;
   }>();
+  private pendingRestoringRecipientRequests = new Map<string, { resolve(): void; reject(error: Error): void }>();
   private disconnecting = false;
   private disconnectError: Error | null = null;
 
-	constructor(returnAddress: string = randomUUID()) {
+	constructor(returnAddress: string = randomUUID(), options: IntercomClientOptions = {}) {
 		super();
 		if (returnAddress.length === 0) throw new Error("Intercom return address must not be empty");
 		this.returnAddress = returnAddress;
+		this.preferredSessionId = options.preferredSessionId;
+		this.acknowledgesReceipt = options.acknowledgesReceipt === true;
 	}
 
   private failPending(error: Error): void {
@@ -188,12 +205,14 @@ export class IntercomClient extends EventEmitter {
     for (const pending of this.pendingGroupLists.values()) pending.reject(error);
     for (const pending of this.pendingLists.values()) pending.reject(error);
     for (const pending of this.pendingSupervisorAuthorizations.values()) pending.reject(error);
+    for (const pending of this.pendingRestoringRecipientRequests.values()) pending.reject(error);
     for (const pending of this.pendingPresence.values()) pending.reject(error);
     for (const pending of this.pendingMemberships.values()) pending.reject(error);
     for (const pending of this.pendingLiveWorkflowStageRoutes.values()) pending.reject(error);
     this.pendingLists.clear();
     this.pendingGroupLists.clear();
     this.pendingSupervisorAuthorizations.clear();
+    this.pendingRestoringRecipientRequests.clear();
     this.pendingPresence.clear();
     this.pendingMemberships.clear();
     this.pendingLiveWorkflowStageRoutes.clear();
@@ -298,6 +317,7 @@ export class IntercomClient extends EventEmitter {
         }
         this._sessionId = null;
         this._supervisorSessionId = null;
+        this.brokerAcknowledgesReceipt = false;
         this._messageSource = undefined;
         this.disconnectError = null;
         if (connectionEstablished && !wasDisconnecting) {
@@ -371,6 +391,8 @@ export class IntercomClient extends EventEmitter {
           session,
           ...(registrationGroup !== undefined ? { registrationGroup } : {}),
 			returnAddress: this.returnAddress,
+			...(this.preferredSessionId === undefined ? {} : { preferredSessionId: this.preferredSessionId }),
+			...(this.acknowledgesReceipt ? { acknowledgesReceipt: true as const } : {}),
           ...(supervisor ? { supervisor } : {}),
           ...(supervisorOwnerToken ? { supervisorOwnerToken } : {}),
         });
@@ -402,7 +424,8 @@ export class IntercomClient extends EventEmitter {
     switch (brokerMessage.type) {
       case "registered": {
         if (typeof brokerMessage.sessionId !== "string"
-          || (brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string")) {
+          || (brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string")
+          || (brokerMessage.acknowledgesReceipt !== undefined && brokerMessage.acknowledgesReceipt !== true)) {
           throw new Error("Invalid registered message");
         }
 
@@ -413,6 +436,8 @@ export class IntercomClient extends EventEmitter {
         this._supervisorSessionId = typeof brokerMessage.supervisorSessionId === "string"
           ? brokerMessage.supervisorSessionId
           : null;
+        // #3761: a broker from before receipts never echoes the capability and drops a client that sends `received`.
+        this.brokerAcknowledgesReceipt = this.acknowledgesReceipt && brokerMessage.acknowledgesReceipt === true;
         this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
         break;
       }
@@ -573,6 +598,12 @@ export class IntercomClient extends EventEmitter {
 			} satisfies StickyLiveDeliveredNotice);
 			break;
 		}
+		case "pending_stage_route_revoked": {
+			const { runId } = brokerMessage;
+			if (typeof runId !== "string") throw new Error("Invalid pending-stage route revocation");
+			this.emit("pending_stage_route_revoked", { runId });
+			break;
+		}
       case "live_workflow_stage_route_registered": {
         const { requestId } = brokerMessage;
         if (typeof requestId !== "string") throw new Error("Invalid live workflow-stage route registration");
@@ -606,6 +637,33 @@ export class IntercomClient extends EventEmitter {
         else this.pendingSends.resolve(messageId, attemptId, result);
         break;
       }
+      case "send_held": {
+        const { messageId, attemptId, timeoutMs } = brokerMessage;
+        if (
+          typeof messageId !== "string" ||
+          (attemptId !== undefined && typeof attemptId !== "string") ||
+          typeof timeoutMs !== "number" ||
+          !Number.isFinite(timeoutMs) ||
+          timeoutMs <= 0
+        ) {
+          throw new Error("Invalid send_held message");
+        }
+        // #3760: the recipient is a subagent being restored; the broker answers within `timeoutMs`.
+        this.pendingSends.extend(messageId, attemptId, timeoutMs + HELD_SEND_GRACE_MS);
+        break;
+      }
+      case "restoring_recipient_ack": {
+        const { requestId, error } = brokerMessage;
+        if (typeof requestId !== "string" || (error !== undefined && typeof error !== "string")) {
+          throw new Error("Invalid restoring_recipient_ack message");
+        }
+        const pending = this.pendingRestoringRecipientRequests.get(requestId);
+        if (!pending) return;
+        this.pendingRestoringRecipientRequests.delete(requestId);
+        if (error === undefined) pending.resolve();
+        else pending.reject(new Error(error));
+        break;
+      }
       case "delivered": {
         const { messageId, attemptId } = brokerMessage;
         if (typeof messageId !== "string" || (attemptId !== undefined && typeof attemptId !== "string")) {
@@ -890,6 +948,66 @@ export class IntercomClient extends EventEmitter {
       }
     });
   }
+
+  /**
+   * #3760: hold sends to the child that `capability` (issued to this session by `authorizeSupervisorChild`)
+   * names, and to its `aliases`, until the child registers with that capability. Calling again adds aliases.
+   * A `dormant` hold keeps the child addressable until the supervisor that restores it takes the hold over.
+   */
+  reserveRestoringRecipient(
+    capability: string,
+    options: { group?: string; aliases?: readonly string[]; dormant?: boolean } = {},
+  ): Promise<void> {
+    return this.restoringRecipientRequest({
+      type: "reserve_restoring_recipient",
+      capability,
+      ...(options.group === undefined ? {} : { group: options.group }),
+      ...(options.aliases === undefined ? {} : { aliases: [...options.aliases] }),
+      ...(options.dormant === true ? { dormant: true } : {}),
+    });
+  }
+
+  /**
+   * #3760: end that hold. With `gone` (the reason), held and later senders are told the child is gone. With
+   * `refusal`, the senders held now are told that reason and later sends are routed normally. With neither,
+   * held sends are routed normally.
+   */
+  releaseRestoringRecipient(capability: string, outcome?: string | { gone?: string; refusal?: string }): Promise<void> {
+    const { gone, refusal } = typeof outcome === "string" ? { gone: outcome, refusal: undefined } : (outcome ?? {});
+    return this.restoringRecipientRequest({
+      type: "release_restoring_recipient",
+      capability,
+      ...(gone === undefined ? {} : { gone }),
+      ...(refusal === undefined ? {} : { refusal }),
+    });
+  }
+
+  private restoringRecipientRequest(frame: Record<string, unknown>): Promise<void> {
+    let socket: net.Socket;
+    try {
+      socket = this.requireActiveSocket();
+    } catch (error) {
+      return Promise.reject(toError(error));
+    }
+    const requestId = randomUUID();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (!this.pendingRestoringRecipientRequests.delete(requestId)) return;
+        reject(new Error("Restoring-recipient request timeout"));
+      }, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS);
+      this.pendingRestoringRecipientRequests.set(requestId, {
+        resolve: () => { clearTimeout(timeout); resolve(); },
+        reject: (error) => { clearTimeout(timeout); reject(error); },
+      });
+      try {
+        writeMessage(socket, { ...frame, requestId });
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingRestoringRecipientRequests.delete(requestId);
+        reject(toError(error));
+      }
+    });
+  }
   registerPendingStageRoute(
 	runId: string,
 	group: string,
@@ -897,6 +1015,7 @@ export class IntercomClient extends EventEmitter {
 	stages?: WorkflowStageRosterAnnouncement[],
 	possibleStages?: WorkflowPossibleStageAnnouncement[],
 	parent?: WorkflowRunParentAnnouncement,
+	dormant?: boolean,
   ): void {
 	writeMessage(this.requireActiveSocket(), {
 		type: "register_pending_stage_route",
@@ -906,6 +1025,7 @@ export class IntercomClient extends EventEmitter {
 		stages,
 		possibleStages,
 		...(parent === undefined ? {} : { parent }),
+		...(dormant === true ? { dormant: true as const } : {}),
 	});
   }
 
@@ -969,6 +1089,15 @@ export class IntercomClient extends EventEmitter {
     return this.sendFrame("send", to, options);
   }
 
+	/**
+	 * #3761: tell the broker this message is saved, so it reports `delivered` to its sender. A no-op unless the
+	 * current registration's broker echoed the capability: that broker already reported `delivered` on the socket write.
+	 */
+	acknowledgeReceived(messageId: string): void {
+		if (!this.brokerAcknowledgesReceipt) return;
+		writeMessage(this.requireActiveSocket(), { type: "received", messageId });
+	}
+
 	sendPendingStageNotification(
 		runId: string,
 		capability: string,
@@ -1015,7 +1144,7 @@ export class IntercomClient extends EventEmitter {
 			requirePendingReply: options.requirePendingReply ?? false,
 			...(options.expectedRecipientId === undefined ? {} : { expectedRecipientId: options.expectedRecipientId }),
 		});
-		acquired = this.pendingSends.acquire(messageId, pendingSignature, 10000);
+		acquired = this.pendingSends.acquire(messageId, pendingSignature, SEND_RESPONSE_TIMEOUT_MS);
     } catch (error) {
       return Promise.reject(toError(error));
     }
@@ -1040,6 +1169,8 @@ export class IntercomClient extends EventEmitter {
 			...(options.requirePendingReply === undefined ? {} : { requirePendingReply: options.requirePendingReply }),
 			...(options.expectedRecipientId === undefined ? {} : { expectedRecipientId: options.expectedRecipientId }),
       ...(options.onReplyTarget === undefined ? {} : { resolveReplyTarget: true as const }),
+			// #3760: this client understands `send_held`, so the broker may hold the send for a subagent being restored.
+			...(type === "send" ? { awaitRestoringRecipient: true as const } : {}),
 			message,
 			attemptId: acquired.attempt.attemptId,
 			...extra,

package/dist/builtin/intercom/broker/database-wake-up-bus.ts

@@ -0,0 +1,274 @@
+import { type SqliteDatabase, type SqliteRow, validateStoragePrefix } from "@bastani/atomic/storage";
+import { OUTBOX_BACKUP_POLL_INTERVAL_MS } from "./multinode-state-store.js";
+import type {
+	WakeUpBus,
+	WakeUpEvent,
+	WakeUpHint,
+	WakeUpListener,
+	WakeUpPublishResult,
+	WakeUpSubscribeResult,
+	WakeUpSubscription,
+} from "./wake-up-bus.js";
+
+/**
+ * S4 wake-up bus (specs/2026-10-19-intercom-multi-node.md §5.6): a hint log in the shared storage database. Each
+ * connection polls the rows addressed to its subscribed brokers, delivers them and deletes them. A failed query drops
+ * the connection; the next poll or publish reopens it and every subscription gets a `reconnected` resync, because
+ * hints written meanwhile may have been pruned or missed. While the database stays unavailable, reopening backs off
+ * exponentially from the poll interval up to `WAKE_UP_RECONNECT_MAX_DELAY_MS`.
+ */
+
+/** How often a connection with subscriptions reads its hints. */
+export const WAKE_UP_POLL_INTERVAL_MS = 500;
+/** Hints nobody consumed (their broker exited) are deleted after this age; the backup poll has covered them. */
+export const WAKE_UP_HINT_RETENTION_MS = OUTBOX_BACKUP_POLL_INTERVAL_MS;
+/**
+ * Hints read and deleted per statement; a poll repeats until a batch comes back short. Each batch's delete binds one
+ * parameter per hint, so a backlog never exceeds SQLite's bound-parameter limit (999 on old builds).
+ */
+export const WAKE_UP_POLL_BATCH_SIZE = 500;
+/** Longest wait between attempts to reopen an unavailable database; the backup poll covers the gap. */
+export const WAKE_UP_RECONNECT_MAX_DELAY_MS = OUTBOX_BACKUP_POLL_INTERVAL_MS;
+
+/** Runs `callback` once after `delayMs` and returns a function that cancels it. */
+export type WakeUpPollScheduler = (callback: () => void, delayMs: number) => () => void;
+
+export interface DatabaseWakeUpBusOptions {
+	/** Opens a connection to the shared storage database; called again after every dropped connection. */
+	readonly openDatabase: () => Promise<SqliteDatabase>;
+	/** The validated storage prefix; the table is `<prefix>intercom_wakeups`. */
+	readonly prefix?: string;
+	readonly pollIntervalMs?: number;
+	readonly schedule?: WakeUpPollScheduler;
+}
+
+interface HintRow extends SqliteRow {
+	readonly id: number;
+	readonly broker_id: string;
+	readonly reason: string;
+	readonly version: number;
+}
+
+interface DatabaseSubscription {
+	readonly brokerId: string;
+	readonly listener: WakeUpListener;
+	open: boolean;
+}
+
+const DATABASE_NOW_MS = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+
+const scheduleTimeout: WakeUpPollScheduler = (callback, delayMs) => {
+	const timer = setTimeout(callback, delayMs);
+	timer.unref?.();
+	return () => clearTimeout(timer);
+};
+
+async function createSchema(database: SqliteDatabase, table: string): Promise<void> {
+	await database.exec(
+		`CREATE TABLE IF NOT EXISTS ${table} (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			broker_id TEXT NOT NULL,
+			reason TEXT NOT NULL CHECK (reason IN ('outbox', 'outcome')),
+			version INTEGER NOT NULL,
+			created_at INTEGER NOT NULL
+		);
+		CREATE INDEX IF NOT EXISTS ${table}_broker ON ${table} (broker_id, id);
+		CREATE INDEX IF NOT EXISTS ${table}_created ON ${table} (created_at);`,
+	);
+}
+
+async function openSchemaConnection(options: DatabaseWakeUpBusOptions, table: string): Promise<SqliteDatabase> {
+	const database = await options.openDatabase();
+	try {
+		await createSchema(database, table);
+	} catch (cause) {
+		await database.close().catch(() => {});
+		throw cause;
+	}
+	return database;
+}
+
+class DatabaseWakeUpBus implements WakeUpBus {
+	private readonly subscriptions = new Set<DatabaseSubscription>();
+	private readonly options: DatabaseWakeUpBusOptions;
+	private readonly table: string;
+	private readonly pollIntervalMs: number;
+	private readonly schedule: WakeUpPollScheduler;
+	private database: SqliteDatabase | undefined;
+	private opening: Promise<SqliteDatabase | undefined> | undefined;
+	private cancelPoll: (() => void) | undefined;
+	private polling: Promise<void> | undefined;
+	private closed = false;
+	private closing: Promise<void> | undefined;
+	/** Consecutive failed attempts to reopen the database; each doubles the wait before the next. */
+	private reconnectFailures = 0;
+	private reconnectNotBefore = 0;
+
+	constructor(options: DatabaseWakeUpBusOptions, table: string, database: SqliteDatabase) {
+		this.options = options;
+		this.table = table;
+		this.database = database;
+		this.pollIntervalMs = options.pollIntervalMs ?? WAKE_UP_POLL_INTERVAL_MS;
+		this.schedule = options.schedule ?? scheduleTimeout;
+	}
+
+	async publish(hint: WakeUpHint): Promise<WakeUpPublishResult> {
+		if (hint.brokerId.length === 0) return { status: "invalid", reason: "empty-broker-id" };
+		const database = await this.connection(false);
+		if (database === undefined) return { status: "unavailable" };
+		try {
+			await database.run(
+				`INSERT INTO ${this.table} (broker_id, reason, version, created_at) VALUES (?, ?, ?, ${DATABASE_NOW_MS})`,
+				hint.brokerId,
+				hint.reason,
+				hint.version,
+			);
+			await database.run(
+				`DELETE FROM ${this.table} WHERE created_at < ${DATABASE_NOW_MS} - ?`,
+				WAKE_UP_HINT_RETENTION_MS,
+			);
+		} catch {
+			this.drop(database);
+			return { status: "unavailable" };
+		}
+		return { status: "published" };
+	}
+
+	async subscribe(brokerId: string, listener: WakeUpListener): Promise<WakeUpSubscribeResult> {
+		if (brokerId.length === 0) return { status: "invalid", reason: "empty-broker-id" };
+		if (this.closed) return { status: "unavailable" };
+		const subscription: DatabaseSubscription = { brokerId, listener, open: true };
+		this.subscriptions.add(subscription);
+		this.deliver(subscription, { kind: "resync", cause: "subscribed" });
+		this.armPoll();
+		const handle: WakeUpSubscription = {
+			brokerId,
+			close: async () => {
+				subscription.open = false;
+				this.subscriptions.delete(subscription);
+			},
+		};
+		return { status: "subscribed", subscription: handle };
+	}
+
+	close(): Promise<void> {
+		this.closing ??= this.shutdown();
+		return this.closing;
+	}
+
+	private async shutdown(): Promise<void> {
+		this.closed = true;
+		this.cancelPoll?.();
+		this.cancelPoll = undefined;
+		for (const subscription of this.subscriptions) subscription.open = false;
+		this.subscriptions.clear();
+		await this.polling;
+		await this.opening;
+		const database = this.database;
+		this.database = undefined;
+		await database?.close().catch(() => {});
+	}
+
+	private deliver(subscription: DatabaseSubscription, event: WakeUpEvent): void {
+		queueMicrotask(() => {
+			if (subscription.open) subscription.listener(event);
+		});
+	}
+
+	private armPoll(): void {
+		if (this.closed || this.cancelPoll !== undefined || this.polling !== undefined) return;
+		if (this.subscriptions.size === 0) return;
+		this.cancelPoll = this.schedule(() => {
+			this.cancelPoll = undefined;
+			this.polling = this.poll().finally(() => {
+				this.polling = undefined;
+				this.armPoll();
+			});
+		}, this.nextPollDelayMs());
+	}
+
+	private nextPollDelayMs(): number {
+		if (this.database !== undefined || this.reconnectFailures === 0) return this.pollIntervalMs;
+		return Math.min(this.pollIntervalMs * 2 ** this.reconnectFailures, WAKE_UP_RECONNECT_MAX_DELAY_MS);
+	}
+
+	private async poll(): Promise<void> {
+		const database = await this.connection(true);
+		const brokerIds = [...new Set([...this.subscriptions].map((subscription) => subscription.brokerId))];
+		if (database === undefined || brokerIds.length === 0) return;
+		const placeholders = brokerIds.map(() => "?").join(", ");
+		for (;;) {
+			let rows: HintRow[];
+			try {
+				rows = await database.all<HintRow>(
+					`SELECT id, broker_id, reason, version FROM ${this.table} WHERE broker_id IN (${placeholders}) ORDER BY id LIMIT ${WAKE_UP_POLL_BATCH_SIZE}`,
+					...brokerIds,
+				);
+				if (rows.length > 0) {
+					await database.run(
+						`DELETE FROM ${this.table} WHERE id IN (${rows.map(() => "?").join(", ")})`,
+						...rows.map((row) => row.id),
+					);
+				}
+			} catch {
+				this.drop(database);
+				return;
+			}
+			for (const row of rows) {
+				const hint: WakeUpHint = {
+					brokerId: row.broker_id,
+					reason: row.reason === "outcome" ? "outcome" : "outbox",
+					version: row.version,
+				};
+				for (const subscription of this.subscriptions) {
+					if (subscription.brokerId === hint.brokerId) this.deliver(subscription, { kind: "hint", hint });
+				}
+			}
+			if (rows.length < WAKE_UP_POLL_BATCH_SIZE || this.closed) return;
+		}
+	}
+
+	/** `force` (the poll) reopens even while backing off; a publish waits for the backoff to pass. */
+	private connection(force: boolean): Promise<SqliteDatabase | undefined> {
+		if (this.closed) return Promise.resolve(undefined);
+		if (this.database !== undefined) return Promise.resolve(this.database);
+		if (!force && this.opening === undefined && Date.now() < this.reconnectNotBefore) return Promise.resolve(undefined);
+		this.opening ??= this.reconnect().finally(() => {
+			this.opening = undefined;
+		});
+		return this.opening;
+	}
+
+	private async reconnect(): Promise<SqliteDatabase | undefined> {
+		let database: SqliteDatabase;
+		try {
+			database = await openSchemaConnection(this.options, this.table);
+		} catch {
+			this.reconnectFailures++;
+			this.reconnectNotBefore = Date.now() + this.nextPollDelayMs();
+			return undefined;
+		}
+		this.reconnectFailures = 0;
+		if (this.closed) {
+			await database.close().catch(() => {});
+			return undefined;
+		}
+		this.database = database;
+		for (const subscription of this.subscriptions) {
+			this.deliver(subscription, { kind: "resync", cause: "reconnected" });
+		}
+		return database;
+	}
+
+	private drop(database: SqliteDatabase): void {
+		if (this.database !== database) return;
+		this.database = undefined;
+		void database.close().catch(() => {});
+	}
+}
+
+/** Opens one broker's connection to the database wake-up bus; a failure to open the database is thrown. */
+export async function openDatabaseWakeUpBus(options: DatabaseWakeUpBusOptions): Promise<WakeUpBus> {
+	const table = `${validateStoragePrefix(options.prefix)}intercom_wakeups`;
+	return new DatabaseWakeUpBus(options, table, await openSchemaConnection(options, table));
+}

package/dist/builtin/intercom/broker/group-membership.ts

@@ -26,7 +26,7 @@ export function sessionsShareGroup(a: SessionInfo, b: SessionInfo): boolean {
 
 /** Return each session visible through at least one of the requester's memberships. */
 export function sessionsVisibleTo(
-	sessions: ReadonlyMap<string, BrokerConnectedSession>,
+	sessions: ReadonlyMap<string, Pick<BrokerConnectedSession, "info">>,
 	requester: SessionInfo,
 ): SessionInfo[] {
 	return [...sessions.values()].map(({ info }) => info).filter((info) => isAgentRecipient(info) && sessionsShareGroup(requester, info));
@@ -34,7 +34,7 @@ export function sessionsVisibleTo(
 
 /** Return sessions that belong to one explicit group. */
 export function sessionsInGroup(
-	sessions: ReadonlyMap<string, BrokerConnectedSession>,
+	sessions: ReadonlyMap<string, Pick<BrokerConnectedSession, "info">>,
 	group: string | undefined,
 ): SessionInfo[] {
 	return [...sessions.values()].map(({ info }) => info).filter((info) => isAgentRecipient(info) && hasGroup(sessionGroups(info), group));