@openclaw/whatsapp 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{connection-controller-C1rwfWb4.js → connection-controller-BVRExqrB.js}

@@ -1,8 +1,8 @@
-import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
-import { t as WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY } from "./connection-controller-runtime-context-CbTsqmPT.js";
-import { c as logoutWeb, f as readWebAuthExistsForDecision, r as WhatsAppAuthUnstableError } from "./auth-store-BQi9pZqQ.js";
-import { c as resolveComparableIdentity } from "./identity-D7L8LCuH.js";
-import { i as DEFAULT_WHATSAPP_SOCKET_TIMING, r as waitForWaConnection, t as createWaSocket } from "./session-mxWFn0eS.js";
+import { r as getWhatsAppChannelRuntime } from "./runtime-BLlToOi6.js";
+import { n as WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY, t as WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY } from "./connection-controller-runtime-context-DG0tuYuw.js";
+import { c as logoutWeb, f as readWebAuthExistsForDecision, r as WhatsAppAuthUnstableError, w as waitForCredsSaveQueueWithTimeout } from "./auth-store-DirYMTbo.js";
+import { c as resolveComparableIdentity } from "./identity-BM4_wZeM.js";
+import { a as waitForWaConnection, m as acquireWhatsAppGatewayConnectionOwner, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, t as closeWhatsAppSocketAndWait } from "./socket-close-BoSHhQNJ.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
 import { computeBackoff, info, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
@@ -18,16 +18,14 @@ const DEFAULT_RECONNECT_POLICY = {
 	maxAttempts: 12
 };
 function resolveHeartbeatSeconds(cfg, overrideSeconds) {
-	const candidate = overrideSeconds ?? cfg.web?.heartbeatSeconds;
+	const candidate = overrideSeconds;
 	if (typeof candidate === "number" && candidate > 0) return candidate;
 	return DEFAULT_HEARTBEAT_SECONDS;
 }
 function resolveReconnectPolicy(cfg, overrides) {
-	const reconnectOverrides = cfg.web?.reconnect ?? {};
 	const overrideConfig = overrides ?? {};
 	const merged = {
 		...DEFAULT_RECONNECT_POLICY,
-		...reconnectOverrides,
 		...overrideConfig
 	};
 	merged.initialMs = Math.max(250, merged.initialMs);
@@ -89,17 +87,28 @@ function createLiveConnection(params) {
 		openedAfterRecentInbound: params.openedAfterRecentInbound,
 		backgroundTasks: /* @__PURE__ */ new Set(),
 		closePromise,
-		resolveClose: resolveClosePromise
+		resolveClose: resolveClosePromise,
+		socketClosed: false
 	};
 }
+async function closeWebSocketBestEffort(sock) {
+	try {
+		await sock.ws?.close?.();
+	} catch {}
+}
 function closeWaSocket(sock) {
 	try {
 		if (typeof sock?.end === "function") {
-			sock.end(/* @__PURE__ */ new Error("OpenClaw WhatsApp socket close"));
+			Promise.resolve(sock.end(/* @__PURE__ */ new Error("OpenClaw WhatsApp socket close"))).catch(async () => await closeWebSocketBestEffort(sock));
 			return;
 		}
-		sock?.ws?.close?.();
-	} catch {}
+		if (sock) closeWebSocketBestEffort(sock);
+	} catch {
+		if (sock) closeWebSocketBestEffort(sock);
+	}
+}
+function stoppedControllerError() {
+	return /* @__PURE__ */ new Error("WhatsApp connection controller is shutting down");
 }
 function closeWaSocketSoon(sock, delayMs = 500) {
 	setTimeout(() => {
@@ -229,6 +238,15 @@ var WhatsAppConnectionController = class {
 		this.disconnectRetryController = new AbortController();
 		this.current = null;
 		this.runtimeContextLease = null;
+		this.pendingOwnerContextLease = null;
+		this.connectionOwnerLease = null;
+		this.retainedOwnerReleaseLease = null;
+		this.connectionOwnerLeasePromise = null;
+		this.connectionSetupPromise = null;
+		this.pendingSocketCleanup = null;
+		this.shuttingDown = false;
+		this.ownerAcquireAbortController = new AbortController();
+		this.setupAbortController = new AbortController();
 		this.reconnectAttempts = 0;
 		this.lastHandledInboundAt = null;
 		this.accountId = params.accountId;
@@ -249,11 +267,17 @@ var WhatsAppConnectionController = class {
 			...params.socketTiming
 		};
 		this.socketRef = { current: null };
-		this.abortPromise = params.abortSignal && new Promise((resolve) => {
-			params.abortSignal?.addEventListener("abort", () => resolve("aborted"), { once: true });
+		const abortSignal = params.abortSignal;
+		if (abortSignal) this.abortPromise = new Promise((resolve) => {
+			const stop = () => {
+				resolve("aborted");
+				this.stopDisconnectRetries();
+				this.ownerAcquireAbortController.abort(abortSignal.reason);
+				this.setupAbortController.abort(abortSignal.reason);
+			};
+			if (abortSignal.aborted) stop();
+			else abortSignal.addEventListener("abort", stop, { once: true });
 		});
-		if (params.abortSignal?.aborted) this.stopDisconnectRetries();
-		else params.abortSignal?.addEventListener("abort", () => this.stopDisconnectRetries(), { once: true });
 	}
 	getActiveListener() {
 		return this.current?.listener ?? null;
@@ -322,7 +346,23 @@ var WhatsAppConnectionController = class {
 		this.current.unregisterUnhandled = unregister;
 	}
 	async openConnection(params) {
+		if (this.shuttingDown) throw stoppedControllerError();
+		if (this.connectionSetupPromise) throw new Error("WhatsApp connection setup is already in progress");
+		const setupPromise = this.openConnectionOwned(params);
+		this.connectionSetupPromise = setupPromise;
+		try {
+			return await setupPromise;
+		} finally {
+			if (this.connectionSetupPromise === setupPromise) this.connectionSetupPromise = null;
+		}
+	}
+	async openConnectionOwned(params) {
+		await this.ensureConnectionOwnership();
+		this.throwIfSetupStopped();
+		await this.finishPendingSocketCleanup();
+		this.throwIfSetupStopped();
 		if (this.current) await this.closeCurrentConnection();
+		this.throwIfSetupStopped();
 		let sock = null;
 		let connection = null;
 		try {
@@ -332,8 +372,9 @@ var WhatsAppConnectionController = class {
 				...params.getMessage ? { getMessage: params.getMessage } : {},
 				...params.cachedGroupMetadata ? { cachedGroupMetadata: params.cachedGroupMetadata } : {}
 			});
-			await waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs });
-			const channelRuntime = getWhatsAppRuntime().channel;
+			this.throwIfSetupStopped();
+			await this.waitForSetupStep(waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs }));
+			this.throwIfSetupStopped();
 			this.socketRef.current = sock;
 			connection = createLiveConnection({
 				connectionId: params.connectionId,
@@ -341,16 +382,24 @@ var WhatsAppConnectionController = class {
 				listener: {},
 				openedAfterRecentInbound: this.isOpeningAfterRecentInbound()
 			});
-			const listener = await params.createListener({
+			const listenerTask = params.createListener({
 				sock,
 				connection
 			});
+			let listener;
+			try {
+				listener = await this.waitForSetupStep(listenerTask);
+			} catch (error) {
+				if (this.setupAbortController.signal.aborted) listenerTask.then((lateListener) => lateListener.close?.()).catch(() => {});
+				throw error;
+			}
 			connection.listener = listener;
+			this.throwIfSetupStopped();
 			this.current = connection;
 			connection.unregisterTransportActivity = this.attachTransportActivityListener(sock);
 			const previousRuntimeContextLease = this.runtimeContextLease;
 			this.runtimeContextLease = registerChannelRuntimeContext({
-				channelRuntime,
+				channelRuntime: getWhatsAppChannelRuntime(),
 				channelId: "whatsapp",
 				accountId: this.accountId,
 				capability: WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY,
@@ -358,16 +407,38 @@ var WhatsAppConnectionController = class {
 				abortSignal: this.abortSignal
 			});
 			previousRuntimeContextLease?.dispose();
+			this.pendingOwnerContextLease?.dispose();
+			this.pendingOwnerContextLease = null;
 			this.startTimers(connection, {
 				onHeartbeat: params.onHeartbeat,
 				onWatchdogTimeout: params.onWatchdogTimeout
 			});
 			return connection;
 		} catch (err) {
-			if (this.socketRef.current === sock) this.socketRef.current = null;
-			closeWaSocket(sock);
-			if (connection?.unregisterUnhandled) connection.unregisterUnhandled();
-			connection?.unregisterTransportActivity?.();
+			try {
+				if (connection && this.current === connection) await this.closeCurrentConnection();
+				else {
+					try {
+						await connection?.listener.close?.();
+					} catch {}
+					if (this.socketRef.current === sock) this.socketRef.current = null;
+					if (sock) {
+						const cleanup = connection ?? {
+							sock,
+							socketClosed: false
+						};
+						await this.finishSocketCleanup(cleanup);
+					}
+					if (connection?.unregisterUnhandled) connection.unregisterUnhandled();
+					connection?.unregisterTransportActivity?.();
+				}
+			} catch (closeError) {
+				if (sock && (!connection || this.current !== connection)) this.pendingSocketCleanup = connection ?? {
+					sock,
+					socketClosed: false
+				};
+				throw new AggregateError([err, closeError], "WhatsApp connection setup and close failed", { cause: err });
+			}
 			throw err;
 		}
 	}
@@ -460,6 +531,7 @@ var WhatsAppConnectionController = class {
 		const connection = this.current;
 		if (!connection) return;
 		this.current = null;
+		this.pendingSocketCleanup = connection;
 		if (this.socketRef.current === connection.sock) this.socketRef.current = null;
 		connection.unregisterUnhandled?.();
 		connection.unregisterTransportActivity?.();
@@ -472,16 +544,103 @@ var WhatsAppConnectionController = class {
 		try {
 			await connection.listener.close?.();
 		} catch {}
-		closeWaSocket(connection.sock);
+		await this.finishSocketCleanup(connection);
+		if (this.pendingSocketCleanup === connection) this.pendingSocketCleanup = null;
 	}
 	async waitBeforeRetry(delayMs) {
 		await this.sleep(delayMs, this.abortSignal);
 	}
 	async shutdown() {
+		this.shuttingDown = true;
+		const stoppedError = stoppedControllerError();
+		this.ownerAcquireAbortController.abort(stoppedError);
+		this.setupAbortController.abort(stoppedError);
 		this.stopDisconnectRetries();
+		await this.connectionSetupPromise?.catch(() => {});
+		await this.connectionOwnerLeasePromise?.catch(() => {});
 		await this.closeCurrentConnection();
-		this.runtimeContextLease?.dispose();
-		this.runtimeContextLease = null;
+		await this.finishPendingSocketCleanup();
+		try {
+			this.runtimeContextLease?.dispose();
+		} finally {
+			this.runtimeContextLease = null;
+			try {
+				this.pendingOwnerContextLease?.dispose();
+			} finally {
+				this.pendingOwnerContextLease = null;
+				if (this.connectionOwnerLease) {
+					await this.connectionOwnerLease.release();
+					this.connectionOwnerLease = null;
+				}
+				if (this.retainedOwnerReleaseLease) {
+					await this.retainedOwnerReleaseLease.release();
+					this.retainedOwnerReleaseLease = null;
+				}
+			}
+		}
+	}
+	async finishSocketCleanup(cleanup) {
+		if (!cleanup.socketClosed) {
+			await closeWhatsAppSocketAndWait(cleanup.sock, "OpenClaw WhatsApp socket close");
+			cleanup.socketClosed = true;
+		}
+		if (await waitForCredsSaveQueueWithTimeout(this.authDir) === "timed_out") throw new Error("WhatsApp credential persistence did not drain before owner release");
+	}
+	async finishPendingSocketCleanup() {
+		const cleanup = this.pendingSocketCleanup;
+		if (!cleanup) return;
+		await this.finishSocketCleanup(cleanup);
+		if (this.pendingSocketCleanup === cleanup) this.pendingSocketCleanup = null;
+	}
+	throwIfSetupStopped() {
+		if (this.shuttingDown || this.setupAbortController.signal.aborted) throw stoppedControllerError();
+	}
+	async waitForSetupStep(task) {
+		this.throwIfSetupStopped();
+		const signal = this.setupAbortController.signal;
+		let onAbort;
+		const aborted = new Promise((_resolve, reject) => {
+			onAbort = () => reject(stoppedControllerError());
+			signal.addEventListener("abort", onAbort, { once: true });
+		});
+		try {
+			return await Promise.race([task, aborted]);
+		} finally {
+			if (onAbort) signal.removeEventListener("abort", onAbort);
+		}
+	}
+	async ensureConnectionOwnership() {
+		if (this.retainedOwnerReleaseLease) {
+			await this.retainedOwnerReleaseLease.release();
+			this.retainedOwnerReleaseLease = null;
+		}
+		if (this.connectionOwnerLease) return;
+		if (!this.connectionOwnerLeasePromise) this.connectionOwnerLeasePromise = (async () => {
+			const ownerLease = await acquireWhatsAppGatewayConnectionOwner(this.authDir, this.ownerAcquireAbortController.signal);
+			try {
+				if (this.shuttingDown) throw stoppedControllerError();
+				this.pendingOwnerContextLease = registerChannelRuntimeContext({
+					channelRuntime: getWhatsAppChannelRuntime(),
+					channelId: "whatsapp",
+					accountId: this.accountId,
+					capability: WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY,
+					context: true,
+					abortSignal: this.abortSignal
+				});
+				this.connectionOwnerLease = ownerLease;
+			} catch (error) {
+				try {
+					await ownerLease.release();
+				} catch (releaseError) {
+					this.retainedOwnerReleaseLease = ownerLease;
+					throw new AggregateError([error, releaseError], "WhatsApp connection ownership setup and release failed", { cause: error });
+				}
+				throw error;
+			}
+		})().finally(() => {
+			this.connectionOwnerLeasePromise = null;
+		});
+		await this.connectionOwnerLeasePromise;
 	}
 	startTimers(connection, hooks) {
 		if (!this.keepAlive) return;

package/dist/connection-controller-runtime-context-DG0tuYuw.js

@@ -0,0 +1,23 @@
+import { t as getOptionalWhatsAppChannelRuntime } from "./runtime-BLlToOi6.js";
+import { getChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
+//#region extensions/whatsapp/src/connection-controller-runtime-context.ts
+const WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY = "connection-controller";
+const WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY = "connection-owner-pending";
+function getWhatsAppConnectionController(accountId) {
+	return getChannelRuntimeContext({
+		channelRuntime: getOptionalWhatsAppChannelRuntime() ?? void 0,
+		channelId: "whatsapp",
+		accountId,
+		capability: "connection-controller"
+	}) ?? null;
+}
+function hasPendingWhatsAppConnectionOwner(accountId) {
+	return Boolean(getChannelRuntimeContext({
+		channelRuntime: getOptionalWhatsAppChannelRuntime() ?? void 0,
+		channelId: "whatsapp",
+		accountId,
+		capability: WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY
+	}));
+}
+//#endregion
+export { hasPendingWhatsAppConnectionOwner as i, WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY as n, getWhatsAppConnectionController as r, WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY as t };

package/dist/contract-api.js

@@ -2,7 +2,7 @@ import { c as normalizeWhatsAppTarget$1, t as isWhatsAppGroupJid$1 } from "./nor
 import { t as whatsappCommandPolicy$1 } from "./command-policy-BIOSHySD.js";
 import { t as resolveLegacyGroupSessionKey$1 } from "./group-session-contract-DDnZSsJ1.js";
 import { r as isLegacyGroupSessionKey$1, t as canonicalizeLegacySessionKey$1 } from "./session-contract-DMTm6Q_L.js";
-import { a as resolveWhatsAppRuntimeGroupPolicy$1, n as testing } from "./access-control-DazDX3RB.js";
+import { a as resolveWhatsAppRuntimeGroupPolicy$1, n as testing } from "./access-control-CRz_v6bR.js";
 //#region extensions/whatsapp/contract-api.ts
 const canonicalizeLegacySessionKey = canonicalizeLegacySessionKey$1;
 const isLegacyGroupSessionKey = isLegacyGroupSessionKey$1;

package/dist/directory-config-BTbJkV1W.js

@@ -0,0 +1,196 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { c as resolveMergedWhatsAppAccountConfig, o as resolveWhatsAppAuthDir } from "./accounts-CxPuEFi-.js";
+import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-DSZnHkKF.js";
+import { i as hasPendingWhatsAppConnectionOwner, r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-DG0tuYuw.js";
+import "./normalize-C-Z16y7Q.js";
+import { f as readWebAuthExistsForDecision, w as waitForCredsSaveQueueWithTimeout } from "./auth-store-DirYMTbo.js";
+import { n as resolveWebAccountId } from "./active-listener-BEjWsCNM.js";
+import { a as waitForWaConnection, h as acquireWhatsAppStandaloneConnectionOwner, n as createWaDirectorySocket, p as WhatsAppConnectionOwnerBusyError, t as closeWhatsAppSocketAndWait } from "./socket-close-BoSHhQNJ.js";
+import { listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-config-runtime";
+//#region extensions/whatsapp/src/directory-config.ts
+var directory_config_exports = /* @__PURE__ */ __exportAll({
+	WHATSAPP_DIRECTORY_UNAVAILABLE_CODE: () => WHATSAPP_DIRECTORY_UNAVAILABLE_CODE,
+	WhatsAppDirectoryUnavailableError: () => WhatsAppDirectoryUnavailableError,
+	listWhatsAppDirectoryGroupsFromConfig: () => listWhatsAppDirectoryGroupsFromConfig,
+	listWhatsAppDirectoryGroupsLive: () => listWhatsAppDirectoryGroupsLive,
+	listWhatsAppDirectoryPeersFromConfig: () => listWhatsAppDirectoryPeersFromConfig
+});
+function resolveWhatsAppDirectoryAccount(cfg, accountId) {
+	return resolveMergedWhatsAppAccountConfig({
+		cfg,
+		accountId
+	});
+}
+async function listWhatsAppDirectoryPeersFromConfig(params) {
+	return listResolvedDirectoryUserEntriesFromAllowFrom({
+		...params,
+		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveAllowFrom: (account) => account.allowFrom,
+		normalizeId: (entry) => {
+			const normalized = normalizeWhatsAppTarget(entry);
+			if (!normalized || isWhatsAppGroupJid(normalized)) return null;
+			return normalized;
+		}
+	});
+}
+async function listWhatsAppDirectoryGroupsFromConfig(params) {
+	return listResolvedDirectoryGroupEntriesFromMapKeys({
+		...params,
+		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveGroups: (account) => account.groups
+	});
+}
+const WHATSAPP_DIRECTORY_UNAVAILABLE_CODE = "whatsapp_directory_unavailable";
+var WhatsAppDirectoryUnavailableError = class extends Error {
+	constructor(reason, message, options) {
+		super(message, options);
+		this.reason = reason;
+		this.code = WHATSAPP_DIRECTORY_UNAVAILABLE_CODE;
+		this.name = "WhatsAppDirectoryUnavailableError";
+	}
+};
+async function fetchLiveGroups(sock, params) {
+	const groups = await sock.groupFetchAllParticipating();
+	const query = params.query?.trim().toLowerCase() ?? "";
+	const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : void 0;
+	const entries = Object.entries(groups).map(([jid, metadata]) => ({
+		kind: "group",
+		id: jid,
+		name: metadata?.subject?.trim() || void 0
+	})).filter((entry) => {
+		if (!query) return true;
+		return entry.id.toLowerCase().includes(query) || entry.name?.toLowerCase().includes(query);
+	}).toSorted((left, right) => left.id.localeCompare(right.id));
+	return limit ? entries.slice(0, limit) : entries;
+}
+function unavailable(reason, message, cause) {
+	return new WhatsAppDirectoryUnavailableError(reason, message, cause ? { cause } : void 0);
+}
+const pendingStandaloneCleanups = /* @__PURE__ */ new Map();
+const STANDALONE_CLEANUP_RETRY_MS = 1e3;
+async function completeStandaloneCleanup(cleanup) {
+	if (cleanup.sock && !cleanup.socketClosed) {
+		await closeWhatsAppSocketAndWait(cleanup.sock, "OpenClaw WhatsApp standalone directory socket close");
+		cleanup.socketClosed = true;
+	}
+	if (cleanup.sock) {
+		if (await waitForCredsSaveQueueWithTimeout(cleanup.authDir) === "timed_out") throw new Error("WhatsApp credential persistence did not drain before socket release");
+	}
+	await cleanup.ownerLease.release();
+	if (pendingStandaloneCleanups.get(cleanup.authDir) === cleanup) pendingStandaloneCleanups.delete(cleanup.authDir);
+	if (cleanup.retryTimer) {
+		clearTimeout(cleanup.retryTimer);
+		cleanup.retryTimer = null;
+	}
+}
+function runStandaloneCleanup(cleanup) {
+	if (cleanup.inFlight) return cleanup.inFlight;
+	const task = completeStandaloneCleanup(cleanup).finally(() => {
+		if (cleanup.inFlight === task) cleanup.inFlight = null;
+	});
+	cleanup.inFlight = task;
+	return task;
+}
+function scheduleStandaloneCleanupRetry(cleanup) {
+	if (cleanup.retryTimer) return;
+	cleanup.retryTimer = setTimeout(() => {
+		cleanup.retryTimer = null;
+		runStandaloneCleanup(cleanup).catch(() => {
+			scheduleStandaloneCleanupRetry(cleanup);
+		});
+	}, STANDALONE_CLEANUP_RETRY_MS);
+	cleanup.retryTimer.unref?.();
+}
+function retainStandaloneCleanup(cleanup) {
+	pendingStandaloneCleanups.set(cleanup.authDir, cleanup);
+	scheduleStandaloneCleanupRetry(cleanup);
+}
+async function finishStandaloneCleanupOrThrow(cleanup, operationError) {
+	try {
+		await runStandaloneCleanup(cleanup);
+	} catch (cleanupError) {
+		retainStandaloneCleanup(cleanup);
+		throw cleanupUnavailable(operationError === void 0 ? cleanupError : new AggregateError([operationError, cleanupError], "WhatsApp live group lookup and cleanup failed", { cause: operationError }));
+	}
+}
+function cleanupUnavailable(error) {
+	return unavailable("cleanup_failed", "WhatsApp live group lookup could not safely close its standalone connection.", error);
+}
+async function finishPriorStandaloneCleanup(authDir) {
+	const cleanup = pendingStandaloneCleanups.get(authDir);
+	if (!cleanup) return;
+	try {
+		await runStandaloneCleanup(cleanup);
+	} catch (error) {
+		scheduleStandaloneCleanupRetry(cleanup);
+		throw cleanupUnavailable(error);
+	}
+}
+async function listGroupsThroughStandaloneOwner(params) {
+	const account = resolveWhatsAppDirectoryAccount(params.cfg, params.accountId);
+	const authDir = resolveWhatsAppAuthDir({
+		cfg: params.cfg,
+		accountId: account.accountId
+	}).authDir;
+	await finishPriorStandaloneCleanup(authDir);
+	let ownerLease;
+	try {
+		ownerLease = await acquireWhatsAppStandaloneConnectionOwner(authDir);
+	} catch (error) {
+		if (error instanceof WhatsAppConnectionOwnerBusyError) throw unavailable("connection_owner_busy", "WhatsApp live groups are unavailable because the account is owned by another process.", error);
+		throw unavailable("connection_failed", "WhatsApp live groups are unavailable because connection ownership failed.", error);
+	}
+	const cleanup = {
+		authDir,
+		inFlight: null,
+		ownerLease,
+		retryTimer: null,
+		sock: null,
+		socketClosed: true
+	};
+	let groups;
+	try {
+		let authState;
+		try {
+			authState = await readWebAuthExistsForDecision(authDir);
+		} catch (error) {
+			throw unavailable("auth_unstable", "WhatsApp live groups are unavailable because linked credentials could not be read.", error);
+		}
+		if (authState.outcome === "unstable") throw unavailable("auth_unstable", "WhatsApp live groups are unavailable while linked credentials are changing.");
+		if (!authState.exists) throw unavailable("not_linked", "WhatsApp live groups are unavailable because this account is not linked.");
+		try {
+			cleanup.sock = await createWaDirectorySocket(authDir);
+			cleanup.socketClosed = false;
+			await waitForWaConnection(cleanup.sock, { timeoutMs: 3e4 });
+		} catch (error) {
+			throw unavailable("connection_failed", "WhatsApp live groups are unavailable because the standalone connection failed.", error);
+		}
+		try {
+			groups = await fetchLiveGroups(cleanup.sock, params);
+		} catch (error) {
+			throw unavailable("lookup_failed", "WhatsApp live group lookup failed.", error);
+		}
+	} catch (error) {
+		await finishStandaloneCleanupOrThrow(cleanup, error);
+		throw error;
+	}
+	await finishStandaloneCleanupOrThrow(cleanup);
+	return groups;
+}
+async function listWhatsAppDirectoryGroupsLive(params) {
+	const accountId = resolveWebAccountId({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const controller = getWhatsAppConnectionController(accountId);
+	if (!controller && !hasPendingWhatsAppConnectionOwner(accountId)) return await listGroupsThroughStandaloneOwner(params);
+	const sock = controller?.getCurrentSock();
+	if (!sock) throw unavailable("active_owner_unavailable", "WhatsApp live groups are unavailable while the gateway connection is offline.");
+	try {
+		return await fetchLiveGroups(sock, params);
+	} catch (error) {
+		throw unavailable("lookup_failed", "WhatsApp live group lookup failed.", error);
+	}
+}
+//#endregion
+export { listWhatsAppDirectoryGroupsFromConfig as n, listWhatsAppDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/directory-contract-api.js

@@ -1,4 +1,4 @@
-import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-CLBQrjtC.js";
+import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-BTbJkV1W.js";
 //#region extensions/whatsapp/directory-contract-api.ts
 const whatsappDirectoryContractPlugin = {
 	id: "whatsapp",

package/dist/doctor-CwzVXKoE.js

@@ -0,0 +1,10 @@
+//#region extensions/whatsapp/src/doctor.ts
+function normalizeCompatibilityConfig({ cfg }) {
+	return {
+		config: cfg,
+		changes: []
+	};
+}
+const whatsappDoctor = { normalizeCompatibilityConfig };
+//#endregion
+export { whatsappDoctor as n, normalizeCompatibilityConfig as t };