@vercel/board 0.20.0 → 0.21.0

package/dist/backend-vercel-DjL8tYIF.mjs

@@ -0,0 +1,1314 @@
+import { _ as RemoteWatcherId } from "./schemas-Be08nyfW.mjs";
+import { f as VERSION, k as RegisterBody, n as compileWatcher, o as METHODS, t as canonicalWatchers } from "./watchers-hash-9sxfL1Gd.mjs";
+import { a as sha256, n as derivedId } from "./ids-C6AYo1bu.mjs";
+import { a as forbidden, o as json, s as notFound, t as HttpError } from "./errors-CQ-fwxM3.mjs";
+import { a as wakePath, i as registrant, n as callerProfile, t as PROJECTS_OWN } from "./backend-http-CLcXkcAU.mjs";
+//#region src/server/backend-vercel.ts
+const PROFILE = /^[A-Za-z][A-Za-z0-9-]{0,31}$/;
+const SESSION = /^[A-Za-z0-9_.:-]{1,128}$/;
+const CLIENT_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
+const MESSAGE_ID = /^msg_([0-9a-f-]{36})_([1-9]\d*)$/;
+/** A cursor this backend made: a time, then the position it names, in base 36. */
+const CURSOR = /^([0-9a-z]+)(?:\.([0-9a-z]+))?$/;
+/** The API's own cursor for one channel, which its message list and feed share, and any process resumes. */
+const API_CURSOR = /^c1\./;
+/** The API's longest page of a channel's messages, and longest long-poll, in seconds. */
+const PAGE_MAX = 100;
+const WAIT_MAX_S = 25;
+/** Pages a filtered read of one channel scans for matches before it answers with what it found. */
+const SCAN_PAGES = 10;
+/** What the API keeps none of: a check that gets one of these is told it isn't kept here. */
+const UNKEPT = {
+	schedule: ["no_scheduler", "Vercel's boards don't schedule messages yet"],
+	schedules: ["no_scheduler", "Vercel's boards don't schedule messages yet"],
+	cancelSchedule: ["no_scheduler", "Vercel's boards don't schedule messages yet"],
+	upload: ["no_files", "Vercel's boards keep no files yet"],
+	attachment: ["no_files", "Vercel's boards keep no files yet"]
+};
+const notSupported = (what) => new HttpError(501, "not_supported", `Vercel's boards don't support ${what} yet`);
+/** What a caller board() verified may do. Null for this deployment's own code, which may do what its credentials may. */
+const accessOf = (caller) => "identity" in caller ? caller.identity.principal.access : null;
+/** A verified caller's grant, which the API can't check: it sees this deployment's credentials. */
+function need(access, permission, channel) {
+	if (access && !access.can(permission, channel)) throw forbidden(`this token can't ${permission} in ${channel}`);
+}
+const apiKind = (kind) => kind === "app" ? "workflow" : kind;
+/** A UUIDv7, which the API takes as an operation ID. */
+function operationId() {
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	const now = BigInt(Date.now());
+	for (let i = 0; i < 6; i++) bytes[i] = Number(now >> BigInt(8 * (5 - i)) & 255n);
+	bytes[6] = bytes[6] & 15 | 112;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+const iso = (ms) => new Date(ms).toISOString();
+const idAt = (threadId, sequence) => `msg_${threadId.slice(4)}_${sequence}`;
+/** Where a message ID points: its thread and its place in it. Null for one that isn't a message's. */
+function locate(id) {
+	const found = MESSAGE_ID.exec(id);
+	return found ? {
+		threadId: `thr_${found[1]}`,
+		sequence: Number(found[2])
+	} : null;
+}
+/** A principal as board names it: `vercel:user:<id>`, `vercel:app:<id>`, `vercel:project:<id>:<env>`. */
+function principalId(principal) {
+	if (principal.type === "user") return `vercel:user:${principal.userId}`;
+	if (principal.type === "app") return `vercel:app:${principal.clientId}`;
+	return `vercel:project:${principal.projectId}:${principal.environment}`;
+}
+const authorOf = (actor) => ({
+	actor: actor.id,
+	principal: principalId(actor.principal),
+	profile: actor.profile?.name ?? null,
+	session: actor.session ?? null
+});
+/** The API names nobody, so an actor's handle is its profile, or a short form of its principal. */
+function actorView(actor) {
+	const { principal } = actor;
+	const base = principal.type === "user" ? `user-${principal.userId.slice(0, 6).toLowerCase()}` : principal.type === "app" ? `app-${principal.clientId.slice(0, 6).toLowerCase()}` : principal.environment === "production" ? principal.projectId : `${principal.projectId}@${principal.environment}`;
+	const handle = actor.profile?.name ?? base;
+	const kind = actor.profile ? "agent" : principal.type === "user" ? "person" : principal.type === "project" ? "deployment" : "workflow";
+	return {
+		id: actor.id,
+		kind,
+		handle,
+		name: handle,
+		avatar: actor.profile?.avatar ?? null
+	};
+}
+/**
+* Vercel's board for your team, in Vercel's API: this deployment keeps nothing and reads and writes
+* it as itself, its people as themselves. Messages, threads, reactions, labels, and a channel's
+* changes work; what the API keeps none of yet (schedules, files, watchers, sync) answers 501.
+*/
+function createVercel(options, environment) {
+	const origin = (options.api ?? "https://api.vercel.com").replace(/\/+$/, "");
+	if (!/^https:\/\/[^/]+$|^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) throw new Error(`vercel: ${origin} isn't Vercel's API: pass an https origin`);
+	if (!options.fetch && !environment) throw new Error("vercel: pass a fetch that sends credentials: outside Node there's no environment to find them in");
+	const doFetch = options.fetch ?? environment.fetch();
+	let binding = null;
+	/** This board's own code's names, which a caller here never takes as its profile. */
+	const own = /* @__PURE__ */ new Set();
+	let team = null;
+	const teamId = () => team ??= options.team ? Promise.resolve(options.team) : environment?.team() ?? Promise.resolve(null);
+	/** One request to the API, as `who`. Its errors are the API's own, with its status and code. */
+	async function api(who, method, path, init = {}) {
+		const url = new URL(`${origin}/v1/messageboard${path}`);
+		const id = await teamId();
+		if (id) url.searchParams.set(id.startsWith("team_") ? "teamId" : "slug", id);
+		for (const [name, value] of Object.entries(init.query ?? {})) if (value !== void 0) url.searchParams.set(name, value);
+		const headers = { "content-type": "application/json" };
+		if (who.profile) headers["x-board-profile"] = who.profile.name;
+		if (who.profile?.avatar?.startsWith("https://")) headers["x-board-avatar"] = who.profile.avatar;
+		if (who.session && SESSION.test(who.session)) headers["x-board-session"] = who.session;
+		let response;
+		try {
+			response = await doFetch(url, {
+				method,
+				headers,
+				redirect: "error",
+				...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
+				...init.signal ? { signal: init.signal } : {}
+			});
+		} catch (error) {
+			if (error instanceof HttpError || error instanceof Error && error.name === "AbortError") throw error;
+			throw new HttpError(502, "unreachable", `Vercel's API didn't answer: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const text = await response.text();
+		let body;
+		try {
+			body = text ? JSON.parse(text) : void 0;
+		} catch {}
+		if (response.ok) return body;
+		const error = body?.error;
+		throw new HttpError(response.status, error?.code ?? "remote_error", error?.message ?? `Vercel's API answered ${response.status}`);
+	}
+	/** Every page of a list, in order. */
+	async function all(who, path, key, query = {}, signal) {
+		const out = [];
+		let cursor;
+		do {
+			const page = await api(who, "GET", path, {
+				query: {
+					...query,
+					cursor
+				},
+				...signal ? { signal } : {}
+			});
+			out.push(...page[key]);
+			cursor = page.cursor ?? void 0;
+		} while (cursor);
+		return out;
+	}
+	let board = null;
+	/**
+	* The board's ID: the one given, or the team's, which the API names only to those it lets in. A
+	* team with none gets one the first time a person uses it, as the API asks of its clients; a
+	* project can't make it, and needs a person to grant it the board anyway.
+	*/
+	const boardId = (who) => (board ??= options.board ? Promise.resolve(options.board) : api(who, "GET", "/boards").then(async ({ defaultBoardId }) => {
+		if (defaultBoardId) return defaultBoardId;
+		if ((await self(who)).actor.principal.type === "project") throw new HttpError(404, "no_board", "Vercel's API names no board this project may use: ask someone on the team to grant it the team's board, or pass `board`");
+		const { board: made } = await api(who, "POST", "/boards/default", { body: { operationId: operationId() } });
+		return made.id;
+	})).catch((error) => {
+		board = null;
+		throw error;
+	});
+	const onBoard = async (who, path = "") => `/boards/${encodeURIComponent(await boardId(who))}${path}`;
+	let channels = null;
+	const loadChannels = async (who, fresh = false) => {
+		if (fresh) channels = null;
+		channels ??= onBoard(who, "/channels").then((path) => all(who, path, "channels"));
+		return channels.catch((error) => {
+			channels = null;
+			throw error;
+		});
+	};
+	/** The channel by `name`, which the API finds without listing the board's. */
+	const named = /* @__PURE__ */ new Map();
+	async function channelNamed(who, name) {
+		const known = named.get(name);
+		if (known) return known;
+		const { channels: [found] } = await api(who, "GET", await onBoard(who, "/channels"), { query: { name } });
+		if (found) named.set(name, found);
+		return found ?? null;
+	}
+	async function channelById(who, id) {
+		const found = (await loadChannels(who)).find((channel) => channel.id === id) ?? (await loadChannels(who, true)).find((channel) => channel.id === id);
+		if (!found) throw new HttpError(502, "remote_error", `Vercel's API names a channel it doesn't list: ${id}`);
+		return found;
+	}
+	/** A channel to post in, made the first time something posts to it, as on any board. */
+	async function channelToPost(who, name) {
+		const found = await channelNamed(who, name);
+		if (found) return found;
+		try {
+			const { channel } = await api(who, "POST", await onBoard(who, "/channels"), { body: {
+				operationId: operationId(),
+				name
+			} });
+			channels = null;
+			named.set(name, channel);
+			return channel;
+		} catch (error) {
+			if (error instanceof HttpError && error.code === "channel_name_taken") {
+				const made = await channelNamed(who, name);
+				if (made) return made;
+			}
+			throw error;
+		}
+	}
+	/** The channels a filter names that `access` reads: one, a channel and those under it (`dev/`), or every one. */
+	async function channelsFor(who, filter, access) {
+		const readable = (channel) => access === null || access.readable(channel.name);
+		if (filter !== void 0 && !filter.endsWith("/")) {
+			const found = await channelNamed(who, filter);
+			return found && readable(found) ? [found] : [];
+		}
+		const listed = (await loadChannels(who, true)).filter(readable);
+		if (filter === void 0) return listed;
+		const path = filter.slice(0, -1);
+		return listed.filter((channel) => channel.name === path || channel.name.startsWith(filter));
+	}
+	async function messageById(who, id, signal) {
+		if (!locate(id)) throw notFound(`message not found: ${id}`, "message_not_found");
+		try {
+			return await api(who, "GET", await onBoard(who, `/messages/${encodeURIComponent(id)}`), signal ? { signal } : {});
+		} catch (error) {
+			if (error instanceof HttpError && error.code === "thread_not_found") throw notFound(`message not found: ${id}`, "message_not_found");
+			throw error;
+		}
+	}
+	/** A message `access` may read, and its channel: one it can't is as missing as one that isn't there. */
+	async function readableMessage(who, access, id, signal) {
+		const found = await messageById(who, id, signal);
+		const channel = await channelById(who, found.thread.channelId);
+		if (access && !access.readable(channel.name)) throw notFound(`message not found: ${id}`, "message_not_found");
+		return {
+			...found,
+			channel
+		};
+	}
+	/** Each thread a read needs, read once: a label matches on its root's, which the API keeps on the thread. */
+	function threadReader(who, signal) {
+		const read = /* @__PURE__ */ new Map();
+		return (id) => {
+			let thread = read.get(id);
+			if (!thread) read.set(id, thread = onBoard(who, `/threads/${encodeURIComponent(id)}`).then((path) => api(who, "GET", path, signal ? { signal } : {})).then((found) => found.thread));
+			return thread;
+		};
+	}
+	const threadMessages = async (who, threadId, signal) => all(who, await onBoard(who, `/threads/${encodeURIComponent(threadId)}/messages`), "messages", {}, signal);
+	/** Who reacted with each emoji. The API counts them on the message and lists them apart. */
+	async function reactors(who, message) {
+		if (!message.reactions || Object.keys(message.reactions).length === 0) return {};
+		const named = message.reactors ?? {};
+		if (Object.entries(message.reactions).every(([emoji, count]) => (named[emoji]?.length ?? 0) >= count)) return Object.fromEntries(Object.entries(named).map(([emoji, actors]) => [emoji, [...actors]]));
+		const path = await onBoard(who, `/threads/${encodeURIComponent(message.threadId)}/messages/${message.sequence}/reactions`);
+		const out = {};
+		for (const reaction of await all(who, path, "reactions")) (out[reaction.emoji] ??= []).push(reaction.actor.id);
+		return out;
+	}
+	async function view(who, message, channel) {
+		const root = message.sequence === 1;
+		return {
+			id: message.id,
+			channel,
+			text: message.text,
+			re: root ? null : idAt(message.threadId, 1),
+			replyTo: message.replyTo !== void 0 && message.replyTo !== 1 ? idAt(message.threadId, message.replyTo) : null,
+			thread: message.threadId,
+			labels: { ...message.labels },
+			reactions: message.deletedAt === void 0 ? await reactors(who, message) : {},
+			mentions: [],
+			by: authorOf(message.createdBy),
+			noSync: false,
+			origin: null,
+			from: null,
+			createdAt: iso(message.createdAt),
+			editedAt: message.editedAt === void 0 ? null : iso(message.editedAt),
+			deleted: message.deletedAt !== void 0,
+			undelivered: {},
+			attachments: [],
+			links: [],
+			version: message.version,
+			author: actorView(message.createdBy)
+		};
+	}
+	const positions = /* @__PURE__ */ new Map();
+	function cursorOf(position) {
+		const key = `${position.t.toString(36)}.${Math.floor(Math.random() * 36 ** 8).toString(36)}`;
+		positions.set(key, position);
+		if (positions.size > 1e4) positions.delete(positions.keys().next().value);
+		return key;
+	}
+	function positionOf(cursor) {
+		const kept = positions.get(cursor);
+		if (kept) return kept;
+		const found = CURSOR.exec(cursor);
+		if (!found) throw new HttpError(400, "invalid_cursor", `after: ${cursor} isn't a cursor here or a message's ID`);
+		return {
+			t: parseInt(found[1], 36),
+			feeds: {}
+		};
+	}
+	/** A time a read goes on from: a cursor's, or a message's own. */
+	async function timeOf(who, after) {
+		return locate(after) ? (await messageById(who, after)).message.createdAt : positionOf(after).t;
+	}
+	/** Each channel's feed now, taken before a read, so what's posted while it reads comes after. */
+	async function heads(who, listed) {
+		const path = await onBoard(who, "/changes");
+		const found = await Promise.all(listed.map((channel) => api(who, "GET", path, { query: {
+			channelId: channel.id,
+			from: "latest"
+		} })));
+		return Object.fromEntries(listed.map((channel, i) => [channel.id, {
+			at: found[i].cursor,
+			skip: 0
+		}]));
+	}
+	/** Whether a message matches a read's filters. A label matches on the message or its thread's root. */
+	function matches(filters, message, thread, me) {
+		if (filters.re !== void 0 && filters.re !== message.id && filters.re !== idAt(thread.id, 1)) return false;
+		if (filters.by !== void 0) {
+			const { createdBy } = message;
+			const names = [
+				createdBy.id,
+				principalId(createdBy.principal),
+				createdBy.profile?.name
+			];
+			if (!(filters.by === "me" ? createdBy.id === me : names.includes(filters.by))) return false;
+		}
+		if (filters.mentions !== void 0) return false;
+		if (filters.from !== void 0 && filters.from !== "board") return false;
+		if (filters.text !== void 0 && !message.text.toLowerCase().includes(filters.text.toLowerCase())) return false;
+		for (const [key, values] of filters.label ?? []) {
+			const on = (labels) => labels !== void 0 && Object.hasOwn(labels, key) && (values === null || values.includes(labels[key]));
+			if (!on(message.labels) && !on(thread.labels)) return false;
+		}
+		return true;
+	}
+	/** The label the API's index can narrow a channel's threads by: a root's `key` or `key=value`. */
+	function indexed(filters) {
+		const first = filters.label?.find(([, values]) => values === null || values.length === 1);
+		return first && (first[1] === null ? first[0] : `${first[0]}=${first[1][0]}`);
+	}
+	async function threadsOf(who, channel, filters, signal) {
+		const label = indexed(filters);
+		return all(who, await onBoard(who, "/threads"), "threads", {
+			channelId: channel.id,
+			label
+		}, signal);
+	}
+	/**
+	* A channel's threads, as far as a read needs: the API lists them most recently active first, so
+	* it stops at the first not active since `after`, or at the `limit` newest when it's given one
+	* (not when the read filters what's listed). One it lists by a label comes oldest first, so it
+	* reads every page.
+	*/
+	async function latestThreads(who, channel, label, page, signal) {
+		const path = await onBoard(who, "/threads");
+		const out = [];
+		let cursor;
+		do {
+			const found = await api(who, "GET", path, {
+				query: {
+					channelId: channel.id,
+					label,
+					cursor
+				},
+				signal
+			});
+			out.push(...found.threads);
+			cursor = found.cursor ?? void 0;
+			const last = out.at(-1);
+			if (label === void 0 && (page.after !== void 0 ? last !== void 0 && last.lastActivityAt <= page.after : page.limit !== void 0 && out.length >= page.limit)) break;
+		} while (cursor);
+		return out;
+	}
+	/** A thread at a glance: its root, its reply count, and its latest reply, read by reference. */
+	async function summary(who, thread, channel, signal) {
+		const [root, last] = await Promise.all([messageById(who, idAt(thread.id, 1), signal), thread.lastMessage && thread.lastMessage.sequence > 1 ? messageById(who, thread.lastMessage.id, signal) : null]);
+		return {
+			message: await view(who, root.message, channel.name),
+			replies: thread.messageCount - 1,
+			last: last && await view(who, last.message, channel.name)
+		};
+	}
+	let me = null;
+	/** Who these credentials are, asked once. */
+	const self = (who) => (me ??= api(who, "GET", "/me")).catch((error) => {
+		me = null;
+		throw error;
+	});
+	/** The actor `who` writes as: the credentials' principal, and its profile, as the API names it. */
+	const actorOf = async (who) => `${principalId((await self(who)).actor.principal)}${who.profile ? `+${who.profile.name.toLowerCase()}` : ""}`;
+	/** Who a caller acts as there: its profile and session, beside this deployment's credentials. */
+	function whoOf(caller) {
+		if ("identity" in caller) {
+			const avatar = caller.identity.actor.avatar?.startsWith("https://") ? caller.identity.actor.avatar : void 0;
+			return {
+				profile: {
+					name: callerProfile(caller.identity.actor.handle, own),
+					...avatar ? { avatar } : {}
+				},
+				session: null
+			};
+		}
+		const named = (profile) => {
+			if (profile === null) return null;
+			const name = typeof profile === "string" ? profile : profile.name;
+			if (!PROFILE.test(name)) throw new HttpError(400, "invalid_request", `as: ${name}: profiles start with a letter and use up to 32 letters, numbers, and hyphens`);
+			return typeof profile === "string" || !profile.avatar ? { name } : {
+				name,
+				avatar: profile.avatar
+			};
+		};
+		if (caller.origin.via?.kind === "client") {
+			const asked = "profile" in caller ? caller.profile : caller.self ?? void 0;
+			const found = environment?.profile() ?? {
+				profile: null,
+				session: null
+			};
+			if (asked === void 0) return {
+				profile: named(found.profile),
+				session: found.session
+			};
+			return {
+				profile: named(asked),
+				session: asked === null ? null : found.session
+			};
+		}
+		return {
+			profile: named(caller.self ?? "client"),
+			session: null
+		};
+	}
+	/** A post's client ID, as the API takes one: its own when it fits, a hash of it when it doesn't. */
+	const clientIdOf = async (id) => CLIENT_ID.test(id) ? id : `h.${(await sha256(id)).slice(0, 64)}`;
+	/** A gateway caller's post IDs are its own, derived under who it is here, since the API sees this deployment. */
+	const postId = async (caller, id) => clientIdOf("identity" in caller ? await derivedId("board-gateway", caller.identity.principal.id, id) : id);
+	/** Messages a read covers, newest last: every thread's in the channels it names, or one thread's. */
+	async function collect(who, access, filters, signal) {
+		let listed;
+		let threads;
+		if (filters.re !== void 0) {
+			const found = await readableMessage(who, access, filters.re, signal).catch((error) => {
+				if (error instanceof HttpError && error.status === 404) return null;
+				throw error;
+			});
+			if (!found) return {
+				messages: [],
+				feeds: {},
+				newest: 0
+			};
+			const { channel } = found;
+			if (filters.channel !== void 0 && !(await channelsFor(who, filters.channel, access)).some((c) => c.id === channel.id)) return {
+				messages: [],
+				feeds: {},
+				newest: 0
+			};
+			listed = [channel];
+			threads = [{
+				thread: found.thread,
+				channel
+			}];
+		} else {
+			listed = await channelsFor(who, filters.channel, access);
+			threads = (await Promise.all(listed.map(async (channel) => (await threadsOf(who, channel, filters, signal)).map((thread) => ({
+				thread,
+				channel
+			}))))).flat();
+		}
+		const feeds = await heads(who, listed);
+		const mine = await actorOf(who);
+		let newest = 0;
+		const messages = [];
+		for (const { thread, channel } of threads) for (const message of await threadMessages(who, thread.id, signal)) {
+			newest = Math.max(newest, message.createdAt);
+			if (matches(filters, message, thread, mine)) messages.push({
+				message,
+				thread,
+				channel
+			});
+		}
+		messages.sort((a, b) => a.message.createdAt - b.message.createdAt || a.thread.id.localeCompare(b.thread.id) || a.message.sequence - b.message.sequence);
+		return {
+			messages,
+			feeds,
+			newest
+		};
+	}
+	/** A change in the API's feed as a board event, with the message as it is now. Null for what isn't a message's. */
+	async function eventOf(who, change, channel, cursor, filters, me, given) {
+		if (!change.messageId || !change.type.startsWith("message.")) return null;
+		const found = given ?? await messageById(who, change.messageId).catch((error) => {
+			if (error instanceof HttpError && error.status === 404) return null;
+			throw error;
+		});
+		if (!found || !matches(filters, found.message, found.thread, me)) return null;
+		const message = await view(who, found.message, channel);
+		const by = authorOf(change.actor);
+		const base = {
+			id: message.id,
+			thread: message.thread
+		};
+		let type;
+		let payload;
+		switch (change.type) {
+			case "message.posted":
+				type = "message.posted";
+				payload = {
+					channel,
+					text: message.text,
+					re: message.re,
+					replyTo: message.replyTo,
+					thread: message.thread,
+					labels: message.labels,
+					noSync: false,
+					mentions: [],
+					by,
+					origin: null,
+					from: null,
+					attachments: [],
+					links: []
+				};
+				break;
+			case "message.edited":
+				type = "message.edited";
+				payload = {
+					...base,
+					text: message.text,
+					mentions: [],
+					by,
+					from: null
+				};
+				break;
+			case "message.deleted":
+				type = "message.deleted";
+				payload = {
+					...base,
+					by,
+					from: null
+				};
+				break;
+			case "message.reaction_added":
+			case "message.reaction_removed":
+				type = change.type === "message.reaction_added" ? "reaction.added" : "reaction.removed";
+				payload = {
+					...base,
+					emoji: change.emoji,
+					by,
+					from: null
+				};
+				break;
+			case "message.labeled": {
+				const changed = Object.entries(change.labels ?? {});
+				type = "labels.changed";
+				payload = {
+					...base,
+					set: Object.fromEntries(changed.flatMap(([key, { to }]) => to === void 0 ? [] : [[key, to]])),
+					unset: changed.flatMap(([key, { to }]) => to === void 0 ? [key] : []),
+					by
+				};
+				break;
+			}
+			default: return null;
+		}
+		return {
+			cursor,
+			type,
+			createdAt: iso(change.createdAt),
+			payload,
+			message,
+			actor: actorView(change.actor)
+		};
+	}
+	/**
+	* One read of every channel's feed from `position`: its events, merged by time, each with the
+	* position right after it, and the position after them all.
+	*/
+	async function read(who, listed, position, filters, signal) {
+		const path = await onBoard(who, "/changes");
+		const pages = await Promise.all(listed.map(async (channel) => {
+			const from = position.feeds[channel.id];
+			const page = await api(who, "GET", path, {
+				query: {
+					channelId: channel.id,
+					...from?.at ? { cursor: from.at } : {}
+				},
+				signal
+			});
+			const skip = from?.skip ?? 0;
+			const events = page.events.map((change, i) => ({
+				change,
+				i
+			})).slice(skip).filter(({ change }) => from || change.createdAt > position.t);
+			return {
+				channel,
+				at: from?.at ?? null,
+				next: page.cursor,
+				events
+			};
+		}));
+		const mine = await actorOf(who);
+		const running = { ...position.feeds };
+		const merged = pages.flatMap((page) => page.events.map((event) => ({
+			...event,
+			page
+		}))).sort((a, b) => a.change.createdAt - b.change.createdAt);
+		const events = [];
+		for (const { change, i, page } of merged) {
+			running[page.channel.id] = {
+				at: page.at,
+				skip: i + 1
+			};
+			const event = await eventOf(who, change, page.channel.name, cursorOf({
+				t: change.createdAt,
+				feeds: { ...running }
+			}), filters, mine);
+			if (event) events.push(event);
+		}
+		const after = { ...position.feeds };
+		for (const page of pages) after[page.channel.id] = {
+			at: page.next,
+			skip: 0
+		};
+		return {
+			events,
+			position: {
+				t: Math.max(position.t, ...merged.map(({ change }) => change.createdAt)),
+				feeds: after
+			}
+		};
+	}
+	/** Whether a read filters on what messages say, who wrote them, or their labels: what the API can't narrow by. */
+	const filtered = (filters) => filters.by !== void 0 || filters.mentions !== void 0 || filters.text !== void 0 || filters.from !== void 0 || (filters.label?.length ?? 0) > 0;
+	/**
+	* One channel's messages, from the API's message list: the latest `limit`, or those after one of
+	* its cursors. A filtered read checks each page here, and asks only for as many as it still needs,
+	* so the cursor it answers with never passes a match it left out.
+	*/
+	async function channelMessages(who, channel, query, signal) {
+		const path = await onBoard(who, "/messages");
+		const limit = query.limit ?? 50;
+		const thread = threadReader(who, signal);
+		const narrowed = filtered(query);
+		const me = narrowed ? await actorOf(who) : null;
+		const keep = async (message) => !narrowed || matches(query, message, query.label?.length ? await thread(message.threadId) : { id: message.threadId }, me);
+		const kept = [];
+		if (query.after === void 0) {
+			const page = await api(who, "GET", path, {
+				query: {
+					channelId: channel.id,
+					limit: String(narrowed ? PAGE_MAX : Math.min(limit, PAGE_MAX))
+				},
+				signal
+			});
+			for (const message of page.messages) if (await keep(message)) kept.push(message);
+			return {
+				messages: kept.slice(-limit),
+				cursor: page.cursor
+			};
+		}
+		let cursor = query.after;
+		for (let pages = 0; pages < SCAN_PAGES && kept.length < limit; pages++) {
+			const page = await api(who, "GET", path, {
+				query: {
+					channelId: channel.id,
+					after: cursor,
+					limit: String(Math.min(limit - kept.length, PAGE_MAX))
+				},
+				signal
+			});
+			cursor = page.cursor;
+			for (const message of page.messages) if (await keep(message)) kept.push(message);
+			if (page.messages.length === 0) break;
+		}
+		return {
+			messages: kept,
+			cursor
+		};
+	}
+	/** One channel's events, from the API's feed after one of its cursors, or from now: a long-poll holds there, not here. */
+	async function channelEvents(who, channel, query, signal) {
+		const path = await onBoard(who, "/changes");
+		const thread = threadReader(who, signal);
+		const me = await actorOf(who);
+		const until = Date.now() + (query.wait ?? 0) * 1e3;
+		let cursor = query.after;
+		for (;;) {
+			const wait = Math.min(WAIT_MAX_S, Math.max(0, Math.ceil((until - Date.now()) / 1e3)));
+			const page = await api(who, "GET", path, {
+				query: {
+					channelId: channel.id,
+					include: "message",
+					...cursor === void 0 ? { from: "latest" } : { cursor },
+					...wait > 0 ? { wait: String(wait) } : {}
+				},
+				signal
+			});
+			cursor = page.cursor;
+			const events = [];
+			for (const change of page.events) {
+				const message = change.currentMessage;
+				const found = message && change.threadId ? {
+					message,
+					thread: query.label?.length ? await thread(change.threadId) : { id: change.threadId }
+				} : null;
+				if (!found) continue;
+				const event = await eventOf(who, change, channel.name, change.cursor ?? page.cursor, query, me, found);
+				if (event) events.push(event);
+			}
+			if (events.length > 0 || Date.now() >= until || signal.aborted) return {
+				events,
+				cursor
+			};
+		}
+	}
+	/** The one channel a read names, when the API can read it directly: not a subtree, and from one of its cursors or now. */
+	async function oneChannel(who, access, query) {
+		if (query.channel === void 0 || query.channel.endsWith("/") || query.re !== void 0) return null;
+		if (query.after !== void 0 && !API_CURSOR.test(query.after)) return null;
+		const [channel] = await channelsFor(who, query.channel, access);
+		return channel ?? null;
+	}
+	/** Who wrote or reacted in the latest messages of each channel `access` reads. */
+	async function actorsSeen(who, access, signal) {
+		const path = await onBoard(who, "/messages");
+		const seen = /* @__PURE__ */ new Set();
+		for (const channel of await channelsFor(who, void 0, access)) {
+			const { messages } = await api(who, "GET", path, {
+				query: {
+					channelId: channel.id,
+					limit: String(PAGE_MAX)
+				},
+				signal
+			});
+			for (const message of messages) {
+				seen.add(message.createdBy.id);
+				for (const actors of Object.values(message.reactors ?? {})) for (const actor of actors) seen.add(actor);
+			}
+		}
+		return seen;
+	}
+	/** What a gateway caller does here, as this deployment: never what's the project's own. */
+	function checkCaller(method, caller) {
+		if ("identity" in caller && PROJECTS_OWN.has(method)) throw forbidden(`this board's callers act as its project on Vercel's board, which can't tell them apart: ${method} is the project's own to do there`);
+	}
+	const meOf = (identity) => {
+		const { principal, author, actor } = identity;
+		return {
+			actor: actor.id,
+			principal: principal.id,
+			kind: actor.kind,
+			handle: actor.handle,
+			name: actor.name,
+			avatar: actor.avatar,
+			profile: author.profile,
+			session: author.session,
+			expiresAt: principal.expiresAt?.toISOString() ?? null,
+			can: principal.access.summary()
+		};
+	};
+	/** A watcher's tail registers with the API as its own: an API watcher, so a match is the API's to make. */
+	const tagOf = async (watch) => (await sha256(canonicalWatchers(watch))).slice(0, 32);
+	/** Who `--by` names, as the API's authors: an actor, a principal, or everyone here with that handle or profile, as of now. */
+	async function authorsOf(who, by) {
+		if (by === "me") return [await actorOf(who)];
+		if (by.startsWith("vercel:")) return [by];
+		const named = (await all(who, await onBoard(who, "/actors"), "actors")).filter((actor) => actor.handle === by || actor.id.endsWith(`+${by.toLowerCase()}`)).map((actor) => actor.id);
+		if (named.length === 0) throw new HttpError(400, "bad_watcher", `--by ${by}: nobody here goes by that yet: name them by their actor ID`);
+		return named;
+	}
+	/**
+	* A tail as the filter the API matches. The API reads no tails: channels, people, and threads are
+	* looked up here, now, and what it can't match (mentions, other sources) is refused rather than
+	* left to match nothing.
+	*/
+	async function filterOf(who, id, spec) {
+		const bad = (message) => new HttpError(400, "bad_watcher", `watch ${id}: ${message}`);
+		if (!RemoteWatcherId.safeParse(id).success) throw bad("ids start with a letter and use up to 32 letters, numbers, and hyphens");
+		let filters;
+		try {
+			({filters} = compileWatcher(id, spec));
+		} catch (error) {
+			throw new HttpError(400, "bad_watcher", error.message);
+		}
+		if (filters.mentions !== void 0) throw bad("Vercel's boards can't match mentions yet");
+		if (filters.from !== void 0 && filters.from !== "board") throw bad(`nothing comes from ${filters.from} here: every message is written on the board`);
+		const filter = {};
+		if (filters.channel !== void 0) {
+			if (filters.channel.endsWith("/")) filter.channelTree = filters.channel.slice(0, -1);
+			else {
+				const found = await channelNamed(who, filters.channel);
+				if (found) filter.channelIds = [found.id];
+				else filter.channelTree = filters.channel;
+			}
+		}
+		if (filters.re !== void 0) {
+			const at = locate(filters.re);
+			if (!at) throw bad(`--re ${filters.re} names no message here`);
+			filter.threadId = at.threadId;
+		}
+		if (filters.by !== void 0) filter.authors = await authorsOf(who, filters.by);
+		if (filters.text !== void 0) filter.text = filters.text;
+		if (filters.label?.length) filter.labels = filters.label.map(([key, values]) => values === null ? { key } : {
+			key,
+			values: [...values]
+		});
+		return {
+			filter,
+			when: spec.when ?? "matches"
+		};
+	}
+	/** A filter shown as a tail again, for listing: what it matches, if not always as it was written. */
+	async function tailOf(who, { filter }) {
+		const parts = [];
+		if (filter.channelIds?.[0]) parts.push((await channelById(who, filter.channelIds[0])).name);
+		else if (filter.channelTree !== void 0) parts.push(`${filter.channelTree}/`);
+		if (filter.threadId !== void 0) parts.push(`--re ${idAt(filter.threadId, 1)}`);
+		if (filter.authors?.[0]) parts.push(`--by ${filter.authors[0]}`);
+		if (filter.text !== void 0) parts.push(`--text ${JSON.stringify(filter.text)}`);
+		for (const { key, values } of filter.labels ?? []) parts.push(`--label ${values ? `${key}=${values.join("|")}` : key}`);
+		return parts.join(" ");
+	}
+	/** Where a registration is woken, as board shows it: its URL, or a path on its project (and a preview's branch). */
+	const whereOf = (found) => found.path ? {
+		url: null,
+		path: found.path,
+		...found.branch ? { branch: found.branch } : {}
+	} : { url: found.url };
+	async function registerAs(who, where, watch) {
+		const specs = Object.fromEntries(Object.entries(watch).map(([id, spec]) => [id, {
+			tail: spec.tail,
+			when: spec.when ?? "matches"
+		}]));
+		const filters = Object.fromEntries(await Promise.all(Object.entries(specs).map(async ([id, spec]) => [id, await filterOf(who, id, spec)])));
+		const made = await api(who, "PUT", await onBoard(who, "/watchers"), { body: {
+			...where,
+			watch: filters,
+			tag: await tagOf(specs)
+		} });
+		return {
+			owner: made.owner,
+			...whereOf(made),
+			watch: specs,
+			sync: [],
+			hash: made.hash
+		};
+	}
+	/** A match as vboard hands it out: its event as `vb tail --json` prints it, with its message as it is now. */
+	async function matchOf(who, match, me) {
+		const found = await messageById(who, match.event.messageId).catch((error) => {
+			if (error instanceof HttpError && error.status === 404) return null;
+			throw error;
+		});
+		const channel = found && await channelById(who, found.thread.channelId);
+		const event = found && channel && await eventOf(who, match.event, channel.name, match.id, {}, me, found);
+		if (!event?.message) return null;
+		return {
+			id: match.id,
+			watcher: match.watcher,
+			thread: event.message.thread,
+			lease: match.lease,
+			attempt: match.attempt,
+			event
+		};
+	}
+	async function pullAs(who, query, signal) {
+		const { matches } = await api(who, "GET", await onBoard(who, "/watchers/matches"), {
+			query: {
+				limit: query.limit?.toString(),
+				wait: query.wait?.toString()
+			},
+			...signal ? { signal } : {}
+		});
+		const me = await actorOf(who);
+		const shown = await Promise.all(matches.map((match) => matchOf(who, match, me)));
+		await Promise.all(matches.map((match, i) => shown[i] ? null : ackAs(who, match.id, {
+			lease: match.lease,
+			skip: true
+		}).catch(() => {})));
+		return shown.filter((match) => match !== null);
+	}
+	async function ackAs(who, id, body) {
+		await api(who, "POST", await onBoard(who, `/watchers/matches/${encodeURIComponent(id)}/ack`), { body: {
+			lease: body.lease,
+			...body.error !== void 0 ? { error: body.error } : {},
+			...body.skip ? { skip: true } : {}
+		} });
+	}
+	/**
+	* The API keeps one registration per principal, and this board reaches it as its own deployment:
+	* one a caller registered through it would replace the deployment's, and every other caller's.
+	*/
+	function ownWatchers(caller, what) {
+		if ("identity" in caller) throw forbidden(`this board registers watchers as its own deployment, so it can't ${what} for you: run them in its config, or register with Vercel's API as yourself`);
+	}
+	/** This deployment's own: what its config's watchers run as. */
+	const deployment = {
+		profile: null,
+		session: null
+	};
+	/** This board's config's watchers, which run here when the API wakes it. */
+	let tails = {};
+	const bound = () => {
+		if (!binding) throw new Error("vercel: used before board() bound it");
+		return binding;
+	};
+	const runner = registrant({
+		remote: "Vercel's API",
+		registry: {
+			register: (where) => registerAs(deployment, where, tails),
+			matches: ({ signal, ...query }) => pullAs(deployment, query, signal),
+			ack: (id, body) => ackAs(deployment, id, body)
+		},
+		wakeAt: async (here) => wakePath(here) ?? { url: here },
+		binding: bound,
+		hash: () => tagOf(tails),
+		hasWork: () => Object.keys(tails).length > 0,
+		rethrow: (error) => {
+			throw error;
+		},
+		registerFor: async (caller, request) => json(await methods.register(caller, RegisterBody.parse(await request.json()), request.signal))
+	});
+	const methods = {
+		...Object.fromEntries(METHODS.map((method) => [method, async () => {
+			const unkept = UNKEPT[method];
+			if (unkept) throw new HttpError(501, unkept[0], unkept[1]);
+			throw notSupported(method === "register" || method === "watchers" || method === "matches" || method === "ack" ? "watchers" : method);
+		}])),
+		async discovery() {
+			const who = {
+				profile: null,
+				session: null
+			};
+			const team = await teamId();
+			return {
+				version: VERSION,
+				url: `${origin}/v1/messageboard${await onBoard(who)}`,
+				audience: origin,
+				team_id: team?.startsWith("team_") ? team : (await self(who)).teamId,
+				project_id: null,
+				sync: [],
+				wake_by_path: true
+			};
+		},
+		async me(caller) {
+			if ("identity" in caller) return meOf(caller.identity);
+			const found = await api(whoOf(caller), "GET", "/me");
+			const { view: named } = found;
+			const shown = named ? {
+				kind: apiKind(named.kind),
+				handle: named.handle,
+				name: named.name ?? named.handle,
+				avatar: named.avatar ?? null
+			} : actorView(found.actor);
+			return {
+				actor: found.actor.id,
+				principal: principalId(found.actor.principal),
+				kind: shown.kind,
+				handle: shown.handle,
+				name: shown.name,
+				avatar: shown.avatar,
+				profile: found.actor.profile?.name ?? null,
+				session: found.actor.session ?? null,
+				expiresAt: null,
+				can: { "*": [
+					"read",
+					"post",
+					"react",
+					"label"
+				] }
+			};
+		},
+		async channels(caller) {
+			return {
+				channels: (await channelsFor(whoOf(caller), void 0, accessOf(caller))).map((channel) => ({
+					path: channel.name,
+					lastIndex: 0,
+					messages: 0,
+					threads: 0
+				})),
+				cursor: cursorOf({
+					t: Date.now(),
+					feeds: {}
+				})
+			};
+		},
+		async actors(caller, _input, signal) {
+			const who = whoOf(caller);
+			const listed = (await all(who, await onBoard(who, "/actors"), "actors", {}, signal)).map((actor) => ({
+				id: actor.id,
+				kind: apiKind(actor.kind),
+				handle: actor.handle,
+				name: actor.name ?? actor.handle,
+				avatar: actor.avatar ?? null
+			}));
+			const cursor = cursorOf({
+				t: Date.now(),
+				feeds: {}
+			});
+			if (!("identity" in caller) || caller.identity.principal.access.readsAll) return {
+				actors: listed,
+				cursor
+			};
+			const { actor: self, principal } = caller.identity;
+			const seen = await actorsSeen(who, principal.access, signal);
+			return {
+				actors: [...listed.filter((actor) => seen.has(actor.id) && actor.id !== self.id), {
+					id: self.id,
+					kind: self.kind,
+					handle: self.handle,
+					name: self.name,
+					avatar: self.avatar
+				}],
+				cursor
+			};
+		},
+		async messages(caller, query, signal) {
+			const who = whoOf(caller);
+			const access = accessOf(caller);
+			const channel = query.before === void 0 ? await oneChannel(who, access, query) : null;
+			if (channel) {
+				const page = await channelMessages(who, channel, query, signal);
+				return {
+					messages: await Promise.all(page.messages.map((message) => view(who, message, channel.name))),
+					cursor: page.cursor
+				};
+			}
+			if (query.after !== void 0 && API_CURSOR.test(query.after)) throw new HttpError(400, "invalid_request", `after: ${query.after} is one channel's cursor: read that channel`);
+			const { messages, feeds, newest } = await collect(who, access, query, signal);
+			const after = query.after !== void 0 ? await timeOf(who, query.after) : void 0;
+			const before = query.before !== void 0 ? await timeOf(who, query.before) : void 0;
+			const limit = query.limit ?? 50;
+			const bounded = messages.filter(({ message }) => (after === void 0 || message.createdAt > after) && (before === void 0 || message.createdAt < before));
+			const page = after !== void 0 ? bounded.slice(0, limit) : bounded.slice(-limit);
+			return {
+				messages: await Promise.all(page.map(({ message, channel }) => view(who, message, channel.name))),
+				cursor: cursorOf({
+					t: newest,
+					feeds
+				})
+			};
+		},
+		async threads(caller, query, signal) {
+			const who = whoOf(caller);
+			const after = query.after !== void 0 ? await timeOf(who, query.after) : void 0;
+			const limit = query.limit ?? 50;
+			const pick = (found) => {
+				const ordered = found.filter(({ at }) => after === void 0 || at > after).sort((a, b) => a.at - b.at);
+				return after !== void 0 ? ordered.slice(0, limit) : ordered.slice(-limit);
+			};
+			if (query.re !== void 0 || query.by !== void 0 || query.mentions !== void 0 || query.text !== void 0 || query.from !== void 0 && query.from !== "board") {
+				const { messages, feeds, newest } = await collect(who, accessOf(caller), query, signal);
+				const latest = /* @__PURE__ */ new Map();
+				for (const { message, thread, channel } of messages) latest.set(thread.id, {
+					thread,
+					channel,
+					at: Math.max(latest.get(thread.id)?.at ?? 0, message.createdAt)
+				});
+				return {
+					threads: await Promise.all(pick([...latest.values()]).map(({ thread, channel }) => summary(who, thread, channel, signal))),
+					cursor: cursorOf({
+						t: newest,
+						feeds
+					})
+				};
+			}
+			const listed = await channelsFor(who, query.channel, accessOf(caller));
+			const feeds = await heads(who, listed);
+			const label = indexed(query);
+			const found = (await Promise.all(listed.map(async (channel) => (await latestThreads(who, channel, label, {
+				...after !== void 0 ? { after } : {},
+				...query.label?.length ? {} : { limit }
+			}, signal)).map((thread) => ({
+				thread,
+				channel,
+				at: thread.lastActivityAt
+			}))))).flat();
+			const rooted = found.filter(({ thread }) => (query.label ?? []).every(([key, values]) => thread.labels !== void 0 && Object.hasOwn(thread.labels, key) && (values === null || values.includes(thread.labels[key]))));
+			const newest = found.reduce((max, { at }) => Math.max(max, at), 0);
+			return {
+				threads: await Promise.all(pick(rooted).map(({ thread, channel }) => summary(who, thread, channel, signal))),
+				cursor: cursorOf({
+					t: newest,
+					feeds
+				})
+			};
+		},
+		async message(caller, { id }, signal) {
+			const who = whoOf(caller);
+			const { thread, channel } = await readableMessage(who, accessOf(caller), id, signal);
+			const [root, ...replies] = await threadMessages(who, thread.id, signal);
+			if (!root) throw notFound(`message not found: ${id}`, "message_not_found");
+			return {
+				message: await view(who, root, channel.name),
+				replies: await Promise.all(replies.map((reply) => view(who, reply, channel.name))),
+				cursor: cursorOf({
+					t: Math.max(root.createdAt, ...replies.map((reply) => reply.createdAt)),
+					feeds: {}
+				})
+			};
+		},
+		async post(caller, input, signal) {
+			checkCaller("post", caller);
+			if (input.attachments?.length) throw new HttpError(501, "no_files", "Vercel's boards keep no files yet");
+			if (input.sync?.length) throw notSupported("sync");
+			const who = whoOf(caller);
+			const access = accessOf(caller);
+			const labeled = Object.keys(input.labels ?? {}).length > 0;
+			const clientId = input.id !== void 0 ? await postId(caller, input.id) : void 0;
+			let made;
+			if (input.channel !== void 0) {
+				need(access, "post", input.channel);
+				if (labeled) need(access, "label", input.channel);
+				const channel = await channelToPost(who, input.channel);
+				made = await api(who, "POST", await onBoard(who, "/threads"), {
+					body: {
+						operationId: operationId(),
+						channelId: channel.id,
+						text: input.text,
+						...input.labels && Object.keys(input.labels).length ? { labels: input.labels } : {},
+						...clientId ? { clientId } : {}
+					},
+					signal
+				});
+			} else {
+				const { thread, message: to, channel } = await readableMessage(who, access, input.re, signal);
+				need(access, "post", channel.name);
+				if (labeled) need(access, "label", channel.name);
+				made = await api(who, "POST", await onBoard(who, `/threads/${encodeURIComponent(thread.id)}/messages`), {
+					body: {
+						operationId: operationId(),
+						text: input.text,
+						...to.sequence > 1 ? { replyTo: to.sequence } : {},
+						...clientId ? { clientId } : {}
+					},
+					signal
+				});
+				if (input.labels && Object.keys(input.labels).length) {
+					const labeled = await api(who, "POST", await onBoard(who, `/threads/${encodeURIComponent(thread.id)}/messages/${made.message.sequence}/labels`), {
+						body: {
+							operationId: operationId(),
+							set: input.labels
+						},
+						signal
+					});
+					made = {
+						...made,
+						message: {
+							...made.message,
+							...labeled.meta.labels ? { labels: labeled.meta.labels } : {},
+							version: labeled.meta.version
+						}
+					};
+				}
+			}
+			const channel = await channelById(who, made.thread.channelId);
+			return { message: await view(who, made.message, channel.name) };
+		},
+		async posted(caller, { id }, signal) {
+			checkCaller("posted", caller);
+			const who = whoOf(caller);
+			const found = await api(who, "GET", await onBoard(who, `/posts/${encodeURIComponent(await postId(caller, id))}`), { signal });
+			const channel = await channelById(who, found.thread.channelId);
+			const access = accessOf(caller);
+			if (access && !access.readable(channel.name)) throw notFound(`no post of yours has id ${id}`, "post_not_found");
+			return { message: await view(who, found.message, channel.name) };
+		},
+		async edit(caller, { id, text }, signal) {
+			checkCaller("edit", caller);
+			const who = whoOf(caller);
+			const at = locate(id);
+			if (!at) throw notFound(`message not found: ${id}`, "message_not_found");
+			await api(who, "PATCH", await onBoard(who, `/threads/${encodeURIComponent(at.threadId)}/messages/${at.sequence}`), {
+				body: {
+					operationId: operationId(),
+					text
+				},
+				signal
+			});
+			return { ok: true };
+		},
+		async delete(caller, { id }, signal) {
+			checkCaller("delete", caller);
+			const who = whoOf(caller);
+			const at = locate(id);
+			if (!at) throw notFound(`message not found: ${id}`, "message_not_found");
+			await api(who, "POST", await onBoard(who, `/threads/${encodeURIComponent(at.threadId)}/messages/${at.sequence}/delete`), {
+				body: { operationId: operationId() },
+				signal
+			});
+			return { ok: true };
+		},
+		async react(caller, { id, emoji, remove }, signal) {
+			checkCaller("react", caller);
+			const who = whoOf(caller);
+			const at = locate(id);
+			if (!at) throw notFound(`message not found: ${id}`, "message_not_found");
+			const access = accessOf(caller);
+			if (access) need(access, "react", (await readableMessage(who, access, id, signal)).channel.name);
+			await api(who, "POST", await onBoard(who, `/threads/${encodeURIComponent(at.threadId)}/messages/${at.sequence}/reactions`), {
+				body: {
+					operationId: operationId(),
+					emoji,
+					...remove ? { remove: true } : {}
+				},
+				signal
+			});
+			return { ok: true };
+		},
+		async label(caller, { id, set, unset }, signal) {
+			checkCaller("label", caller);
+			const who = whoOf(caller);
+			const at = locate(id);
+			if (!at) throw notFound(`message not found: ${id}`, "message_not_found");
+			const access = accessOf(caller);
+			if (access) need(access, "label", (await readableMessage(who, access, id, signal)).channel.name);
+			await api(who, "POST", await onBoard(who, `/threads/${encodeURIComponent(at.threadId)}/messages/${at.sequence}/labels`), {
+				body: {
+					operationId: operationId(),
+					...set ? { set } : {},
+					...unset ? { unset } : {}
+				},
+				signal
+			});
+			return { ok: true };
+		},
+		async events(caller, query, signal) {
+			checkCaller("events", caller);
+			const who = whoOf(caller);
+			const access = accessOf(caller);
+			const channel = await oneChannel(who, access, query);
+			if (channel) return channelEvents(who, channel, query, signal);
+			if (query.after !== void 0 && API_CURSOR.test(query.after)) throw new HttpError(400, "invalid_request", `after: ${query.after} is one channel's cursor: read that channel`);
+			const listed = await channelsFor(who, query.channel, access);
+			let position = query.after === void 0 ? {
+				t: Date.now(),
+				feeds: await heads(who, listed)
+			} : locate(query.after) ? {
+				t: await timeOf(who, query.after),
+				feeds: {}
+			} : positionOf(query.after);
+			const until = Date.now() + (query.wait ?? 0) * 1e3;
+			for (;;) {
+				const page = await read(who, listed, position, query, signal);
+				position = page.position;
+				if (page.events.length > 0 || Date.now() >= until || signal.aborted) return {
+					events: page.events,
+					cursor: cursorOf(position)
+				};
+				await new Promise((resolve) => setTimeout(resolve, Math.min(1e3, until - Date.now())));
+			}
+		},
+		async typing() {
+			return { targets: [] };
+		},
+		async readSource(_caller, { key }) {
+			throw notFound(`this board doesn't run sync entry ${key}`, "not_synced_here");
+		},
+		async watchers(caller) {
+			ownWatchers(caller, "list watchers");
+			const who = whoOf(caller);
+			const { watchers } = await api(who, "GET", await onBoard(who, "/watchers"));
+			return { watchers: await Promise.all(watchers.map(async (found) => ({
+				owner: found.owner,
+				...whereOf(found),
+				watch: Object.fromEntries(await Promise.all(Object.entries(found.watch).map(async ([id, spec]) => [id, {
+					tail: await tailOf(who, spec),
+					when: spec.when
+				}]))),
+				sync: [],
+				hash: found.hash
+			}))) };
+		},
+		async register(caller, body) {
+			ownWatchers(caller, "register watchers");
+			if ((body.sync?.length ?? 0) > 0) throw notSupported("sync");
+			return registerAs(whoOf(caller), typeof body.path === "string" ? {
+				path: body.path,
+				...body.branch ? { branch: body.branch } : {}
+			} : { url: body.url ?? null }, body.watch);
+		},
+		async matches(caller, query, signal) {
+			ownWatchers(caller, "pull matches");
+			return { matches: await pullAs(whoOf(caller), query, signal) };
+		},
+		async ack(caller, { id, ...body }) {
+			ownWatchers(caller, "ack matches");
+			await ackAs(whoOf(caller), id, body);
+			return { ok: true };
+		}
+	};
+	return {
+		...Object.fromEntries(Object.entries(methods).map(([name, method]) => [name, (...args) => {
+			if (binding) runner.start();
+			return method(...args);
+		}])),
+		routes: runner.routes,
+		keeps: false,
+		bind(next) {
+			if (binding) throw new Error("vercel: this backend already serves a board: create one vercel() per board()");
+			if (Object.values(next.subscriptions).map((subscription) => subscription.kind).includes("sync")) throw new Error("vercel: Vercel's boards don't run sync yet: leave `sync` out");
+			for (const id of Object.keys(next.subscriptions)) own.add(id);
+			tails = Object.fromEntries(Object.entries(next.subscriptions).flatMap(([id, subscription]) => subscription.kind === "tail" ? [[id, {
+				tail: subscription.tail,
+				when: subscription.when
+			}]] : []));
+			binding = next;
+		},
+		/** Registers this board's watchers with Vercel's API now, as `POST /watchers` does. */
+		registerWatchers: runner.registerNow,
+		/** Stops pulling, for a board that pulls on its own. */
+		close: runner.close
+	};
+}
+//#endregion
+export { createVercel as t };