@vercel/board 0.16.0 → 0.17.0

package/dist/sync-slack.mjs

@@ -1,8 +1,9 @@
 import { m as MESSAGE_TEXT_MAX } from "./schemas-Be08nyfW.mjs";
-import "./contract-CuJmlrhw.mjs";
-import { c as eventSchema, i as UnreadableError, s as envelope } from "./provider-CuewcDNZ.mjs";
-import { r as withUserTokens, t as connectUserTokens } from "./users-Dls7_ANV.mjs";
-import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-jFSeyNmB.mjs";
+import "./external-BV_cUncs.mjs";
+import { i as UnreadableError, s as channels } from "./provider-B3DpYSDq.mjs";
+import { i as eventSchema, r as envelope } from "./events-CewD4kw7.mjs";
+import { r as withUserTokens, t as connectUserTokens } from "./users-yryHKFMo.mjs";
+import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-YHy-WbrB.mjs";
 import { z } from "zod";
 import { stringifyMarkdown } from "chat";
 import { createSlackAdapter } from "@chat-adapter/slack";
@@ -211,18 +212,35 @@ function slackFileName(filename, mimeType) {
 }
 const SlackEvent = eventSchema("slack", "message");
 /**
-* Syncs Slack channels with board channels. Keys are channels by name
-* (`'#prs'`) or ID (`'C0123ABC'`); values are a board channel (a two-way
-* mirror) or a callback that handles every incoming event. The app joins public
-* channels it isn't in; private ones need an invite.
+* Syncs a Slack workspace with the board: `app` is a Vercel Connect connector
+* (`'slack/acme'`) or the options, and `sync` is what each event does, both ways,
+* like `channels({ '#prs': 'prs' })`. Invite the app to each channel it syncs:
+* it never joins one on its own.
 */
