@openclaw/whatsapp 2026.7.2-beta.7 → 2026.7.34

package/dist/{connection-controller-BOB2MVKY.js → .setup/connection-controller-Dt62u6fI.mjs}

@@ -1,15 +1,12 @@
-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-DcEpIOmE.js";
-import { c as resolveComparableIdentity } from "./identity-CPrT5aEU.js";
-import { a as waitForWaConnection, m as acquireWhatsAppGatewayConnectionOwner, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, t as closeWhatsAppSocketAndWait } from "./socket-close-DridEuzz.js";
-import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
+import { n as registerWhatsAppConnectionController, r as unregisterWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.mjs";
+import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.mjs";
+import { t as DEFAULT_WHATSAPP_SOCKET_TIMING } from "./socket-timing-DhbVFjah.mjs";
+import { c as logoutWeb, f as readWebAuthExistsForDecision, r as WhatsAppAuthUnstableError } from "./auth-store-BZKGa0tW.mjs";
+import { c as resolveComparableIdentity } from "./identity-CDB1bT-p.mjs";
+import { r as waitForWaConnection, t as createWaSocket } from "./session-vUI41Jel.mjs";
 import { computeBackoff, info, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
-import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { clamp } from "openclaw/plugin-sdk/text-utility-runtime";
 import { randomUUID } from "node:crypto";
-//#region extensions/whatsapp/src/reconnect.ts
-const DEFAULT_HEARTBEAT_SECONDS = 60;
 const DEFAULT_RECONNECT_POLICY = {
 	initialMs: 2e3,
 	maxMs: 3e4,
@@ -18,14 +15,16 @@ const DEFAULT_RECONNECT_POLICY = {
 	maxAttempts: 12
 };
 function resolveHeartbeatSeconds(cfg, overrideSeconds) {
-	const candidate = overrideSeconds;
+	const candidate = overrideSeconds ?? cfg.web?.heartbeatSeconds;
 	if (typeof candidate === "number" && candidate > 0) return candidate;
-	return DEFAULT_HEARTBEAT_SECONDS;
+	return 60;
 }
 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);
@@ -87,49 +86,23 @@ function createLiveConnection(params) {
 		openedAfterRecentInbound: params.openedAfterRecentInbound,
 		backgroundTasks: /* @__PURE__ */ new Set(),
 		closePromise,
-		resolveClose: resolveClosePromise,
-		socketClosed: false
+		resolveClose: resolveClosePromise
 	};
 }
-async function closeWebSocketBestEffort(sock) {
-	try {
-		await sock.ws?.close?.();
-	} catch {}
-}
 function closeWaSocket(sock) {
 	try {
 		if (typeof sock?.end === "function") {
-			Promise.resolve(sock.end(/* @__PURE__ */ new Error("OpenClaw WhatsApp socket close"))).catch(async () => await closeWebSocketBestEffort(sock));
+			sock.end(/* @__PURE__ */ new Error("OpenClaw WhatsApp socket close"));
 			return;
 		}
-		if (sock) closeWebSocketBestEffort(sock);
-	} catch {
-		if (sock) closeWebSocketBestEffort(sock);
-	}
-}
-function stoppedControllerError() {
-	return /* @__PURE__ */ new Error("WhatsApp connection controller is shutting down");
+		sock?.ws?.close?.();
+	} catch {}
 }
 function closeWaSocketSoon(sock, delayMs = 500) {
 	setTimeout(() => {
 		closeWaSocket(sock);
 	}, delayMs);
 }
-async function waitForLoginSocket(params) {
-	if (!params.credentialPersistenceFailure) {
-		await params.wait();
-		return;
-	}
-	const outcome = await Promise.race([params.wait().then(() => ({ kind: "connected" })), params.credentialPersistenceFailure.then((failure) => ({
-		kind: "credential-persistence-failed",
-		failure
-	}))]);
-	if (outcome.kind === "credential-persistence-failed") throw outcome.failure.error;
-}
-function throwIfCredentialPersistenceFailed(getFailure) {
-	const failure = getFailure?.();
-	if (failure) throw failure.error;
-}
 async function waitForWhatsAppLoginResult(params) {
 	const wait = params.waitForConnection ?? waitForWaConnection;
 	const createSocket = params.createSocket ?? createWaSocket;
@@ -144,9 +117,7 @@ async function waitForWhatsAppLoginResult(params) {
 				authDir: params.authDir,
 				...params.socketTiming,
 				onQr: params.onQr,
-				beforeCredentialPersistence: params.beforeCredentialPersistence,
-				onCredentialPersistenceError: params.onCredentialPersistenceError,
-				onCredentialPersistenceTask: params.onCredentialPersistenceTask
+				beforeCredentialPersistence: params.beforeCredentialPersistence
 			});
 			params.onSocketReplaced?.(currentSock);
 			return null;
