@vercel/board 0.29.0 → 0.31.0

package/dist/conformance.d.mts

@@ -1,4 +1,4 @@
-import { d as Board } from "./backend-CPC_vyOo.mjs";
+import { f as Board } from "./backend-Bob-5CM7.mjs";
 //#region src/conformance/index.d.ts
 /**
  * Checks that a board speaks the protocol, through a handle on it (`conformance(board())`), as
@@ -7,7 +7,7 @@ import { d as Board } from "./backend-CPC_vyOo.mjs";
  * (`conformance` by default), keeps every post on the board, and deletes what it posted.
  */
 /** What a check is about, for the report's headings. */
-export type CheckGroup = 'core' | 'schedules' | 'attachments' | 'watchers' | 'sync';
+export type CheckGroup = 'core' | 'schedules' | 'grants' | 'tokens' | 'attachments' | 'watchers' | 'sync';
 export type CheckResult = {
   group: CheckGroup;
   name: string;
@@ -24,6 +24,12 @@ export type ConformanceReport = {
 export type ConformanceOptions = {
   /** Where it posts. Default `conformance`. */
   channel?: string;
+  /**
+   * The same board, with a board token's secret as the credential (as `BOARD_TOKEN` sends it):
+   * the tokens check calls it so to see that a token does only what its `can` says. Without it,
+   * that check is skipped.
+   */
+  withToken?: (secret: string) => Board;
 };
 /** Runs the checks against `board`, in order, and reports each. It never throws for what the board answers. */
 export declare function conformance(board: Board, options?: ConformanceOptions): Promise<ConformanceReport>;

package/dist/conformance.mjs

@@ -1,2 +1,2 @@
-import { t as conformance } from "./conformance-DlnfuzEB.mjs";
+import { t as conformance } from "./conformance-DK43HiHf.mjs";
 export { conformance };

package/dist/{engine-DQxXk7dX.mjs → engine-DurYIRt8.mjs}

@@ -1,14 +1,13 @@
 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-DBmUO6pr.mjs";
-import { c as externalMessageKey, l as isThreadTarget, s as channelOf } from "./external-D3p5T57R.mjs";
+import { l as isThreadTarget, s as channelOf } from "./external-D3p5T57R.mjs";
 import { t as canonicalEmoji } from "./emoji-CTLpvH-A.mjs";
+import { r as badRequest, s as notFound, t as HttpError } from "./errors-CJXhhzvT.mjs";
 import { r as derivedId, t as waitUntil } from "./wait-until-Dw4XrIDQ.mjs";
-import { r as badRequest, s as notFound, t as HttpError } from "./errors-CusN4x2l.mjs";
 import { n as replaceMentions } from "./mentions-CB6ShY4R.mjs";
-import { t as DroppedError } from "./middleware-CXjEeef4.mjs";
+import { t as DroppedError } from "./middleware-BavYSDUa.mjs";
 import { t as afterRetry } from "./attempts-HXcskN1w.mjs";
-import { a as channelMissing, i as UnreadableError, n as ResolvedTarget, o as routesFor, t as ReceivedEvent } from "./provider-BaVmi4Hi.mjs";
-import { a as immutable, n as SyncOverrides } from "./events-qf5XG5VQ.mjs";
+import { a as immutable, d as routesFor, l as UnreadableError, n as SyncOverrides, o as ReceivedEvent, s as ResolvedTarget, u as channelMissing } from "./events-lujPA3gQ.mjs";
 import { t as displayText } from "./bots-CGkO76qH.mjs";
 //#region src/sync/engine.ts
 /** `files`: a message with files may have no text. */
@@ -44,18 +43,6 @@ const linkKey = (link) => JSON.stringify([
 ]);
 /** 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. */
@@ -153,23 +140,16 @@ function createSyncEngine(entries) {
 	/** The actors sync renders with, as the board has them now. */
 	async function actorsNow() {
 		const { actors } = await call("actors", {});
-		const state = {
-			byId: {},
-			links: {}
+		const state = { byId: {} };
+		for (const actor of actors) state.byId[actor.id] = {
+			id: actor.id,
+			kind: actor.kind,
+			handle: actor.handle,
+			name: actor.name,
+			avatar: actor.avatar
 		};
-		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 name that didn't resolve (say, a Slack channel that doesn't exist yet) waits before another try. */
 	const RETRY_MS = 6e4;
 	const resolutions = /* @__PURE__ */ new Map();
@@ -331,10 +311,11 @@ function createSyncEngine(entries) {
 	* 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.
+	* asked about it and `linker`, the platform message that links it. 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 = []) {
+	async function resolveLinks(platform, links, linker, channel, previous = []) {
 		if (links.length === 0) return [];
 		const resolved = [];
 		for (const link of links) {
@@ -375,7 +356,7 @@ function createSyncEngine(entries) {
 				resolved.push(kept);
 				continue;
 			}
-			const fetched = await platform.fetchLink(link).catch((error) => ({
+			const fetched = await platform.fetchLink(link, linker).catch((error) => ({
 				snapshot: null,
 				unavailable: describe(error)
 			}));
@@ -466,9 +447,7 @@ function createSyncEngine(entries) {
 			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`,
@@ -559,86 +538,6 @@ function createSyncEngine(entries) {
 			}
 		};
 	}
-	/**
-	* 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);
@@ -729,7 +628,10 @@ function createSyncEngine(entries) {
 					attachments: [],
 					notes: []
 				};
-				const links = await resolveLinks(platform, event.links ?? [], synced?.channel ?? channel);
+				const links = await resolveLinks(platform, event.links ?? [], {
+					thread: event.subthread ?? event.thread,
+					message: event.message
+				}, synced?.channel ?? channel);
 				const base = {
 					...links.length ? { links } : {},
 					author: event.author,
@@ -833,7 +735,7 @@ function createSyncEngine(entries) {
 						text,
 						source: from
 					}));
-					const links = stored ? await resolveLinks(platform, event.links ?? [], stored.channel, stored.links) : [];
+					const links = stored ? await resolveLinks(platform, event.links ?? [], origin, stored.channel, stored.links) : [];
 					if (stored && !sameLinks(links, stored.links)) await call("syncImport", {
 						op: "links",
 						author,
@@ -959,63 +861,10 @@ function createSyncEngine(entries) {
 			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.
-	*/
+	/** How `platform` mentions an actor: natively when it's the platform's own account, or null. */
 	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;
-		}
+		const account = actors.byId[actor];
+		return account ? platform.mention(account) : null;
 	}
 	/** 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) {
@@ -1087,16 +936,6 @@ function createSyncEngine(entries) {
 			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;
 		}
@@ -1115,8 +954,7 @@ function createSyncEngine(entries) {
 			target,
 			external: {
 				thread: copy.thread,
-				message: copy.message,
-				...copy.asUser ? { asUser: true } : {}
+				message: copy.message
 			},
 			...copy.files !== void 0 ? { files: copy.files } : {}
 		});
@@ -1281,14 +1119,8 @@ function createSyncEngine(entries) {
 			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;
-					}
 					if (root.attachments.length === 0 || !platform.startsThreadsWithFiles) return platform.post(native(target), "channel", body);
 				}
 				try {
@@ -1309,8 +1141,7 @@ function createSyncEngine(entries) {
 			const external = {
 				thread: externalThread,
 				message: sent.message,
-				...uploaded !== void 0 ? { files: uploaded } : {},
-				...postedAsPerson ? { asUser: true } : {}
+				...uploaded !== void 0 ? { files: uploaded } : {}
 			};
 			await recordDelivery(root, target, external);
 			await deliverFiles(root, target, external, actors, renderer);
@@ -1381,17 +1212,9 @@ function createSyncEngine(entries) {
 				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));
+					if (event.type === "message.edited") 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);
+						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);
@@ -1536,10 +1359,6 @@ function createSyncEngine(entries) {
 		findByEmail,
 		handleWebhook,
 		inboxChannel,
-		signsIn,
-		signIn,
-		signedIn,
-		redeemSignIn,
 		typing,
 		readSource,
 		joinSource

package/dist/{errors-DDktVeUa.d.mts → errors-2vGs49Db.d.mts}

@@ -1,4 +1,4 @@
-import { r as ErrorOrigin } from "./client-BqAjk0Q4.mjs";
+import { r as ErrorOrigin } from "./client-COfYrgfV.mjs";
 //#region src/server/errors.d.ts
 declare class HttpError extends Error {
   readonly status: number;

package/dist/{client-D0Px7KzF.mjs → errors-CJXhhzvT.mjs}

@@ -1,5 +1,6 @@
 import { a as typeOf, n as DIRECT_UPLOAD_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import { r as normalizeEmoji } from "./emoji-CTLpvH-A.mjs";
+import { ZodError } from "zod";
 //#region src/client/sse.ts
 /** Parses a text/event-stream body into messages. */
 async function* parseSse(body, signal) {
@@ -178,11 +179,12 @@ function createBoardClient(options) {
 		discovery: () => call("GET", "/", { auth: false }),
 		me: () => call("GET", "/me"),
 		channels: async () => (await call("GET", "/channels")).channels,
+		/**
+		* Makes a channel before anything posts to it, as a first post would. Needs `read` and `post`
+		* there. `created` is false when it was there already; it's left as it is.
+		*/
+		createChannel: (path) => call("POST", "/channels", { body: { path } }),
 		actors: async () => (await call("GET", "/actors")).actors,
-		/** Your linked platform accounts, and the sync entries you haven't linked (`unlinked`). */
-		identity: () => call("GET", "/identity"),
-		/** Unlinks one of your accounts, by actor ID or handle. History keeps its messages as they were. */
-		unlinkAccount: (account) => call("POST", "/identity/unlink", { body: { actor: account } }),
 		messages: (query = {}) => call("GET", `/messages${queryString(query)}`),
 		thread: (id) => call("GET", `/messages/${path(id)}`),
 		/** Your own post with the client ID you gave it, as posting it answered: 404 `post_not_found` when there's none. */
@@ -221,6 +223,26 @@ function createBoardClient(options) {
 		/** Stops a schedule: yours, or any with manage in its channel. `canceled` is false when it was already done or canceled. */
 		cancelSchedule: (id) => call("POST", `/schedules/${path(id)}/cancel`, { body: {} }),
 		/**
+		* Lets in callers with an OIDC token from `issuer` that carries every one of `claims`, to do
+		* what `can` says (read, post, react, and label everywhere when left out). Setting the same
+		* issuer and claims again changes its `can`: `created` says which. Needs manage in every channel.
+		*/
+		createGrant: (input) => call("POST", "/grants", { body: input }),
+		/** The board's grants. Needs manage in every channel. */
+		grants: async () => (await call("GET", "/grants")).grants,
+		/** `revoked` is false when it was already gone. Its principals' next requests are refused. */
+		revokeGrant: (id) => call("POST", `/grants/${path(id)}/revoke`, { body: {} }),
+		/**
+		* A token that acts as you, narrowed to `can`, writing as `profile` and `session` when they're
+		* given: for a widget, a sandbox, a script. `secret` shows only here. It lives 30 days, or
+		* `expires`, at most 90.
+		*/
+		createToken: (input) => call("POST", "/tokens", { body: input }),
+		/** Your live tokens, or everyone's with manage in every channel. Never their secrets. */
+		tokens: async () => (await call("GET", "/tokens")).tokens,
+		/** It and every token minted with it stop. `revoked` is false when it was already revoked. */
+		revokeToken: (id) => call("POST", `/tokens/${path(id)}/revoke`, { body: {} }),
+		/**
 		* Stores a file on the board, for a post or reply's `attachments`. Up to 4 MB goes in one
 		* request; bigger, up to 100 MB, goes straight to the board's blob store on a URL the board
 		* signs, where its store can (`no_direct_uploads` where it can't).
@@ -230,10 +252,13 @@ function createBoardClient(options) {
 			const size = input.data instanceof Blob ? input.data.size : input.data.byteLength;
 			if (size > 4194304) {
 				if (size > 104857600) throw new BoardError("too_large", `Attachments are at most ${DIRECT_UPLOAD_BYTES_MAX / 1024 / 1024} MB.`, 413);
+				const bytes = input.data instanceof Blob ? await input.data.arrayBuffer() : input.data;
+				const sha256 = btoa(String.fromCharCode(...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))));
 				const ticket = await call("POST", "/attachments/uploads", { body: {
 					name: input.name,
 					type,
-					size
+					size,
+					sha256
 				} }).catch((error) => {
 					if (error instanceof BoardError && error.status === 404 && error.code === "not_found") throw new BoardError("too_large", `This board takes files of at most ${ATTACHMENT_BYTES_MAX / 1024 / 1024} MB.`, 413);
 					throw error;
@@ -260,18 +285,28 @@ function createBoardClient(options) {
 		},
 		/** An attachment's bytes, as the board serves them: `content-type` is the file's type. */
 		download: (id, opts = {}) => raw("GET", `/attachments/${encodeURIComponent(id)}`, opts.signal ? { signal: opts.signal } : {}),
-		edit: (id, text) => call("POST", `/messages/${path(id)}/edit`, { body: { text } }),
-		delete: (id) => call("POST", `/messages/${path(id)}/delete`, { body: {} }),
+		/**
+		* `revision` is the message's as you read it: if it's been edited or deleted since, nothing
+		* changes, and it throws a 409 `revision_conflict`.
+		*/
+		edit: (id, text, opts = {}) => call("POST", `/messages/${path(id)}/edit`, { body: {
+			text,
+			...opts
+		} }),
+		delete: (id, opts = {}) => call("POST", `/messages/${path(id)}/delete`, { body: { ...opts } }),
 		/** `emoji` is a short name, `:name:`, or the character itself. */
 		react: (id, emoji, opts = {}) => call("POST", `/messages/${path(id)}/reactions`, { body: {
 			emoji: normalizeEmoji(emoji),
 			...opts
 		} }),
+		/**
+		* `if` is what the labels must be now, a value or null for one that mustn't be set: if one
+		* isn't, nothing changes, and it throws a 409 `label_conflict`.
+		*/
 		label: (id, change) => call("POST", `/messages/${path(id)}/labels`, { body: change }),
 		/**
-		* Shows typing in the platform threads the message's thread is synced to
-		* (on WhatsApp, also marking the latest inbound message read). Ephemeral:
-		* nothing goes in the log. Answers the external threads that took it.
+		* Shows typing in the platform threads the message's thread is synced to.
+		* Ephemeral: nothing goes in the log. Answers the external threads that took it.
 		* `status` replaces "Typing…" on Slack ("running tests…").
 		*/
 		typing: async (id, status) => (await call("POST", `/messages/${path(id)}/typing`, { body: status ? { status } : {} })).targets,
@@ -315,31 +350,16 @@ function createBoardClient(options) {
 		syncReceipt: (body) => call("POST", "/sync/receipts", { body }),
 		/** A board thread's sync, by its key. */
 		syncThread: (thread) => call("GET", `/sync/threads/${path(thread)}`),
-		/** What platform IDs are on the board: a thread, a message, who an account is, a person's accounts. */
+		/** What platform IDs are on the board: a thread, or a message. */
 		syncFind: (query, opts = {}) => call("GET", `/sync/find${queryString(query)}`, opts.signal ? { signal: opts.signal } : {}),
 		/** Messages' copies on platforms, by message and target. */
 		syncCopies: async (messages) => (await call("GET", `/sync/copies?${messages.map((id) => `message=${encodeURIComponent(id)}`).join("&")}`)).copies,
-		/** A person's roots since `since`. */
-		syncRoots: async (by, since) => (await call("GET", `/sync/roots${queryString({
-			by,
-			since: since instanceof Date ? since.getTime() : since
-		})}`)).roots,
 		/** Pushes platform events into your inbox for sync key `key`; each platform ID lands once. */
 		inboxPush: (key, events) => call("POST", `/inbox/${path(key)}`, { body: { events } }),
 		/** Your next inbox events for `key`, leased to you until you ack them, one platform thread at a time. */
 		inboxNext: async (key, opts = {}) => (await call("GET", `/inbox/${path(key)}/next${queryString(opts)}`)).items,
 		/** How an inbox event went: done, or an error to try it again. */
 		inboxAck: (key, id, body) => call("POST", `/inbox/${path(key)}/${path(id)}/ack`, { body }),
-		/**
-		* A one-time code for linking your account on sync entry `sync`, to post from that account where
-		* the board syncs, and `signIn` when the entry signs people in: open it (only you) and approve.
-		* Only people get one, each for themselves. `identity()` shows the link once it's made.
-		*/
-		syncCode: (sync) => call("POST", "/sync/codes", { body: { sync } }),
-		/** Links a platform account to whoever a code was issued to: one posted from it, or carried through its sign-in. */
-		syncAccount: (body) => call("POST", "/sync/accounts", { body }),
-		/** Unlinks a platform account: your own, or anyone's with `sync`. */
-		syncUnlink: (account) => call("POST", "/sync/accounts/unlink", { body: { account } }),
 		/** Live events. Reconnects from the last seen index whenever the stream closes. */
 		async *events(query = {}, opts = {}) {
 			let after = query.after;
@@ -405,4 +425,89 @@ async function toError(response) {
 	return new BoardError("http_error", `The board answered ${`${response.status} ${response.statusText}`.trim()}.`, response.status);
 }
 //#endregion
-export { handleErrors as i, createBoardClient as n, duration as r, BoardError as t };
+//#region src/server/errors.ts
+var HttpError = class extends Error {
+	status;
+	code;
+	/** What fixes it, when there's one (`BoardError`'s `hint`). */
+	hint;
+	/** `handle` for a handle's own error on its way through: everything else is the board's. */
+	origin;
+	constructor(status, code, message, options = {}) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.hint = options.hint;
+		this.origin = options.origin ?? "board";
+	}
+};
+/** A request a host's own verifier rejected with `response`, which the board answers with as it is. */
+var RejectedError = class extends HttpError {
+	response;
+	constructor(response) {
+		super(response.status, "rejected", `rejected with ${response.status}`);
+		this.response = response;
+	}
+};
+const badRequest = (message, code = "invalid_request") => new HttpError(400, code, message);
+const unauthorized = (message) => new HttpError(401, "unauthorized", message);
+const forbidden = (message) => new HttpError(403, "forbidden", message);
+const notFound = (message, code = "not_found") => new HttpError(404, code, message);
+const duplicateId = () => new HttpError(409, "duplicate_id", "that id was already used for a different write");
+const json = (body, status = 200, headers) => new Response(JSON.stringify(body), {
+	status,
+	headers: {
+		"content-type": "application/json",
+		...headers
+	}
+});
+/**
+* The issue a request is told about. A union that matched no option says only "Invalid input", so
+* it's the first issue of the option that came closest, the one with the fewest, at its own path.
+*/
+function reported(issue) {
+	if (issue.code !== "invalid_union" || issue.errors.length === 0) return issue;
+	const first = issue.errors.reduce((best, option) => option.length < best.length ? option : best)[0];
+	return first ? reported({
+		...first,
+		path: [...issue.path, ...first.path]
+	}) : issue;
+}
+/** Every failure becomes `{ error: { code, message, hint? } }` with a matching status. */
+function toErrorResponse(error) {
+	if (error instanceof RejectedError) return error.response;
+	if (error instanceof HttpError) {
+		const response = json({ error: {
+			code: error.code,
+			message: error.message,
+			...error.hint !== void 0 ? { hint: error.hint } : {}
+		} }, error.status);
+		if (error.origin === "handle") handleErrors.add(response);
+		return response;
+	}
+	if (error instanceof ZodError) {
+		const issue = error.issues[0] && reported(error.issues[0]);
+		const path = issue?.path.length ? `${issue.path.join(".")}: ` : "";
+		return json({ error: {
+			code: "invalid_request",
+			message: `${path}${issue?.message ?? "invalid request"}`
+		} }, 400);
+	}
+	const code = error?.code;
+	if (code === "INVALID_PAYLOAD") return json({ error: {
+		code: "invalid_request",
+		message: error.message
+	} }, 400);
+	if (code === "PARTIAL_DUPLICATE_BATCH" || code === "DUPLICATE_EVENT_ID") return toErrorResponse(duplicateId());
+	if (code === "STORE_UNAVAILABLE" || code === "STORE_NOT_CONFIGURED") return json({ error: {
+		code: "unavailable",
+		message: error.message
+	} }, 503);
+	console.error("[board]", error);
+	return json({ error: {
+		code: "internal",
+		message: "internal error"
+	} }, 500);
+}
+//#endregion
+export { forbidden as a, toErrorResponse as c, createBoardClient as d, duration as f, duplicateId as i, unauthorized as l, RejectedError as n, json as o, badRequest as r, notFound as s, HttpError as t, BoardError as u };