-function slack(options) {
-	return new SlackProvider(options);
+function slack(app, sync) {
+	return new SlackProvider(typeof app === "string" ? { adapter: app } : app, sync);
 }
+/**
+* Slack's client retries 10 times over about 30 minutes by default, which outlives any function:
+* here a call gets 3 more tries. Each still waits out Slack's `Retry-After` (about a minute at
+* most), and `timeout` caps only the request itself, at 30 seconds.
+*/
+const SLACK_CLIENT = {
+	retryConfig: {
+		retries: 3,
+		factor: 2,
+		minTimeout: 500,
+		randomize: true
+	},
+	timeout: 3e4
+};
 /** A Slack adapter, client, and people's tokens, all from one Vercel Connect connector. */
 function fromConnector(connector) {
 	const credentials = connectSlackAdapter(connector);
-	const adapter = withUserTokens(createSlackAdapter(credentials), connectUserTokens(connector));
+	const adapter = withUserTokens(createSlackAdapter({
+		...credentials,
+		webClientOptions: SLACK_CLIENT
+	}), connectUserTokens(connector));
 	const botToken = credentials.botToken;
 	const client = async () => adapter.withBotToken(typeof botToken === "function" ? await botToken() : botToken, () => adapter.webClient);
 	return {
@@ -233,7 +251,7 @@ function fromConnector(connector) {
 var SlackProvider = class extends ChatSyncProvider {
 	web;
 	customize;
-	constructor(given) {
+	constructor(given, sync) {
 		const connected = typeof given.adapter === "string" ? fromConnector(given.adapter) : null;
 		const options = connected ? {
 			...given,
@@ -300,26 +318,6 @@ var SlackProvider = class extends ChatSyncProvider {
 			if (!found) throw new UnreadableError("channel_not_found", publicOnly ? `no public Slack channel named #${name} (the app lacks groups:read, so a private channel needs its ID)` : `no Slack channel named #${name} (a private channel shows up once the app is invited)`);
 			return found;
 		}
-		const joined = /* @__PURE__ */ new Map();
-		function join(client, id, known) {
-			let promise = joined.get(id);
-			if (!promise) {
-				promise = (async () => {
-					const channel = known ?? await client.conversations.info({ channel: id }).then((r) => r.channel, () => void 0);
-					if (!channel || channel.is_member) return;
-					const label = channel.name ? `#${channel.name}` : id;
-					if (channel.is_private) return console.warn(`[board] slack: invite the app to ${label}; it can't join private channels itself`);
-					try {
-						await client.conversations.join({ channel: id });
-					} catch (error) {
-						joined.delete(id);
-						console.warn(`[board] slack: couldn't join ${label} (${slackError(error)}); invite the app to it`);
-					}
-				})();
-				joined.set(id, promise);
-			}
-			return promise;
-		}
 		const avatars = /* @__PURE__ */ new Map();
 		function avatarOf(user) {
 			let promise = avatars.get(user);
@@ -365,7 +363,6 @@ var SlackProvider = class extends ChatSyncProvider {
 					fetchMetadata: rest
 				};
 			},
-			render: options.render,
 			platform: "slack",
 			adapter: options.adapter,
 			canStartThreads: true,
@@ -399,15 +396,11 @@ var SlackProvider = class extends ChatSyncProvider {
 			},
 			mention: (actor) => actor.id.startsWith("slack:user:") ? `<@${actor.id.slice(11)}>` : null,
 			async resolveChannel(key) {
-				if (!key.startsWith("#")) {
-					const web = await client().catch(() => void 0);
-					if (web) await join(web, key);
-					return key;
-				}
+				if (!key.startsWith("#")) return key;
 				const web = await client();
 				if (!web) throw new Error(`can't look up Slack channel ${key}: use its ID instead`);
 				const channel = await find(web, key.slice(1));
-				await join(web, channel.id, channel);
+				if (!channel.is_member) console.warn(`[board] slack: invite the app to ${key}; its events don't arrive until it's in`);
 				return channel.id;
 			},
 			markdown(message) {
@@ -421,6 +414,26 @@ var SlackProvider = class extends ChatSyncProvider {
 				const raw = message.raw;
 				return slackLinks(key, typeof raw?.text === "string" ? raw.text : message.text, Array.isArray(raw?.attachments) ? raw.attachments : [], mrkdwn);
 			},
+			locate(url) {
+				const found = permalinkOf(url.trim());
+				return found ? {
+					thread: `${found.channel}:${found.thread}`,
+					message: found.ts
+				} : null;
+			},
+			async url(thread, message) {
+				const [channel] = thread.split(":");
+				const web = await client();
+				if (!web?.chat?.getPermalink || !channel) return null;
+				try {
+					return (await web.chat.getPermalink({
+						channel,
+						message_ts: message
+					})).permalink ?? null;
+				} catch {
+					return null;
+				}
+			},
 			async fetchLink(link) {
 				const [, channel, thread] = link.thread.split(":");
 				const web = await client();
@@ -614,8 +627,7 @@ var SlackProvider = class extends ChatSyncProvider {
 					kind: at === -1 ? "channel" : "thread"
 				};
 			}
-		});
-		for (const [key, value] of Object.entries(options.channels)) this.map(key, value);
+		}, sync);
 		this.web = client;
 	}
 	/**
@@ -725,4 +737,4 @@ var SlackProvider = class extends ChatSyncProvider {
 	}
 };
 //#endregion
-export { SlackEvent, SlackProvider, forwardText, slack, slackFileName, slackIcon, slackLinks, withUserTokens, withoutHtml, withoutLabel };
+export { SlackEvent, SlackProvider, channels, forwardText, slack, slackFileName, slackIcon, slackLinks, withUserTokens, withoutHtml, withoutLabel };

package/dist/sync.chat.d.mts

@@ -1,2 +1,2 @@
-import { i as externalAuthor, n as ChatSyncProvider, r as ChatTransport, t as ChatInput } from "./chat-provider-XCnQlxq6.mjs";
+import { i as externalAuthor, n as ChatSyncProvider, r as ChatTransport, t as ChatInput } from "./chat-provider-DNJQyajS.mjs";
 export { ChatInput, ChatSyncProvider, ChatTransport, externalAuthor };

package/dist/sync.chat.mjs

@@ -1,2 +1,2 @@
-import { n as externalAuthor, t as ChatSyncProvider } from "./chat-provider-jFSeyNmB.mjs";
+import { n as externalAuthor, t as ChatSyncProvider } from "./chat-provider-YHy-WbrB.mjs";
 export { ChatSyncProvider, externalAuthor };

package/dist/sync.d.mts

@@ -1,3 +1,3 @@
-import { _ as ExternalFile, g as ExternalEvent, h as ExternalAuthor } from "./reducers-B_vUGQRp.mjs";
-import { C as SyncResult, E as eventSchema, S as SyncOverrides, T as envelope, _ as connectUserTokens, a as ProviderFile, b as ProviderEvent, c as Receive, d as ResolvedTarget, f as SyncClient, g as UserTokens, h as SyncProvider, i as ProviderDelivery, l as ReceivedEvent, m as SyncHandler, o as ProviderOptions, p as SyncContext, r as FileDelivery, s as ProviderPost, t as EventMapping, u as RenderInput, v as withUserTokens, w as SyncRoot, x as RootOverride, y as EventBase } from "./provider-BGjz-mDa.mjs";
-export { EventBase, type EventMapping, type ExternalAuthor, ExternalEvent, type ExternalFile, type FileDelivery, type ProviderDelivery, type ProviderEvent, type ProviderFile, type ProviderOptions, type ProviderPost, type Receive, ReceivedEvent, type RenderInput, ResolvedTarget, type RootOverride, type SyncClient, type SyncContext, type SyncHandler, SyncOverrides, SyncProvider, type SyncResult, type SyncRoot, type UserTokens, connectUserTokens, envelope, eventSchema, withUserTokens };
+import { d as ExternalFile, l as ExternalAuthor, u as ExternalEvent } from "./folds-CRYY14kc.mjs";
+import { A as SyncOverrides, C as channels, D as EventBase, E as render, M as SyncRoot, N as envelope, O as ProviderEvent, P as eventSchema, S as SyncUnit, T as mirror, _ as withUserTokens, a as ProviderOptions, b as SyncIn, c as ReceivedEvent, d as ResolvedTarget, f as SyncContext, g as connectUserTokens, h as UserTokens, i as ProviderFile, j as SyncResult, k as RootOverride, l as RenderInput, m as UnreadableError, n as FileDelivery, o as ProviderPost, p as SyncProvider, r as ProviderDelivery, s as Receive, u as Renderer, v as Sync, w as into, x as SyncOut, y as SyncFn } from "./provider-B0b9Qxw4.mjs";
+export { EventBase, type ExternalAuthor, ExternalEvent, type ExternalFile, type FileDelivery, type ProviderDelivery, type ProviderEvent, type ProviderFile, type ProviderOptions, type ProviderPost, type Receive, ReceivedEvent, type RenderInput, type Renderer, ResolvedTarget, type RootOverride, type Sync, type SyncContext, type SyncFn, type SyncIn, type SyncOut, SyncOverrides, SyncProvider, type SyncResult, type SyncRoot, type SyncUnit, UnreadableError, type UserTokens, channels, connectUserTokens, envelope, eventSchema, into, mirror, render, withUserTokens };

package/dist/sync.mjs

@@ -1,4 +1,5 @@
-import { r as ExternalEvent } from "./contract-CuJmlrhw.mjs";
-import { a as EventBase, c as eventSchema, n as ResolvedTarget, o as SyncOverrides, r as SyncProvider, s as envelope, t as ReceivedEvent } from "./provider-CuewcDNZ.mjs";
-import { r as withUserTokens, t as connectUserTokens } from "./users-Dls7_ANV.mjs";
-export { EventBase, ExternalEvent, ReceivedEvent, ResolvedTarget, SyncOverrides, SyncProvider, connectUserTokens, envelope, eventSchema, withUserTokens };
+import { n as ExternalEvent } from "./external-BV_cUncs.mjs";
+import { c as into, i as UnreadableError, l as mirror, n as ResolvedTarget, r as SyncProvider, s as channels, t as ReceivedEvent, u as render } from "./provider-B3DpYSDq.mjs";
+import { i as eventSchema, n as SyncOverrides, r as envelope, t as EventBase } from "./events-CewD4kw7.mjs";
+import { r as withUserTokens, t as connectUserTokens } from "./users-yryHKFMo.mjs";
+export { EventBase, ExternalEvent, ReceivedEvent, ResolvedTarget, SyncOverrides, SyncProvider, UnreadableError, channels, connectUserTokens, envelope, eventSchema, into, mirror, render, withUserTokens };

package/dist/targets-C-wdR5wP.mjs

@@ -0,0 +1,33 @@
+import { l as isThreadTarget } from "./external-BV_cUncs.mjs";
+import { n as replaceMentions, t as extractMentions } from "./mentions-CB6ShY4R.mjs";
+//#region src/server/targets.ts
+/** A target as a post or a receipt names it, resolved: a plain one's kind goes by its shape. */
+const syncTarget = (target) => typeof target === "string" ? {
+	target,
+	kind: isThreadTarget(target) ? "thread" : "channel"
+} : target;
+/** Whether `text` mentions anyone by email, `@[ada@vercel.com]`, which sync looks up. */
+const mentionsEmails = (text) => extractMentions(text).some((token) => token.kind === "actor" && token.actor.includes("@"));
+/**
+* `@[ada@vercel.com]`: each email `find` knows (a synced platform's user) becomes that user's
+* exact mention, `@[slack:user:U0456]`, so it reads natively there; the rest stay plain text.
+*/
+async function withEmailMentions(text, find) {
+	const emails = extractMentions(text).flatMap((token) => token.kind === "actor" && token.actor.includes("@") ? [token.actor] : []);
+	if (emails.length === 0) return {
+		text,
+		found: []
+	};
+	const byEmail = /* @__PURE__ */ new Map();
+	for (const email of emails) byEmail.set(email, await find?.(email).catch(() => null) ?? null);
+	return {
+		text: replaceMentions(text, (token) => {
+			if (token.kind !== "actor" || !byEmail.has(token.actor)) return null;
+			const actor = byEmail.get(token.actor);
+			return actor ? `@[${actor.id}]` : token.actor;
+		}),
+		found: [...byEmail.values()].filter((actor) => actor !== null)
+	};
+}
+//#endregion
+export { syncTarget as n, withEmailMentions as r, mentionsEmails as t };

package/dist/{tokens-DKLn5P9B.mjs → tokens-DhuzKzAl.mjs}

@@ -1,5 +1,5 @@
 import { l as unauthorized } from "./errors-DX3hpwWt.mjs";
-import { f as markVerified, m as trustedIssuers, n as TOKENS, r as VERCEL_ISSUER, u as issuerName } from "./auth-COzc09sn.mjs";
+import { f as markVerified, m as trustedIssuers, n as TOKENS, r as VERCEL_ISSUER, u as issuerName } from "./auth-Drg9FiC2.mjs";
 import { createRemoteJWKSet, decodeJwt, jwtVerify } from "jose";
 //#region src/server/identity.ts
 let fromDisk;

package/dist/{types-BHCjTZdB.d.mts → types-8yq2VnKI.d.mts}

@@ -1,5 +1,5 @@
-import { a as ExternalCopy, c as SyncedThread, o as Message, p as BoardEvent } from "./reducers-B_vUGQRp.mjs";
-import { A2Store } from "experimental-a2/server";
+import { a as ExternalCopy, c as SyncedThread, g as BoardEvent, o as Message } from "./folds-CRYY14kc.mjs";
+import { t as A2Store } from "./store-D0MhBvg6-4Z2L0Kqd.mjs";
 //#region src/store/types.d.ts
 /**
  * What a query matches, resolved by the board: handles are already actor and

package/dist/{users-Dls7_ANV.mjs → users-yryHKFMo.mjs}

@@ -2,8 +2,8 @@
 const USER_TOKENS = Symbol.for("board.userTokens");
 /**
 * Gives an adapter people's tokens, for your own OAuth: `slack({ adapter:
-* withUserTokens(createSlackAdapter(...), { authorize, token }) })`. A Connect
-* connector name (`adapter: 'slack/acme'`) does this for you.
+* withUserTokens(createSlackAdapter(...), { authorize, token }) }, sync)`. A
+* Connect connector name (`slack('slack/acme', sync)`) does this for you.
 */
 function withUserTokens(adapter, tokens) {
 	Object.defineProperty(adapter, USER_TOKENS, {

package/dist/{watch-spec-W0c7ypHJ.mjs → watchers-hash-DojIuoFg.mjs}

@@ -1,6 +1,7 @@
-import { n as DIRECT_UPLOAD_BYTES_MAX } from "./files-SniSmeEr.mjs";
+import { n as DIRECT_UPLOAD_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import { S as storable, a as AttachmentId, c as ChannelPath, d as LabelKey, g as MessageText, l as Emoji, m as MESSAGE_TEXT_MAX, n as ActorId, p as Labels, x as platformAvatar } from "./schemas-Be08nyfW.mjs";
-import { a as ExternalTarget, c as Link, l as Origin, n as ExternalAuthor, r as ExternalEvent } from "./contract-CuJmlrhw.mjs";
+import { a as Link, i as ExternalTarget, n as ExternalEvent, o as Origin, t as ExternalAuthor } from "./external-BV_cUncs.mjs";
+import { r as badRequest, t as HttpError } from "./errors-DX3hpwWt.mjs";
 import { z } from "zod";
 //#region src/api/routes.ts
 /**
@@ -150,6 +151,8 @@ const SourceReadQuery = z.object({
 	target: z.string().min(1).max(4e3),
 	limit: z.coerce.number().int().min(1).max(200).optional()
 });
+/** A platform's link to a message or thread, such as a Slack permalink or a GitHub comment's URL. */
+const LinkedQuery = z.object({ url: z.string().url().max(4e3) });
 const IdentityUnlinkBody = z.object({ actor: z.string().min(1).max(256) });
 /** A sync entry's key: `slack`, `github`. */
 const SyncKey = z.string().min(1).max(64);
@@ -414,6 +417,17 @@ const routes = {
 		path: "/messages/:id/sync",
 		body: SyncBody
 	},
+	/** Where the message's thread is synced, and its copy on each target: needs `read` where it is. */
+	synced: {
+		method: "GET",
+		path: "/messages/:id/sync"
+	},
+	/** The board message a platform link names, from what the board synced: 404 `message_not_found` for one it didn't, or that the caller can't read. */
+	linked: {
+		method: "GET",
+		path: "/links",
+		query: LinkedQuery
+	},
 	/** Ephemeral: shows typing in the thread's synced platform threads, and writes nothing to the log. Needs `post` where the thread is. */
 	typing: {
 		method: "POST",
@@ -612,35 +626,205 @@ const routes = {
 	}
 };
 //#endregion
-//#region src/client/ids.ts
-const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-/** SHA-256 of `text`, in hex. */
-async function sha256(text) {
-	return hex(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))));
+//#region src/server/backend.ts
+/** The subscription sync's outbound runs on, in `BoardBinding.subscriptions`. No watcher's ID starts with `@`. */
+const SYNC = "@sync";
+//#endregion
+//#region src/version.ts
+const VERSION = "0.17.0";
+//#endregion
+//#region src/server/routing.ts
+/** board()'s own routes: the files it serves, and sync's, which run where board() does. */
+const BOARD_ROUTES = [
+	"avatar",
+	"openapi",
+	"webhook",
+	"signIn",
+	"signedIn",
+	"identityUnlink",
+	"sync"
+];
+/** Every protocol method, by the route it's served at. */
+const METHODS = [
+	"discovery",
+	"me",
+	"channels",
+	"actors",
+	"identity",
+	"messages",
+	"threads",
+	"message",
+	"post",
+	"posted",
+	"edit",
+	"delete",
+	"react",
+	"label",
+	"schedule",
+	"schedules",
+	"cancelSchedule",
+	"upload",
+	"attachment",
+	"uploadStart",
+	"uploadFinish",
+	"watchers",
+	"register",
+	"matches",
+	"ack",
+	"events",
+	"syncImport",
+	"syncReceipt",
+	"syncThread",
+	"syncFind",
+	"syncCopies",
+	"syncRoots",
+	"inboxPush",
+	"inboxNext",
+	"inboxAck",
+	"inbox",
+	"syncCode",
+	"syncAccount",
+	"syncUnlink",
+	"typing",
+	"readSource",
+	"synced",
+	"linked"
+];
+const escape = (literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function compile(method, path, target, own) {
+	const parts = path.split("/").filter(Boolean);
+	const source = parts.map((part) => part.startsWith(":") ? "/([^/]+)" : `/${escape(part)}`).join("");
+	return {
+		method,
+		pattern: new RegExp(`${source}$`),
+		names: parts.filter((part) => part.startsWith(":")).map((part) => part.slice(1)),
+		target,
+		segments: parts.length,
+		literals: parts.filter((part) => !part.startsWith(":")).length,
+		own
+	};
 }
 /**
-* A UUIDv8 from `parts`, exactly as A2's `idempotentId` makes one: the IDs a board derives for the
-* writes its own code makes, which no request may post with.
+* The routes a board answers, most specific first: each is matched as a suffix of the request's
+* path, so `/api/board/messages/12` is `GET /messages/:id` under `/api/board`. A backend's own
+* route at a protocol path takes its place. Discovery is the mount itself.
 */
-async function derivedId(...parts) {
-	const bytes = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(parts)))).slice(0, 16);
-	bytes[6] = bytes[6] & 15 | 128;
-	bytes[8] = bytes[8] & 63 | 128;
-	const text = hex(bytes);
-	return `${text.slice(0, 8)}-${text.slice(8, 12)}-${text.slice(12, 16)}-${text.slice(16, 20)}-${text.slice(20, 32)}`;
+function createRouter(backendRoutes, basePath) {
+	const patterns = [
+		...BOARD_ROUTES.map((name) => compile(routes[name].method, routes[name].path, {
+			kind: "board",
+			name
+		}, false)),
+		...METHODS.filter((name) => name !== "discovery").map((name) => compile(routes[name].method, routes[name].path, {
+			kind: "protocol",
+			name
+		}, false)),
+		...backendRoutes.map((route) => compile(route.method, route.path, {
+			kind: "backend",
+			route
+		}, true))
+	].sort((a, b) => b.segments - a.segments || b.literals - a.literals || Number(b.own) - Number(a.own));
+	/** A segment that isn't URI-encoded names nothing: no route. */
+	const found = (candidate, base, values) => {
+		const params = {};
+		try {
+			candidate.names.forEach((name, i) => params[name] = decodeURIComponent(values[i]));
+		} catch {
+			return null;
+		}
+		const first = candidate.names[0];
+		return {
+			target: candidate.target,
+			base,
+			param: first === void 0 ? null : params[first],
+			params
+		};
+	};
+	const discovery = (base) => ({
+		target: {
+			kind: "protocol",
+			name: "discovery"
+		},
+		base,
+		param: null,
+		params: {},
+		root: true
+	});
+	return function route(method, pathname) {
+		const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
+		if (basePath !== void 0) {
+			const base = basePath.replace(/\/+$/, "");
+			if (path !== base && !path.startsWith(`${base}/`)) return null;
+			const rest = path.slice(base.length) || "/";
+			if (rest === "/") return method === "GET" ? discovery(base) : null;
+			for (const candidate of patterns) {
+				const hit = candidate.method === method ? rest.match(new RegExp(`^${candidate.pattern.source}`)) : null;
+				if (hit) return found(candidate, base, hit.slice(1));
+			}
+			return null;
+		}
+		for (const candidate of patterns) {
+			if (candidate.method !== method) continue;
+			const hit = path.match(candidate.pattern);
+			if (hit) return found(candidate, path.slice(0, hit.index), hit.slice(1));
+		}
+		return method === "GET" ? discovery(path === "/" ? "" : path) : null;
+	};
+}
+function queryObject(url) {
+	const out = {};
+	for (const key of new Set(url.searchParams.keys())) {
+		const values = url.searchParams.getAll(key);
+		out[key] = values.length > 1 ? values : values[0];
+	}
+	return out;
+}
+async function readJson(request) {
+	const text = await request.text();
+	if (text.trim() === "") return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw badRequest("request body is not valid JSON");
+	}
+}
+const tooLarge = () => new HttpError(413, "too_large", `attachments are at most ${ATTACHMENT_BYTES_MAX / 1024 / 1024} MB`);
+/** The body, refused as soon as it's past `max`: with or without a `content-length`, it never reads more. */
+async function readCapped(request, max) {
+	if (Number(request.headers.get("content-length") ?? 0) > max) throw tooLarge();
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of request.body ?? []) {
+		size += chunk.byteLength;
+		if (size > max) throw tooLarge();
+		chunks.push(chunk);
+	}
+	const body = new Uint8Array(size);
+	let at = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, at);
+		at += chunk.byteLength;
+	}
+	return body;
+}
+function openapi() {
+	const paths = {};
+	for (const [name, definition] of Object.entries(routes)) {
+		const path = definition.path.replace(/:(\w+)/g, "{$1}");
+		const operation = { operationId: name };
+		if ("query" in definition) operation["x-query-schema"] = z.toJSONSchema(definition.query, { io: "input" });
+		if ("body" in definition) operation.requestBody = { content: { "application/json": { schema: z.toJSONSchema(definition.body, { io: "input" }) } } };
+		(paths[path] ??= {})[definition.method.toLowerCase()] = operation;
+	}
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: "board",
+			version: VERSION
+		},
+		paths
+	};
 }