@@ -160,14 +131,8 @@ async function waitForWhatsAppLoginResult(params) {
 		}
 	};
 	while (true) try {
-		await waitForLoginSocket({
-			wait: async () => await wait(currentSock, { timeout: "none" }),
-			credentialPersistenceFailure: params.credentialPersistenceFailure
-		});
-		await params.waitForCredentialPersistence?.();
-		throwIfCredentialPersistenceFailed(params.getCredentialPersistenceFailure);
+		await wait(currentSock, { timeout: "none" });
 		const persistedAuth = await readWebAuthExistsForDecision(params.authDir);
-		throwIfCredentialPersistenceFailed(params.getCredentialPersistenceFailure);
 		if (persistedAuth.outcome === "unstable") return {
 			outcome: "failed",
 			message: WHATSAPP_LOGIN_AUTH_UNSTABLE_MESSAGE,
@@ -237,16 +202,6 @@ var WhatsAppConnectionController = class {
 	constructor(params) {
 		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;
@@ -267,17 +222,11 @@ var WhatsAppConnectionController = class {
 			...params.socketTiming
 		};
 		this.socketRef = { current: null };
-		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 });
+		this.abortPromise = params.abortSignal && new Promise((resolve) => {
+			params.abortSignal?.addEventListener("abort", () => resolve("aborted"), { once: true });
 		});
+		if (params.abortSignal?.aborted) this.stopDisconnectRetries();
+		else params.abortSignal?.addEventListener("abort", () => this.stopDisconnectRetries(), { once: true });
 	}
 	getActiveListener() {
 		return this.current?.listener ?? null;
@@ -346,23 +295,7 @@ 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 {
@@ -372,9 +305,7 @@ var WhatsAppConnectionController = class {
 				...params.getMessage ? { getMessage: params.getMessage } : {},
 				...params.cachedGroupMetadata ? { cachedGroupMetadata: params.cachedGroupMetadata } : {}
 			});
-			this.throwIfSetupStopped();
-			await this.waitForSetupStep(waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs }));
-			this.throwIfSetupStopped();
+			await waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs });
 			this.socketRef.current = sock;
 			connection = createLiveConnection({
 				connectionId: params.connectionId,
@@ -382,63 +313,24 @@ var WhatsAppConnectionController = class {
 				listener: {},
 				openedAfterRecentInbound: this.isOpeningAfterRecentInbound()
 			});
-			const listenerTask = params.createListener({
+			const listener = await 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: getWhatsAppChannelRuntime(),
-				channelId: "whatsapp",
-				accountId: this.accountId,
-				capability: WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY,
-				context: this,
-				abortSignal: this.abortSignal
-			});
-			previousRuntimeContextLease?.dispose();
-			this.pendingOwnerContextLease?.dispose();
-			this.pendingOwnerContextLease = null;
+			registerWhatsAppConnectionController(this.accountId, this);
 			this.startTimers(connection, {
 				onHeartbeat: params.onHeartbeat,
 				onWatchdogTimeout: params.onWatchdogTimeout
 			});
 			return connection;
 		} catch (err) {
-			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 });
-			}
+			if (this.socketRef.current === sock) this.socketRef.current = null;
+			closeWaSocket(sock);
+			if (connection?.unregisterUnhandled) connection.unregisterUnhandled();
+			connection?.unregisterTransportActivity?.();
 			throw err;
 		}
 	}
@@ -531,7 +423,6 @@ 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?.();
@@ -544,103 +435,15 @@ var WhatsAppConnectionController = class {
 		try {
 			await connection.listener.close?.();
 		} catch {}
-		await this.finishSocketCleanup(connection);
-		if (this.pendingSocketCleanup === connection) this.pendingSocketCleanup = null;
+		closeWaSocket(connection.sock);
 	}
 	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();
