@vercel/board 0.0.0 → 0.15.0

package/dist/engine-3EvQ8idk.mjs

@@ -0,0 +1,1449 @@
+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 { t as canonicalEmoji } from "./emoji-CTLpvH-A.mjs";
+import { r as badRequest, s as notFound, t as HttpError } from "./errors-DX3hpwWt.mjs";
+import { s as replaceMentions } from "./actors-rdN4dDTU.mjs";
+import { i as DroppedError } from "./targets-ojFEXEyN.mjs";
+import { c as isThreadTarget, r as externalMessageKey } from "./reducers-mUPFuFJV.mjs";
+import { _ as waitUntil, o as channelOf, t as afterRetry } from "./attempts-BQUp9MKO.mjs";
+import { i as UnreadableError, l as immutable, n as ResolvedTarget, o as SyncOverrides, t as ReceivedEvent } from "./provider-CuewcDNZ.mjs";
+import { t as displayText } from "./bots-CGkO76qH.mjs";
+//#region src/sync/engine.ts
+/** `files`: a message with files may have no text. */
+const clampText = (raw, files = false) => {
+	const text = toStorable(raw);
+	const trimmed = text.trim() === "" ? files ? "" : "(no text)" : text;
+	return trimmed.length > 1e4 ? `${trimmed.slice(0, MESSAGE_TEXT_MAX - 1).toWellFormed()}…` : trimmed;
+};
+/** A platform file the board couldn't bring over gets a line in the text instead. */
+const fileNote = (file, why, name = file.name ?? "a file") => `📎 ${name}${file.size !== void 0 ? ` (${fileSize(file.size)})` : ""} didn't come over: ${why}`;
+/** What a board that keeps no files answers for every file route. */
+const keepsNoFiles = (error) => error instanceof HttpError && error.code === "no_files";
+/**
+* A platform file on a board that keeps no files: a link to where it lives on the platform, which
+* its readers there can open, or its name when the platform gave no URL.
+*/
+const fileLink = (file) => {
+	const name = file.name ?? "a file";
+	if (!file.url || !/^https?:\/\//.test(file.url)) return fileNote(file, "this board keeps no files");
+	const label = name.replace(/[[\]\\]/g, (char) => `\\${char}`);
+	const url = file.url.replace(/[ ()]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+	return fileNote(file, "this board keeps no files", `[${label}](${url})`);
+};
+/** A platform message's text with its file notes after it. */
+const withNotes = (text, notes) => notes.length ? `${text.trim() ? `${text}\n\n` : ""}${notes.join("\n")}` : text;
+/** The file notes in a message's text, so a platform edit (which only knows the text it shows) keeps them. */
+const notesIn = (text) => text.split("\n").filter((line) => /^📎 .* didn't come over: /u.test(line));
+const linkKey = (link) => JSON.stringify([
+	link.url,
+	link.message,
+	link.snapshot,
+	link.unavailable
+]);
+/** Whether two link lists say the same, whatever order their keys were written in. */
+const sameLinks = (a, b) => a.length === b.length && a.every((link, i) => linkKey(link) === linkKey(b[i]));
+/**
+* A one-time code for linking an account: a platform message that is only a live
+* code is claimed, not imported.
+*/
+const CODE = /^\s*`?(vb-[a-z0-9]{4}-[a-z0-9]{4})`?\s*$/i;
+/**
+* How long a board message written by someone who posts as themselves may still be
+* on its way out: their copy comes back through the webhook looking like any of
+* their messages, and until its receipt lands, it's held back rather than imported twice.
+*/
+const ECHO_WINDOW_MS = 6e4;
+const ECHO_ATTEMPTS = 6;
+/** Tries per file before it's noted instead: a retry repeats the whole message, so keep it short. */
+const FILE_ATTEMPTS = 3;
+/** How long a webhook waits for the board's tables before it lets an event into the inbox anyway: platforms resend after about 3 seconds. */
+const GATE_WAIT_MS = 2e3;
+/**
+* A2 dead-letters an event after 10 failures, and a dead letter stops its lane,
+* which is the thread's: nothing after it would sync. So a delivery retries a
+* few times, then records a `failed` receipt and lets the thread move on.
+*/
+const DELIVERY_ATTEMPTS = 5;
+/** How long one pull of the inbox runs before it leaves the rest to the next. */
+const PULL_MS = 24e4;
+/** A signal that never aborts, for the engine's own calls. */
+const NEVER = new AbortController().signal;
+const jsonSafe = (value) => {
+	try {
+		return JSON.parse(JSON.stringify(value ?? null));
+	} catch {
+		return null;
+	}
+};
+/** Plain JSON with every string, keys too, as the board keeps it: platforms send what Postgres can't store. */
+const storableJson = (value) => {
+	if (typeof value === "string") return toStorable(value);
+	if (Array.isArray(value)) return value.map(storableJson);
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [toStorable(key), storableJson(item)]));
+	return value;
+};
+/** A platform error's code (`not_in_channel`) when it has one, else its message. */
+const describe = (error) => {
+	const code = error?.data?.error;
+	const text = typeof code === "string" ? code : error instanceof Error ? error.message : String(error);
+	return toStorable(text.slice(0, 500)) || "unknown error";
+};
+/** A board error that says what wasn't there. */
+const missing = (error) => error instanceof HttpError && error.status === 404;
+/**
+* Two-way sync between a board and its platforms, run by board(): webhooks come in through its
+* adapters and land in the backend's inbox, and what the board's subscription delivers goes out
+* to them. It reads and writes only through the backend's protocol methods, as `caller`.
+*/
+function createSyncEngine(entries) {
+	let bound = null;
+	const host = () => {
+		if (!bound) throw new Error("sync used before board() bound it");
+		return bound;
+	};
+	/** Sync's own caller: on a2(), `board:sync`; on http(), this deployment itself. */
+	const me = {
+		self: "sync",
+		origin: { via: { kind: "engine" } }
+	};
+	/** One protocol method, as sync. */
+	function call(method, input, signal = NEVER, caller = me) {
+		const backend = host().backend;
+		return backend[method].call(backend, caller, input, signal);
+	}
+	const platformOf = (key) => {
+		const platform = entries[key];
+		if (!platform) throw badRequest(`no sync entry named ${key}`);
+		return platform;
+	};
+	const keyOf = (target) => target.slice(0, target.indexOf(":"));
+	/** A target of this sync's own: another sync on the board (its own, or one elsewhere) delivers the rest. */
+	const ours = (target) => entries[keyOf(target)] !== void 0;
+	const native = (external) => external.slice(external.indexOf(":") + 1);
+	/** A thread's sync, or null when the board has no such thread. */
+	async function syncOf(thread) {
+		try {
+			return await call("syncThread", { thread });
+		} catch (error) {
+			if (missing(error)) return null;
+			throw error;
+		}
+	}
+	/** A board thread: its root and every reply, deleted ones included. */
+	async function threadOf(root) {
+		try {
+			const { message, replies } = await call("message", { id: root });
+			return [message, ...replies];
+		} catch (error) {
+			if (missing(error)) return [];
+			throw error;
+		}
+	}
+	/** One board message as it is now. */
+	async function messageOf(id) {
+		return (await threadOf(id)).find((message) => message.id === id) ?? null;
+	}
+	async function copiesOf(ids) {
+		if (ids.length === 0) return {};
+		return (await call("syncCopies", { message: [...new Set(ids)] })).copies;
+	}
+	const find = (query, signal) => call("syncFind", query, signal);
+	/** The actors sync renders with, as the board has them now. */
+	async function actorsNow() {
+		const { actors } = await call("actors", {});
+		const state = {
+			byId: {},
+			links: {}
+		};
+		for (const { person, ...actor } of actors) {
+			state.byId[actor.id] = {
+				id: actor.id,
+				kind: actor.kind,
+				handle: actor.handle,
+				name: actor.name,
+				avatar: actor.avatar
+			};
+			if (person) state.links[actor.id] = person.id;
+		}
+		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. */
+	const RETRY_MS = 6e4;
+	const resolved = /* @__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.
+	*/
+	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);
+		const entry = {
+			complete: true,
+			at: Date.now(),
+			map: Promise.resolve(/* @__PURE__ */ new Map())
+		};
+		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;
+		});
+		resolved.set(key, entry);
+		return entry.map;
+	};
+	/** A synced platform's user with this email, for `@[ada@vercel.com]`. */
+	async function findByEmail(email) {
+		for (const platform of Object.values(entries)) {
+			const author = await platform.findByEmail(email).catch(() => null);
+			if (author) return {
+				id: author.id,
+				kind: "external",
+				handle: author.handle,
+				name: author.name,
+				avatar: author.avatar
+			};
+		}
+		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(":");
+		if (at <= 0) throw badRequest(`sync targets look like <key>:<channel or thread>, got: ${target}`);
+		const key = target.slice(0, at);
+		const platform = platformOf(key);
+		try {
+			const resolved = ResolvedTarget.parse(await platform.resolveTarget(target.slice(at + 1)));
+			if (resolved.kind === "channel" && !platform.canStartThreads) throw new Error(`${platform.platform} cannot start threads; use an existing thread`);
+			return {
+				target: `${key}:${resolved.target}`,
+				kind: resolved.kind
+			};
+		} catch (error) {
+			throw badRequest(`can't sync to ${target}: ${error.message}`);
+		}
+	}
+	async function intake(key, received) {
+		const { event, raw, dedupe } = ReceivedEvent.parse(storableJson({
+			...received,
+			raw: jsonSafe(received.raw)
+		}));
+		for (const location of [
+			event.channel,
+			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;
+		await call("inboxPush", {
+			key,
+			events: [{
+				id: dedupe,
+				event,
+				raw
+			}]
+		});
+	}
+	/**
+	* Whether the board syncs a platform thread outside its mapped channels. A receipt or a
+	* request that just synced it may not be in its tables yet, so a miss waits for them;
+	* if they're still catching up, the inbox decides, since it waits as long as it takes.
+	*/
+	async function syncsThread(thread) {
+		try {
+			return (await find({ thread }, AbortSignal.timeout(GATE_WAIT_MS))).thread !== null;
+		} catch (error) {
+			const name = error?.name;
+			if (name === "TimeoutError" || name === "AbortError") return true;
+			throw error;
+		}
+	}
+	async function handleWebhook(key, request) {
+		const platform = entries[key];
+		if (!platform) throw notFound(`no sync entry named ${key}`);
+		let response;
+		try {
+			response = await platform.receive(key, request, (received) => intake(key, received));
+		} catch (error) {
+			console.error("[board] intake failed", error);
+			return new Response("intake failed", { status: 500 });
+		}
+		const pulling = pull([key]).catch((error) => console.error(`[board] couldn't pull ${key}'s inbox:`, describe(error)));
+		waitUntil(pulling);
+		return response;
+	}
+	/**
+	* Pulls what this board's sync queued in the backend's inbox, runs it, and acks it, until
+	* nothing's left or this run's time is up. A platform thread's events come one at a time.
+	*/
+	async function pull(keys = Object.keys(entries)) {
+		let ran = 0;
+		const until = Date.now() + PULL_MS;
+		for (const key of keys) while (Date.now() < until) {
+			const { items } = await call("inboxNext", {
+				key,
+				limit: 10
+			});
+			if (items.length === 0) break;
+			await Promise.all(items.map((item) => runItem(key, item)));
+			ran += items.length;
+		}
+		return ran;
+	}
+	async function runItem(key, item) {
+		let error;
+		try {
+			await inbound(key, {
+				event: item.event,
+				raw: item.raw
+			}, {
+				id: item.id,
+				attempt: item.attempt + 1
+			});
+		} catch (failure) {
+			console.error(`[board] sync ${key} couldn't import ${item.id}:`, describe(failure));
+			error = describe(failure);
+		}
+		await call("inboxAck", {
+			key,
+			id: item.id,
+			lease: item.lease,
+			...error !== void 0 ? { error } : {}
+		}).catch((failure) => console.error(`[board] couldn't ack an inbox event:`, describe(failure)));
+	}
+	/**
+	* What a platform message's links point to, for a message in board channel `channel`. A linked
+	* message the board has (it was synced) in that same channel is that board message; otherwise
+	* it's what the platform sent about it (Slack's unfurl, which the platform checked against who
+	* posted the link), what an earlier version of this message had, or what the platform says when
+	* asked. A board copy in another channel is never one: sync reads every channel, and the link's
+	* readers may not read that one. A link nobody can read says why.
+	*/
+	async function resolveLinks(platform, links, channel, previous = []) {
+		if (links.length === 0) return [];
+		const resolved = [];
+		for (const link of links) {
+			if (resolved.some((done) => done.url === link.url)) continue;
+			const id = (await find({
+				thread: link.thread,
+				message: link.message
+			})).message;
+			const copy = id === null ? null : await messageOf(id);
+			if (copy && !copy.deleted && copy.channel === channel) {
+				resolved.push({
+					url: link.url,
+					message: copy.id,
+					unavailable: null,
+					snapshot: {
+						author: copy.author?.name ?? copy.by.actor,
+						text: copy.text,
+						createdAt: copy.createdAt,
+						files: copy.attachments.map((file) => ({
+							name: file.name,
+							url: null
+						}))
+					}
+				});
+				continue;
+			}
+			if (link.snapshot) {
+				resolved.push({
+					url: link.url,
+					message: null,
+					snapshot: link.snapshot,
+					unavailable: null
+				});
+				continue;
+			}
+			const kept = previous.find((earlier) => earlier.url === link.url && earlier.snapshot && earlier.message === null);
+			if (kept) {
+				resolved.push(kept);
+				continue;
+			}
+			const fetched = await platform.fetchLink(link).catch((error) => ({
+				snapshot: null,
+				unavailable: describe(error)
+			}));
+			resolved.push({
+				url: link.url,
+				message: null,
+				snapshot: fetched.snapshot,
+				unavailable: fetched.snapshot ? null : (fetched.unavailable ?? "unknown").slice(0, 300)
+			});
+		}
+		return storableJson(resolved);
+	}
+	/**
+	* A platform message's files, onto the board: each is fetched through its
+	* adapter (Chat SDK's `rehydrateAttachment`, so any platform that has it works)
+	* and uploaded. A file that can't come over (too big, the platform refused)
+	* becomes a line in the text, and on a board that keeps no files, a line that
+	* links it where it lives; a failed fetch retries the message a few times first.
+	*/
+	async function importFiles(platform, files, attempt) {
+		const attachments = [];
+		const notes = [];
+		let noFiles = false;
+		for (const file of files.slice(0, 10)) {
+			if (noFiles) {
+				notes.push(fileLink(file));
+				continue;
+			}
+			if (file.size !== void 0 && file.size > 26214400) {
+				notes.push(fileNote(file, `over ${IMPORT_BYTES_MAX / 1024 / 1024} MB`));
+				continue;
+			}
+			let data;
+			try {
+				const fetched = await platform.fetchFile(file);
+				if (fetched === null) {
+					notes.push(fileNote(file, `${platform.platform} can't hand it over`));
+					continue;
+				}
+				data = fetched;
+			} catch (error) {
+				if (attempt < FILE_ATTEMPTS) throw error;
+				console.warn(`[board] couldn't fetch ${file.name ?? "a file"} from ${platform.platform}:`, describe(error));
+				notes.push(fileNote(file, `${platform.platform} wouldn't hand it over`));
+				continue;
+			}
+			if (data.byteLength > 26214400) {
+				notes.push(fileNote(file, `over ${IMPORT_BYTES_MAX / 1024 / 1024} MB`));
+				continue;
+			}
+			if (data.byteLength === 0) {
+				notes.push(fileNote(file, "it was empty"));
+				continue;
+			}
+			const name = file.name ?? `${file.type}`;
+			try {
+				attachments.push((await call("upload", {
+					data,
+					name,
+					type: file.mimeType || typeOf(name)
+				})).attachment);
+			} catch (error) {
+				if (error instanceof HttpError && (error.code === "too_large" || error.code === "no_direct_uploads")) {
+					notes.push(fileNote(file, `over ${ATTACHMENT_BYTES_MAX / 1024 / 1024} MB`));
+					continue;
+				}
+				if (!keepsNoFiles(error)) throw error;
+				noFiles = true;
+				notes.push(fileLink(file));
+			}
+		}
+		for (const file of files.slice(10)) notes.push(fileNote(file, `a message carries at most 10`));
+		return {
+			attachments,
+			notes
+		};
+	}
+	/** One platform event from the inbox, onto the board. `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({
+				thread: event.subthread ?? event.thread,
+				message: event.message
+			})).message;
+			if (copied !== null) {
+				const origin = (await messageOf(copied))?.origin;
+				if (!origin || origin.message !== event.message || (origin.subthread ?? origin.thread) !== (event.subthread ?? event.thread)) return;
+			} else if (platform.users && meta.attempt < ECHO_ATTEMPTS && await deliveringAsPerson(linked, event)) throw new Error(`holding ${event.message} until ${event.author.id}'s board message there has its receipt`);
+			const code = event.author.isBot ? void 0 : CODE.exec(event.text)?.[1];
+			if (code && await claimCode(key, event, code)) return;
+		}
+		const author = "author" in event ? event.author : {
+			id: `${platform.platform}:system`,
+			handle: platform.platform,
+			name: platform.platform,
+			avatar: null,
+			isBot: true
+		};
+		const board = host().client({
+			author,
+			key,
+			...originOf(key, event)
+		}, meta.id);
+		let applied;
+		let active = true;
+		const context = {
+			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
+					};
+				});
+				return applied;
+			},
+			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
+				};
+			}
+		};
+		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);
+		} finally {
+			active = false;
+		}
+	}
+	/**
+	* 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.
+	*/
+	function originOf(key, event) {
+		const platform = platformOf(key);
+		const thread = ("subthread" in event ? event.subthread : null) ?? event.thread;
+		return {
+			via: {
+				kind: "sync",
+				key,
+				platform: platform.platform,
+				channel: event.channel,
+				thread
+			},
+			respond: async (text) => {
+				await platform.post(native(thread), "thread", { markdown: text });
+			}
+		};
+	}
+	/**
+	* Whether a board message by the person behind `event`'s author (an account they
+	* signed in with) may be on its way there as them, without a receipt yet: then
+	* `event` could be that very copy. In a thread the board knows (`thread`), that's
+	* any of the person's messages still going to it; anywhere else, a new thread of
+	* theirs still going to `event`'s channel, whose platform thread the board learns
+	* only from the receipt.
+	*/
+	async function deliveringAsPerson(thread, event) {
+		const person = (await find({ account: event.author.id })).person;
+		if (!person || person.method !== "consent") return false;
+		const now = Date.now();
+		const pending = (message, target, copies) => message.by.principal === person.id && message.by.profile === null && message.from === null && !message.deleted && !message.noSync && now - Date.parse(message.createdAt) < ECHO_WINDOW_MS && !copies[target] && !message.undelivered[target];
+		if (thread !== void 0) {
+			const synced = await syncOf(thread);
+			if (!synced) return false;
+			const targets = synced.targets.filter((target) => synced.external[target] === event.thread);
+			const messages = await threadOf(synced.root);
+			const copies = await copiesOf(messages.map((message) => message.id));
+			return messages.some((message) => targets.some((target) => pending(message, target, copies[message.id] ?? {})));
+		}
+		const { roots } = await call("syncRoots", {
+			by: person.id,
+			since: now - ECHO_WINDOW_MS
+		});
+		const copies = await copiesOf(roots.map((root) => root.id));
+		for (const root of roots) {
+			const synced = await syncOf(root.thread);
+			if (synced?.targets.includes(event.channel) && !synced.external[event.channel] && pending(root, event.channel, copies[root.id] ?? {})) return true;
+		}
+		return false;
+	}
+	/** A live code, posted from `event`'s account through the entry it was issued for: link them. */
+	async function claimCode(key, event, code) {
+		try {
+			await call("syncAccount", {
+				sync: key,
+				account: event.author,
+				code,
+				message: externalMessageKey(event.subthread ?? event.thread, event.message)
+			});
+		} catch (error) {
+			if (missing(error)) return false;
+			throw error;
+		}
+		await platformOf(key).react(native(event.subthread ?? event.thread), event.message, "check", true).catch((error) => console.warn(`[board] couldn't confirm a linking code on ${key}:`, describe(error)));
+		return true;
+	}
+	/** Whether entry `key` signs people in: its sign-in links the account, and lets the board post as them. */
+	const signsIn = (key) => platformOf(key).users !== null;
+	/**
+	* A sign-in on entry `key` for `subject`, the person a code was issued to: the platform's URL,
+	* which sends them to `callback` once they've approved.
+	*/
+	async function signIn(key, subject, callback) {
+		const platform = platformOf(key);
+		if (!platform.users) throw badRequest(`${key} can't sign people in: link it with a code`);
+		return platform.users.authorize(subject, callback ? { callback } : {});
+	}
+	/** The account `subject` signed in with on entry `key`, or null while they haven't. */
+	async function signedIn(key, subject) {
+		const platform = platformOf(key);
+		if (!platform.users) throw badRequest(`${key} can't sign people in: link it with a code`);
+		const token = await platform.users.token(subject);
+		if (!token) return null;
+		const account = await platform.whoAmI(token);
+		if (!account.id.startsWith(`${platform.platform}:user:`)) throw badRequest(`${key} named an account that isn't a ${platform.platform} user`);
+		return account;
+	}
+	/** Links the account `subject` signed in with to them, by the code they carried through: null while they haven't. */
+	async function redeemSignIn(key, subject, code) {
+		const account = await signedIn(key, subject);
+		if (!account) return null;
+		return (await call("syncAccount", {
+			sync: key,
+			account,
+			code,
+			method: "consent"
+		})).link;
+	}
+	async function applyIncoming(key, item, meta, channel, overrides) {
+		const { event, raw } = item;
+		const source = originOf(key, event);
+		const platform = platformOf(key);
+		const threadKey = (await find({ thread: event.thread })).thread ?? void 0;
+		const synced = threadKey ? await syncOf(threadKey) : null;
+		const rootId = synced?.root;
+		const writeId = (n) => derivedId("board-inbound", meta.id, String(n));
+		const from = {
+			key,
+			channel: source.via.channel,
+			thread: source.via.thread
+		};
+		const screened = async (answer) => {
+			if (!answer.dropped) return answer.message;
+			for (const text of answer.dropped) await source.respond(text);
+			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",
+					from: key,
+					source: from,
+					...input,
+					origin: input.origin ?? null,
+					...attachments.length ? { attachments: attachments.map((file) => file.id) } : {}
+				}, NEVER, caller)),
+				re: input.re ?? null
+			};
+		};
+		const result = (message) => ({
+			root: message.re ?? message.id,
+			message: message.id
+		});
+		const labels = (defaults = {}) => {
+			const merged = {
+				...defaults,
+				...overrides.labels
+			};
+			for (const key of overrides.unset ?? []) delete merged[key];
+			return merged;
+		};
+		const rootDraft = (draft) => {
+			if (!overrides.root) return draft;
+			const patch = overrides.root(immutable(structuredClone(draft)));
+			if (patch && typeof patch === "object" && "then" in patch) throw badRequest("root overrides must be synchronous");
+			const checked = SyncOverrides.pick({
+				text: true,
+				labels: true
+			}).parse(patch);
+			return {
+				...draft,
+				text: checked.text ?? draft.text,
+				labels: {
+					...draft.labels,
+					...checked.labels
+				}
+			};
+		};
+		/** Labels for the thread's root, as `author`. */
+		const setLabels = (author, set, unset) => call("syncImport", {
+			op: "labels",
+			author,
+			from: key,
+			origin: { thread: event.thread },
+			set,
+			unset
+		});
+		const setExtraLabels = async (author, id) => {
+			if (!overrides.labels && !overrides.unset) return;
+			const root = await messageOf(id);
+			const set = Object.fromEntries(Object.entries(overrides.labels ?? {}).filter(([key, value]) => root?.labels[key] !== value));
+			const unset = (overrides.unset ?? []).filter((key) => root?.labels[key] !== void 0);
+			if (Object.keys(set).length || unset.length) await setLabels(author, set, unset);
+		};
+		switch (event.kind) {
+			case "message": {
+				const existing = (await find({
+					thread: event.subthread ?? event.thread,
+					message: event.message
+				})).message;
+				if (existing !== null) return {
+					root: rootId ?? existing,
+					message: existing
+				};
+				const { attachments, notes } = event.files?.length ? await importFiles(platform, event.files, meta.attempt) : {
+					attachments: [],
+					notes: []
+				};
+				const links = await resolveLinks(platform, event.links ?? [], synced?.channel ?? channel);
+				const base = {
+					...links.length ? { links } : {},
+					author: event.author,
+					text: clampText(withNotes(overrides.text ?? event.text, notes), attachments.length > 0),
+					...attachments.length ? { attachments } : {},
+					origin: {
+						channel: event.channel,
+						thread: event.thread,
+						subthread: event.subthread,
+						message: event.message,
+						context: event.context
+					},
+					id: await writeId(0)
+				};
+				const reply = {
+					...base,
+					...overrides.noSync ? { noSync: true } : {}
+				};
+				if (rootId !== void 0) {
+					await setExtraLabels(event.author, rootId);
+					return result(await post({
+						...reply,
+						re: rootId
+					}));
+				}
+				const fetched = await platform.fetchRoot(native(event.thread));
+				if (fetched === null) {
+					const draft = rootDraft({
+						text: event.text,
+						labels: {},
+						author: event.author,
+						raw
+					});
+					return result(await post({
+						...base,
+						channel,
+						text: clampText(withNotes(overrides.text ?? draft.text, notes), attachments.length > 0),
+						labels: labels(draft.labels)
+					}));
+				}
+				const draft = rootDraft({
+					...fetched,
+					raw: fetched.raw ?? null
+				});
+				const root = await post({
+					author: fetched.author,
+					channel,
+					text: clampText(draft.text),
+					labels: labels(draft.labels),
+					origin: {
+						channel: event.channel,
+						thread: event.thread,
+						subthread: null,
+						message: `root:${meta.id}`,
+						context: null
+					},
+					id: await writeId(1)
+				});
+				return result(await post({
+					...reply,
+					re: root.id
+				}));
+			}
+			case "edited":
+			case "deleted":
+			case "reaction": {
+				const id = (await find({
+					thread: event.subthread ?? event.thread,
+					message: event.message
+				})).message;
+				if (id === null) return {
+					root: rootId ?? null,
+					message: null
+				};
+				const author = "author" in event ? event.author : {
+					id: `${platform.platform}:system`,
+					handle: platform.platform,
+					name: platform.platform,
+					avatar: null,
+					isBot: true
+				};
+				const origin = {
+					thread: event.subthread ?? event.thread,
+					message: event.message
+				};
+				if (rootId !== void 0) await setExtraLabels(author, rootId);
+				if (event.kind === "deleted") await call("syncImport", {
+					op: "delete",
+					author,
+					from: key,
+					origin
+				});
+				else if (event.kind === "edited") {
+					const stored = await messageOf(id);
+					const text = clampText(withNotes(overrides.text ?? event.text, stored ? notesIn(stored.text) : []), (stored?.attachments.length ?? 0) > 0);
+					if (stored && !event.linksOnly && stored.text !== text) await screened(await call("syncImport", {
+						op: "edit",
+						author,
+						from: key,
+						origin,
+						text,
+						source: from
+					}));
+					const links = stored ? await resolveLinks(platform, event.links ?? [], stored.channel, stored.links) : [];
+					if (stored && !sameLinks(links, stored.links)) await call("syncImport", {
+						op: "links",
+						author,
+						from: key,
+						origin,
+						links
+					});
+				} else {
+					if (platform.singleReaction) {
+						const emoji = canonicalEmoji(event.emoji);
+						for (const [held, actors] of Object.entries((await messageOf(id))?.reactions ?? {})) if (actors.includes(author.id) && !(event.added && held === emoji)) await call("syncImport", {
+							op: "react",
+							author,
+							from: key,
+							origin,
+							emoji: held,
+							remove: true
+						});
+					}
+					if (!platform.singleReaction || event.added) await call("syncImport", {
+						op: "react",
+						author,
+						from: key,
+						origin,
+						emoji: event.emoji,
+						remove: !event.added
+					});
+				}
+				return {
+					root: rootId ?? null,
+					message: id
+				};
+			}
+			case "lifecycle": {
+				if (rootId !== void 0) {
+					const root = await messageOf(rootId);
+					const createdHere = root?.origin?.message === `lifecycle:${meta.id}`;
+					const desired = labels((createdHere ? rootDraft({
+						text: event.url ? `${event.title}\n${event.url}` : event.title,
+						labels: event.labels,
+						author: event.author,
+						raw
+					}) : null)?.labels ?? event.labels);
+					const owned = (key) => event.owns?.some((prefix) => key.startsWith(prefix)) ?? false;
+					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.reply) return result(await post({
+						author: event.author,
+						re: rootId,
+						text: clampText(overrides.text ?? event.reply),
+						...overrides.noSync ? { noSync: true } : {},
+						id: await writeId(1)
+					}));
+					return {
+						root: rootId,
+						message: createdHere ? rootId : null
+					};
+				}
+				if (!event.createRoot) return {
+					root: null,
+					message: null
+				};
+				const draft = rootDraft({
+					text: event.url ? `${event.title}\n${event.url}` : event.title,
+					labels: event.labels,
+					author: event.author,
+					raw
+				});
+				const root = await post({
+					author: event.author,
+					channel,
+					text: clampText(event.reply ? draft.text : overrides.text ?? draft.text),
+					labels: labels(draft.labels),
+					origin: {
+						channel: event.channel,
+						thread: event.thread,
+						subthread: null,
+						message: `lifecycle:${meta.id}`,
+						context: null
+					},
+					id: await writeId(0)
+				});
+				if (event.reply) return result(await post({
+					author: event.author,
+					re: root.id,
+					text: clampText(overrides.text ?? event.reply),
+					...overrides.noSync ? { noSync: true } : {},
+					id: await writeId(1)
+				}));
+				return result(root);
+			}
+		}
+	}
+	/**
+	* A message's text for a platform: each mention it resolved reads natively where the
+	* actor is the platform's own, and as their plain name anywhere else. A handle it
+	* didn't resolve goes out as written.
+	*/
+	function textFor(platform, message, actors, text = message.text) {
+		const mentioned = message.mentions.map((id) => actors.byId[id]).filter((actor) => actor !== void 0);
+		return replaceMentions(text, (token, written) => {
+			const actor = token.kind === "actor" ? mentioned.find((candidate) => candidate.id === token.actor) : mentioned.find((candidate) => candidate.handle.toLowerCase() === token.handle);
+			if (actor) return nativeMention(platform, actor.id, actors) ?? actor.name;
+			return null;
+		});
+	}
+	/**
+	* How `platform` mentions an actor: its own account, its person's, or any account
+	* its person linked there. An agent is just itself.
+	*/
+	function nativeMention(platform, actor, actors) {
+		const native = (id) => {
+			const account = actors.byId[id];
+			return account ? platform.mention(account) : null;
+		};
+		const person = actors.links[actor] ?? actor;
+		const direct = native(actor) ?? (person === actor ? null : native(person));
+		if (direct) return direct;
+		for (const id of linkedTo(actors, person)) {
+			const linked = native(id);
+			if (linked) return linked;
+		}
+		return null;
+	}
+	/**
+	* A person's own token on `platform`, to post `message` as them: only for what they
+	* wrote on the board themselves, not their agents, and null when they haven't
+	* signed in. A token that can't be had is the bot's turn, never a failed delivery.
+	* A new post (`linked`) goes as them only once they've linked the account they signed
+	* in with, so its echo is recognized as theirs and `vb identity unlink` stops it. Their
+	* copies already out there stay theirs to change.
+	*/
+	async function personToken(platform, message, linked) {
+		if (!platform.users || message.from !== null || message.by.profile !== null || !message.by.principal.startsWith("vercel:user:")) return null;
+		if (linked) {
+			const { accounts } = await find({ person: message.by.principal });
+			if (!accounts.some((account) => account.method === "consent" && account.id.startsWith(`${platform.platform}:user:`))) return null;
+		}
+		try {
+			return await platform.users.token(message.by.principal);
+		} catch (error) {
+			console.warn(`[board] no ${platform.platform} token for ${message.by.principal}; posting #${message.id} as the app:`, describe(error));
+			return null;
+		}
+	}
+	/** What a message says as its author: no name in front, since it's theirs. */
+	function renderAsPerson(target, message, actors) {
+		const platform = platformOf(keyOf(target));
+		const markdown = textFor(platform, message, actors, displayText(message.text, message.by.actor));
+		return { markdown: message.attachments.length > 0 && !platform.uploadsFiles ? `${markdown}\n${attachmentNotes(message)}` : markdown };
+	}
+	/** Posts as the message's author when they've signed in; null to post as the app. */
+	async function postAsPerson(target, place, kind, message, actors) {
+		const platform = platformOf(keyOf(target));
+		if (!message.text.trim()) return null;
+		const token = await personToken(platform, message, true);
+		if (!token) return null;
+		try {
+			return await platform.postAs(token, native(place), kind, renderAsPerson(target, message, actors));
+		} catch (error) {
+			console.warn(`[board] couldn't post #${message.id} to ${target} as its author; posting as the app:`, describe(error));
+			return null;
+		}
+	}
+	/** A board message as markdown for a platform, which converts it to its own format. */
+	function render(key, target, message, actors) {
+		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({
+			message: {
+				...structuredClone(message),
+				text: displayText(message.text, message.by.actor)
+			},
+			author: actor ? { ...actor } : null,
+			mentionOf: (id) => nativeMention(platform, id, actors),
+			label: name,
+			target
+		}));
+		if (typeof body !== "string") throw badRequest("a provider renderer must return markdown");
+		const markdown = textFor(platform, message, actors, body);
+		return message.by.profile && !message.from ? {
+			markdown,
+			as: {
+				name,
+				avatar: senderAvatar(message, actor, actors)
+			}
+		} : { markdown };
+	}
+	/** An agent's own picture, or for the board's built-in one, its person's Vercel avatar: `claude via julian` shows Julian. */
+	function senderAvatar(message, actor, actors) {
+		const builtIn = (avatar) => !avatar || /\/avatars\/[a-z0-9-]+$/.test(avatar);
+		const own = actor?.avatar ?? null;
+		if (!builtIn(own)) return own;
+		const person = actors.byId[message.by.principal]?.avatar;
+		if (!builtIn(person)) return person;
+		const username = actor?.handle.split("/")[0] ?? "";
+		if (!message.by.principal.startsWith("vercel:user:") || !username || /^user-/.test(username)) return own;
+		return `https://vercel.com/api/www/avatar?u=${encodeURIComponent(username)}&s=64&format=png`;
+	}
+	/** What a platform shows for files it didn't get: one line each, so a reader knows they're on the board. */
+	const attachmentNotes = (message) => message.attachments.map((a) => `\n📎 ${a.name} (${fileSize(a.size)}, on the board: #${message.id})`).join("");
+	/**
+	* `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 key = keyOf(target);
+		const { markdown, as } = render(key, target, message, actors);
+		return {
+			markdown: message.attachments.length > 0 && (noted || !platformOf(key).uploadsFiles) ? `${markdown}\n${attachmentNotes(message)}` : markdown,
+			...as ? { as } : {}
+		};
+	};
+	async function postReply(message, target, externalThread, actors) {
+		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 files;
+		let sentId;
+		if (!body.markdown.trim() && message.attachments.length && platform.uploadsFiles) try {
+			const sent = await uploadMessageFiles(message, target, place);
+			sentId = sent.message;
+			files = sent.files;
+		} catch (error) {
+			if (!platform.refusesFiles(error) && !keepsNoFiles(error)) throw error;
+			body = renderFor(target, message, actors, true);
+			sentId = (await platform.post(native(place), "thread", body)).message;
+			files = null;
+		}
+		else {
+			const asPerson = await postAsPerson(target, place, "thread", message, actors);
+			if (asPerson) {
+				const external = {
+					thread: place,
+					message: asPerson.message,
+					asUser: true
+				};
+				await recordDelivery(message, target, external);
+				return external;
+			}
+			if (!body.markdown.trim()) throw badRequest("a renderer must return text unless the message has media");
+			sentId = (await platform.post(native(place), "thread", body)).message;
+		}
+		const external = {
+			thread: place,
+			message: sentId,
+			...files !== void 0 ? { files } : {}
+		};
+		await recordDelivery(message, target, external);
+		return external;
+	}
+	async function recordDelivery(message, target, copy) {
+		await call("syncReceipt", {
+			kind: "message",
+			message: message.id,
+			target,
+			external: {
+				thread: copy.thread,
+				message: copy.message,
+				...copy.asUser ? { asUser: true } : {}
+			},
+			...copy.files !== void 0 ? { files: copy.files } : {}
+		});
+	}
+	/** A message's files, as the board has them. */
+	async function messageFiles(message) {
+		return Promise.all(message.attachments.map(async (a) => {
+			const { data } = await call("attachment", { id: a.id });
+			return {
+				data: data instanceof Uint8Array ? data : new Uint8Array(await new Response(data).arrayBuffer()),
+				filename: a.name,
+				mimeType: a.type
+			};
+		}));
+	}
+	async function uploadMessageFiles(message, target, thread) {
+		return platformOf(keyOf(target)).uploadFiles(native(thread), await messageFiles(message));
+	}
+	/**
+	* A message's files, into the thread its text went to, once. The text's
+	* 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) {
+		const platform = platformOf(keyOf(target));
+		if (!platform.uploadsFiles || message.attachments.length === 0 || copy.files !== void 0) return;
+		let ids;
+		try {
+			ids = (await uploadMessageFiles(message, target, copy.thread)).files;
+		} catch (error) {
+			if (!platform.refusesFiles(error) && !keepsNoFiles(error)) throw Object.assign(/* @__PURE__ */ new Error(`files: ${describe(error)}`), {
+				cause: error,
+				data: { error: `files: ${describe(error)}` }
+			});
+			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 call("syncReceipt", {
+			kind: "files",
+			message: message.id,
+			target,
+			files: ids
+		});
+	}
+	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", {
+				kind: "failed",
+				message: id,
+				target,
+				error: describe(error)
+			});
+		}
+	}
+	/**
+	* 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.
+	*/
+	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", {
+			kind: "thread",
+			message: message.id,
+			target: target.target,
+			targetKind: target.kind,
+			cause: "config"
+		});
+	}
+	async function deliverThread(event, attempt) {
+		const { thread, target } = event.payload;
+		if (!ours(target)) return;
+		if ((event.payload.kind ?? (isThreadTarget(target) ? "thread" : "channel")) === "thread") return;
+		const synced = await syncOf(thread);
+		const [root, ...replies] = synced ? await threadOf(synced.root) : [];
+		if (!synced || !root || root.id !== synced.root || root.deleted) return;
+		const actors = await actorsNow();
+		const copies = await copiesOf([root.id, ...replies.map((reply) => reply.id)]);
+		let externalThread = synced.external[target];
+		if (!externalThread) try {
+			const platform = platformOf(keyOf(target));
+			const body = renderFor(target, root, actors);
+			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;
+			let postedAsPerson = false;
+			const post = async () => {
+				if (!mediaOnly) {
+					const asPerson = await postAsPerson(target, target, "channel", root, actors);
+					if (asPerson) {
+						postedAsPerson = true;
+						return asPerson;
+					}
+					return platform.post(native(target), "channel", body);
+				}
+				try {
+					const sent = await platform.post(native(target), "channel", {
+						...body,
+						files: await messageFiles(root)
+					});
+					uploaded = sent.files ?? [];
+					return sent;
+				} catch (error) {
+					if (!platform.refusesFiles(error) && !keepsNoFiles(error)) throw error;
+					uploaded = null;
+					return platform.post(native(target), "channel", renderFor(target, root, actors, true));
+				}
+			};
+			const sent = await post();
+			externalThread = `${keyOf(target)}:${sent.thread}`;
+			const external = {
+				thread: externalThread,
+				message: sent.message,
+				...uploaded !== void 0 ? { files: uploaded } : {},
+				...postedAsPerson ? { asUser: true } : {}
+			};
+			await recordDelivery(root, target, external);
+			await deliverFiles(root, target, external, actors);
+		} catch (error) {
+			return settle(attempt, [{
+				id: root.id,
+				target,
+				error
+			}]);
+		}
+		else {
+			const copy = copies[root.id]?.[target];
+			if (copy) try {
+				await deliverFiles(root, target, copy, actors);
+			} catch (error) {
+				return settle(attempt, [{
+					id: root.id,
+					target,
+					error
+				}]);
+			}
+		}
+		const failures = [];
+		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);
+			} catch (error) {
+				failures.push({
+					id: reply.id,
+					target,
+					error
+				});
+			}
+		}
+		await settle(attempt, failures);
+	}
+	/** 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.payload.noSync) return;
+		const synced = await syncOf(event.payload.thread);
+		if (!synced || synced.targets.length === 0) return;
+		const message = await messageOf(event.message.id);
+		if (!message || message.deleted) return;
+		const actors = await actorsNow();
+		const failures = [];
+		for (const target of synced.targets) {
+			const externalThread = synced.external[target];
+			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 settle(attempt, failures);
+	}
+	/** Edits, deletes, and reactions are best-effort: a platform that can't do one skips it. */
+	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 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);
+			} catch (error) {
+				console.warn(`[board] skipped ${event.type} on ${target}:`, error.message);
+			}
+		}
+	}
+	/**
+	* A renderer can read labels (a PR root showing its state), so a label change edits
+	* each copy whose rendering it changes. The default renderer doesn't, so this never edits.
+	*/
+	async function deliverLabels(event) {
+		const { id } = event.payload;
+		const copies = (await copiesOf([id]))[id] ?? {};
+		const after = event.message;
+		if (!after || Object.keys(copies).length === 0) return;
+		const current = await messageOf(id);
+		if (!current || current.deleted) return;
+		const actors = await actorsNow();
+		const message = {
+			...current,
+			labels: after.labels
+		};
+		const previous = {
+			...current,
+			labels: event.before?.labels ?? {}
+		};
+		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);
+			} catch (error) {
+				console.warn(`[board] skipped labels.changed on ${target}:`, describe(error));
+			}
+		}
+	}
+	/**
+	* Delivers one board event to the platforms: what the board's subscription for sync hands
+	* it, on its thread's lane. A throw is retried; `attempt` counts tries from 1.
+	*/
+	async function deliver(event, { attempt }) {
+		switch (event.type) {
+			case "thread.synced": return deliverThread(event, attempt);
+			case "message.posted": return deliverPost(event, attempt);
+			case "message.edited":
+			case "message.deleted":
+			case "reaction.added":
+			case "reaction.removed": return deliverChange(event);
+			case "labels.changed": return deliverLabels(event);
+		}
+	}
+	/**
+	* Shows typing in every platform thread a board thread is synced to. It's
+	* ephemeral and best-effort: nothing goes in the log, and a platform that
+	* fails is skipped. Answers the external threads that took it. `status`
+	* replaces "Typing…" where the platform shows text (Slack).
+	*/
+	async function typing(messages, status) {
+		const synced = messages[0] ? await syncOf(messages[0].thread) : null;
+		if (!synced) return [];
+		const externals = [...new Set(Object.values(synced.external))].filter(ours);
+		return (await Promise.all(externals.map(async (external) => {
+			const key = keyOf(external);
+			try {
+				const platform = platformOf(key);
+				let latest = null;
+				for (let i = messages.length - 1; i >= 0 && latest === null; i--) {
+					const origin = messages[i];
+					if (!origin.deleted && origin.origin?.thread === external) latest = origin.origin.message;
+				}
+				await platform.startTyping(native(external), latest, status);
+				return external;
+			} catch (error) {
+				console.warn(`[board] skipped typing on ${external}:`, describe(error));
+				return null;
+			}
+		}))).filter((external) => external !== null);
+	}
+	/** A channel the inbox listing names, as its platform ID: `#general` to `slack:C0123`. */
+	async function inboxChannel(key, channel) {
+		try {
+			return `${key}:${await platformOf(key).resolveChannel(channel)}`;
+		} catch (error) {
+			throw badRequest(`can't resolve inbox channel: ${error.message}`);
+		}
+	}
+	/** The status for what a platform wouldn't read: the caller's mistake, missing, refused, or the platform failing. */
+	const unreadableStatus = (code) => {
+		if (code === "unsupported" || code === "invalid_target") return 400;
+		if (code === "channel_not_found") return 404;
+		if (code === "ratelimited") return 429;
+		if ([
+			"no_client",
+			"list_failed",
+			"internal_error",
+			"fatal_error",
+			"service_unavailable",
+			"request_timeout"
+		].includes(code)) return 502;
+		return 403;
+	};
+	/** A platform channel or thread, read for the caller: nothing is synced, stored, or joined. */
+	async function readSource(key, target, limit) {
+		const platform = platformOf(key);
+		try {
+			return await platform.read(target, { limit });
+		} catch (error) {
+			if (error instanceof UnreadableError) throw new HttpError(unreadableStatus(error.code), error.code, error.message);
+			throw badRequest(`can't read ${target} from ${key}: ${describe(error)}`, "platform_error");
+		}
+	}
+	return {
+		entries,
+		bind(next) {
+			bound = next;
+		},
+		/** Sync's own caller, for its lookups. */
+		caller: me,
+		deliver,
+		receive: inbound,
+		pull,
+		configTargets,
+		normalizeTarget,
+		findByEmail,
+		handleWebhook,
+		inboxChannel,
+		signsIn,
+		signIn,
+		signedIn,
+		redeemSignIn,
+		typing,
+		readSource
+	};
+}
+//#endregion
+export { createSyncEngine };