-/** A derived ID's shape. */
-const DERIVED_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-8[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-/**
-* A post's ID, from one derived for it, under `principal`: a board takes a `key:<principal>:` ID
-* only from that principal, so no one else can post with it first.
-*/
-const keyId = async (principal, derived) => `key:${principal}:${(await sha256(`board-key\u001f${derived}`)).slice(0, 32)}`;
-/**
-* Whether `id` is exactly the shape `keyId` makes for `principal`. A prefix check isn't enough:
-* a principal's ID can be the start of another's (`oidc:gitlab.com:acme` and `oidc:gitlab.com:acme:ci`).
-*/
-const isKeyIdOf = (id, principal) => id.startsWith(`key:${principal}:`) && /^[0-9a-f]{32}$/.test(id.slice(`key:${principal}:`.length));
 //#endregion
 //#region src/api/tail.ts
 /** The filter flags `read`, `tail`, and `wait` share, and that a watcher's `tail` accepts. */
@@ -784,4 +968,25 @@ function compileWatcher(id, spec) {
 	};
 }
 //#endregion
-export { SyncBody as A, UploadStartBody as B, Ref as C, SignInQuery as D, SchedulesQuery as E, SyncReceiptBody as F, SyncRootsQuery as I, SyncUnlinkBody as L, SyncCopiesQuery as M, SyncFindQuery as N, SourceReadQuery as O, SyncImportBody as P, ThreadsQuery as R, ReactBody as S, ScheduleBody as T, routes as V, InboxQuery as _, DERIVED_ID as a, MessagesQuery as b, keyId as c, EditBody as d, EventsQuery as f, InboxPushBody as g, InboxNextQuery as h, withMentions as i, SyncCodeBody as j, SyncAccountBody as k, sha256 as l, InboxAckBody as m, hasCriteria as n, derivedId as o, IdentityUnlinkBody as p, FILTER_FLAGS as r, isKeyIdOf as s, compileWatcher as t, AckBody as u, LabelBody as v, RegisterBody as w, PostBody as x, MatchesQuery as y, TypingBody as z };
+//#region src/server/watchers-hash.ts
+/** By UTF-16 code unit, as `sort()` orders strings: the same in every locale and runtime. */
+const byCodeUnit = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/**
+* What `watchersHash` hashes, the same on both ends: a board on `http()` hashes its watchers, and
+* whether its sync subscribes, and the board it uses hashes what it holds.
+*/
+function canonicalWatchers(watch, sync = []) {
+	const canonical = Object.keys(watch).sort(byCodeUnit).map((id) => [
+		id,
+		watch[id].tail,
+		watch[id].when
+	]);
+	if (sync.length > 0) canonical.push(["sync", [...sync].sort((a, b) => byCodeUnit(a.key, b.key)).map((entry) => [
+		entry.key,
+		entry.platform,
+		entry.signIn
+	])]);
+	return JSON.stringify(canonical);
+}
+//#endregion
+export { ScheduleBody as A, SyncReceiptBody as B, LinkedQuery as C, ReactBody as D, PostBody as E, SyncBody as F, UploadStartBody as G, SyncUnlinkBody as H, SyncCodeBody as I, routes as K, SyncCopiesQuery as L, SignInQuery as M, SourceReadQuery as N, Ref as O, SyncAccountBody as P, SyncFindQuery as R, LabelBody as S, MessagesQuery as T, ThreadsQuery as U, SyncRootsQuery as V, TypingBody as W, IdentityUnlinkBody as _, withMentions as a, InboxPushBody as b, openapi as c, readJson as d, VERSION as f, EventsQuery as g, EditBody as h, FILTER_FLAGS as i, SchedulesQuery as j, RegisterBody as k, queryObject as l, AckBody as m, compileWatcher as n, METHODS as o, SYNC as p, hasCriteria as r, createRouter as s, canonicalWatchers as t, readCapped as u, InboxAckBody as v, MatchesQuery as w, InboxQuery as x, InboxNextQuery as y, SyncImportBody as z };