-		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;
+		unregisterWhatsAppConnectionController(this.accountId, this);
 	}
 	startTimers(connection, hooks) {
 		if (!this.keepAlive) return;

package/dist/.setup/connection-controller-registry-TSX_udJp.mjs

@@ -0,0 +1,22 @@
+//#region extensions/whatsapp/src/connection-controller-registry.ts
+const CONNECTION_REGISTRY_KEY = Symbol.for("openclaw.whatsapp.connectionControllerRegistry");
+function getConnectionRegistryState() {
+	const globalState = globalThis;
+	const existing = globalState[CONNECTION_REGISTRY_KEY];
+	if (existing) return existing;
+	const created = { controllers: /* @__PURE__ */ new Map() };
+	globalState[CONNECTION_REGISTRY_KEY] = created;
+	return created;
+}
+function getRegisteredWhatsAppConnectionController(accountId) {
+	return getConnectionRegistryState().controllers.get(accountId) ?? null;
+}
+function registerWhatsAppConnectionController(accountId, controller) {
+	getConnectionRegistryState().controllers.set(accountId, controller);
+}
+function unregisterWhatsAppConnectionController(accountId, controller) {
+	const controllers = getConnectionRegistryState().controllers;
+	if (controllers.get(accountId) === controller) controllers.delete(accountId);
+}
+//#endregion
+export { registerWhatsAppConnectionController as n, unregisterWhatsAppConnectionController as r, getRegisteredWhatsAppConnectionController as t };

package/dist/{constants-HU41RHGI.js → .setup/constants-C7m81BNe.mjs}

@@ -1,4 +1,4 @@
 //#region extensions/whatsapp/src/auto-reply/constants.ts
-const DEFAULT_WEB_MEDIA_BYTES = 5 * 1024 * 1024;
+const DEFAULT_WEB_MEDIA_BYTES = 5242880;
 //#endregion
 export { DEFAULT_WEB_MEDIA_BYTES as t };

package/dist/.setup/directory-config-B7Obxrq2.mjs

@@ -0,0 +1,37 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-6PTOSfaI.mjs";
+import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-bVWjgftN.mjs";
+import "./normalize-eddWWsNV.mjs";
+import { listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-config-runtime";
+//#region extensions/whatsapp/src/directory-config.ts
+var directory_config_exports = /* @__PURE__ */ __exportAll({
+	listWhatsAppDirectoryGroupsFromConfig: () => listWhatsAppDirectoryGroupsFromConfig,
+	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
+	});
+}
+//#endregion
+export { listWhatsAppDirectoryGroupsFromConfig as n, listWhatsAppDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/.setup/doctor-By3SB4lm.mjs

@@ -0,0 +1,48 @@
+//#region extensions/whatsapp/src/doctor.ts
+function normalizeCompatibilityConfig({ cfg }) {
+	const legacyAckReaction = cfg.messages?.ackReaction?.trim();
+	if (!legacyAckReaction || cfg.channels?.whatsapp === void 0) return {
+		config: cfg,
+		changes: []
+	};
+	if (cfg.channels.whatsapp?.ackReaction !== void 0) return {
+		config: cfg,
+		changes: []
+	};
+	const legacyScope = cfg.messages?.ackReactionScope ?? "group-mentions";
+	let direct = true;
+	let group = "mentions";
+	if (legacyScope === "all") {
+		direct = true;
+		group = "always";
+	} else if (legacyScope === "direct") {
+		direct = true;
+		group = "never";
+	} else if (legacyScope === "group-all") {
+		direct = false;
+		group = "always";
+	} else if (legacyScope === "group-mentions") {
+		direct = false;
+		group = "mentions";
+	}
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				whatsapp: {
+					...cfg.channels?.whatsapp,
+					ackReaction: {
+						emoji: legacyAckReaction,
+						direct,
+						group
+					}
+				}
+			}
+		},
+		changes: [`Copied messages.ackReaction → channels.whatsapp.ackReaction (scope: ${legacyScope}).`]
+	};
+}
+const whatsappDoctor = { normalizeCompatibilityConfig };
+//#endregion
+export { whatsappDoctor as n, normalizeCompatibilityConfig as t };

package/dist/{group-session-key-DVMZlO3x.js → .setup/group-session-key-CEwPRRRK.mjs}

@@ -1,37 +1,8 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.js";
-import { c as normalizeWhatsAppTarget } from "./normalize-target-CugRyONv.js";
-import "./normalize-C7Hkc_vE.js";
-import { r as jidToE164 } from "./targets-runtime-TMk0lGuy.js";
-import "./text-runtime-CaKLhowd.js";
-import { createChannelApprovalAuth } from "openclaw/plugin-sdk/approval-auth-runtime";
-import { formatMediaPlaceholderText } from "openclaw/plugin-sdk/channel-inbound";
+import { r as jidToE164 } from "./targets-runtime-C-GiVn6Y.mjs";
+import "./text-runtime-CUrq1mFq.mjs";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
-//#region extensions/whatsapp/src/approval-auth.ts
-function normalizeWhatsAppApproverId(value) {
-	const normalized = normalizeWhatsAppTarget(String(value));
-	if (!normalized || normalized.endsWith("@g.us")) return;
-	return normalized;
-}
-function normalizeWhatsAppApproverEntry(value) {
-	return String(value).trim() === "*" ? "*" : normalizeWhatsAppApproverId(value);
-}
-const whatsappApproval = createChannelApprovalAuth({
-	channelLabel: "WhatsApp",
-	resolveInputs: ({ cfg, accountId }) => {
-		return { allowFrom: resolveWhatsAppAccount({
-			cfg,
-			accountId
-		}).allowFrom };
-	},
-	normalizeApprover: normalizeWhatsAppApproverEntry,
-	normalizeSenderId: normalizeWhatsAppApproverId,
-	isWildcardAuthorized: ({ purpose, approvers }) => purpose === "action" && approvers.includes("*")
-});
-const getWhatsAppApprovalApprovers = whatsappApproval.resolveApprovers;
-const whatsappApprovalAuth = whatsappApproval.approvalAuth;
-//#endregion
 //#region extensions/whatsapp/src/quoted-message.ts
