@vercel/board 0.30.0 → 0.31.0

package/dist/{engine-DkdkXQEy.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-C_5rB8Iz.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 { n as replaceMentions } from "./mentions-CB6ShY4R.mjs";
-import { t as DroppedError } from "./middleware-DlJQYiwV.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-87TVtXeb.d.mts → errors-2vGs49Db.d.mts}

@@ -1,4 +1,4 @@
-import { r as ErrorOrigin } from "./client-CjAatpV4.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/{errors-C_5rB8Iz.mjs → errors-CJXhhzvT.mjs}

@@ -179,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. */
@@ -222,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).
@@ -284,9 +305,8 @@ function createBoardClient(options) {
 		*/
 		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,
@@ -330,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;

package/dist/{provider-BaVmi4Hi.mjs → events-lujPA3gQ.mjs}

@@ -1,4 +1,5 @@
-import { n as ExternalEvent } from "./external-D3p5T57R.mjs";
+import { d as LabelKey, p as Labels } from "./schemas-DBmUO6pr.mjs";
+import { n as ExternalEvent, r as ExternalLocation } from "./external-D3p5T57R.mjs";
 import { z } from "zod";
 //#region src/sync/fn.ts
 const ROUTES = Symbol.for("board.syncRoutes");
@@ -122,8 +123,6 @@ var SyncProvider = class {
 	uploadsFiles;
 	startsThreadsWithFiles;
 	fn;
-	/** People's tokens, when the adapter has them: messages they write post as them. */
-	users;
 	options;
 	constructor(options, sync) {
 		if (typeof sync !== "function") throw new Error(`${options.platform} needs a sync function: what each event does, like channels({ '#dev': 'dev' })`);
@@ -131,23 +130,12 @@ var SyncProvider = class {
 		const routes = routesOf(sync);
 		if (routes) routed.set(this, routes);
 		this.options = options;
-		this.users = options.users ?? null;
 		this.platform = options.platform;
 		this.canStartThreads = options.canStartThreads ?? false;
 		this.singleReaction = options.singleReaction ?? false;
 		this.uploadsFiles = options.uploadsFiles ?? false;
 		this.startsThreadsWithFiles = this.uploadsFiles && (options.startsThreadsWithFiles ?? false);
 	}
-	/** The platform account a person's token belongs to. */
-	async whoAmI(_token) {
-		throw new Error(`${this.platform} can't post as a person`);
-	}
-	/** `post`, as the person whose token this is. */
-	async postAs(_token, _target, _kind, _body) {
-		throw new Error(`${this.platform} can't post as a person`);
-	}
-	async editAs(_token, _thread, _message, _body) {}
-	async deleteAs(_token, _thread, _message) {}
 	async findByEmail(_email) {
 		return null;
 	}
@@ -164,8 +152,12 @@ var SyncProvider = class {
 	async permalink(_event) {
 		return null;
 	}
-	/** A linked message the platform didn't describe, read from the platform. */
-	async fetchLink(_link) {
+	/**
+	* A linked message the platform didn't describe, read from the platform. `linker` is the
+	* platform message that links it, by its own IDs: what the platform says about the link may be
+	* there by now.
+	*/
+	async fetchLink(_link, _linker) {
 		return {
 			snapshot: null,
 			unavailable: `${this.platform} can't read it`
@@ -223,4 +215,75 @@ var SyncProvider = class {
 	}
 };
 //#endregion
-export { channelMissing as a, into as c, withRoutes as d, UnreadableError as i, mirror as l, ResolvedTarget as n, routesFor as o, SyncProvider as r, channels as s, ReceivedEvent as t, render as u };
+//#region src/sync/events.ts
+const EventBase = z.object({
+	id: z.string().min(1),
+	platform: z.string().min(1),
+	key: z.string().min(1),
+	...ExternalLocation.shape,
+	raw: z.unknown()
+});
+const eventTypes = {
+	message: "message",
+	edited: "message.edited",
+	deleted: "message.deleted",
+	reaction: "reaction.added",
+	lifecycle: "lifecycle"
+};
+function envelope(platform, key, event, raw, id) {
+	return {
+		...event,
+		...EventBase.parse({
+			id,
+			platform,
+			key,
+			channel: event.channel,
+			thread: event.thread,
+			subthread: "subthread" in event ? event.subthread : null,
+			raw
+		}),
+		type: event.kind === "lifecycle" ? event.type : event.kind === "reaction" && !event.added ? "reaction.removed" : eventTypes[event.kind]
+	};
+}
+function eventSchema(platform, messageType) {
+	const [message, edited, deleted, reaction, lifecycle] = ExternalEvent.options;
+	const common = {
+		...EventBase.shape,
+		platform: z.literal(platform)
+	};
+	return z.discriminatedUnion("kind", [
+		message.extend({
+			...common,
+			type: z.literal(messageType)
+		}),
+		edited.extend({
+			...common,
+			type: z.literal("message.edited")
+		}),
+		deleted.extend({
+			...common,
+			type: z.literal("message.deleted")
+		}),
+		reaction.extend({
+			...common,
+			type: z.enum(["reaction.added", "reaction.removed"])
+		}),
+		lifecycle.extend(common)
+	]);
+}
+const SyncOverrides = z.object({
+	root: z.custom((value) => typeof value === "function").optional(),
+	text: z.string().optional(),
+	labels: Labels.optional(),
+	unset: z.array(LabelKey).optional(),
+	noSync: z.boolean().optional()
+}).strict();
+function immutable(value) {
+	if (value && typeof value === "object") {
+		for (const item of Object.values(value)) immutable(item);
+		Object.freeze(value);
+	}
+	return value;
+}
+//#endregion
+export { immutable as a, SyncProvider as c, routesFor as d, channels as f, withRoutes as g, render as h, eventSchema as i, UnreadableError as l, mirror as m, SyncOverrides as n, ReceivedEvent as o, into as p, envelope as r, ResolvedTarget as s, EventBase as t, channelMissing as u };