@openclaw/slack 2026.9.5 → 2026.9.7

package/dist/.setup/{actions-BvGUGk3w.mjs → actions-Df0CzcDl.mjs}

@@ -1,12 +1,12 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as resolveSlackAccount, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId } from "./accounts-C1FspRF-.mjs";
-import { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, M as truncateSlackTextByUtf8Bytes, Mt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, S as stripSlackNativeDataBlocks, T as renderSlackBlockFallbackText, Y as normalizeSlackOutboundText, f as assertSlackDetachedTargetAllowed, h as appendSlackNativeDataPlainTextFallback, lt as validateSlackBlocksArray, m as appendSlackNativeDataFallbackText, ot as escapeSlackMrkdwn, v as hasSlackNativeDataBlock, w as buildSlackCompleteBlocksFallbackText, y as isSlackInvalidBlocksError } from "./session-status-BhG6pdiH.mjs";
-import { n as formatSlackTarget } from "./target-parsing-DEsPjngB.mjs";
-import { g as getSlackWriteClient, l as createSlackLookupClient, m as createSlackWriteClient } from "./probe-64C6k3_Q.mjs";
-import { m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-6GCb3lBP.mjs";
+import { r as __exportAll } from "./streaming-compat-C5Wut626.mjs";
+import { h as resolveSlackBotToken, o as resolveDefaultSlackAccountId, s as resolveSlackAccount } from "./accounts-D_N9IqNA.mjs";
+import { n as formatSlackTarget } from "./target-parsing-FFE26kOV.mjs";
+import { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, M as truncateSlackTextByUtf8Bytes, Q as normalizeSlackOutboundText, S as stripSlackNativeDataBlocks, T as renderSlackBlockFallbackText, Ut as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, f as assertSlackDetachedTargetAllowed, h as appendSlackNativeDataPlainTextFallback, lt as escapeSlackMrkdwn, m as appendSlackNativeDataFallbackText, v as hasSlackNativeDataBlock, vt as validateSlackBlocksArray, w as buildSlackCompleteBlocksFallbackText, y as isSlackInvalidBlocksError } from "./session-status-DscajIsd.mjs";
+import { _ as getSlackWriteClient, h as createSlackWriteClient, u as createSlackLookupClient } from "./probe-B2Y9qc_z.mjs";
+import { p as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-BOVLQi3n.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createSubsystemLogger, logVerbose, logVerbose as logVerbose$1 } from "openclaw/plugin-sdk/runtime-env";
+import { asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { captureChannelReadAuthority as captureChannelReadAuthority$1 } from "openclaw/plugin-sdk/fetch-runtime";
 import { fetchWithRuntimeDispatcher as fetchWithRuntimeDispatcher$1 } from "openclaw/plugin-sdk/runtime-fetch";
@@ -15,7 +15,7 @@ import { z } from "zod";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import fs from "node:fs/promises";
 import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeHostname } from "openclaw/plugin-sdk/host-runtime";
 import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
 import { saveRemoteMedia, unlinkIfExists } from "openclaw/plugin-sdk/media-runtime";
@@ -57,11 +57,8 @@ function buildSlackEditTextPayload(content, blocks) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/block-text.ts
-function readSlackBlockType(block) {
-	return block && typeof block === "object" && !Array.isArray(block) ? block.type : void 0;
-}
 function hasSlackTableBlock(blocks) {
-	return blocks?.some((block) => readSlackBlockType(block) === "table") ?? false;
+	return blocks?.some((block) => asOptionalRecord(block)?.type === "table") ?? false;
 }
 function hasSlackMessageTableBlock(message) {
 	return hasSlackTableBlock(message.blocks) || message.attachments?.some((attachment) => !isSlackUnfurlAttachment(attachment) && hasSlackTableBlock(attachment.blocks)) === true;
@@ -75,7 +72,7 @@ function resolveSlackBlocksText(blocks) {
 	let hasRichText = false;
 	let hasNativeData = false;
 	for (const block of blocks) {
-		const blockType = readSlackBlockType(block);
+		const blockType = asOptionalRecord(block)?.type;
 		hasRichText ||= blockType === "rich_text";
 		hasNativeData ||= blockType === "data_visualization" || blockType === "data_table" || blockType === "table";
 		const text = renderSlackBlockFallbackText(block, {
@@ -103,7 +100,7 @@ function resolveSlackAttachmentTableTexts(attachments) {
 	for (const attachment of attachments ?? []) {
 		if (isSlackUnfurlAttachment(attachment)) continue;
 		for (const block of attachment.blocks ?? []) {
-			if (readSlackBlockType(block) !== "table") continue;
+			if (asOptionalRecord(block)?.type !== "table") continue;
 			const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
 			if (!text || seen.has(text)) continue;
 			seen.add(text);
@@ -115,7 +112,7 @@ function resolveSlackAttachmentTableTexts(attachments) {
 /** Resolve agent-visible Slack text while admitting only native tables from attachments. */
 function resolveSlackMessageText(message, options = {}) {
 	let resolved = chooseSlackPrimaryText({
-		messageText: options.preserveMessageTextWhitespace ? typeof message.text === "string" && message.text.trim().length > 0 ? message.text : void 0 : normalizeOptionalString(message.text),
+		messageText: options.preserveMessageTextWhitespace ? readNonBlankString(message.text) : normalizeOptionalString(message.text),
 		blocksText: resolveSlackBlocksText(message.blocks)
 	});
 	for (const tableText of resolveSlackAttachmentTableTexts(message.attachments)) resolved = appendDistinctSlackText(resolved, tableText);
@@ -195,13 +192,14 @@ function assertSlackFileUrl(rawUrl, govSlack) {
 	if (!isSlackHostname(parsed.hostname, govSlack)) throw new Error(`Refusing to send Slack token to non-Slack host "${parsed.hostname}" (url: ${rawUrl})`);
 	return parsed;
 }
-function createSlackAuthHeaders(token) {
-	return { Authorization: `Bearer ${token}` };
-}
-function createSlackMediaRequest(url, token, govSlack) {
-	return {
-		url: assertSlackFileUrl(url, govSlack).href,
-		requestInit: { headers: createSlackAuthHeaders(token) }
+function captureSlackMediaReadGuard(params) {
+	const inherited = captureChannelReadAuthority$1();
+	const { assertCurrent, abortSignal } = params;
+	if (!assertCurrent && !abortSignal) return inherited;
+	return () => {
+		inherited?.();
+		abortSignal?.throwIfAborted();
+		assertCurrent?.();
 	};
 }
 function createSlackMediaFetch(govSlack, assertReadAuthority = captureChannelReadAuthority$1()) {
@@ -237,34 +235,41 @@ const SLACK_GOV_MEDIA_SSRF_POLICY = {
 const SLACK_MEDIA_READ_IDLE_TIMEOUT_MS = 6e4;
 const SLACK_MEDIA_TOTAL_TIMEOUT_MS = 12e4;
 async function saveSlackMedia(params) {
-	const timeoutAbortController = params.totalTimeoutMs ? new AbortController() : void 0;
-	const abortSignals = [
-		params.abortSignal,
-		params.options.requestInit?.signal ?? void 0,
-		timeoutAbortController?.signal
-	].filter((signal) => Boolean(signal));
+	const url = assertSlackFileUrl(params.url, params.govSlack).href;
+	const totalTimeoutMs = params.totalTimeoutMs ?? SLACK_MEDIA_TOTAL_TIMEOUT_MS;
+	const timeoutAbortController = totalTimeoutMs ? new AbortController() : void 0;
+	const abortSignals = [params.abortSignal, timeoutAbortController?.signal].filter((signal) => Boolean(signal));
 	const signal = abortSignals.length > 1 ? AbortSignal.any(abortSignals) : abortSignals[0];
 	let timedOut = false;
 	let timeoutHandle = null;
 	const savePromise = saveRemoteMedia({
-		...params.options,
-		readIdleTimeoutMs: params.readIdleTimeoutMs ?? 6e4,
-		...signal ? { requestInit: {
-			...params.options.requestInit,
-			signal
-		} } : {}
+		url,
+		fetchImpl: createSlackMediaFetch(params.govSlack, params.assertReadAuthority),
+		beforeRequest: params.assertReadAuthority,
+		assertCurrent: params.assertCurrent,
+		requestInit: {
+			headers: { Authorization: `Bearer ${params.token}` },
+			...signal ? { signal } : {}
+		},
+		...params.file ? {
+			filePathHint: params.file.name,
+			fallbackContentType: resolveSlackMediaMimetype(params.file)
+		} : {},
+		maxBytes: params.maxBytes,
+		ssrfPolicy: params.govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY,
+		readIdleTimeoutMs: params.readIdleTimeoutMs ?? 6e4
 	}).catch((error) => {
 		if (timedOut) return new Promise(() => {});
 		throw error;
 	});
 	try {
-		if (!params.totalTimeoutMs) return await savePromise;
+		if (!totalTimeoutMs) return await savePromise;
 		const timeoutPromise = new Promise((_, reject) => {
 			timeoutHandle = setTimeout(() => {
 				timedOut = true;
 				timeoutAbortController?.abort();
-				reject(/* @__PURE__ */ new Error(`slack media download timed out after ${params.totalTimeoutMs}ms`));
-			}, params.totalTimeoutMs);
+				reject(/* @__PURE__ */ new Error(`slack media download timed out after ${totalTimeoutMs}ms`));
+			}, totalTimeoutMs);
 			timeoutHandle.unref?.();
 		});
 		return await Promise.race([savePromise, timeoutPromise]);
@@ -306,42 +311,35 @@ function formatSlackMediaFailure(error) {
 }
 async function fetchFreshSlackFileUrl(params) {
 	if (!params.file.id || !params.client) return null;
+	const assertCurrent = captureSlackMediaReadGuard(params);
 	try {
-		const freshFile = (await params.client.files.info({ file: params.file.id })).file;
+		assertCurrent?.();
+		const info = await params.client.files.info({ file: params.file.id });
+		assertCurrent?.();
+		const freshFile = info.file;
 		if (freshFile && params.isRefreshedFileAllowed?.(freshFile) === false) {
-			logVerbose$1(`slack: refreshed file metadata rejected for file id=${params.file.id}`);
+			logVerbose(`slack: refreshed file metadata rejected for file id=${params.file.id}`);
 			return null;
 		}
 		const freshUrl = freshFile?.url_private_download ?? freshFile?.url_private;
 		if (freshUrl) {
-			logVerbose$1(`slack: refreshed file URL via files.info for file id=${params.file.id}`);
+			logVerbose(`slack: refreshed file URL via files.info for file id=${params.file.id}`);
 			return freshUrl;
 		}
-		logVerbose$1(`slack: files.info returned no private URL for file id=${params.file.id}`);
+		logVerbose(`slack: files.info returned no private URL for file id=${params.file.id}`);
 		return null;
 	} catch (error) {
-		logVerbose$1(`slack: files.info failed for file id=${params.file.id}: ${formatErrorMessage(error)}`);
+		assertCurrent?.();
+		logVerbose(`slack: files.info failed for file id=${params.file.id}: ${formatErrorMessage(error)}`);
 		return null;
 	}
 }
 async function downloadSlackMediaFile(params) {
-	const assertReadAuthority = captureChannelReadAuthority$1();
+	const assertReadAuthority = captureSlackMediaReadGuard(params);
 	assertReadAuthority?.();
-	const { url: slackUrl, requestInit } = createSlackMediaRequest(params.url, params.token, params.govSlack);
 	const saved = await saveSlackMedia({
-		options: {
-			url: slackUrl,
-			fetchImpl: createSlackMediaFetch(params.govSlack, assertReadAuthority),
-			beforeRequest: assertReadAuthority,
-			requestInit,
-			filePathHint: params.file.name,
-			fallbackContentType: resolveSlackMediaMimetype(params.file, params.file.mimetype),
-			maxBytes: params.maxBytes,
-			ssrfPolicy: params.govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY
-		},
-		readIdleTimeoutMs: params.readIdleTimeoutMs,
-		totalTimeoutMs: params.totalTimeoutMs ?? SLACK_MEDIA_TOTAL_TIMEOUT_MS,
-		abortSignal: params.abortSignal
+		...params,
+		assertReadAuthority
 	});
 	const fileMime = normalizeOptionalLowercaseString(params.file.mimetype);
 	const fileName = normalizeLowercaseStringOrEmpty(params.file.name);
@@ -351,9 +349,8 @@ async function downloadSlackMediaFile(params) {
 			throw new Error("blocked: unexpected HTML content");
 		}
 	}
-	const effectiveMime = resolveSlackMediaMimetype(params.file, saved.contentType);
+	const contentType = resolveSlackMediaMimetype(params.file, saved.contentType);
 	const label = saved.fileName ?? params.file.name;
-	const contentType = effectiveMime ?? saved.contentType;
 	return {
 		path: saved.path,
 		...contentType ? { contentType } : {},
@@ -364,16 +361,11 @@ async function downloadSlackMediaFile(params) {
 		})}]`
 	};
 }
-function isForwardedSlackAttachment(attachment) {
-	return attachment.is_share === true;
-}
 function resolveForwardedAttachmentImageUrl(attachment, govSlack) {
 	const rawUrl = attachment.image_url?.trim();
 	if (!rawUrl) return null;
 	try {
-		const parsed = new URL(rawUrl);
-		if (parsed.protocol !== "https:" || !isSlackHostname(parsed.hostname, govSlack)) return null;
-		return parsed.toString();
+		return assertSlackFileUrl(rawUrl, govSlack).href;
 	} catch {
 		return null;
 	}
@@ -383,6 +375,7 @@ function resolveForwardedAttachmentImageUrl(attachment, govSlack) {
 * Returns `null` when no files could be downloaded.
 */
 async function resolveSlackMedia(params) {
+	const assertCurrent = captureSlackMediaReadGuard(params);
 	const govSlack = isGovSlackClient(params.client);
 	const files = params.files ?? [];
 	const limitedFiles = files.length > 8 ? files.slice(0, 8) : files;
@@ -390,10 +383,13 @@ async function resolveSlackMedia(params) {
 	const refreshFileUrl = (file) => fetchFreshSlackFileUrl({
 		file,
 		client: params.client,
-		isRefreshedFileAllowed: params.isRefreshedFileAllowed
+		isRefreshedFileAllowed: params.isRefreshedFileAllowed,
+		assertCurrent: params.assertCurrent,
+		abortSignal: params.abortSignal
 	});
-	const { results } = await runTasksWithConcurrency({
+	const { results, hasError, firstError } = await runTasksWithConcurrency({
 		tasks: limitedFiles.map((file) => async () => {
+			assertCurrent?.();
 			const preloaded = params.preloadedMedia?.get(file);
 			if (preloaded) return preloaded;
 			const eventUrl = file.url_private_download ?? file.url_private;
@@ -410,6 +406,7 @@ async function resolveSlackMedia(params) {
 				} catch (error) {
 					reason = formatSlackMediaFailure(error);
 				}
+				assertCurrent?.();
 				url = attempt === 0 && eventUrl ? await refreshFileUrl(file) : null;
 			}
 			params.unavailableFiles?.set(file, reason);
@@ -417,15 +414,15 @@ async function resolveSlackMedia(params) {
 			return null;
 		}),
 		limit: MAX_SLACK_MEDIA_CONCURRENCY,
-		errorMode: "stop",
-		throwOnError: true
+		errorMode: "stop"
 	});
+	if (hasError) throw toErrorObject(firstError, "Slack media read failed");
 	const resolved = results.filter((result) => result !== null);
 	return resolved.length > 0 ? resolved : null;
 }
 /** Extracts text and media from forwarded-message attachments. Returns null when empty. */
 async function resolveSlackAttachmentContent(params) {
-	const forwardedAttachments = (params.attachments ?? []).filter((attachment) => isForwardedSlackAttachment(attachment)).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
+	const forwardedAttachments = (params.attachments ?? []).filter((attachment) => attachment.is_share === true).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
 	const candidates = [...params.files ?? [], ...forwardedAttachments.flatMap((attachment) => attachment.files ?? [])];
 	if (forwardedAttachments.length === 0 && candidates.length === 0) return null;
 	const fileIds = /* @__PURE__ */ new Set();
@@ -456,47 +453,48 @@ async function resolveSlackAttachmentContent(params) {
 			return selected ? [selected] : [];
 		})
 	});
-	const directMediaPromise = resolveFiles(params.files);
 	const textBlocks = [];
-	const attachmentMedia = [];
 	let unavailableMediaCount = 0;
 	const govSlack = isGovSlackClient(params.client);
-	for (const att of forwardedAttachments) {
-		const text = att.text?.trim() || att.fallback?.trim();
-		if (text) {
-			const author = att.author_name;
-			const heading = author ? `[Forwarded message from ${author}]` : "[Forwarded message]";
-			textBlocks.push(`${heading}\n${text}`);
-		}
-		const imageUrl = resolveForwardedAttachmentImageUrl(att, govSlack);
-		if (imageUrl) try {
-			const { url: slackUrl, requestInit } = createSlackMediaRequest(imageUrl, params.token, govSlack);
-			const saved = await saveSlackMedia({
-				options: {
-					url: slackUrl,
-					fetchImpl: createSlackMediaFetch(govSlack),
-					requestInit,
-					maxBytes: params.maxBytes,
-					ssrfPolicy: govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY
-				},
-				readIdleTimeoutMs: params.readIdleTimeoutMs,
-				totalTimeoutMs: params.totalTimeoutMs ?? SLACK_MEDIA_TOTAL_TIMEOUT_MS,
-				abortSignal: params.abortSignal
-			});
-			const label = saved.fileName ?? "forwarded image";
-			attachmentMedia.push({
-				path: saved.path,
-				contentType: saved.contentType,
-				...saved.fileName ? { fileName: saved.fileName } : {},
-				placeholder: `[Forwarded image: ${label}]`
-			});
-		} catch (error) {
-			unavailableMediaCount += 1;
-			slackMediaLog.warn(`slack: forwarded image unavailable (${formatSlackMediaFailure(error)})`);
-		}
-		attachmentMedia.push(...await resolveFiles(att.files) ?? []);
-	}
-	const allMedia = [...await directMediaPromise ?? [], ...attachmentMedia];
+	const { results, hasError, firstError } = await runTasksWithConcurrency({
+		tasks: [() => resolveFiles(params.files), async () => {
+			const attachmentMedia = [];
+			for (const att of forwardedAttachments) {
+				const text = att.text?.trim() || att.fallback?.trim();
+				if (text) {
+					const author = att.author_name;
+					const heading = author ? `[Forwarded message from ${author}]` : "[Forwarded message]";
+					textBlocks.push(`${heading}\n${text}`);
+				}
+				const imageUrl = resolveForwardedAttachmentImageUrl(att, govSlack);
+				if (imageUrl) try {
+					const assertReadAuthority = captureSlackMediaReadGuard(params);
+					const saved = await saveSlackMedia({
+						...params,
+						url: imageUrl,
+						govSlack,
+						assertReadAuthority
+					});
+					const label = saved.fileName ?? "forwarded image";
+					attachmentMedia.push({
+						path: saved.path,
+						contentType: saved.contentType,
+						...saved.fileName ? { fileName: saved.fileName } : {},
+						placeholder: `[Forwarded image: ${label}]`
+					});
+				} catch (error) {
+					unavailableMediaCount += 1;
+					slackMediaLog.warn(`slack: forwarded image unavailable (${formatSlackMediaFailure(error)})`);
+				}
+				attachmentMedia.push(...await resolveFiles(att.files) ?? []);
+			}
+			return attachmentMedia;
+		}],
+		limit: 2,
+		errorMode: "stop"
+	});
+	if (hasError) throw toErrorObject(firstError, "Slack attachment read failed");
+	const allMedia = results.flatMap((media) => media ?? []);
 	const unavailableFiles = allFiles.flatMap((file, index) => {
 		const reason = index >= 8 ? SLACK_MEDIA_LIMIT_REASON : unavailableFileReasons.get(file);
 		return reason ? [{
@@ -648,39 +646,29 @@ async function getClient(opts = {}, mode = "read") {
 		if (opts.assertDirectAdapterHandoff) return createSlackWriteClient(token, { teamId: opts.teamId }, opts.assertDirectAdapterHandoff);
 		return getSlackWriteClient(token, { teamId: opts.teamId });
 	}
-	return opts.assertDirectAdapterHandoff ? createSlackLookupClient(token, { teamId: opts.teamId }, opts.assertDirectAdapterHandoff) : createSlackLookupClient(token, { teamId: opts.teamId });
+	return createSlackLookupClient(token, { teamId: opts.teamId }, opts.assertDirectAdapterHandoff);
 }
 async function resolveBotUserId(client) {
 	const auth = await client.auth.test();
 	if (!auth?.user_id) throw new Error("Failed to resolve Slack bot user id");
 	return auth.user_id;
 }
-async function reactSlackMessage(channelId, messageId, emoji, opts = {}) {
-	const client = await getClient(opts, "write");
-	try {
-		await client.reactions.add({
-			channel: channelId,
-			timestamp: messageId,
-			name: normalizeSlackEmojiName(emoji)
-		});
-	} catch (err) {
-		if (hasSlackPlatformError(err, "already_reacted")) return;
-		throw err;
-	}
-}
-async function removeSlackReaction(channelId, messageId, emoji, opts = {}) {
-	const client = await getClient(opts, "write");
-	try {
-		await client.reactions.remove({
-			channel: channelId,
-			timestamp: messageId,
-			name: normalizeSlackEmojiName(emoji)
-		});
-	} catch (err) {
-		if (hasSlackPlatformError(err, "no_reaction")) return;
-		throw err;
-	}
+function createSlackReactionUpdater(method, unchangedError) {
+	return async (channelId, messageId, emoji, opts = {}) => {
+		const client = await getClient(opts, "write");
+		try {
+			await client.reactions[method]({
+				channel: channelId,
+				timestamp: messageId,
+				name: normalizeSlackEmojiName(emoji)
+			});
+		} catch (err) {
+			if (!hasSlackPlatformError(err, unchangedError)) throw err;
+		}
+	};
 }
+const reactSlackMessage = createSlackReactionUpdater("add", "already_reacted");
+const removeSlackReaction = createSlackReactionUpdater("remove", "no_reaction");
 async function removeOwnSlackReactions(channelId, messageId, opts = {}) {
 	const client = await getClient(opts, "write");
 	const userId = await resolveBotUserId(client);
@@ -752,7 +740,7 @@ async function editSlackRenderedMessage(channelId, messageId, content, opts = {}
 	try {
 		await client.chat.update(update);
 	} catch (error) {
-		if (!hasSlackNativeDataBlock(blocks) || !isSlackInvalidBlocksError(error)) throw error;
+		if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
 		logVerbose("slack edit: native data block rejected, retrying with text fallback");
 		const survivorBlocks = stripSlackNativeDataBlocks(blocks);
 		const survivorText = buildSlackBlocksFallbackText(survivorBlocks) ?? "";
@@ -803,30 +791,18 @@ async function readSlackMessages(channelId, opts = {}) {
 		oldest: normalizeSlackReadTimestamp(opts.after, "after")
 	};
 	const client = await getClient(opts);
-	if (opts.threadId) {
-		const oldest = exactMessageId ? exactMessageId : exactBounds.oldest && Number(exactBounds.oldest) > Number(opts.threadId) ? exactBounds.oldest : opts.threadId;
-		const result = await client.conversations.replies({
-			channel: channelId,
-			ts: opts.threadId,
-			limit: readLimit,
-			...exactBounds,
-			oldest
-		});
-		return {
-			messages: (result.messages ?? []).filter((message) => {
-				if (exactMessageId) return message.ts === exactMessageId;
-				return message.ts !== opts.threadId;
-			}).map(renderSlackReadMessageText),
-			hasMore: exactMessageId ? false : Boolean(result.has_more)
-		};
-	}
-	const result = await client.conversations.history({
+	const query = {
 		channel: channelId,
 		limit: readLimit,
 		...exactBounds
-	});
+	};
+	const result = opts.threadId ? await client.conversations.replies({
+		...query,
+		ts: opts.threadId,
+		oldest: exactMessageId ? exactMessageId : exactBounds.oldest && Number(exactBounds.oldest) > Number(opts.threadId) ? exactBounds.oldest : opts.threadId
+	}) : await client.conversations.history(query);
 	return {
-		messages: (result.messages ?? []).filter((message) => !exactMessageId || message.ts === exactMessageId).map(renderSlackReadMessageText),
+		messages: (result.messages ?? []).filter((message) => exactMessageId ? message.ts === exactMessageId : !opts.threadId || message.ts !== opts.threadId).map(renderSlackReadMessageText),
 		hasMore: exactMessageId ? false : Boolean(result.has_more)
 	};
 }
@@ -851,55 +827,23 @@ async function unpinSlackMessage(channelId, messageId, opts = {}) {
 async function listSlackPins(channelId, opts = {}) {
 	return (await (await getClient(opts)).pins.list({ channel: channelId })).items ?? [];
 }
-function collectSlackDirectShareChannelIds(file) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const group of [
+function hasSlackScopeProof(params) {
+	const channelId = normalizeOptionalString(params.channelId);
+	if (!channelId) return false;
+	const threadId = normalizeOptionalString(params.threadId);
+	const { file } = params;
+	if (!threadId && [
 		file.channels,
 		file.groups,
 		file.ims
-	]) {
-		if (!Array.isArray(group)) continue;
-		for (const entry of group) {
-			if (typeof entry !== "string") continue;
-			const normalized = normalizeOptionalString(entry);
-			if (normalized) ids.add(normalized);
-		}
-	}
-	return ids;
-}
-function collectSlackShareMaps(file) {
-	if (!file.shares || typeof file.shares !== "object" || Array.isArray(file.shares)) return [];
-	const shares = file.shares;
-	return [shares.public, shares.private].filter((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
-}
-function collectSlackShares(file) {
-	const shares = [];
-	for (const shareMap of collectSlackShareMaps(file)) for (const [rawChannelId, rawEntries] of Object.entries(shareMap)) {
-		const channelId = normalizeOptionalString(rawChannelId);
-		if (!channelId || !Array.isArray(rawEntries)) continue;
-		for (const rawEntry of rawEntries) {
-			if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) continue;
-			const entry = rawEntry;
-			const ts = typeof entry.ts === "string" ? normalizeOptionalString(entry.ts) : void 0;
-			const threadTs = typeof entry.thread_ts === "string" ? normalizeOptionalString(entry.thread_ts) : void 0;
-			if (ts || threadTs) shares.push({
-				channelId,
-				ts,
-				threadTs
-			});
-		}
-	}
-	return shares;
-}
-function lacksSlackScopeProof(params) {
-	const channelId = normalizeOptionalString(params.channelId);
-	if (!channelId) return true;
-	const threadId = normalizeOptionalString(params.threadId);
-	const directIds = collectSlackDirectShareChannelIds(params.file);
-	const shares = collectSlackShares(params.file);
-	if (!(directIds.has(channelId) || shares.some((entry) => entry.channelId === channelId))) return true;
-	if (!threadId) return false;
-	return !shares.some((entry) => entry.channelId === channelId && (entry.threadTs === threadId || entry.ts === threadId));
+	].some((group) => Array.isArray(group) && group.some((entry) => normalizeOptionalString(entry) === channelId))) return true;
+	if (!isRecord(file.shares)) return false;
+	return [file.shares.public, file.shares.private].some((shareMap) => isRecord(shareMap) && Object.entries(shareMap).some(([sharedChannelId, entries]) => normalizeOptionalString(sharedChannelId) === channelId && Array.isArray(entries) && entries.some((entry) => {
+		if (!isRecord(entry)) return false;
+		const ts = normalizeOptionalString(entry.ts);
+		const threadTs = normalizeOptionalString(entry.thread_ts);
+		return threadId ? ts === threadId || threadTs === threadId : Boolean(ts || threadTs);
+	})));
 }
 /**
 * Downloads a Slack file by ID and saves it to the local media store.
@@ -909,7 +853,7 @@ function lacksSlackScopeProof(params) {
 async function downloadSlackFile(fileId, opts) {
 	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
 	const client = await getClient(opts);
-	const isFileAllowed = (file) => !lacksSlackScopeProof({
+	const isFileAllowed = (file) => hasSlackScopeProof({
 		file,
 		channelId: opts.channelId,
 		threadId: opts.threadId
@@ -932,4 +876,4 @@ async function downloadSlackFile(fileId, opts) {
 	}))?.[0] ?? null;
 }
 //#endregion
-export { hasSlackMessageTableBlock as C, resolveSlackMessageText as D, resolveSlackBlocksText as E, buildSlackEditTextPayload as O, formatSlackFileReferenceList as S, isSlackUnfurlAttachment as T, media_exports as _, editSlackRenderedMessage as a, saveRemoteMedia as b, listSlackPins as c, reactSlackMessage as d, readSlackMessages as f, unpinSlackMessage as g, sendSlackMessage as h, editSlackMessage as i, listSlackReactions as l, removeSlackReaction as m, deleteSlackMessage as n, getSlackMemberInfo as o, removeOwnSlackReactions as p, downloadSlackFile as r, listSlackEmojis as s, actions_exports as t, pinSlackMessage as u, logVerbose$1 as v, hasSlackTableBlock as w, formatSlackFileReference as x, isGovSlackClient as y };
+export { hasSlackTableBlock as C, buildSlackEditTextPayload as D, resolveSlackMessageText as E, hasSlackMessageTableBlock as S, resolveSlackBlocksText as T, media_exports as _, editSlackRenderedMessage as a, formatSlackFileReference as b, listSlackPins as c, reactSlackMessage as d, readSlackMessages as f, unpinSlackMessage as g, sendSlackMessage as h, editSlackMessage as i, listSlackReactions as l, removeSlackReaction as m, deleteSlackMessage as n, getSlackMemberInfo as o, removeOwnSlackReactions as p, downloadSlackFile as r, listSlackEmojis as s, actions_exports as t, pinSlackMessage as u, isGovSlackClient as v, isSlackUnfurlAttachment as w, formatSlackFileReferenceList as x, saveRemoteMedia as y };