-const CACHE_TTL_MS = 600 * 1e3;
+const CACHE_TTL_MS = 6e5;
 const MAX_ENTRIES = 500;
 const cache = /* @__PURE__ */ new Map();
 function makeCacheKey(accountId, remoteJid, messageId) {
@@ -60,7 +31,6 @@ function lookupInboundMessageMeta(accountId, remoteJid, messageId) {
 		participant: entry.participant,
 		participantE164: entry.participantE164,
 		body: entry.body,
-		media: entry.media,
 		fromMe: entry.fromMe
 	};
 }
@@ -98,7 +68,6 @@ function lookupInboundMessageMetaForTarget(accountId, targetJid, messageId) {
 		participant: exact.participant,
 		participantE164: exact.participantE164,
 		body: exact.body,
-		media: exact.media,
 		fromMe: exact.fromMe
 	};
 	const prefix = `${accountId}:`;
@@ -115,7 +84,6 @@ function lookupInboundMessageMetaForTarget(accountId, targetJid, messageId) {
 			participant: entry.participant,
 			participantE164: entry.participantE164,
 			body: entry.body,
-			media: entry.media,
 			fromMe: entry.fromMe
 		};
 		if (!matchesQuotedConversationTarget(targetJid, candidate)) continue;
@@ -128,7 +96,6 @@ function buildQuotedMessageOptions(params) {
 	const id = params.messageId?.trim();
 	const remoteJid = params.remoteJid?.trim();
 	if (!id || !remoteJid) return;
-	const previewText = [params.messageText, formatMediaPlaceholderText(params.media ? [params.media] : [])].filter(Boolean).join("\n");
 	return { quoted: {
 		key: {
 			remoteJid,
@@ -136,7 +103,7 @@ function buildQuotedMessageOptions(params) {
 			fromMe: params.fromMe ?? false,
 			participant: params.participant
 		},
-		message: { conversation: previewText }
+		message: { conversation: params.messageText ?? "" }
 	} };
 }
 //#endregion
@@ -167,4 +134,4 @@ function resolveWhatsAppGroupSessionRoute(route) {
 	};
 }
 //#endregion
-export { cacheInboundMessageMeta as a, getWhatsAppApprovalApprovers as c, buildQuotedMessageOptions as i, whatsappApprovalAuth as l, resolveWhatsAppGroupSessionRoute as n, lookupInboundMessageMeta as o, resolveWhatsAppLegacyGroupSessionKey as r, lookupInboundMessageMetaForTarget as s, resolveWhatsAppGroupSessionKey as t };
+export { cacheInboundMessageMeta as a, buildQuotedMessageOptions as i, resolveWhatsAppGroupSessionRoute as n, lookupInboundMessageMeta as o, resolveWhatsAppLegacyGroupSessionKey as r, lookupInboundMessageMetaForTarget as s, resolveWhatsAppGroupSessionKey as t };

package/dist/{identity-CPrT5aEU.js → .setup/identity-CDB1bT-p.mjs}

@@ -1,5 +1,5 @@
-import { r as jidToE164 } from "./targets-runtime-TMk0lGuy.js";
-import { t as normalizeE164 } from "./text-runtime-CaKLhowd.js";
+import { r as jidToE164 } from "./targets-runtime-C-GiVn6Y.mjs";
+import { n as normalizeE164 } from "./text-runtime-CUrq1mFq.mjs";
 //#region extensions/whatsapp/src/identity.ts
 const WHATSAPP_LID_RE = /@(lid|hosted\.lid)$/i;
 function normalizeDeviceScopedJid(jid) {

package/dist/.setup/legacy-session-surface-api-B2szjq4r.mjs

@@ -0,0 +1,2 @@
+import { whatsappLegacySessionSurface } from "../legacy-session-surface-api.js";
+export { whatsappLegacySessionSurface };

package/dist/.setup/legacy-state-migrations-api-DXCxufZz.mjs

@@ -0,0 +1,3 @@
+import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-D_BmQUR9.mjs";
+import "../legacy-state-migrations-api.js";
+export { detectWhatsAppLegacyStateMigrations };