package/docs/01-board/01-mounting.md

@@ -102,7 +102,7 @@ any backend:
 | `middleware` | Runs on every post and edit before it reaches the backend, whatever it came from. See [Middleware](./08-middleware.md) |
 | `project` | `{ id, teamId? }`: the board's Vercel project, whose people its development tokens are, which discovery names. Defaults to `VERCEL_PROJECT_ID`, then `.vercel/project.json`. The team scopes `vercelProject()` rules named without one |
 | `watch` | Tails the board runs for you, keyed by id: `{ triage: { tail, run } }`. See [Watchers](./06-watchers.md) |
-| `sync` | Two-way sync, keyed by a name you choose: `{ slack: slack({…}) }`. See [Sync](../02-sync/01-overview.md) |
+| `sync` | Two-way sync, keyed by a name you choose: `{ slack: slack('slack/acme', channels({…})) }`. See [Sync](../02-sync/01-overview.md) |
 | `url` | The board's public URL, which every token's audience must equal. Inferred from requests otherwise |
 | `basePath` | The mount path, e.g. `/api/board`. Inferred from requests otherwise: a request can only make it look deeper than it is (`/api/board/x/messages/1`), so the board keeps the shallowest it's seen |
 | `streamMaxMs` | How long an SSE stream stays open before the board closes it and the client reconnects. Default `280000` |