@openclaw/slack 2026.11.3 → 2026.11.5-beta.2

package/dist/.setup/{send-C-8wY0lK.mjs → send-yK6_-px6.mjs}

@@ -1,16 +1,16 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { d as resolveSlackOperationToken, s as resolveSlackAccount } from "./accounts-msihSF3-.mjs";
-import { a as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-FFE26kOV.mjs";
-import { A as SLACK_MESSAGE_TEXT_HARD_LIMIT, D as buildSlackCompleteBlocksFallbackText, F as truncateSlackTextByUtf8Bytes, K as resolveSlackQuestionActionIds, L as SLACK_QUESTION_FINALIZATION_BLOCKS, M as SLACK_TEXT_LIMIT, O as renderSlackBlockFallbackText, P as truncateSlackText, T as stripSlackNativeDataBlocks, X as chunkSlackMrkdwnText, Z as markdownToSlackMrkdwnChunks, b as hasSlackNativeDataBlock, gt as validateSlackBlocksArray, j as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, k as SLACK_EDIT_TEXT_MAX_BYTES, m as assertSlackDetachedTargetAllowed, v as buildSlackNativeDataAccessibilityText, w as renderSlackNativeDataPlainTextBlock, x as isSlackInvalidBlocksError, y as createSlackNativeDataBaseTextConsumer } from "./session-status-Dv8wNBEt.mjs";
-import { _ as getSlackWriteClient, b as writeLruMapEntry, d as createSlackReadClient, h as createSlackWriteClient, o as formatSlackError, p as createSlackTokenCacheKey, s as getSlackWebApiErrorData } from "./probe-IiHogLQN.mjs";
+import { f as resolveSlackOperationToken, s as resolveSlackAccount } from "./accounts-CGJScKtk.mjs";
+import { a as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-Bx2UZniD.mjs";
+import { Ct as markdownToSlackMrkdwnChunks, D as createSlackNativeDataBaseTextConsumer, E as buildSlackNativeDataAccessibilityText, F as truncateSlackText, I as truncateSlackTextByUtf8Bytes, J as resolveSlackQuestionActionIds, M as renderSlackNativeDataPlainTextBlock, N as stripSlackNativeDataBlocks, O as hasSlackNativeDataBlock, R as SLACK_QUESTION_FINALIZATION_BLOCKS, S as assertSlackDetachedTargetAllowed, St as chunkSlackMrkdwnText, at as buildSlackCompleteBlocksFallbackText, bt as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, h as getSlackWebApiErrorData, k as isSlackInvalidBlocksError, m as formatSlackError, ot as renderSlackBlockFallbackText, rt as validateSlackBlocksArray, vt as SLACK_EDIT_TEXT_MAX_BYTES, xt as SLACK_TEXT_LIMIT, yt as SLACK_MESSAGE_TEXT_HARD_LIMIT } from "./probe-DANukR3O.mjs";
 import { r as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-Cvt7WD6B.mjs";
+import { c as createSlackWriteClient, d as getOrCreateWeakOwnerMap, i as createSlackReadClient, m as writeLruMapEntry, o as createSlackTokenCacheKey, u as getSlackWriteClient } from "./cursor-pages-CATAzbTT.mjs";
 import { t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.mjs";
-import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { asOptionalObjectRecord, asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { logVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
-import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 import { createHash, createHmac } from "node:crypto";
 import { withTrustedEnvProxyGuardedFetchMode } from "openclaw/plugin-sdk/fetch-runtime";
@@ -112,63 +112,9 @@ function buildSlackMessageIdentityPayload(identity) {
 		...identity?.iconUrl ? { icon_url: identity.iconUrl } : identity?.iconEmoji ? { icon_emoji: identity.iconEmoji } : {}
 	};
 }
-function classifySlackCustomIdentityError(err) {
-	const data = getSlackWebApiErrorData(err);
-	const code = normalizeLowercaseStringOrEmpty(data?.error);
-	if (code === "invalid_arguments" || code === "invalid_arg_name") return "argument";
-	if (code !== "missing_scope") return;
-	if (normalizeLowercaseStringOrEmpty(data?.needed).includes("chat:write.customize")) return "scope";
-	return [...normalizeTrimmedStringList(data?.response_metadata?.scopes), ...normalizeTrimmedStringList(data?.response_metadata?.acceptedScopes)].map((scope) => normalizeLowercaseStringOrEmpty(scope)).includes("chat:write.customize") ? "scope" : void 0;
-}
 function hasSlackMessageIdentity(identity) {
 	return Boolean(identity?.username || identity?.iconUrl || identity?.iconEmoji);
 }
-/** Post with the requested identity, degrading only on Slack identity-specific errors. */
-async function postSlackMessageWithIdentityFallback(params) {
-	const { basePayload, identity, post } = params;
-	try {
-		if (!identity) return await post(basePayload);
-		return await post({
-			...basePayload,
-			...buildSlackMessageIdentityPayload(identity)
-		}, identity);
-	} catch (err) {
-		if (!identity || !hasSlackMessageIdentity(identity)) throw err;
-		const rejection = classifySlackCustomIdentityError(err);
-		if (!rejection) throw err;
-		if (rejection === "argument" && identity.username && (identity.iconUrl || identity.iconEmoji)) {
-			logVerbose("slack send: custom icon rejected, retrying with username only");
-			try {
-				return await post({
-					...basePayload,
-					username: identity.username
-				}, { username: identity.username });
-			} catch (retryError) {
-				if (!classifySlackCustomIdentityError(retryError)) throw retryError;
-			}
-		}
-		logVerbose("slack send: custom identity rejected, retrying without custom identity");
-		return post(basePayload);
-	}
-}
-//#endregion
-//#region extensions/slack/src/post-message-payload.ts
-function buildSlackPostMessagePayload(params) {
-	const threadPayload = params.replyBroadcast && params.threadTs ? {
-		thread_ts: params.threadTs,
-		reply_broadcast: true
-	} : params.threadTs ? { thread_ts: params.threadTs } : {};
-	return {
-		channel: params.channelId,
-		text: params.text,
-		...params.blocks?.length ? { blocks: params.blocks } : {},
-		...params.metadata ? { metadata: params.metadata } : {},
-		...typeof params.mrkdwn === "boolean" ? { mrkdwn: params.mrkdwn } : {},
-		...threadPayload,
-		unfurl_links: params.unfurl?.unfurlLinks ?? false,
-		...typeof params.unfurl?.unfurlMedia === "boolean" ? { unfurl_media: params.unfurl.unfurlMedia } : {}
-	};
-}
 //#endregion
 //#region extensions/slack/src/client-delivery.ts
 const SLACK_COMMERCIAL_API_HOSTNAME = "slack.com";
@@ -291,18 +237,61 @@ function requireSlackPostMessageTimestamp(response) {
 	if (!timestamp) throw new Error("Slack chat.postMessage returned no message timestamp");
 	return timestamp;
 }
+function classifySlackCustomIdentityError(err) {
+	const data = getSlackWebApiErrorData(err);
+	const code = normalizeLowercaseStringOrEmpty(data?.error);
+	if (code === "invalid_arguments" || code === "invalid_arg_name") return "argument";
+	if (code !== "missing_scope") return;
+	if (normalizeLowercaseStringOrEmpty(data?.needed).includes("chat:write.customize")) return "scope";
+	return [...normalizeTrimmedStringList(data?.response_metadata?.scopes), ...normalizeTrimmedStringList(data?.response_metadata?.acceptedScopes)].map((scope) => normalizeLowercaseStringOrEmpty(scope)).includes("chat:write.customize") ? "scope" : void 0;
+}
 async function postSlackMessageBestEffort(params) {
-	const basePayload = buildSlackPostMessagePayload(params);
+	const threadPayload = params.replyBroadcast && params.threadTs ? {
+		thread_ts: params.threadTs,
+		reply_broadcast: true
+	} : params.threadTs ? { thread_ts: params.threadTs } : {};
+	const basePayload = {
+		channel: params.channelId,
+		text: params.text,
+		...params.blocks?.length ? { blocks: params.blocks } : {},
+		...params.metadata ? { metadata: params.metadata } : {},
+		...params.mrkdwn !== void 0 ? { mrkdwn: params.mrkdwn } : {},
+		...threadPayload,
+		unfurl_links: params.unfurl?.unfurlLinks ?? false,
+		...params.unfurl?.unfurlMedia !== void 0 ? { unfurl_media: params.unfurl.unfurlMedia } : {}
+	};
 	const postChatMessage = params.client.chat.postMessage.bind(params.client.chat);
 	const post = async (payload, identity) => ({
 		response: await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(payload)).catch(rethrowSlackPermanentOutboundApiRejection),
 		identity
 	});
-	const posted = await postSlackMessageWithIdentityFallback({
-		basePayload,
-		identity: params.identity,
-		post
-	});
+	const identity = params.identity;
+	const posted = await (async () => {
+		try {
+			if (!identity) return await post(basePayload);
+			return await post({
+				...basePayload,
+				...buildSlackMessageIdentityPayload(identity)
+			}, identity);
+		} catch (err) {
+			if (!identity || !hasSlackMessageIdentity(identity)) throw err;
+			const rejection = classifySlackCustomIdentityError(err);
+			if (!rejection) throw err;
+			if (rejection === "argument" && identity.username && (identity.iconUrl || identity.iconEmoji)) {
+				logVerbose("slack send: custom icon rejected, retrying with username only");
+				try {
+					return await post({
+						...basePayload,
+						username: identity.username
+					}, { username: identity.username });
+				} catch (retryError) {
+					if (!classifySlackCustomIdentityError(retryError)) throw retryError;
+				}
+			}
+			logVerbose("slack send: custom identity rejected, retrying without custom identity");
+			return post(basePayload);
+		}
+	})();
 	const timestamp = requireSlackPostMessageTimestamp(posted.response);
 	return {
 		...posted,
@@ -463,18 +452,11 @@ const slackDmChannelCaches = /* @__PURE__ */ new WeakMap();
 function createSlackDmCacheKey(params) {
 	return `${params.accountId ?? "default"}:${createSlackTokenCacheKey(params.token)}:${params.recipientId}`;
 }
-function getSlackDmChannelCache(client) {
-	const existing = slackDmChannelCaches.get(client);
-	if (existing) return existing;
-	const cache = /* @__PURE__ */ new Map();
-	slackDmChannelCaches.set(client, cache);
-	return cache;
-}
 function readCachedSlackDmChannelId(params) {
-	return getSlackDmChannelCache(params.cacheOwner).get(createSlackDmCacheKey(params));
+	return slackDmChannelCaches.get(params.cacheOwner)?.get(createSlackDmCacheKey(params));
 }
 function cacheSlackDmChannelId(params, channelId) {
-	const cache = getSlackDmChannelCache(params.cacheOwner);
+	const cache = getOrCreateWeakOwnerMap(slackDmChannelCaches, params.cacheOwner);
 	const key = createSlackDmCacheKey(params);
 	writeLruMapEntry(cache, key, channelId, SLACK_DM_CHANNEL_CACHE_MAX);
 }
@@ -542,17 +524,23 @@ function resolvePostedMessageThreadTs(response) {
 }
 async function updateMessageSlack(params) {
 	const cfg = requireRuntimeConfig(params.cfg, "Slack update");
-	const account = resolveSlackAccount({
-		cfg,
-		accountId: params.accountId
-	});
-	assertSlackDetachedTargetAllowed(account.accountId, params.teamId);
-	const token = resolveToken({
-		accountId: account.accountId,
-		fallbackToken: account.botToken,
-		fallbackSource: account.botTokenSource
+	const { client } = resolveSlackDelivery({
+		account: resolveSlackAccount({
+			cfg,
+			accountId: params.accountId
+		}),
+		eventScope: params.eventScope,
+		opts: {
+			cfg,
+			token: params.token
+		},
+		recipient: {
+			kind: "channel",
+			id: params.channelId,
+			teamId: params.teamId
+		}
 	});
-	await getSlackWriteClient(token, { teamId: params.teamId }).chat.update({
+	await client.chat.update({
 		channel: params.channelId,
 		ts: params.messageTs,
 		text: truncateSlackTextByUtf8Bytes(params.text, SLACK_EDIT_TEXT_MAX_BYTES),
@@ -629,19 +617,20 @@ function parseEnterpriseEventRecipient(raw) {
 function resolveSlackDelivery(params) {
 	if (params.eventScope) {
 		if (!params.eventScope.writeClient) throw new Error("missing_enterprise_slack_write_client");
-		return Object.freeze({
+		return {
 			client: params.eventScope.writeClient,
 			credential: SLACK_ENTERPRISE_LISTENER_QUEUE_CREDENTIAL,
 			identity: normalizeSlackSendIdentity(params.opts.identity),
 			recipient: params.recipient,
 			teamId: params.eventScope.teamId,
 			unfurl: { unfurlMedia: params.account.config.unfurlMedia },
-			upload: Object.freeze({
+			upload: {
 				client: params.eventScope.client,
 				auditContext: "slack-enterprise-immediate-upload"
-			})
-		});
+			}
+		};
 	}
+	assertSlackDetachedTargetAllowed(params.account.accountId, params.recipient.teamId);
 	const credential = resolveToken({
 		explicit: params.opts.token,
 		accountId: params.account.accountId,
@@ -650,7 +639,7 @@ function resolveSlackDelivery(params) {
 	});
 	const cachedClient = params.recipient.teamId ? getSlackWriteClient(credential, { teamId: params.recipient.teamId }) : params.opts.client ?? getSlackWriteClient(credential);
 	const client = params.opts.assertDirectAdapterHandoff ? createSlackWriteClient(credential, { teamId: params.recipient.teamId }, params.opts.assertDirectAdapterHandoff) : cachedClient;
-	return Object.freeze({
+	return {
 		client,
 		...client !== cachedClient ? { dmCacheOwner: cachedClient } : {},
 		credential,
@@ -661,7 +650,7 @@ function resolveSlackDelivery(params) {
 			unfurlLinks: params.account.config.unfurlLinks,
 			unfurlMedia: params.account.config.unfurlMedia
 		}
-	});
+	};
 }
 async function resolveChannelId(client, recipient, params) {
 	if (recipient.kind !== "user") return recipient.id;
@@ -678,20 +667,6 @@ async function resolveChannelId(client, recipient, params) {
 	cacheSlackDmChannelId(cacheParams, channelId);
 	return channelId;
 }
-function resolveSlackTextChunks(params) {
-	const text = params.text;
-	const chunkLimit = params.chunkLimit;
-	if (params.preservePlainText) return text ? chunkTextForOutbound(text, chunkLimit, { preserveWhitespace: true }) : [];
-	if (params.textIsSlackMrkdwn) return resolveTextChunksWithFallback(text, chunkSlackMrkdwnText(text, chunkLimit));
-	const tableMode = resolveMarkdownTableMode({
-		cfg: params.cfg,
-		channel: "slack",
-		...params.accountId ? { accountId: params.accountId } : {}
-	});
-	const chunkMode = resolveChunkMode(params.cfg, "slack", params.accountId);
-	const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(text, chunkLimit, chunkMode) : [text]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode }));
-	return resolveTextChunksWithFallback(text, chunks);
-}
 async function resolveSlackDmChannelId(params) {
 	return await resolveChannelId(params.client, {
 		kind: "user",
@@ -762,37 +737,8 @@ const SLACK_RECONCILIATION_EVIDENCE_RANK = {
 	conflict: 2,
 	complete: 3
 };
-function findSlackConversationDeliveryParts(params) {
-	const matches = [];
-	for (const message of params.messages) {
-		const marker = asOptionalRecord(asOptionalRecord(message.metadata)?.event_payload);
-		if (!marker || marker[SLACK_DELIVERY_METADATA_KEY] !== params.deliveryId) continue;
-		const partIndex = marker[SLACK_DELIVERY_METADATA_PART_INDEX_KEY];
-		const partCount = marker[SLACK_DELIVERY_METADATA_PART_COUNT_KEY];
-		if (typeof partIndex !== "number" || !Number.isInteger(partIndex) || typeof partCount !== "number" || !Number.isInteger(partCount) || partIndex < 0 || partCount <= 0 || partIndex >= partCount) continue;
-		const expectedSignature = createSlackDeliveryMetadataSignature({
-			queueId: params.queueId,
-			channelId: params.channelId,
-			threadTs: params.threadTs,
-			partIndex,
-			partCount
-		});
-		const actualSignature = marker[SLACK_DELIVERY_METADATA_SIGNATURE_KEY];
-		if (typeof actualSignature !== "string" || !safeEqualSecret(actualSignature, expectedSignature)) continue;
-		const messageId = typeof message.ts === "string" ? normalizeSlackThreadTsCandidate(message.ts) : void 0;
-		if (!messageId) continue;
-		const threadTs = typeof message.thread_ts === "string" ? normalizeSlackThreadTsCandidate(message.thread_ts) : void 0;
-		matches.push({
-			messageId,
-			partIndex,
-			partCount,
-			...threadTs ? { threadTs } : {}
-		});
-	}
-	return matches;
-}
 async function scanSlackConversationForDelivery(params) {
-	const threadTs = params.threadTs;
+	const lookupThreadTs = params.threadTs;
 	let cursor;
 	let expectedPartCount;
 	const deliveryParts = /* @__PURE__ */ new Map();
@@ -805,17 +751,36 @@ async function scanSlackConversationForDelivery(params) {
 			limit: SLACK_RECONCILE_LIMIT,
 			...cursor ? { cursor } : {}
 		};
-		const response = threadTs ? await withSlackDnsRequestRetry("conversations.replies", () => params.client.conversations.replies({
+		const response = lookupThreadTs ? await withSlackDnsRequestRetry("conversations.replies", () => params.client.conversations.replies({
 			...query,
-			ts: threadTs
+			ts: lookupThreadTs
 		})) : await withSlackDnsRequestRetry("conversations.history", () => params.client.conversations.history(query));
-		const matches = findSlackConversationDeliveryParts({
-			messages: asSlackConversationMessages(response),
-			queueId: params.queueId,
-			deliveryId: params.deliveryId,
-			channelId: params.channelId,
-			...threadTs ? { threadTs } : {}
-		});
+		const matches = [];
+		for (const message of asSlackConversationMessages(response)) {
+			const marker = asOptionalRecord(asOptionalRecord(message.metadata)?.event_payload);
+			if (!marker || marker[SLACK_DELIVERY_METADATA_KEY] !== params.deliveryId) continue;
+			const partIndex = marker[SLACK_DELIVERY_METADATA_PART_INDEX_KEY];
+			const partCount = marker[SLACK_DELIVERY_METADATA_PART_COUNT_KEY];
+			if (typeof partIndex !== "number" || !Number.isInteger(partIndex) || typeof partCount !== "number" || !Number.isInteger(partCount) || partIndex < 0 || partCount <= 0 || partIndex >= partCount) continue;
+			const expectedSignature = createSlackDeliveryMetadataSignature({
+				queueId: params.queueId,
+				channelId: params.channelId,
+				threadTs: lookupThreadTs,
+				partIndex,
+				partCount
+			});
+			const actualSignature = marker[SLACK_DELIVERY_METADATA_SIGNATURE_KEY];
+			if (typeof actualSignature !== "string" || !safeEqualSecret(actualSignature, expectedSignature)) continue;
+			const messageId = typeof message.ts === "string" ? normalizeSlackThreadTsCandidate(message.ts) : void 0;
+			if (!messageId) continue;
+			const threadTs = typeof message.thread_ts === "string" ? normalizeSlackThreadTsCandidate(message.thread_ts) : void 0;
+			matches.push({
+				messageId,
+				partIndex,
+				partCount,
+				...threadTs ? { threadTs } : {}
+			});
+		}
 		for (const match of matches) {
 			expectedPartCount ??= match.partCount;
 			const existing = deliveryParts.get(match.partIndex);
@@ -921,209 +886,207 @@ async function reconcileSlackUnknownSend(ctx) {
 		return unresolvedSlackDelivery(readSlackRequestErrorMessage(enrichSlackWebApiError(err)), ctx.retryCount < 3);
 	}
 }
-async function sendMessageSlack(to, message, opts) {
+async function sendMessageSlack(to, message, options) {
 	const normalizedMessage = normalizeOptionalString(message) ?? "";
-	const trimmedMessage = opts.textIsSlackPlainText && normalizedMessage ? message : normalizedMessage;
-	const cfg = requireRuntimeConfig(opts.cfg, "Slack send");
+	const trimmedMessage = options.textIsSlackPlainText && normalizedMessage ? message : normalizedMessage;
+	const cfg = requireRuntimeConfig(options.cfg, "Slack send");
 	const account = resolveSlackAccount({
 		cfg,
-		accountId: opts.accountId
+		accountId: options.accountId
 	});
-	const eventScope = opts.eventScope;
+	const eventScope = options.eventScope;
 	if (eventScope && (!/^T[A-Z0-9]+$/i.test(eventScope.teamId) || !eventScope.client)) throw new Error("invalid_enterprise_slack_listener_scope");
-	const recipient = eventScope ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
-	if (!eventScope) assertSlackDetachedTargetAllowed(account.accountId, recipient.teamId);
-	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
-	if (!normalizedMessage && !opts.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
-	const queuedOpts = Object.freeze({ ...opts });
+	const parsedRecipient = eventScope ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
+	const blocks = options.blocks == null ? void 0 : validateSlackBlocksArray(options.blocks);
+	if (!normalizedMessage && !options.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
+	const opts = { ...options };
 	const delivery = resolveSlackDelivery({
 		account,
 		eventScope,
-		opts: queuedOpts,
-		recipient
+		opts,
+		recipient: parsedRecipient
 	});
 	const workspaceScope = delivery.teamId ? `:${delivery.teamId}` : "";
-	const queueKey = `${account.accountId}:${createSlackTokenCacheKey(delivery.credential)}${workspaceScope}:${delivery.recipient.kind}:${delivery.recipient.id}:${opts.threadTs ?? ""}`;
-	const result = await slackSendQueue.enqueue(queueKey, () => sendMessageSlackQueued({
-		trimmedMessage,
-		opts: queuedOpts,
-		cfg,
-		account,
-		blocks,
-		delivery
-	}).catch((err) => {
-		throw enrichSlackWebApiError(err);
-	}));
-	const threadTs = result.threadTs ?? normalizeSlackThreadTsCandidate(queuedOpts.threadTs);
-	if (threadTs && result.channelId && account.accountId) recordSlackThreadParticipation(account.accountId, result.channelId, threadTs, { teamId: delivery.teamId });
-	return result;
-}
-async function sendMessageSlackQueued(params) {
-	const { opts, cfg, account, blocks, trimmedMessage, delivery } = params;
-	const { client, identity, recipient, unfurl } = delivery;
-	if (opts.replyBroadcast && opts.mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-	const directUserPostChannelId = !opts.deliveryQueueId && recipient.kind === "user" && !opts.mediaUrl && !opts.threadTs ? recipient.id : void 0;
-	const channelId = directUserPostChannelId ? directUserPostChannelId : await resolveChannelId(client, recipient, {
-		accountId: account.accountId,
-		token: delivery.credential,
-		...delivery.dmCacheOwner ? { dmCacheOwner: delivery.dmCacheOwner } : {}
-	});
-	const deliveredResults = [];
-	const reportDelivery = async (result, deliveredBlocks) => {
-		const slackQuestionActionIds = resolveSlackQuestionActionIds(deliveredBlocks);
-		const deliveryResult = slackQuestionActionIds.length ? {
-			...result,
-			meta: {
-				...result.meta,
-				slackQuestionActionIds,
-				[SLACK_QUESTION_FINALIZATION_BLOCKS]: deliveredBlocks.filter((block) => block.type !== "actions")
-			}
-		} : result;
-		deliveredResults.push(deliveryResult);
-		await opts.onDeliveryResult?.(deliveryResult);
-		return deliveryResult;
-	};
-	let didDispatch = false;
-	const dispatchOnce = async () => {
-		if (didDispatch) return;
-		didDispatch = true;
-		await opts.onPlatformSendDispatch?.();
-	};
-	const explicitNativeDataFallbackBase = Object.hasOwn(opts, "nativeDataFallbackBaseText") ? opts.nativeDataFallbackBaseText?.trim() ?? "" : void 0;
-	const authoredTextPlacement = opts.authoredTextPlacement ?? "outside-blocks";
-	const nativeDataFallbackBase = blocks && authoredTextPlacement === "outside-blocks" ? explicitNativeDataFallbackBase ?? trimmedMessage : "";
-	const hasNativeData = Boolean(blocks && hasSlackNativeDataBlock(blocks));
-	const textChunkLimit = Math.min(opts.textLimit ?? resolveTextChunkLimit(cfg, "slack", account.accountId, { fallbackLimit: 8e3 }), SLACK_TEXT_LIMIT);
-	const usesOrderedBlockAccessibility = Boolean(blocks && (hasNativeData || opts.authoredTextPlacement !== void 0));
-	const orderedBlockDeliveryPlan = blocks && usesOrderedBlockAccessibility ? buildSlackNativeDataDeliveryPlan({
-		baseText: nativeDataFallbackBase,
-		blocks,
-		textLimit: textChunkLimit
-	}) : void 0;
-	const completeBlockFallbackText = blocks ? buildSlackCompleteBlocksFallbackText(blocks) : "";
-	const rawBlockAccessibilityText = trimmedMessage ? [trimmedMessage, ...completeBlockFallbackText.includes(trimmedMessage) ? [] : [completeBlockFallbackText]].join("\n\n") : completeBlockFallbackText;
-	const blockAccessibilityText = blocks ? orderedBlockDeliveryPlan?.accessibilityText ?? rawBlockAccessibilityText : void 0;
-	let pendingBlockFallback = orderedBlockDeliveryPlan?.skipOriginalBlocks ? orderedBlockDeliveryPlan : void 0;
-	let lastMessageId = "";
-	let deliveredChannelId = channelId;
-	let canonicalDeliveredThreadTs;
-	let sendIdentity = identity;
-	const postPart = async (part) => {
-		const posted = await postSlackMessageBestEffort({
-			client,
-			channelId,
-			threadTs: opts.threadTs,
-			identity: sendIdentity,
-			unfurl,
-			...part
-		});
-		const { response } = posted;
-		sendIdentity = posted.identity;
-		lastMessageId = response.ts;
-		deliveredChannelId = (typeof response.channel === "string" ? normalizeOptionalString(response.channel) : null) ?? deliveredChannelId;
-		const responseThreadTs = resolvePostedMessageThreadTs(response);
-		canonicalDeliveredThreadTs ??= responseThreadTs;
-		return await reportDelivery(createSlackSendResult(response.ts, deliveredChannelId, part.blocks ? "card" : "text", responseThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs)), part.blocks);
-	};
-	if (blocks && opts.mediaUrl) throw new Error("Slack send does not support blocks with mediaUrl");
-	if (blocks) {
-		if (pendingBlockFallback) logVerbose("slack send: native data accessibility exceeds hard limit, using text fallback");
-		else {
-			const accessibilityText = usesOrderedBlockAccessibility ? blockAccessibilityText ?? "Slack could not render this Block Kit message." : truncateSlackText(blockAccessibilityText ?? "", SLACK_TEXT_LIMIT);
-			const initialBlockMetadata = withSlackDeliveryMetadata(opts.metadata, {
-				queueId: opts.deliveryQueueId,
-				channelId,
-				threadTs: opts.threadTs,
-				partIndex: 0,
-				partCount: 1
+	const queueKey = `${account.accountId}:${createSlackTokenCacheKey(delivery.credential)}${workspaceScope}:${delivery.recipient.kind}:${delivery.recipient.id}:${options.threadTs ?? ""}`;
+	const sent = await slackSendQueue.enqueue(queueKey, async () => {
+		try {
+			const { client, identity, recipient, unfurl } = delivery;
+			if (opts.replyBroadcast && opts.mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
+			const directUserPostChannelId = !opts.deliveryQueueId && recipient.kind === "user" && !opts.mediaUrl && !opts.threadTs ? recipient.id : void 0;
+			const channelId = directUserPostChannelId ? directUserPostChannelId : await resolveChannelId(client, recipient, {
+				accountId: account.accountId,
+				token: delivery.credential,
+				...delivery.dmCacheOwner ? { dmCacheOwner: delivery.dmCacheOwner } : {}
 			});
-			await dispatchOnce();
-			try {
-				return await postPart({
-					text: accessibilityText,
-					replyBroadcast: opts.replyBroadcast,
-					blocks,
-					metadata: initialBlockMetadata,
-					...usesOrderedBlockAccessibility ? { mrkdwn: false } : {}
+			const deliveredResults = [];
+			const reportDelivery = async (result, deliveredBlocks) => {
+				const slackQuestionActionIds = resolveSlackQuestionActionIds(deliveredBlocks);
+				const deliveryResult = slackQuestionActionIds.length ? {
+					...result,
+					meta: {
+						...result.meta,
+						slackQuestionActionIds,
+						[SLACK_QUESTION_FINALIZATION_BLOCKS]: deliveredBlocks
+					}
+				} : result;
+				deliveredResults.push(deliveryResult);
+				await opts.onDeliveryResult?.(deliveryResult);
+				return deliveryResult;
+			};
+			let didDispatch = false;
+			const dispatchOnce = async () => {
+				if (didDispatch) return;
+				didDispatch = true;
+				await opts.onPlatformSendDispatch?.();
+			};
+			const explicitNativeDataFallbackBase = Object.hasOwn(opts, "nativeDataFallbackBaseText") ? opts.nativeDataFallbackBaseText?.trim() ?? "" : void 0;
+			const authoredTextPlacement = opts.authoredTextPlacement ?? "outside-blocks";
+			const nativeDataFallbackBase = blocks && authoredTextPlacement === "outside-blocks" ? explicitNativeDataFallbackBase ?? trimmedMessage : "";
+			const hasNativeData = Boolean(blocks && hasSlackNativeDataBlock(blocks));
+			const textChunkLimit = Math.min(opts.textLimit ?? resolveTextChunkLimit(cfg, "slack", account.accountId, { fallbackLimit: 8e3 }), SLACK_TEXT_LIMIT);
+			const usesOrderedBlockAccessibility = Boolean(blocks && (hasNativeData || opts.authoredTextPlacement !== void 0));
+			const orderedBlockDeliveryPlan = blocks && usesOrderedBlockAccessibility ? buildSlackNativeDataDeliveryPlan({
+				baseText: nativeDataFallbackBase,
+				blocks,
+				textLimit: textChunkLimit
+			}) : void 0;
+			let pendingBlockFallback = orderedBlockDeliveryPlan?.skipOriginalBlocks ? orderedBlockDeliveryPlan : void 0;
+			let lastMessageId = "";
+			let deliveredChannelId = channelId;
+			let canonicalDeliveredThreadTs;
+			let sendIdentity = identity;
+			const postPart = async (part) => {
+				const posted = await postSlackMessageBestEffort({
+					client,
+					channelId,
+					threadTs: opts.threadTs,
+					identity: sendIdentity,
+					unfurl,
+					...part
+				});
+				const { response } = posted;
+				sendIdentity = posted.identity;
+				lastMessageId = response.ts;
+				deliveredChannelId = (typeof response.channel === "string" ? normalizeOptionalString(response.channel) : null) ?? deliveredChannelId;
+				const responseThreadTs = resolvePostedMessageThreadTs(response);
+				canonicalDeliveredThreadTs ??= responseThreadTs;
+				return await reportDelivery(createSlackSendResult(response.ts, deliveredChannelId, part.blocks ? "card" : "text", responseThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs)), part.blocks);
+			};
+			if (blocks && opts.mediaUrl) throw new Error("Slack send does not support blocks with mediaUrl");
+			if (blocks) {
+				if (pendingBlockFallback) logVerbose("slack send: native data accessibility exceeds hard limit, using text fallback");
+				else {
+					let accessibilityText = orderedBlockDeliveryPlan?.accessibilityText;
+					if (accessibilityText === void 0) {
+						const fallback = buildSlackCompleteBlocksFallbackText(blocks);
+						accessibilityText = truncateSlackText(trimmedMessage ? [trimmedMessage, ...fallback.includes(trimmedMessage) ? [] : [fallback]].join("\n\n") : fallback, SLACK_TEXT_LIMIT);
+					}
+					const initialBlockMetadata = withSlackDeliveryMetadata(opts.metadata, {
+						queueId: opts.deliveryQueueId,
+						channelId,
+						threadTs: opts.threadTs,
+						partIndex: 0,
+						partCount: 1
+					});
+					await dispatchOnce();
+					try {
+						return await postPart({
+							text: accessibilityText,
+							replyBroadcast: opts.replyBroadcast,
+							blocks,
+							metadata: initialBlockMetadata,
+							...usesOrderedBlockAccessibility ? { mrkdwn: false } : {}
+						});
+					} catch (error) {
+						if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
+						logVerbose("slack send: native data rejected, delivering complete text fallback");
+						pendingBlockFallback = orderedBlockDeliveryPlan;
+					}
+				}
+			}
+			let messages;
+			if (pendingBlockFallback) messages = pendingBlockFallback.fallbackMessages;
+			else {
+				let resolvedChunks;
+				if (opts.textIsSlackPlainText) resolvedChunks = trimmedMessage ? chunkTextForOutbound(trimmedMessage, textChunkLimit, { preserveWhitespace: true }) : [];
+				else if (opts.textIsSlackMrkdwn) resolvedChunks = resolveTextChunksWithFallback(trimmedMessage, chunkSlackMrkdwnText(trimmedMessage, textChunkLimit));
+				else {
+					const tableMode = resolveMarkdownTableMode({
+						cfg,
+						channel: "slack",
+						...account.accountId ? { accountId: account.accountId } : {}
+					});
+					const chunkMode = resolveChunkMode(cfg, "slack", account.accountId);
+					const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(trimmedMessage, textChunkLimit, chunkMode) : [trimmedMessage]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, textChunkLimit, { tableMode }));
+					resolvedChunks = resolveTextChunksWithFallback(trimmedMessage, chunks);
+				}
+				const mediaMaxBytes = opts.mediaMaxBytes ?? (typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : void 0);
+				let chunksToPost;
+				if (opts.mediaUrl) {
+					const [firstChunk, ...rest] = resolvedChunks;
+					lastMessageId = await uploadSlackFile({
+						client: delivery.upload?.client ?? client,
+						completionClient: client,
+						channelId,
+						mediaUrl: opts.mediaUrl,
+						mediaAccess: opts.mediaAccess,
+						uploadFileName: opts.uploadFileName,
+						uploadTitle: opts.uploadTitle,
+						mediaLocalRoots: opts.mediaLocalRoots,
+						mediaReadFile: opts.mediaReadFile,
+						caption: firstChunk,
+						threadTs: opts.threadTs,
+						maxBytes: mediaMaxBytes,
+						...opts.forceDocument ? { optimizeImages: false } : {},
+						onPlatformSendDispatch: dispatchOnce,
+						assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff,
+						...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
+					});
+					await reportDelivery(createSlackSendResult(lastMessageId, channelId, "media", normalizeSlackThreadTsCandidate(opts.threadTs)));
+					chunksToPost = rest;
+				} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
+				messages = chunksToPost.map((text) => opts.textIsSlackPlainText ? {
+					text,
+					mrkdwn: false
+				} : { text });
+			}
+			let questionDelivery;
+			for (const [partIndex, part] of messages.entries()) {
+				const carriesPrimaryMessageOptions = partIndex === 0 && !opts.mediaUrl;
+				const baseMetadata = carriesPrimaryMessageOptions ? opts.metadata : void 0;
+				const metadata = opts.mediaUrl ? baseMetadata : withSlackDeliveryMetadata(baseMetadata, {
+					queueId: opts.deliveryQueueId,
+					channelId,
+					threadTs: opts.threadTs,
+					partIndex,
+					partCount: messages.length
 				});
-			} catch (error) {
-				if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
-				logVerbose("slack send: native data rejected, delivering complete text fallback");
-				pendingBlockFallback = orderedBlockDeliveryPlan;
+				if (partIndex === 0 && !opts.mediaUrl) await dispatchOnce();
+				const partDelivery = await postPart({
+					...part,
+					replyBroadcast: carriesPrimaryMessageOptions ? opts.replyBroadcast : void 0,
+					metadata
+				});
+				if (pendingBlockFallback && partDelivery.meta?.slackQuestionActionIds.length) questionDelivery = partDelivery;
 			}
+			const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+			return {
+				messageId: lastMessageId,
+				channelId: deliveredChannelId,
+				threadTs: deliveredThreadTs,
+				...questionDelivery?.meta ? { meta: {
+					...questionDelivery.meta,
+					slackQuestionMessageId: questionDelivery.messageId
+				} } : {},
+				receipt: createSlackSendReceiptFromResults(deliveredResults, deliveredThreadTs)
+			};
+		} catch (err) {
+			throw enrichSlackWebApiError(err);
 		}
-	}
-	let messages;
-	if (pendingBlockFallback) messages = pendingBlockFallback.fallbackMessages;
-	else {
-		const resolvedChunks = resolveSlackTextChunks({
-			cfg,
-			accountId: account.accountId,
-			text: trimmedMessage,
-			chunkLimit: textChunkLimit,
-			...opts.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
-			...opts.textIsSlackPlainText ? { preservePlainText: true } : {}
-		});
-		const mediaMaxBytes = opts.mediaMaxBytes ?? (typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : void 0);
-		let chunksToPost;
-		if (opts.mediaUrl) {
-			const [firstChunk, ...rest] = resolvedChunks;
-			lastMessageId = await uploadSlackFile({
-				client: delivery.upload?.client ?? client,
-				completionClient: client,
-				channelId,
-				mediaUrl: opts.mediaUrl,
-				mediaAccess: opts.mediaAccess,
-				uploadFileName: opts.uploadFileName,
-				uploadTitle: opts.uploadTitle,
-				mediaLocalRoots: opts.mediaLocalRoots,
-				mediaReadFile: opts.mediaReadFile,
-				caption: firstChunk,
-				threadTs: opts.threadTs,
-				maxBytes: mediaMaxBytes,
-				...opts.forceDocument ? { optimizeImages: false } : {},
-				onPlatformSendDispatch: dispatchOnce,
-				assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff,
-				...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
-			});
-			await reportDelivery(createSlackSendResult(lastMessageId, channelId, "media", normalizeSlackThreadTsCandidate(opts.threadTs)));
-			chunksToPost = rest;
-		} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
-		messages = chunksToPost.map((text) => opts.textIsSlackPlainText ? {
-			text,
-			mrkdwn: false
-		} : { text });
-	}
-	let questionDelivery;
-	for (const [partIndex, part] of messages.entries()) {
-		const carriesPrimaryMessageOptions = partIndex === 0 && !opts.mediaUrl;
-		const baseMetadata = carriesPrimaryMessageOptions ? opts.metadata : void 0;
-		const metadata = opts.mediaUrl ? baseMetadata : withSlackDeliveryMetadata(baseMetadata, {
-			queueId: opts.deliveryQueueId,
-			channelId,
-			threadTs: opts.threadTs,
-			partIndex,
-			partCount: messages.length
-		});
-		if (partIndex === 0 && !opts.mediaUrl) await dispatchOnce();
-		const partDelivery = await postPart({
-			...part,
-			replyBroadcast: carriesPrimaryMessageOptions ? opts.replyBroadcast : void 0,
-			metadata
-		});
-		if (pendingBlockFallback && partDelivery.meta?.slackQuestionActionIds.length) questionDelivery = partDelivery;
-	}
-	const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-	return {
-		messageId: lastMessageId,
-		channelId: deliveredChannelId,
-		threadTs: deliveredThreadTs,
-		...questionDelivery?.meta ? { meta: {
-			...questionDelivery.meta,
-			slackQuestionMessageId: questionDelivery.messageId
-		} } : {},
-		receipt: createSlackSendReceiptFromResults(deliveredResults, deliveredThreadTs)
-	};
+	});
+	const threadTs = sent.threadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+	if (threadTs && sent.channelId && account.accountId) recordSlackThreadParticipation(account.accountId, sent.channelId, threadTs, { teamId: delivery.teamId });
+	return sent;
 }
 //#endregion
-export { clearSlackThreadParticipationCache as a, hasSlackThreadParticipationWithPersistence as c, requireSlackPostMessageTimestamp as d, buildSlackMessageIdentityPayload as f, chunkSlackTextAtHardLimit as h, clearSlackThreadFailureNotice as i, recordSlackThreadFailureNotice as l, buildSlackNativeDataDeliveryPlan as m, send_exports as n, hasSlackThreadFailureNotice as o, hasSlackMessageIdentity as p, setSlackDefaultSendIdentity as r, hasSlackThreadParticipation as s, sendMessageSlack as t, recordSlackThreadParticipation as u };
+export { clearSlackThreadFailureNotice as a, hasSlackThreadParticipation as c, recordSlackThreadParticipation as d, requireSlackPostMessageTimestamp as f, chunkSlackTextAtHardLimit as g, buildSlackNativeDataDeliveryPlan as h, updateMessageSlack as i, hasSlackThreadParticipationWithPersistence as l, hasSlackMessageIdentity as m, send_exports as n, clearSlackThreadParticipationCache as o, buildSlackMessageIdentityPayload as p, setSlackDefaultSendIdentity as r, hasSlackThreadFailureNotice as s, sendMessageSlack as t, recordSlackThreadFailureNotice as u };