@vercel/board 0.16.0 → 0.18.0

package/dist/{engine-Bir5s8ts.mjs → engine-D0oBUBEK.mjs}

@@ -1,13 +1,14 @@
 import { a as typeOf, i as fileSize, r as IMPORT_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import { C as toStorable, c as ChannelPath, m as MESSAGE_TEXT_MAX } from "./schemas-Be08nyfW.mjs";
-import { o as derivedId } from "./watch-spec-W0c7ypHJ.mjs";
+import { c as externalMessageKey, l as isThreadTarget, s as channelOf } from "./external-BV_cUncs.mjs";
 import { t as canonicalEmoji } from "./emoji-CTLpvH-A.mjs";
+import { n as derivedId } from "./ids-C6AYo1bu.mjs";
 import { r as badRequest, s as notFound, t as HttpError } from "./errors-DX3hpwWt.mjs";
-import { s as replaceMentions } from "./actors-DjMeZpnU.mjs";
-import { i as DroppedError } from "./targets-yM5JBUgr.mjs";
-import { c as isThreadTarget, r as externalMessageKey } from "./reducers-mUPFuFJV.mjs";
-import { _ as waitUntil, o as channelOf, t as afterRetry } from "./attempts-Bxp9KgPf.mjs";
-import { i as UnreadableError, l as immutable, n as ResolvedTarget, o as SyncOverrides, t as ReceivedEvent } from "./provider-CuewcDNZ.mjs";
+import { n as replaceMentions } from "./mentions-CB6ShY4R.mjs";
+import { t as DroppedError } from "./middleware-CqaCwucP.mjs";
+import { n as waitUntil, t as afterRetry } from "./attempts-CLG840Oj.mjs";
+import { a as channelMissing, i as UnreadableError, n as ResolvedTarget, o as routesFor, t as ReceivedEvent } from "./provider-B3DpYSDq.mjs";
+import { a as immutable, n as SyncOverrides } from "./events-CewD4kw7.mjs";
 import { t as displayText } from "./bots-CGkO76qH.mjs";
 //#region src/sync/engine.ts
 /** `files`: a message with files may have no text. */
@@ -169,38 +170,43 @@ function createSyncEngine(entries) {
 		return state;
 	}
 	const linkedTo = (actors, person) => Object.entries(actors.links).filter(([, to]) => to === person).map(([actor]) => actor);
-	/** How long a key that didn't resolve (say, a Slack channel that doesn't exist yet) waits before another try. */
+	/** How long a name that didn't resolve (say, a Slack channel that doesn't exist yet) waits before another try. */
 	const RETRY_MS = 6e4;
-	const resolved = /* @__PURE__ */ new Map();
+	const resolutions = /* @__PURE__ */ new Map();
 	/**
-	* External channel → board channel or inbound function, for one entry. Each key
-	* resolves on its own: one that can't is logged and skipped, and the rest sync.
+	* A platform channel's ID from its name, on entry `key`: what sync functions route by. Each
+	* resolves once. One the platform says doesn't exist is logged and
+	* tried again a minute later; one it couldn't check is asked again on the next call, so a
+	* retried event asks again.
 	*/
-	const mappings = (key) => {
-		const cached = resolved.get(key);
-		if (cached && (cached.complete || Date.now() - cached.at < RETRY_MS)) return cached.map;
-		const platform = platformOf(key);
-		const pairs = Object.entries(platform.mappings);
+	function resolve(key, name) {
+		const at = `${key}:${name}`;
+		const cached = resolutions.get(at);
+		if (cached && (!cached.failed || Date.now() - cached.at < RETRY_MS)) return cached.id;
 		const entry = {
-			complete: true,
-			at: Date.now(),
-			map: Promise.resolve(/* @__PURE__ */ new Map())
+			id: platformOf(key).resolveChannel(name),
+			failed: false,
+			at: Date.now()
 		};
-		entry.map = Promise.allSettled(pairs.map(([raw]) => platform.resolveChannel(raw))).then((results) => {
-			const map = /* @__PURE__ */ new Map();
-			results.forEach((result, i) => {
-				const [raw, target] = pairs[i];
-				if (result.status === "fulfilled") map.set(`${key}:${result.value}`, target);
-				else {
-					entry.complete = false;
-					console.warn(`[board] sync ${key}: skipping ${raw}: ${result.reason.message}`);
-				}
-			});
-			return map;
+		entry.id.catch((error) => {
+			entry.failed = true;
+			const missing = channelMissing(error);
+			if (!missing && resolutions.get(at) === entry) resolutions.delete(at);
+			console.warn(`[board] sync ${key}: ${missing ? "skipping" : "couldn't resolve"} ${name}: ${error.message}`);
 		});
-		resolved.set(key, entry);
-		return entry.map;
-	};
+		resolutions.set(at, entry);
+		return entry.id;
+	}
+	/** The platform channel a target is in, as the platform names it; null when its provider can't tell. */
+	function channelIn(key, target) {
+		if (!isThreadTarget(target)) return native(target);
+		try {
+			const channel = platformOf(key).inboxChannel(key, target);
+			return channel === null ? null : native(channel);
+		} catch {
+			return null;
+		}
+	}
 	/** A synced platform's user with this email, for `@[ada@vercel.com]`. */
 	async function findByEmail(email) {
 		for (const platform of Object.values(entries)) {
@@ -215,18 +221,6 @@ function createSyncEngine(entries) {
 		}
 		return null;
 	}
-	/** External channels a new root in this board channel starts threads in. */
-	async function configTargets(channel) {
-		const targets = [];
-		for (const [key, platform] of Object.entries(entries)) {
-			if (!platform.canStartThreads) continue;
-			for (const [external, target] of await mappings(key)) if (target.channel === channel) targets.push({
-				target: external,
-				kind: "channel"
-			});
-		}
-		return targets;
-	}
 	/** Validates a requested target and resolves names (`slack:#prs`) to IDs. */
 	async function normalizeTarget(target) {
 		const at = target.indexOf(":");
@@ -254,7 +248,8 @@ function createSyncEngine(entries) {
 			event.thread,
 			"subthread" in event ? event.subthread : null
 		]) if (location !== null && !location.startsWith(`${key}:`)) throw badRequest(`provider locations must belong to sync entry ${key}`);
-		if (!(await mappings(key)).has(event.channel) && !await syncsThread(event.thread)) return;
+		const routes = routesFor(platformOf(key));
+		if (routes && !await routes(native(event.channel), (name) => resolve(key, name)) && !await syncsThread(event.thread)) return;
 		await call("inboxPush", {
 			key,
 			events: [{
@@ -458,11 +453,10 @@ function createSyncEngine(entries) {
 			notes
 		};
 	}
-	/** One platform event from the inbox, onto the board. `id` is its ID there, which its writes derive theirs from. */
+	/** One platform event from the inbox, through its entry's sync function. `id` is its ID there, which its writes derive theirs from. */
 	async function inbound(key, item, meta) {
 		const { event, raw } = item;
 		const platform = platformOf(key);
-		const mapping = (await mappings(key)).get(event.channel);
 		const linked = (await find({ thread: event.thread })).thread ?? void 0;
 		if (event.kind === "message") {
 			const copied = (await find({
@@ -483,56 +477,68 @@ function createSyncEngine(entries) {
 			avatar: null,
 			isBot: true
 		};
-		const board = host().client({
-			author,
-			key,
-			...originOf(key, event)
-		}, meta.id);
-		let applied;
-		let active = true;
-		const context = {
+		let typed;
+		const typedEvent = () => typed ??= immutable(platform.event({
 			id: meta.id,
 			key,
 			event,
-			raw,
-			board,
-			apply(channel, overrides = {}) {
-				if (!active) throw badRequest("the sync callback has finished");
-				if (applied) throw badRequest("an event can only be imported once per callback");
-				applied = applyIncoming(key, item, meta, ChannelPath.parse(channel), SyncOverrides.parse(overrides)).catch(async (error) => {
-					if (!(error instanceof DroppedError)) throw error;
-					const thread = (await find({ thread: event.thread })).thread;
-					return {
-						root: thread === null ? null : (await syncOf(thread))?.root ?? null,
-						message: null
-					};
+			raw
+		}));
+		let imported;
+		let link;
+		let active = true;
+		const sync = {
+			direction: "in",
+			key,
+			channel: native(event.channel),
+			get event() {
+				return typedEvent();
+			},
+			board: host().client({
+				author,
+				key,
+				...originOf(key, event)
+			}, meta.id),
+			import(channel, overrides = {}) {
+				if (!active) throw badRequest("the sync function has finished");
+				imported ??= importEvent(key, item, meta, linked, channel, overrides);
+				return imported;
+			},
+			permalink() {
+				const promise = link ?? platform.permalink(typedEvent());
+				link = promise;
+				promise.catch(() => {
+					if (link === promise) link = void 0;
 				});
-				return applied;
+				return promise;
 			},
-			client(publicEvent) {
-				async function sync(first, second, overrides) {
-					if (!active) throw badRequest("the sync callback has finished");
-					if (typeof second === "string") return board.sync(first, second);
-					if (typeof first !== "string" || second !== publicEvent) throw badRequest("sync only accepts the current verified event");
-					return platform.sync(context, first, overrides);
-				}
-				return {
-					...board,
-					sync
-				};
-			}
+			resolve: (name) => resolve(key, name)
 		};
 		try {
-			if (mapping?.run) {
-				await mapping.run(context);
-				return;
-			}
-			const channel = mapping?.channel ?? (linked ? (await syncOf(linked))?.channel : void 0);
-			if (channel) await platform.sync(context, channel);
+			await platform.sync(sync);
+			await imported;
 		} finally {
 			active = false;
 		}
 	}
+	/** The import `sync.import` makes: into the event's board thread, or a new root in `channel`. */
+	async function importEvent(key, item, meta, linked, channel, overrides) {
+		const where = channel ?? (linked ? (await syncOf(linked))?.channel : void 0);
+		if (where === void 0) return {
+			root: null,
+			message: null
+		};
+		try {
+			return await applyIncoming(key, item, meta, ChannelPath.parse(where), SyncOverrides.parse(overrides));
+		} catch (error) {
+			if (!(error instanceof DroppedError)) throw error;
+			const thread = (await find({ thread: item.event.thread })).thread;
+			return {
+				root: thread === null ? null : (await syncOf(thread))?.root ?? null,
+				message: null
+			};
+		}
+	}
 	/**
 	* Where a platform event's writes come from, for the middleware, and how it answers
 	* there: a reply in the event's own platform thread.
@@ -652,14 +658,6 @@ function createSyncEngine(entries) {
 			throw new DroppedError(answer.dropped);
 		};
 		const post = async ({ attachments = [], ...input }) => {
-			const where = input.channel ?? synced?.channel ?? channel;
-			const caller = input.re === void 0 ? {
-				...me,
-				origin: {
-					...me.origin,
-					config: await configTargets(where)
-				}
-			} : me;
 			return {
 				id: await screened(await call("syncImport", {
 					op: "post",
@@ -668,7 +666,7 @@ function createSyncEngine(entries) {
 					...input,
 					origin: input.origin ?? null,
 					...attachments.length ? { attachments: attachments.map((file) => file.id) } : {}
-				}, NEVER, caller)),
+				})),
 				re: input.re ?? null
 			};
 		};
@@ -883,6 +881,24 @@ function createSyncEngine(entries) {
 					const set = Object.fromEntries(Object.entries(desired).filter(([key, value]) => root?.labels[key] !== value));
 					const unset = Object.keys(root?.labels ?? {}).filter((key) => !(key in desired) && (event.unset.includes(key) || overrides.unset?.includes(key) || owned(key)));
 					if (root && !root.deleted && (Object.keys(set).length || unset.length)) await setLabels(event.author, set, unset);
+					if (event.retitled && root && !root.deleted && root.from === key && root.origin?.thread === event.thread) {
+						const text = clampText(overrides.text ?? rootDraft({
+							text: event.url ? `${event.title}\n${event.url}` : event.title,
+							labels: root.labels,
+							author: event.author,
+							raw
+						}).text);
+						if (root.text !== text) await screened(await call("syncImport", {
+							op: "edit",
+							author: event.author,
+							from: key,
+							origin: {
+								thread: root.origin.thread,
+								message: root.origin.message
+							},
+							text
+						}));
+					}
 					if (event.reply) return result(await post({
 						author: event.author,
 						re: rootId,
@@ -1001,14 +1017,14 @@ function createSyncEngine(entries) {
 			return null;
 		}
 	}
-	/** A board message as markdown for a platform, which converts it to its own format. */
-	function render(key, target, message, actors) {
+	/** A board message as markdown for a platform, which converts it to its own format: by `renderer`, or the provider's own. */
+	function render(key, target, message, actors, renderer) {
 		const actor = actors.byId[message.by.actor];
 		let name = actor?.name ?? message.by.actor;
 		if (message.by.profile && actor?.handle.includes("/")) name = `${actor.name} via ${actor.handle.split("/")[0]}`;
 		if (message.from) name = `${name} (${entries[message.from]?.platform ?? message.by.actor.slice(0, message.by.actor.indexOf(":"))})`;
 		const platform = platformOf(key);
-		const body = platform.render(immutable({
+		const body = (renderer ?? ((input) => platform.render(input)))(immutable({
 			message: {
 				...structuredClone(message),
 				text: displayText(message.text, message.by.actor)
@@ -1045,19 +1061,19 @@ function createSyncEngine(entries) {
 	* `render`, with a line per file where the files won't follow: on a platform
 	* that takes no uploads, or one that refused them (`noted`).
 	*/
-	const renderFor = (target, message, actors, noted = false) => {
+	const renderFor = (target, message, actors, noted = false, renderer) => {
 		const key = keyOf(target);
-		const { markdown, as } = render(key, target, message, actors);
+		const { markdown, as } = render(key, target, message, actors, renderer);
 		return {
 			markdown: message.attachments.length > 0 && (noted || !platformOf(key).uploadsFiles) ? `${markdown}\n${attachmentNotes(message)}` : markdown,
 			...as ? { as } : {}
 		};
 	};
-	async function postReply(message, target, externalThread, actors) {
+	async function postReply(message, target, externalThread, actors, renderer) {
 		const replyCopy = message.replyTo === null ? void 0 : (await copiesOf([message.replyTo]))[message.replyTo]?.[target];
 		const place = replyCopy !== void 0 && replyCopy.thread !== externalThread ? replyCopy.thread : externalThread;
 		const platform = platformOf(keyOf(target));
-		let body = renderFor(target, message, actors);
+		let body = renderFor(target, message, actors, false, renderer);
 		let files;
 		let sentId;
 		if (!body.markdown.trim() && message.attachments.length && platform.uploadsFiles) try {
@@ -1066,7 +1082,7 @@ function createSyncEngine(entries) {
 			files = sent.files;
 		} catch (error) {
 			if (!platform.refusesFiles(error) && !keepsNoFiles(error)) throw error;
-			body = renderFor(target, message, actors, true);
+			body = renderFor(target, message, actors, true, renderer);
 			sentId = (await platform.post(native(place), "thread", body)).message;
 			files = null;
 		}
@@ -1124,7 +1140,7 @@ function createSyncEngine(entries) {
 	* receipt comes first, so a retry sends only what's missing. If the platform
 	* refuses files, the text gets a line for each; any other failure retries.
 	*/
-	async function deliverFiles(message, target, copy, actors) {
+	async function deliverFiles(message, target, copy, actors, renderer) {
 		const platform = platformOf(keyOf(target));
 		if (!platform.uploadsFiles || message.attachments.length === 0 || copy.files !== void 0) return;
 		let ids;
@@ -1137,7 +1153,7 @@ function createSyncEngine(entries) {
 			});
 			console.warn(`[board] ${target} won't take #${message.id}'s files (${describe(error)}); noting them in its text`);
 			ids = null;
-			await platform.edit(native(copy.thread), copy.message, renderFor(target, message, actors, true)).catch((edit) => console.warn(`[board] couldn't note #${message.id}'s files on ${target}:`, describe(edit)));
+			await platform.edit(native(copy.thread), copy.message, renderFor(target, message, actors, true, renderer)).catch((edit) => console.warn(`[board] couldn't note #${message.id}'s files on ${target}:`, describe(edit)));
 		}
 		await call("syncReceipt", {
 			kind: "files",
@@ -1146,12 +1162,20 @@ function createSyncEngine(entries) {
 			files: ids
 		});
 	}
+	/** Records a failure once: a delivery's own and the sync function that passed it on are one. */
+	const failed = (failures, id, target, error) => {
+		if (!failures.some((failure) => failure.error === error)) failures.push({
+			id,
+			target,
+			error
+		});
+	};
 	async function settle(attempt, failures) {
 		if (failures.length === 0) return;
 		if (attempt < DELIVERY_ATTEMPTS || afterRetry(attempt)) throw failures[0].error;
 		for (const { id, target, error } of failures) {
-			console.error(`[board] gave up delivering #${id} to ${target}:`, describe(error));
-			await call("syncReceipt", {
+			console.error(`[board] gave up ${target === null ? `syncing #${id}` : `delivering #${id} to ${target}`}:`, describe(error));
+			if (target !== null) await call("syncReceipt", {
 				kind: "failed",
 				message: id,
 				target,
@@ -1160,20 +1184,66 @@ function createSyncEngine(entries) {
 		}
 	}
 	/**
-	* A new root: the targets its channel syncs with. A root that came through this board landed
-	* with them; one that came another way (straight to the board this one uses) gets them now.
+	* Hands one board event, for one target, to its entry's sync function: `send` is what its
+	* `deliver` does, at most once. A throw, the function's or the delivery's, comes back here.
 	*/
-	async function configure(message) {
-		if (message.re !== null || message.noSync) return;
-		const originChannel = message.origin ? message.origin.channel ?? channelOf(message.origin.thread) : null;
-		for (const target of await configTargets(message.channel)) if (target.target !== originChannel) await call("syncReceipt", {
+	async function offer(key, event, message, target, send) {
+		let sent;
+		let active = true;
+		const finished = () => badRequest("the sync function has finished");
+		const sync = {
+			direction: "out",
+			key,
+			channel: target === null ? null : channelIn(key, target),
+			event: immutable(structuredClone(event)),
+			message: immutable(structuredClone(message)),
+			target,
+			deliver(options = {}) {
+				if (!active) throw finished();
+				sent ??= target === null ? Promise.resolve() : send(options.render);
+				return sent;
+			},
+			start(channel) {
+				if (!active) throw finished();
+				return startThread(key, message, channel);
+			},
+			resolve: (name) => resolve(key, name)
+		};
+		try {
+			await platformOf(key).sync(sync);
+			await sent;
+		} finally {
+			active = false;
+		}
+	}
+	/** Syncs a message's thread with a platform channel, as a sync function asked: never the channel it came from. */
+	async function startThread(key, message, channel) {
+		const { target, kind } = await normalizeTarget(`${key}:${channel}`);
+		const root = message.re === null ? message : await messageOf(message.re);
+		if (!root || root.deleted || root.noSync) return;
+		if (target === (root.origin ? root.origin.channel ?? channelOf(root.origin.thread) : null)) return;
+		await call("syncReceipt", {
 			kind: "thread",
-			message: message.id,
-			target: target.target,
-			targetKind: target.kind,
+			message: root.id,
+			target,
+			targetKind: kind,
 			cause: "config"
 		});
 	}
+	/** A new root, offered to each platform that can start threads: its sync function may `start` one there. */
+	async function deliverRoot(event, attempt) {
+		const starters = Object.keys(entries).filter((key) => entries[key].canStartThreads);
+		if (event.payload.noSync || starters.length === 0) return;
+		const root = await messageOf(event.message.id);
+		if (!root || root.deleted) return;
+		const failures = [];
+		for (const key of starters) try {
+			await offer(key, event, root, null, async () => {});
+		} catch (error) {
+			failed(failures, root.id, null, error);
+		}
+		await settle(attempt, failures);
+	}
 	async function deliverThread(event, attempt) {
 		const { thread, target } = event.payload;
 		if (!ours(target)) return;
@@ -1181,12 +1251,33 @@ function createSyncEngine(entries) {
 		const synced = await syncOf(thread);
 		const [root, ...replies] = synced ? await threadOf(synced.root) : [];
 		if (!synced || !root || root.id !== synced.root || root.deleted) return;
+		const failures = [];
+		try {
+			await offer(keyOf(target), event, root, target, (renderer) => backfill(synced, root, replies, target, failures, renderer));
+		} catch (error) {
+			failed(failures, root.id, target, error);
+		}
+		await settle(attempt, failures);
+	}
+	/**
+	* A thread's root into a platform channel, then what's been said in it, each once. A reply
+	* waits for its root; every reply is tried, and the first failure is thrown.
+	*/
+	async function backfill(synced, root, replies, target, failures, renderer) {
 		const actors = await actorsNow();
 		const copies = await copiesOf([root.id, ...replies.map((reply) => reply.id)]);
+		const rootFailed = (error) => {
+			failures.push({
+				id: root.id,
+				target,
+				error
+			});
+			return error;
+		};
 		let externalThread = synced.external[target];
 		if (!externalThread) try {
 			const platform = platformOf(keyOf(target));
-			const body = renderFor(target, root, actors);
+			const body = renderFor(target, root, actors, false, renderer);
 			const mediaOnly = !body.markdown.trim() && root.attachments.length > 0 && platform.uploadsFiles;
 			if (!body.markdown.trim() && !mediaOnly) throw badRequest("a renderer must return text unless the message has media");
 			let uploaded;
@@ -1210,7 +1301,7 @@ function createSyncEngine(entries) {
 				} catch (error) {
 					if (!platform.refusesFiles(error) && !keepsNoFiles(error)) throw error;
 					uploaded = null;
-					return platform.post(native(target), "channel", renderFor(target, root, actors, true));
+					return platform.post(native(target), "channel", renderFor(target, root, actors, true, renderer));
 				}
 			};
 			const sent = await post();
@@ -1222,46 +1313,39 @@ function createSyncEngine(entries) {
 				...postedAsPerson ? { asUser: true } : {}
 			};
 			await recordDelivery(root, target, external);
-			await deliverFiles(root, target, external, actors);
+			await deliverFiles(root, target, external, actors, renderer);
 		} catch (error) {
-			return settle(attempt, [{
-				id: root.id,
-				target,
-				error
-			}]);
+			throw rootFailed(error);
 		}
 		else {
 			const copy = copies[root.id]?.[target];
 			if (copy) try {
-				await deliverFiles(root, target, copy, actors);
+				await deliverFiles(root, target, copy, actors, renderer);
 			} catch (error) {
-				return settle(attempt, [{
-					id: root.id,
-					target,
-					error
-				}]);
+				throw rootFailed(error);
 			}
 		}
-		const failures = [];
+		const mine = [];
 		for (const reply of replies) {
 			if (reply.deleted || reply.noSync || cameFrom(reply, target)) continue;
 			try {
-				await deliverFiles(reply, target, copies[reply.id]?.[target] ?? await postReply(reply, target, externalThread, actors), actors);
+				await deliverFiles(reply, target, copies[reply.id]?.[target] ?? await postReply(reply, target, externalThread, actors, renderer), actors, renderer);
 			} catch (error) {
-				failures.push({
+				mine.push({
 					id: reply.id,
 					target,
 					error
 				});
 			}
 		}
-		await settle(attempt, failures);
+		failures.push(...mine);
+		if (mine.length) throw mine[0].error;
 	}
 	/** Never deliver a message back to the platform it came from. */
 	const cameFrom = (message, target) => message.origin?.thread === target || message.from !== null && keyOf(target) === message.from;
 	async function deliverPost(event, attempt) {
 		if (!event.message) return;
-		if (event.message.re === null) return configure(event.message);
+		if (event.message.re === null) return deliverRoot(event, attempt);
 		if (event.payload.noSync) return;
 		const synced = await syncOf(event.payload.thread);
 		if (!synced || synced.targets.length === 0) return;
@@ -1274,13 +1358,12 @@ function createSyncEngine(entries) {
 			if (!ours(target) || !externalThread) continue;
 			if (cameFrom(message, target)) continue;
 			try {
-				await deliverFiles(message, target, (await copiesOf([message.id]))[message.id]?.[target] ?? await postReply(message, target, externalThread, actors), actors);
-			} catch (error) {
-				failures.push({
-					id: message.id,
-					target,
-					error
+				await offer(keyOf(target), event, message, target, async (renderer) => {
+					const copy = (await copiesOf([message.id]))[message.id]?.[target] ?? await postReply(message, target, externalThread, actors, renderer);
+					await deliverFiles(message, target, copy, actors, renderer);
 				});
+			} catch (error) {
+				failed(failures, message.id, target, error);
 			}
 		}
 		await settle(attempt, failures);
@@ -1289,28 +1372,30 @@ function createSyncEngine(entries) {
 	async function deliverChange(event) {
 		const copies = (await copiesOf([event.payload.id]))[event.payload.id] ?? {};
 		if (Object.keys(copies).length === 0) return;
-		const message = event.type === "message.edited" ? await messageOf(event.payload.id) : event.message;
-		if (event.type === "message.edited" && (!message || message.deleted)) return;
+		const message = event.type === "message.edited" ? await messageOf(event.payload.id) : event.message ?? await messageOf(event.payload.id);
+		if (!message || event.type === "message.edited" && message.deleted) return;
 		const actors = await actorsNow();
 		for (const [target, copy] of Object.entries(copies)) {
 			if (!ours(target) || event.payload.from !== null && keyOf(target) === event.payload.from) continue;
 			try {
-				const platform = platformOf(keyOf(target));
-				const thread = native(copy.thread);
-				const theirs = copy.asUser && message && (event.type === "message.edited" || event.type === "message.deleted");
-				const token = theirs ? await personToken(platform, message, false) : null;
-				if (theirs && !token) {
-					console.warn(`[board] skipped ${event.type} on ${target}: #${message.id} was posted as its author, and their token is gone`);
-					continue;
-				}
-				if (event.type === "message.edited" && message) if (token) await platform.editAs(token, thread, copy.message, renderAsPerson(target, message, actors));
-				else await platform.edit(thread, copy.message, renderFor(target, message, actors, copy.files === null));
-				else if (event.type === "message.deleted") {
-					if (token) await platform.deleteAs(token, thread, copy.message);
-					else await platform.delete(thread, copy.message);
-					if (copy.files?.length) await platform.deleteFiles(copy.files);
-				} else if (event.type === "reaction.added") await platform.react(thread, copy.message, canonicalEmoji(event.payload.emoji), true);
-				else if (event.type === "reaction.removed") await platform.react(thread, copy.message, canonicalEmoji(event.payload.emoji), false);
+				await offer(keyOf(target), event, message, target, async (renderer) => {
+					const platform = platformOf(keyOf(target));
+					const thread = native(copy.thread);
+					const theirs = copy.asUser && (event.type === "message.edited" || event.type === "message.deleted");
+					const token = theirs ? await personToken(platform, message, false) : null;
+					if (theirs && !token) {
+						console.warn(`[board] skipped ${event.type} on ${target}: #${message.id} was posted as its author, and their token is gone`);
+						return;
+					}
+					if (event.type === "message.edited") if (token) await platform.editAs(token, thread, copy.message, renderAsPerson(target, message, actors));
+					else await platform.edit(thread, copy.message, renderFor(target, message, actors, copy.files === null, renderer));
+					else if (event.type === "message.deleted") {
+						if (token) await platform.deleteAs(token, thread, copy.message);
+						else await platform.delete(thread, copy.message);
+						if (copy.files?.length) await platform.deleteFiles(copy.files);
+					} else if (event.type === "reaction.added") await platform.react(thread, copy.message, canonicalEmoji(event.payload.emoji), true);
+					else await platform.react(thread, copy.message, canonicalEmoji(event.payload.emoji), false);
+				});
 			} catch (error) {
 				console.warn(`[board] skipped ${event.type} on ${target}:`, error.message);
 			}
@@ -1339,9 +1424,11 @@ function createSyncEngine(entries) {
 		for (const [target, copy] of Object.entries(copies)) {
 			if (!ours(target)) continue;
 			try {
-				const body = renderFor(target, message, actors, copy.files === null);
-				if (body.markdown === renderFor(target, previous, actors, copy.files === null).markdown) continue;
-				await platformOf(keyOf(target)).edit(native(copy.thread), copy.message, body);
+				await offer(keyOf(target), event, message, target, async (renderer) => {
+					const body = renderFor(target, message, actors, copy.files === null, renderer);
+					if (body.markdown === renderFor(target, previous, actors, copy.files === null, renderer).markdown) return;
+					await platformOf(keyOf(target)).edit(native(copy.thread), copy.message, body);
+				});
 			} catch (error) {
 				console.warn(`[board] skipped labels.changed on ${target}:`, describe(error));
 			}
@@ -1432,7 +1519,6 @@ function createSyncEngine(entries) {
 		deliver,
 		receive: inbound,
 		pull,
-		configTargets,
 		normalizeTarget,
 		findByEmail,
 		handleWebhook,