@vercel/board 0.0.0-stage → 0.15.0

package/dist/sync-slack.mjs

@@ -0,0 +1,728 @@
+import { m as MESSAGE_TEXT_MAX } from "./schemas-Be08nyfW.mjs";
+import "./contract-CuJmlrhw.mjs";
+import { c as eventSchema, i as UnreadableError, s as envelope } from "./provider-CuewcDNZ.mjs";
+import { r as withUserTokens, t as connectUserTokens } from "./users-Dls7_ANV.mjs";
+import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-jFSeyNmB.mjs";
+import { z } from "zod";
+import { stringifyMarkdown } from "chat";
+import { createSlackAdapter } from "@chat-adapter/slack";
+import { connectSlackAdapter } from "@vercel/connect/chat";
+//#region src/sync/slack.ts
+/** The `**name**: ` a message's text opens with, taken out when Slack shows the name as the sender. */
+function withoutLabel(markdown, name) {
+	const label = new RegExp(`^\\*\\*${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\*\\*: `);
+	return markdown.replace(label, "");
+}
+/** HTML elements GitHub renders in comments; anything else in angle brackets (`<@U123>`, `<https://…>`, `a < b`) is left alone. */
+const HTML_TAGS = new Set("a abbr b bdi bdo blockquote br caption center cite code dd del details dfn div dl dt em figcaption figure font h1 h2 h3 h4 h5 h6 hr i img ins kbd li mark ol p picture pre q rp rt ruby s samp section small source span strike strong sub summary sup table tbody td tfoot th thead time tr tt u ul var video wbr".split(" "));
+const MARKS = {
+	b: "**",
+	strong: "**",
+	i: "_",
+	em: "_",
+	code: "`",
+	kbd: "`",
+	s: "~~",
+	del: "~~",
+	strike: "~~"
+};
+const BLOCKS = /* @__PURE__ */ new Set([
+	"p",
+	"div",
+	"details",
+	"table",
+	"tr",
+	"ul",
+	"ol",
+	"li",
+	"blockquote",
+	"pre",
+	"hr",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]);
+const attribute = (attrs, name) => new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i").exec(attrs)?.slice(1).find((v) => v !== void 0) ?? "";
+/** GitHub's markdown allows inline HTML, which Slack shows as raw tags: as markdown instead, outside code. */
+function withoutHtml(markdown) {
+	if (!/<\/?[a-z!]/i.test(markdown) || /[\uE000\uE001]/.test(markdown)) return markdown;
+	const code = [];
+	let hidden = false;
+	const text = markdown.replace(/(```[\s\S]*?(?:```|$)|~~~[\s\S]*?(?:~~~|$)|``[^\n]*?``|`[^`\n]+`)|<!--[\s\S]*?(?:-->|$)/g, (_, span) => span === void 0 ? (hidden = true, "") : `\uE000${code.push(span) - 1}\uE001`);
+	const out = text.replace(/<img\b([^>]*)>/gi, (_, attrs) => attribute(attrs, "alt")).replace(/<source\b[^>]*>/gi, "").replace(/<a\b([^>]*)>([\s\S]*?)<\/a\s*>/gi, (_, attrs, inner) => {
+		const href = attribute(attrs, "href");
+		const label = inner.replace(/<[^>]*>/g, "").trim();
+		return href ? label ? `[${label}](${href})` : href : label;
+	}).replace(/<br\s*\/?>/gi, "\n").replace(/<\/?([a-z][a-z0-9]*)\b(?:\s[^<>]*)?\/?>/gi, (tag, name) => {
+		const lower = name.toLowerCase();
+		if (!HTML_TAGS.has(lower)) return tag;
+		const closing = tag.startsWith("</");
+		if (lower === "summary") return closing ? "**\n\n" : "**";
+		return MARKS[lower] ?? (BLOCKS.has(lower) && closing ? "\n" : "");
+	});
+	if (!hidden && out === text) return markdown;
+	return out.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+|\n+$/g, "").replace(/\uE000(\d+)\uE001/g, (_, i) => code[Number(i)]);
+}
+/**
+* A sender's picture as Slack's `icon_url`: an https image. The board's built-in agent
+* avatars are SVGs, which Slack won't show, so those keep the app's icon.
+*/
+function slackIcon(avatar) {
+	if (!avatar) return null;
+	try {
+		const url = new URL(avatar);
+		return url.protocol === "https:" && !/\/avatars\/[a-z0-9-]+$/.test(url.pathname) && !url.pathname.endsWith(".svg") ? avatar : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Slack message permalinks in mrkdwn: `https://acme.slack.com/archives/C0123/p1727000000123456`,
+* with `?thread_ts=…` for a reply. Slack escapes `&` in text as `&amp;`.
+*/
+const PERMALINK = /https:\/\/[a-z0-9-]+(?:\.enterprise)?\.slack\.com\/archives\/([A-Z0-9]+)\/p(\d{10})(\d{6})((?:\?|&amp;|&)[^\s|>]*)?/g;
+/** `1727000000.123456` → its ISO time. */
+const tsTime = (ts) => {
+	const seconds = Number(ts);
+	return ts && Number.isFinite(seconds) ? (/* @__PURE__ */ new Date(seconds * 1e3)).toISOString() : null;
+};
+const filesOf = (files) => (files ?? []).slice(0, 20).map((file) => ({
+	name: (file.name || file.title || "file").slice(0, 1e3),
+	url: file.permalink?.slice(0, 4e3) ?? null
+}));
+/** A permalink's channel, ts and thread, or null when `url` isn't a Slack message's. */
+function permalinkOf(url) {
+	const match = new RegExp(PERMALINK.source).exec(url);
+	if (!match || match.index !== 0) return null;
+	const [, channel, seconds, micros, query] = match;
+	const ts = `${seconds}.${micros}`;
+	return {
+		url: match[0].replaceAll("&amp;", "&"),
+		channel,
+		ts,
+		thread: /[?&]thread_ts=(\d+\.\d+)/.exec(query?.replaceAll("&amp;", "&") ?? "")?.[1] ?? ts
+	};
+}
+/** A Slack attachment as a link's snapshot. */
+const snapshotOf = (att, ts, markdown) => ({
+	author: (att.author_subname || att.author_name || att.author_id || "someone").slice(0, 256),
+	text: markdown(att.text ?? "").slice(0, MESSAGE_TEXT_MAX),
+	createdAt: tsTime(att.ts ?? ts),
+	files: filesOf(att.files)
+});
+/**
+* Every Slack message a message's mrkdwn links to, in order, with the unfurls Slack attached for them,
+* then the messages it forwards: a forward's shared message is only in its `is_share` attachments.
+*/
+function slackLinks(key, text, attachments = [], markdown = (t) => t) {
+	const links = [];
+	const add = (found, att) => {
+		const known = links.find((link) => link.url === found.url || link.thread === `${key}:${found.channel}:${found.thread}` && link.message === found.ts);
+		if (known) {
+			if (!known.snapshot && att) known.snapshot = snapshotOf(att, found.ts, markdown);
+			return;
+		}
+		if (found.url.length > 4e3 || links.length === 10) return;
+		links.push({
+			url: found.url,
+			thread: `${key}:${found.channel}:${found.thread}`,
+			message: found.ts,
+			snapshot: att ? snapshotOf(att, found.ts, markdown) : null
+		});
+	};
+	for (const match of text.matchAll(PERMALINK)) {
+		const found = permalinkOf(match[0]);
+		add(found, attachments.find((att) => att.is_msg_unfurl && (att.channel_id === found.channel && att.ts === found.ts || att.from_url?.replaceAll("&amp;", "&") === found.url)));
+	}
+	for (const att of attachments) {
+		const found = att.is_share ? permalinkOf(att.from_url ?? att.original_url ?? "") : null;
+		if (found) add(found, att);
+	}
+	return links;
+}
+/**
+* What a forward with no text of its own says: the messages it shares, quoted,
+* so the board (and whoever watches it) reads what was forwarded, not "(no text)".
+*/
+function forwardText(links) {
+	return links.filter((link) => link.snapshot).map((link) => {
+		const { author, text } = link.snapshot;
+		const lines = text.trim() ? text.trim().split("\n") : [""];
+		return [.../^(```|~~~|[-*+] |\d+[.)] |#{1,6} |>)/.test(lines[0]) ? [`> **${author}**:`, `> ${lines[0]}`] : [`> **${author}**: ${lines[0]}`], ...lines.slice(1).map((line) => `> ${line}`)].map((line) => line.trimEnd()).concat("", link.url).join("\n");
+	}).join("\n\n");
+}
+/** Slack's answers that mean "no files from this app", not "try again". */
+const REFUSED = /* @__PURE__ */ new Set([
+	"missing_scope",
+	"not_allowed_token_type",
+	"no_permission",
+	"restricted_action",
+	"file_uploads_disabled",
+	"file_uploads_except_images_disabled",
+	"file_upload_size_restricted"
+]);
+/** A Slack API error's code (`missing_scope`), with the scope it needed. */
+function slackError(error) {
+	const data = error.data;
+	if (!data?.error) return error.message;
+	return data.needed ? `${data.error}, needs ${data.needed}` : data.error;
+}
+/** Extensions Slack shows as text (a preview, not a download): it calls any other extension binary. */
+const SLACK_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+	"txt",
+	"md",
+	"markdown",
+	"csv",
+	"json",
+	"yaml",
+	"yml",
+	"xml",
+	"html",
+	"css",
+	"js",
+	"ts",
+	"py",
+	"rb",
+	"go",
+	"rs",
+	"java",
+	"c",
+	"h",
+	"cpp",
+	"sh",
+	"bash",
+	"sql",
+	"diff",
+	"patch"
+]);
+const TEXT_TYPES = /^(text\/|application\/(json|x-ndjson|xml|yaml|x-yaml|javascript|x-sh)\b)/;
+/**
+* The name a file goes to Slack under. Slack picks a file's type from its
+* extension, so a text file named `run.log` arrives as a binary download;
+* `run.log.txt` arrives as text it previews. The board keeps the file's own name.
+*/
+function slackFileName(filename, mimeType) {
+	if (!mimeType || !TEXT_TYPES.test(mimeType)) return filename;
+	const extension = /\.([^./]+)$/.exec(filename)?.[1]?.toLowerCase();
+	return extension && SLACK_TEXT_EXTENSIONS.has(extension) ? filename : `${filename}.txt`;
+}
+const SlackEvent = eventSchema("slack", "message");
+/**
+* Syncs Slack channels with board channels. Keys are channels by name
+* (`'#prs'`) or ID (`'C0123ABC'`); values are a board channel (a two-way
+* mirror) or a callback that handles every incoming event. The app joins public
+* channels it isn't in; private ones need an invite.
+*/
+function slack(options) {
+	return new SlackProvider(options);
+}
+/** A Slack adapter, client, and people's tokens, all from one Vercel Connect connector. */
+function fromConnector(connector) {
+	const credentials = connectSlackAdapter(connector);
+	const adapter = withUserTokens(createSlackAdapter(credentials), connectUserTokens(connector));
+	const botToken = credentials.botToken;
+	const client = async () => adapter.withBotToken(typeof botToken === "function" ? await botToken() : botToken, () => adapter.webClient);
+	return {
+		adapter,
+		client
+	};
+}
+var SlackProvider = class extends ChatSyncProvider {
+	web;
+	customize;
+	constructor(given) {
+		const connected = typeof given.adapter === "string" ? fromConnector(given.adapter) : null;
+		const options = connected ? {
+			...given,
+			adapter: connected.adapter,
+			client: given.client ?? connected.client
+		} : {
+			...given,
+			adapter: given.adapter
+		};
+		const tokens = options.adapter;
+		let directClient;
+		if (!options.client) try {
+			directClient = options.adapter.webClient;
+		} catch {
+			throw new Error("slack requires a public client resolver when the adapter uses async tokens");
+		}
+		async function client() {
+			return options.client ? options.client() : directClient;
+		}
+		let listing;
+		let publicOnly = false;
+		async function list(client, types) {
+			const channels = [];
+			let cursor;
+			do {
+				const page = await client.conversations.list({
+					types,
+					exclude_archived: true,
+					limit: 1e3,
+					...cursor ? { cursor } : {}
+				});
+				channels.push(...page.channels ?? []);
+				cursor = page.response_metadata?.next_cursor || void 0;
+			} while (cursor);
+			return channels;
+		}
+		async function listAll(client) {
+			if (!publicOnly) try {
+				return await list(client, "public_channel,private_channel");
+			} catch (error) {
+				if (!slackError(error).startsWith("missing_scope")) throw error;
+				publicOnly = true;
+			}
+			return list(client, "public_channel");
+		}
+		function channels(client, fresh) {
+			if (fresh || !listing) {
+				const promise = listAll(client);
+				promise.catch(() => {
+					if (listing === promise) listing = void 0;
+				});
+				listing = promise;
+			}
+			return listing;
+		}
+		async function find(client, name) {
+			const match = (all) => all.find((channel) => channel.name === name && !!channel.id);
+			let found;
+			try {
+				found = match(await channels(client, false)) ?? match(await channels(client, true));
+			} catch (error) {
+				throw new UnreadableError("list_failed", `can't list Slack channels to find #${name} (${slackError(error)}); use its ID instead`);
+			}
+			if (!found) throw new UnreadableError("channel_not_found", publicOnly ? `no public Slack channel named #${name} (the app lacks groups:read, so a private channel needs its ID)` : `no Slack channel named #${name} (a private channel shows up once the app is invited)`);
+			return found;
+		}
+		const joined = /* @__PURE__ */ new Map();
+		function join(client, id, known) {
+			let promise = joined.get(id);
+			if (!promise) {
+				promise = (async () => {
+					const channel = known ?? await client.conversations.info({ channel: id }).then((r) => r.channel, () => void 0);
+					if (!channel || channel.is_member) return;
+					const label = channel.name ? `#${channel.name}` : id;
+					if (channel.is_private) return console.warn(`[board] slack: invite the app to ${label}; it can't join private channels itself`);
+					try {
+						await client.conversations.join({ channel: id });
+					} catch (error) {
+						joined.delete(id);
+						console.warn(`[board] slack: couldn't join ${label} (${slackError(error)}); invite the app to it`);
+					}
+				})();
+				joined.set(id, promise);
+			}
+			return promise;
+		}
+		const avatars = /* @__PURE__ */ new Map();
+		function avatarOf(user) {
+			let promise = avatars.get(user);
+			if (!promise) {
+				promise = client().then(async (web) => {
+					const profile = (await web?.users?.info({ user }))?.user?.profile;
+					return profile?.image_72 ?? profile?.image_48 ?? null;
+				}).catch(() => null);
+				avatars.set(user, promise);
+			}
+			return promise;
+		}
+		const converter = options.adapter.formatConverter;
+		const mrkdwn = (text) => {
+			try {
+				return converter ? stringifyMarkdown(converter.toAst(text)).trim() : text;
+			} catch {
+				return text;
+			}
+		};
+		const names = /* @__PURE__ */ new Map();
+		function nameOf(user) {
+			let promise = names.get(user);
+			if (!promise) {
+				promise = client().then(async (web) => {
+					const found = (await web?.users?.info({ user }))?.user;
+					return found?.profile?.real_name || found?.real_name || found?.profile?.display_name || found?.name || user;
+				}).catch(() => user);
+				names.set(user, promise);
+			}
+			return promise;
+		}
+		const fileIds = (raw) => (raw?.uploadedFileIds ?? []).filter(Boolean);
+		const internals = options.adapter;
+		const singleWorkspace = !!internals.defaultBotTokenProvider && !internals.installationProvider && !internals.clientId;
+		super({
+			fileIds,
+			fileToFetch(file) {
+				if (!singleWorkspace || !file.fetchMetadata) return file;
+				const { teamId: _team, enterpriseId: _enterprise, isEnterpriseInstall: _install, ...rest } = file.fetchMetadata;
+				return {
+					...file,
+					fetchMetadata: rest
+				};
+			},
+			render: options.render,
+			platform: "slack",
+			adapter: options.adapter,
+			canStartThreads: true,
+			async uploadFiles(thread, files) {
+				const sent = await options.adapter.postMessage(thread, {
+					markdown: "",
+					files
+				});
+				return {
+					message: sent.id,
+					files: fileIds(sent.raw)
+				};
+			},
+			uploadName: (file) => slackFileName(file.filename, file.mimeType),
+			refusesFiles: (error) => REFUSED.has(error?.data?.error ?? ""),
+			async deleteFiles(ids) {
+				const web = await client();
+				for (const file of ids) await web?.files?.delete({ file }).catch((error) => console.warn(`[board] slack: couldn't delete file ${file} (${slackError(error)})`));
+			},
+			async findByEmail(email) {
+				const user = (await (await client())?.users?.lookupByEmail?.({ email }).catch(() => void 0))?.user;
+				if (!user?.id) return null;
+				const handle = user.profile?.display_name || user.name || user.id;
+				return {
+					id: `slack:user:${user.id}`,
+					handle,
+					name: user.profile?.real_name || user.real_name || handle,
+					avatar: user.profile?.image_72 ?? user.profile?.image_48 ?? null,
+					isBot: user.is_bot === true
+				};
+			},
+			mention: (actor) => actor.id.startsWith("slack:user:") ? `<@${actor.id.slice(11)}>` : null,
+			async resolveChannel(key) {
+				if (!key.startsWith("#")) {
+					const web = await client().catch(() => void 0);
+					if (web) await join(web, key);
+					return key;
+				}
+				const web = await client();
+				if (!web) throw new Error(`can't look up Slack channel ${key}: use its ID instead`);
+				const channel = await find(web, key.slice(1));
+				await join(web, channel.id, channel);
+				return channel.id;
+			},
+			markdown(message) {
+				const text = markdownOf(message);
+				if (text.trim()) return text;
+				const raw = message.raw;
+				const shared = Array.isArray(raw?.attachments) ? raw.attachments.filter((att) => att.is_share) : [];
+				return shared.length ? forwardText(slackLinks("", "", shared, mrkdwn)) : text;
+			},
+			links(key, message) {
+				const raw = message.raw;
+				return slackLinks(key, typeof raw?.text === "string" ? raw.text : message.text, Array.isArray(raw?.attachments) ? raw.attachments : [], mrkdwn);
+			},
+			async fetchLink(link) {
+				const [, channel, thread] = link.thread.split(":");
+				const web = await client();
+				if (!web?.conversations.replies || !channel || !thread) return {
+					snapshot: null,
+					unavailable: "no Slack client to read it with"
+				};
+				let found;
+				try {
+					const info = (await web.conversations.info({ channel })).channel;
+					if (!info) return {
+						snapshot: null,
+						unavailable: "channel_not_found"
+					};
+					if (info.is_private || info.is_im || info.is_mpim) return {
+						snapshot: null,
+						unavailable: "private_channel"
+					};
+					if (!info.is_member) return {
+						snapshot: null,
+						unavailable: "not_in_channel"
+					};
+					const { messages } = await web.conversations.replies({
+						channel,
+						ts: thread,
+						oldest: link.message,
+						latest: link.message,
+						inclusive: true,
+						limit: 1
+					});
+					found = messages?.find((m) => m.ts === link.message);
+				} catch (error) {
+					return {
+						snapshot: null,
+						unavailable: slackError(error)
+					};
+				}
+				if (!found) return {
+					snapshot: null,
+					unavailable: "message_not_found"
+				};
+				return {
+					unavailable: null,
+					snapshot: {
+						author: (found.user ? await nameOf(found.user) : found.username || found.bot_profile?.name || "someone").slice(0, 256),
+						text: mrkdwn(found.text ?? "").slice(0, MESSAGE_TEXT_MAX),
+						createdAt: tsTime(found.ts),
+						files: filesOf(found.files)
+					}
+				};
+			},
+			async read(target, { limit }) {
+				const web = await client();
+				if (!web) throw new UnreadableError("no_client", "no Slack client to read it with");
+				let channel;
+				let thread = null;
+				const link = new RegExp(PERMALINK.source).exec(target);
+				if (link) {
+					const [, id, seconds, micros, query] = link;
+					channel = id;
+					thread = /[?&]thread_ts=(\d+\.\d+)/.exec(query?.replaceAll("&amp;", "&") ?? "")?.[1] ?? `${seconds}.${micros}`;
+				} else if (target.startsWith("#")) channel = (await find(web, target.slice(1))).id;
+				else {
+					const parsed = /^([A-Z0-9]+)(?::(\d+\.\d+))?$/.exec(target);
+					if (!parsed) throw new UnreadableError("invalid_target", `not a Slack channel, thread, or message link: ${target} (try #name, C0123, C0123:1727000000.123456, or a permalink)`);
+					channel = parsed[1];
+					thread = parsed[2] ?? null;
+				}
+				let found;
+				let more = false;
+				let name = null;
+				try {
+					const info = (await web.conversations.info({ channel })).channel;
+					if (!info) throw new UnreadableError("channel_not_found", `no Slack channel ${channel}`);
+					name = info.name ?? null;
+					const label = name ? `#${name}` : channel;
+					if (info.is_private || info.is_im || info.is_mpim) throw new UnreadableError("private_channel", `${label} is private: the board only reads public channels on demand`);
+					if (info.is_ext_shared) throw new UnreadableError("shared_channel", `${label} is shared with another organization: the board doesn't read those on demand`);
+					if (!info.is_member) throw new UnreadableError("not_in_channel", `the app isn't in ${label}: someone needs to add it (it won't join on its own)`);
+					if (thread) {
+						const replies = web.conversations.replies;
+						if (!replies) throw new UnreadableError("no_client", "this Slack client can't read threads");
+						let page = await replies({
+							channel,
+							ts: thread,
+							limit
+						});
+						const root = page.messages?.[0]?.thread_ts;
+						if (root && root !== thread) {
+							thread = root;
+							page = await replies({
+								channel,
+								ts: root,
+								limit
+							});
+						}
+						found = page.messages ?? [];
+						more = page.has_more ?? false;
+					} else {
+						if (!web.conversations.history) throw new UnreadableError("no_client", "this Slack client can't read channels");
+						const page = await web.conversations.history({
+							channel,
+							limit
+						});
+						found = (page.messages ?? []).reverse();
+						more = page.has_more ?? false;
+					}
+				} catch (error) {
+					if (error instanceof UnreadableError) throw error;
+					throw new UnreadableError(slackError(error).split(",")[0], `Slack refused to read ${target}: ${slackError(error)}`);
+				}
+				const messages = await Promise.all(found.slice(0, limit).filter((m) => m.ts).map(async (m) => ({
+					id: m.ts,
+					thread: `${channel}:${m.thread_ts ?? m.ts}`,
+					author: (m.user ? await nameOf(m.user) : m.username || m.bot_profile?.name || "someone").slice(0, 256),
+					text: mrkdwn(m.text ?? "").slice(0, MESSAGE_TEXT_MAX),
+					createdAt: tsTime(m.ts),
+					replies: m.reply_count ?? 0,
+					files: filesOf(m.files)
+				})));
+				return {
+					channel,
+					name,
+					thread,
+					messages,
+					more: more || found.length > limit
+				};
+			},
+			intercept(key, _headers, body) {
+				let event;
+				try {
+					event = JSON.parse(body).event;
+				} catch {
+					return [];
+				}
+				const inner = event?.message;
+				if (event?.type !== "message" || event.subtype !== "message_changed" || !event.channel || !inner?.ts) return [];
+				if (!inner.attachments?.some((att) => att.is_msg_unfurl) || inner.text !== event.previous_message?.text) return [];
+				const links = slackLinks(key, inner.text ?? "", inner.attachments, mrkdwn);
+				const unfurled = links.filter((link) => link.snapshot);
+				if (unfurled.length === 0) return [];
+				const thread = `${key}:${event.channel}:${inner.thread_ts ?? inner.ts}`;
+				return [{
+					dedupe: `unfurl:${thread}|${inner.ts}|${unfurled.map((link) => link.message).join(",")}`,
+					raw: event,
+					event: {
+						kind: "edited",
+						channel: `${key}:${event.channel}`,
+						thread,
+						subthread: null,
+						message: inner.ts,
+						text: inner.text ?? "",
+						linksOnly: true,
+						links,
+						author: {
+							id: "slack:system",
+							handle: "slack",
+							name: "Slack",
+							avatar: null,
+							isBot: true
+						}
+					}
+				}];
+			},
+			avatar: (message) => message.author.userId ? avatarOf(message.author.userId) : Promise.resolve(null),
+			groupThread: (thread) => thread,
+			isRoot: (thread, messageId) => thread.slice(thread.lastIndexOf(":") + 1) === messageId,
+			context: () => null,
+			...typeof tokens.withBotToken === "function" ? {
+				runAs: (token, fn) => tokens.withBotToken(token, fn),
+				async whoAmI(token) {
+					const me = await tokens.withBotToken(token, () => tokens.webClient.auth.test());
+					if (!me.user_id) throw new Error("Slack didn't say whose token this is");
+					const user = (await (await client().catch(() => void 0))?.users?.info({ user: me.user_id }).catch(() => void 0))?.user;
+					const handle = user?.profile?.display_name || user?.name || me.user || me.user_id;
+					return {
+						id: `slack:user:${me.user_id}`,
+						handle,
+						name: user?.profile?.real_name || user?.real_name || handle,
+						avatar: user?.profile?.image_72 ?? user?.profile?.image_48 ?? null,
+						isBot: false
+					};
+				}
+			} : {},
+			async resolveTarget(target) {
+				const at = target.indexOf(":");
+				const channel = await this.resolveChannel(at === -1 ? target : target.slice(0, at));
+				return {
+					target: at === -1 ? channel : `${channel}:${target.slice(at + 1)}`,
+					channel,
+					kind: at === -1 ? "channel" : "thread"
+				};
+			}
+		});
+		for (const [key, value] of Object.entries(options.channels)) this.map(key, value);
+		this.web = client;
+	}
+	/**
+	* An agent's message goes out under its own name (`clever-lemur via vboard-factory`), and its
+	* picture when it has one Slack can show, instead of the app's, with the text's
+	* `**name**: ` label dropped. Without `chat:write.customize` it posts as the app, label and all.
+	*/
+	async post(target, kind, body) {
+		const { as, ...given } = body;
+		const post = {
+			...given,
+			markdown: withoutHtml(given.markdown)
+		};
+		return (as && !post.files?.length ? await this.postNamed(target, as, post.markdown) : null) ?? super.post(target, kind, post);
+	}
+	/** An edit keeps the label out only where the message went out under the agent's name. */
+	async edit(thread, message, body) {
+		const { as, ...given } = body;
+		const post = {
+			...given,
+			markdown: withoutHtml(given.markdown)
+		};
+		const named = as ? await this.sentAs(thread, message, as.name) : false;
+		await super.edit(thread, message, named && as ? {
+			...post,
+			markdown: withoutLabel(post.markdown, as.name)
+		} : post);
+	}
+	async postNamed(target, as, markdown) {
+		const adapter = await this.ready();
+		const web = await this.web();
+		if (!web?.chat || !adapter.formatConverter?.toSlackPayload || !await this.canCustomize(web)) return null;
+		const threadId = this.toChat(target);
+		const { channel, threadTs } = adapter.decodeThreadId(threadId);
+		const message = { markdown: withoutLabel(markdown, as.name) };
+		const resolved = await adapter.resolveMessageMentions?.(message, threadId) ?? message;
+		const icon = slackIcon(as.avatar);
+		const sent = await web.chat.postMessage({
+			channel,
+			...threadTs ? { thread_ts: threadTs } : {},
+			...adapter.formatConverter.toSlackPayload(resolved),
+			unfurl_links: false,
+			unfurl_media: false,
+			username: as.name.slice(0, 80),
+			...icon ? { icon_url: icon } : {}
+		});
+		if (!sent.ts) throw new Error("slack: chat.postMessage returned no ts");
+		return {
+			thread: this.toNative(`${adapter.name}:${channel}:${threadTs || sent.ts}`),
+			message: sent.ts
+		};
+	}
+	/** Whether the app may set a message's username and icon (`chat:write.customize`), asked once. */
+	canCustomize(web) {
+		this.customize ??= (async () => (await web.auth?.test())?.response_metadata?.scopes?.includes("chat:write.customize") ?? false)().catch((error) => {
+			this.customize = void 0;
+			console.warn(`[board] slack: couldn't check the app's scopes (${slackError(error)}); posting as the app`);
+			return false;
+		});
+		return this.customize;
+	}
+	/** Whether a message Slack has went out under `name`. */
+	async sentAs(thread, message, name) {
+		const web = await this.web().catch(() => void 0);
+		const channel = thread.slice(0, thread.indexOf(":"));
+		if (!web?.conversations.replies || !channel) return false;
+		return (await web.conversations.replies({
+			channel,
+			ts: message,
+			oldest: message,
+			latest: message,
+			inclusive: true,
+			limit: 1
+		}).then((page) => page.messages?.find((m) => m.ts === message), () => void 0))?.username === name.slice(0, 80);
+	}
+	/**
+	* Slack's link to the event's message, from `chat.getPermalink`, so it has the workspace's
+	* own host (Enterprise Grid included) and a reply's `thread_ts`. Null for an event without
+	* one message to link (a lifecycle event, or a deleted message Slack no longer has); throws
+	* when Slack won't say. It reads only the URL: nothing is synced or joined.
+	*/
+	async permalink(event) {
+		if (event.kind === "lifecycle" || event.kind === "deleted") return null;
+		const channel = event.channel.slice(event.key.length + 1);
+		const web = await this.web();
+		if (!web?.chat?.getPermalink) throw new Error("slack: no client with chat.getPermalink to link the message with");
+		let found;
+		try {
+			found = (await web.chat.getPermalink({
+				channel,
+				message_ts: event.message
+			})).permalink;
+		} catch (error) {
+			throw new Error(`slack: couldn't get the permalink for ${channel} ${event.message} (${slackError(error)})`);
+		}
+		if (!found) throw new Error("slack: chat.getPermalink returned no permalink");
+		return found;
+	}
+	eventId(key, input) {
+		if (input.kind !== "reaction") return super.eventId(key, input);
+		const reaction = input.reaction;
+		const stamp = z.looseObject({ event_ts: z.string().min(1) }).parse(reaction.raw).event_ts;
+		return `reaction:${key}:${this.toNative(reaction.threadId)}|${reaction.messageId}|${reaction.rawEmoji}|${reaction.user.userId}|${reaction.added}|${stamp}`;
+	}
+	event(context) {
+		return SlackEvent.parse(envelope(this.platform, context.key, context.event, context.raw, context.id));
+	}
+};
+//#endregion
+export { SlackEvent, SlackProvider, forwardText, slack, slackFileName, slackIcon, slackLinks, withUserTokens, withoutHtml, withoutLabel };