@vercel/board 0.29.0 → 0.30.0

package/dist/{conformance-DlnfuzEB.mjs → conformance-C7fwIvmN.mjs}

@@ -1,4 +1,5 @@
-import { t as BoardError } from "./client-D0Px7KzF.mjs";
+import { u as BoardError } from "./errors-C_5rB8Iz.mjs";
+import { r as compileAccess } from "./access-CQ39gqEV.mjs";
 //#region src/conformance/index.ts
 var Mismatch = class extends Error {};
 const show = (value) => JSON.stringify(value) ?? String(value);
@@ -41,6 +42,31 @@ const needRoot = (ctx) => {
 		reply: ctx.reply
 	};
 };
+/** The sync key the sync checks register, a platform of their own, so nothing reaches a real one. */
+const SYNC_KEY = "conformance";
+/**
+* Registers a sync on `SYNC_KEY` for a check, and says where to put the token's registration back
+* after: or why it can't, since registering replaces the token's watchers.
+*/
+async function registerSync(ctx) {
+	const registered = (await ctx.board.watchers()).find((registration) => registration.owner === ctx.me.principal);
+	if (registered && (Object.keys(registered.watch).length > 0 || (registered.sync?.length ?? 0) > 0)) return { skip: "this token has watchers or a sync registered here, which registering would replace" };
+	const where = wokenAt(registered);
+	try {
+		await ctx.board.register({
+			url: null,
+			watch: {},
+			sync: [{
+				key: SYNC_KEY,
+				platform: SYNC_KEY
+			}]
+		});
+	} catch (error) {
+		if (error instanceof BoardError && error.status === 403) return { skip: "this token can't register a sync here" };
+		throw error;
+	}
+	return { where };
+}
 async function post(ctx, text, extra = {}) {
 	const message = await ctx.board.post(ctx.channel, {
 		text,
@@ -51,6 +77,15 @@ async function post(ctx, text, extra = {}) {
 	ctx.posted.push(message.id);
 	return message;
 }
+async function reply(ctx, re, text, extra = {}) {
+	const message = await ctx.board.reply(re, {
+		text,
+		noSync: true,
+		...extra
+	});
+	ctx.posted.push(message.id);
+	return message;
+}
 const CHECKS = [
 	{
 		group: "core",
@@ -80,6 +115,31 @@ const CHECKS = [
 			check((await ctx.board.thread(root.id)).replies.some((m) => m.id === reply.id), `the thread's replies should include ${reply.id}`);
 		}
 	},
+	{
+		group: "core",
+		name: "replies after a message only while it's the thread's newest, one of any that race",
+		run: async (ctx) => {
+			const root = await post(ctx, "conformance: a thread to reply after");
+			const first = await reply(ctx, root.id, "conformance: after the root", { after: root.id });
+			await rejects(reply(ctx, root.id, "conformance: late", { after: root.id }), 409, "newer_message", "a reply after the root, once another came after it");
+			same((await ctx.board.thread(root.id)).replies.length, 1, "the replies after a refused one");
+			const deleted = await reply(ctx, root.id, "conformance: deleted", { after: first.id });
+			await ctx.board.delete(deleted.id);
+			await rejects(reply(ctx, root.id, "conformance: after a deleted one", { after: first.id }), 409, "newer_message", "a reply after a message a deleted one came after");
+			const racing = await Promise.allSettled([
+				1,
+				2,
+				3
+			].map((n) => reply(ctx, root.id, `conformance: racing ${n}`, { after: deleted.id })));
+			same(racing.filter((result) => result.status === "fulfilled").length, 1, "the replies that landed of three racing after the same message");
+			for (const result of racing) {
+				if (result.status === "fulfilled") continue;
+				const error = result.reason;
+				check(error instanceof BoardError && error.status === 409 && error.code === "newer_message", `a reply that lost the race should be 409 newer_message, got ${error instanceof BoardError ? `${error.status} ${error.code}` : String(error)}`);
+			}
+			same((await ctx.board.thread(root.id)).replies.length, 3, "the replies after the race, a deleted one included");
+		}
+	},
 	{
 		group: "core",
 		name: "posts once for a client ID, however many times it is sent",
@@ -116,6 +176,78 @@ const CHECKS = [
 			same((await version()).labels.state, void 0, "the label unset");
 		}
 	},
+	{
+		group: "core",
+		name: "labels a message only while its labels are as the write says, one of any that race",
+		run: async (ctx) => {
+			const message = await post(ctx, "conformance: a message to claim");
+			const labels = async () => (await ctx.board.thread(message.id)).message.labels;
+			const racing = await Promise.allSettled([
+				1,
+				2,
+				3
+			].map((n) => ctx.board.label(message.id, {
+				set: { owner: `agent-${n}` },
+				if: { owner: null }
+			})));
+			const landed = racing.flatMap((result, n) => result.status === "fulfilled" ? [`agent-${n + 1}`] : []);
+			same(landed.length, 1, "the claims that landed of three racing where no one had one");
+			for (const result of racing) {
+				if (result.status === "fulfilled") continue;
+				const error = result.reason;
+				check(error instanceof BoardError && error.status === 409 && error.code === "label_conflict", `a claim that lost the race should be 409 label_conflict, got ${error instanceof BoardError ? `${error.status} ${error.code}` : String(error)}`);
+			}
+			same((await labels()).owner, landed[0], "the owner, after the race");
+			await rejects(ctx.board.label(message.id, {
+				set: { owner: "someone" },
+				if: { owner: "no-one" }
+			}), 409, "label_conflict", "a label write from a value the label doesn't have");
+			same((await labels()).owner, landed[0], "the owner, after a write from the wrong value");
+			await ctx.board.label(message.id, {
+				unset: ["owner"],
+				if: { owner: landed[0] }
+			});
+			same((await labels()).owner, void 0, "the owner, released from the value it had");
+		}
+	},
+	{
+		group: "core",
+		name: "edits and deletes a message only at the revision it was read at, which only edits and deletes change",
+		run: async (ctx) => {
+			const message = await post(ctx, "conformance: a message to edit");
+			const read = async () => (await ctx.board.thread(message.id)).message;
+			const first = (await read()).revision;
+			check(typeof first === "number", `a message's revision should be a number, got ${show(first)}`);
+			await ctx.board.react(message.id, "eyes");
+			await ctx.board.label(message.id, { set: { state: "open" } });
+			same((await read()).revision, first, "the revision after a reaction and a label");
+			await ctx.board.edit(message.id, "conformance: edited", { revision: first });
+			const second = (await read()).revision;
+			check(second !== first, `an edit should change the revision from ${first}`);
+			await rejects(ctx.board.edit(message.id, "conformance: stale", { revision: first }), 409, "revision_conflict", "an edit at a revision an edit came after");
+			await rejects(ctx.board.delete(message.id, { revision: first }), 409, "revision_conflict", "a delete at a revision an edit came after");
+			const after = await read();
+			check(after.text === "conformance: edited" && !after.deleted, `refused writes should leave it as it was, got ${show({
+				text: after.text,
+				deleted: after.deleted
+			})}`);
+			const racing = await Promise.allSettled([
+				1,
+				2,
+				3
+			].map((n) => ctx.board.edit(message.id, `conformance: racing ${n}`, { revision: second })));
+			same(racing.filter((result) => result.status === "fulfilled").length, 1, "the edits that landed of three racing at the same revision");
+			for (const result of racing) {
+				if (result.status === "fulfilled") continue;
+				const error = result.reason;
+				check(error instanceof BoardError && error.status === 409 && error.code === "revision_conflict", `an edit that lost the race should be 409 revision_conflict, got ${error instanceof BoardError ? `${error.status} ${error.code}` : String(error)}`);
+			}
+			const last = (await read()).revision;
+			await ctx.board.delete(message.id, { revision: last });
+			check((await read()).deleted, "a delete at the revision it has should delete it");
+			await rejects(ctx.board.edit(message.id, "conformance: too late", { revision: last }), 409, "revision_conflict", "an edit at a revision a delete came after");
+		}
+	},
 	{
 		group: "core",
 		name: "matches a label on the message or its thread's root",
@@ -261,6 +393,24 @@ const CHECKS = [
 			same(canceled.state, "canceled", "the canceled schedule");
 		}
 	},
+	{
+		group: "schedules",
+		name: "keeps noSync on a schedule, so its sends stay off every platform",
+		run: async (ctx) => {
+			const { root } = needRoot(ctx);
+			const schedule = await ctx.board.schedule({ re: root.id }, {
+				text: "conformance: later, on the board only",
+				noSync: true,
+				in: "1d"
+			});
+			try {
+				same(schedule.noSync, true, "the schedule's noSync");
+				same((await ctx.board.schedules({ re: root.id })).find((s) => s.id === schedule.id)?.noSync, true, "the listed schedule's noSync");
+			} finally {
+				await ctx.board.cancelSchedule(schedule.id).catch(() => {});
+			}
+		}
+	},
 	{
 		group: "attachments",
 		name: "takes a file, posts it, and gives it back",
@@ -341,7 +491,7 @@ const CHECKS = [
 		group: "sync",
 		name: "keeps sync's records: an import as a platform author, its lookups by platform ID, a receipt, and where it's synced",
 		run: async (ctx) => {
-			const key = "conformance";
+			const key = SYNC_KEY;
 			const thread = `${key}:${ctx.labels.conformance}:1`;
 			const author = {
 				id: `${key}:user:${ctx.labels.conformance}`,
@@ -354,22 +504,9 @@ const CHECKS = [
 				thread,
 				message: "1"
 			};
-			const registered = (await ctx.board.watchers()).find((registration) => registration.owner === ctx.me.principal);
-			if (registered && (Object.keys(registered.watch).length > 0 || (registered.sync?.length ?? 0) > 0)) return "this token has watchers or a sync registered here, which registering would replace";
-			const where = wokenAt(registered);
-			try {
-				await ctx.board.register({
-					url: null,
-					watch: {},
-					sync: [{
-						key,
-						platform: key
-					}]
-				});
-			} catch (error) {
-				if (error instanceof BoardError && error.status === 403) return "this token can't register a sync here";
-				throw error;
-			}
+			const registered = await registerSync(ctx);
+			if ("skip" in registered) return registered.skip;
+			const { where } = registered;
 			let imported;
 			try {
 				imported = await ctx.board.syncImport({
@@ -477,6 +614,109 @@ const CHECKS = [
 				}).catch(() => {});
 			}
 		}
+	},
+	{
+		group: "sync",
+		name: "queues a platform thread's events in its sync's inbox once, and leases each after the one before is acked",
+		run: async (ctx) => {
+			const registered = await registerSync(ctx);
+			if ("skip" in registered) return registered.skip;
+			try {
+				const run = ctx.labels.conformance;
+				const author = {
+					id: `${SYNC_KEY}:user:${run}`,
+					handle: "conformance",
+					name: "Conformance",
+					avatar: null,
+					isBot: false
+				};
+				const thread = `${SYNC_KEY}:${run}:inbox`;
+				const eventOf = (message) => ({
+					id: `conformance-inbox-${run}-${message}`,
+					event: {
+						kind: "message",
+						channel: `${SYNC_KEY}:${run}`,
+						thread,
+						subthread: null,
+						message,
+						isRoot: message === "1",
+						text: `conformance: inbox event ${message}`,
+						context: null,
+						author
+					},
+					raw: {
+						conformance: run,
+						message
+					}
+				});
+				const pushed = [eventOf("1"), eventOf("2")];
+				await ctx.board.inboxPush(SYNC_KEY, pushed);
+				await ctx.board.inboxPush(SYNC_KEY, [pushed[0]]);
+				const lease = async () => (await ctx.board.inboxNext(SYNC_KEY, { limit: 50 })).filter((item) => item.thread === thread);
+				for (const { event, raw } of pushed) {
+					const leased = await lease();
+					same(leased.length, 1, `the events leased from the platform thread, for message ${event.message}`);
+					const item = leased[0];
+					same(item.event.kind === "message" ? item.event.message : null, event.message, "the platform message leased next");
+					same(JSON.stringify(item.raw), JSON.stringify(raw), "the leased event's raw payload");
+					await ctx.board.inboxAck(SYNC_KEY, item.id, { lease: item.lease });
+				}
+				same((await lease()).length, 0, "the events leased once both are acked");
+			} finally {
+				await ctx.board.register({
+					...registered.where,
+					watch: {}
+				}).catch(() => {});
+			}
+		}
+	},
+	{
+		group: "sync",
+		name: "hands a sync each message change as a match of its @sync watcher",
+		run: async (ctx) => {
+			const access = compileAccess(ctx.me.can);
+			if (access.anywhere("sync") && !access.can("sync", ctx.channel)) return `this token can't sync in ${ctx.channel}`;
+			const registered = await registerSync(ctx);
+			if ("skip" in registered) return registered.skip;
+			try {
+				const message = await post(ctx, "conformance: for a sync");
+				const deadline = Date.now() + 1e4;
+				let match;
+				while (!match && Date.now() < deadline) match = (await ctx.board.matches({ wait: 5 })).find((m) => m.watcher === "@sync" && m.event.message?.id === message.id);
+				check(match, "a pull should hand the sync a match for the post, as its @sync watcher's");
+				same(match.event.type, "message.posted", "the sync's match");
+				await ctx.board.ack(match.id, { lease: match.lease });
+			} finally {
+				await ctx.board.register({
+					...registered.where,
+					watch: {}
+				}).catch(() => {});
+			}
+		}
+	},
+	{
+		group: "sync",
+		name: "keeps noSync on a post and a reply, so sync sends neither",
+		run: async (ctx) => {
+			const { root, reply } = needRoot(ctx);
+			const thread = await ctx.board.thread(root.id);
+			same(thread.message.noSync, true, "a post's noSync, read back");
+			same(thread.replies.find((m) => m.id === reply.id)?.noSync, true, "a reply's noSync, read back");
+		}
+	},
+	{
+		group: "sync",
+		name: "finds no one for a platform account nobody linked",
+		run: async (ctx) => {
+			let found;
+			try {
+				found = await ctx.board.syncFind({ account: `${SYNC_KEY}:user:${ctx.labels.conformance}` });
+			} catch (error) {
+				if (error instanceof BoardError && error.status === 403) return "this token can't look up a sync here";
+				throw error;
+			}
+			same(found.person, null, "who an account nobody linked is");
+		}
 	}
 ];
 /** Runs the checks against `board`, in order, and reports each. It never throws for what the board answers. */

package/dist/conformance.d.mts

@@ -1,4 +1,4 @@
-import { d as Board } from "./backend-CPC_vyOo.mjs";
+import { d as Board } from "./backend-n3hajfrD.mjs";
 //#region src/conformance/index.d.ts
 /**
  * Checks that a board speaks the protocol, through a handle on it (`conformance(board())`), as

package/dist/conformance.mjs

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

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

@@ -2,10 +2,10 @@ import { a as typeOf, i as fileSize, r as IMPORT_BYTES_MAX, t as ATTACHMENT_BYTE
 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 { 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 derivedId, t as waitUntil } from "./wait-until-Dw4XrIDQ.mjs";
-import { r as badRequest, s as notFound, t as HttpError } from "./errors-CusN4x2l.mjs";
 import { n as replaceMentions } from "./mentions-CB6ShY4R.mjs";
-import { t as DroppedError } from "./middleware-CXjEeef4.mjs";
+import { t as DroppedError } from "./middleware-DlJQYiwV.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";

package/dist/{errors-DDktVeUa.d.mts → errors-87TVtXeb.d.mts}

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

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

@@ -1,5 +1,6 @@
 import { a as typeOf, n as DIRECT_UPLOAD_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import { r as normalizeEmoji } from "./emoji-CTLpvH-A.mjs";
+import { ZodError } from "zod";
 //#region src/client/sse.ts
 /** Parses a text/event-stream body into messages. */
 async function* parseSse(body, signal) {
@@ -230,10 +231,13 @@ function createBoardClient(options) {
 			const size = input.data instanceof Blob ? input.data.size : input.data.byteLength;
 			if (size > 4194304) {
 				if (size > 104857600) throw new BoardError("too_large", `Attachments are at most ${DIRECT_UPLOAD_BYTES_MAX / 1024 / 1024} MB.`, 413);
+				const bytes = input.data instanceof Blob ? await input.data.arrayBuffer() : input.data;
+				const sha256 = btoa(String.fromCharCode(...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))));
 				const ticket = await call("POST", "/attachments/uploads", { body: {
 					name: input.name,
 					type,
-					size
+					size,
+					sha256
 				} }).catch((error) => {
 					if (error instanceof BoardError && error.status === 404 && error.code === "not_found") throw new BoardError("too_large", `This board takes files of at most ${ATTACHMENT_BYTES_MAX / 1024 / 1024} MB.`, 413);
 					throw error;
@@ -260,13 +264,24 @@ function createBoardClient(options) {
 		},
 		/** An attachment's bytes, as the board serves them: `content-type` is the file's type. */
 		download: (id, opts = {}) => raw("GET", `/attachments/${encodeURIComponent(id)}`, opts.signal ? { signal: opts.signal } : {}),
-		edit: (id, text) => call("POST", `/messages/${path(id)}/edit`, { body: { text } }),
-		delete: (id) => call("POST", `/messages/${path(id)}/delete`, { body: {} }),
+		/**
+		* `revision` is the message's as you read it: if it's been edited or deleted since, nothing
+		* changes, and it throws a 409 `revision_conflict`.
+		*/
+		edit: (id, text, opts = {}) => call("POST", `/messages/${path(id)}/edit`, { body: {
+			text,
+			...opts
+		} }),
+		delete: (id, opts = {}) => call("POST", `/messages/${path(id)}/delete`, { body: { ...opts } }),
 		/** `emoji` is a short name, `:name:`, or the character itself. */
 		react: (id, emoji, opts = {}) => call("POST", `/messages/${path(id)}/reactions`, { body: {
 			emoji: normalizeEmoji(emoji),
 			...opts
 		} }),
+		/**
+		* `if` is what the labels must be now, a value or null for one that mustn't be set: if one
+		* isn't, nothing changes, and it throws a 409 `label_conflict`.
+		*/
 		label: (id, change) => call("POST", `/messages/${path(id)}/labels`, { body: change }),
 		/**
 		* Shows typing in the platform threads the message's thread is synced to
@@ -405,4 +420,89 @@ async function toError(response) {
 	return new BoardError("http_error", `The board answered ${`${response.status} ${response.statusText}`.trim()}.`, response.status);
 }
 //#endregion
-export { handleErrors as i, createBoardClient as n, duration as r, BoardError as t };
+//#region src/server/errors.ts
+var HttpError = class extends Error {
+	status;
+	code;
+	/** What fixes it, when there's one (`BoardError`'s `hint`). */
+	hint;
+	/** `handle` for a handle's own error on its way through: everything else is the board's. */
+	origin;
+	constructor(status, code, message, options = {}) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.hint = options.hint;
+		this.origin = options.origin ?? "board";
+	}
+};
+/** A request a host's own verifier rejected with `response`, which the board answers with as it is. */
+var RejectedError = class extends HttpError {
+	response;
+	constructor(response) {
+		super(response.status, "rejected", `rejected with ${response.status}`);
+		this.response = response;
+	}
+};
+const badRequest = (message, code = "invalid_request") => new HttpError(400, code, message);
+const unauthorized = (message) => new HttpError(401, "unauthorized", message);
+const forbidden = (message) => new HttpError(403, "forbidden", message);
+const notFound = (message, code = "not_found") => new HttpError(404, code, message);
+const duplicateId = () => new HttpError(409, "duplicate_id", "that id was already used for a different write");
+const json = (body, status = 200, headers) => new Response(JSON.stringify(body), {
+	status,
+	headers: {
+		"content-type": "application/json",
+		...headers
+	}
+});
+/**
+* The issue a request is told about. A union that matched no option says only "Invalid input", so
+* it's the first issue of the option that came closest, the one with the fewest, at its own path.
+*/
+function reported(issue) {
+	if (issue.code !== "invalid_union" || issue.errors.length === 0) return issue;
+	const first = issue.errors.reduce((best, option) => option.length < best.length ? option : best)[0];
+	return first ? reported({
+		...first,
+		path: [...issue.path, ...first.path]
+	}) : issue;
+}
+/** Every failure becomes `{ error: { code, message, hint? } }` with a matching status. */
+function toErrorResponse(error) {
+	if (error instanceof RejectedError) return error.response;
+	if (error instanceof HttpError) {
+		const response = json({ error: {
+			code: error.code,
+			message: error.message,
+			...error.hint !== void 0 ? { hint: error.hint } : {}
+		} }, error.status);
+		if (error.origin === "handle") handleErrors.add(response);
+		return response;
+	}
+	if (error instanceof ZodError) {
+		const issue = error.issues[0] && reported(error.issues[0]);
+		const path = issue?.path.length ? `${issue.path.join(".")}: ` : "";
+		return json({ error: {
+			code: "invalid_request",
+			message: `${path}${issue?.message ?? "invalid request"}`
+		} }, 400);
+	}
+	const code = error?.code;
+	if (code === "INVALID_PAYLOAD") return json({ error: {
+		code: "invalid_request",
+		message: error.message
+	} }, 400);
+	if (code === "PARTIAL_DUPLICATE_BATCH" || code === "DUPLICATE_EVENT_ID") return toErrorResponse(duplicateId());
+	if (code === "STORE_UNAVAILABLE" || code === "STORE_NOT_CONFIGURED") return json({ error: {
+		code: "unavailable",
+		message: error.message
+	} }, 503);
+	console.error("[board]", error);
+	return json({ error: {
+		code: "internal",
+		message: "internal error"
+	} }, 500);
+}
+//#endregion
+export { forbidden as a, toErrorResponse as c, createBoardClient as d, duration as f, duplicateId as i, unauthorized as l, RejectedError as n, json as o, badRequest as r, notFound as s, HttpError as t, BoardError as u };

package/dist/{exports-BG-0Wyn-.mjs → exports-CG0P8Qi4.mjs}

@@ -1,12 +1,11 @@
 import { t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import "./schemas-DBmUO6pr.mjs";
-import { A as SchedulesQuery, B as SyncReceiptBody, C as MatchesQuery, D as Ref, E as ReactBody, F as SyncBody, G as UploadStartBody, H as SyncUnlinkBody, I as SyncCodeBody, L as SyncCopiesQuery, M as SourceJoinBody, N as SourceReadQuery, O as RegisterBody, P as SyncAccountBody, R as SyncFindQuery, S as LinkedQuery, T as PostBody, U as ThreadsQuery, V as SyncRootsQuery, W as TypingBody, _ as InboxAckBody, a as METHODS, b as InboxQuery, c as queryObject, d as VERSION, f as SYNC, g as IdentityUnlinkBody, h as EventsQuery, j as SignInQuery, k as ScheduleBody, l as readCapped, m as EditBody, o as createRouter, p as AckBody, s as openapi, u as readJson, v as InboxNextQuery, w as MessagesQuery, x as LabelBody, y as InboxPushBody, z as SyncImportBody } from "./watchers-hash-BDhLVkV5.mjs";
-import { n as createBoardClient, t as BoardError } from "./client-D0Px7KzF.mjs";
+import { A as ScheduleBody, B as SyncImportBody, C as LinkedQuery, D as ReactBody, E as PostBody, F as SyncAccountBody, G as TypingBody, H as SyncRootsQuery, I as SyncBody, K as UploadStartBody, L as SyncCodeBody, M as SignInQuery, N as SourceJoinBody, O as Ref, P as SourceReadQuery, R as SyncCopiesQuery, S as LabelBody, T as MessagesQuery, U as SyncUnlinkBody, V as SyncReceiptBody, W as ThreadsQuery, _ as IdentityUnlinkBody, a as METHODS, b as InboxPushBody, c as queryObject, d as VERSION, f as SYNC, g as EventsQuery, h as EditBody, j as SchedulesQuery, k as RegisterBody, l as readCapped, m as DeleteBody, o as createRouter, p as AckBody, s as openapi, u as readJson, v as InboxAckBody, w as MatchesQuery, x as InboxQuery, y as InboxNextQuery, z as SyncFindQuery } from "./watchers-hash-B_5b0-ZG.mjs";
+import { a as forbidden, c as toErrorResponse, d as createBoardClient, l as unauthorized, n as RejectedError, o as json, r as badRequest, s as notFound, t as HttpError, u as BoardError } from "./errors-C_5rB8Iz.mjs";
 import { r as derivedId } from "./wait-until-Dw4XrIDQ.mjs";
-import { a as forbidden, c as toErrorResponse, l as unauthorized, n as RejectedError, o as json, r as badRequest, s as notFound, t as HttpError } from "./errors-CusN4x2l.mjs";
-import { d as issuersOf, g as verifiesTokens, l as hostPrincipal, o as createAuthority, s as fromTokens } from "./auth-JO22iIwr.mjs";
-import { i as resolveActor, r as claimsOf, t as KNOWN_AGENTS } from "./actors-DcJhFbwJ.mjs";
-import { r as runMiddleware, t as DroppedError } from "./middleware-CXjEeef4.mjs";
+import { i as resolveActor, r as claimsOf, t as KNOWN_AGENTS } from "./actors-xPiamLWk.mjs";
+import { d as issuersOf, g as verifiesTokens, l as hostPrincipal, o as createAuthority, s as fromTokens } from "./auth-BPinwfN0.mjs";
+import { r as runMiddleware, t as DroppedError } from "./middleware-DlJQYiwV.mjs";
 import { n as syncTarget, r as withEmailMentions, t as mentionsEmails } from "./targets-Cgjs29T0.mjs";
 //#region src/server/policy.ts
 /**
@@ -216,7 +215,6 @@ async function inputOf(name, request, url, params) {
 		case "message":
 		case "posted":
 		case "synced":
-		case "delete":
 		case "cancelSchedule":
 		case "attachment":
 		case "uploadFinish": return { id };
@@ -237,6 +235,10 @@ async function inputOf(name, request, url, params) {
 			id,
 			...EditBody.parse(await body())
 		};
+		case "delete": return {
+			id,
+			...DeleteBody.parse(await body())
+		};
 		case "react": return {
 			id,
 			...ReactBody.parse(await body())
@@ -513,6 +515,25 @@ async function createServe(context) {
 		}));
 	}
 	/**
+	* A schedule, on a backend whose sends post elsewhere: its message through the middleware once,
+	* as the caller's post of it, since its text and labels never change and no send comes back here.
+	*/
+	function screenSchedule(caller, input, signal) {
+		const { channel, re, text, labels, noSync, attachments } = input;
+		return screenPost(caller, {
+			...channel !== void 0 ? { channel } : {},
+			...re !== void 0 ? { re } : {},
+			text,
+			...labels ? { labels } : {},
+			...noSync !== void 0 ? { noSync } : {},
+			...attachments ? { attachments } : {}
+		}, signal, (screened) => backend.schedule(caller, {
+			...input,
+			text: screened.text,
+			...screened.labels ? { labels: screened.labels } : {}
+		}, signal));
+	}
+	/**
 	* The caller's own message, still there, where it may post: what an edit of it changes. One it
 	* can't read may still be its own, as board()'s own code finds it, only if it was written there
 	* without reading too: one its principal wrote where it reads (a repo's workflows share one) is
@@ -709,22 +730,27 @@ async function createServe(context) {
 		switch (name) {
 			case "post": return importPost(caller, input, signal);
 			case "edit": {
-				const { id, text } = input;
+				const { id, text, revision } = input;
 				return change({
 					op: "edit",
 					author,
 					from: null,
 					message: id,
 					text: await withEmails(text),
-					source
+					source,
+					...revision !== void 0 ? { revision } : {}
+				});
+			}
+			case "delete": {
+				const { id, revision } = input;
+				return change({
+					op: "delete",
+					author,
+					from: null,
+					message: id,
+					...revision !== void 0 ? { revision } : {}
 				});
 			}
-			case "delete": return change({
-				op: "delete",
-				author,
-				from: null,
-				message: input.id
-			});
 			case "react": {
 				const { id, emoji, remove } = input;
 				return change({
@@ -737,14 +763,15 @@ async function createServe(context) {
 				});
 			}
 			case "label": {
-				const { id, set, unset } = input;
+				const { id, set, unset, if: expected } = input;
 				return change({
 					op: "labels",
 					author,
 					from: null,
 					message: id,
 					...set ? { set } : {},
-					...unset ? { unset } : {}
+					...unset ? { unset } : {},
+					...expected ? { if: expected } : {}
 				});
 			}
 			default: return invoke(name, me, input, signal);
@@ -780,7 +807,8 @@ async function createServe(context) {
 			...input.labels ? { labels: input.labels } : {},
 			...input.noSync ? { noSync: true } : {},
 			...input.attachments?.length ? { attachments: input.attachments } : {},
-			...input.id !== void 0 ? { id: input.id } : {}
+			...input.id !== void 0 ? { id: input.id } : {},
+			...input.after !== void 0 ? { after: input.after } : {}
 		}, signal));
 		for (const target of targets) await backend.syncReceipt(me, {
 			kind: "thread",
@@ -796,27 +824,25 @@ async function createServe(context) {
 		switch (name) {
 			case "post": return post(caller, input, signal);
 			case "edit": {
-				const { id, text } = input;
+				const edit = input;
 				const send = (body) => screenEdit(caller, body, signal, (patched) => backend.edit(caller, patched, signal));
-				if (!engine || !mentionsEmails(text) || !await mayPost(caller, { re: id }, signal)) return send({
-					id,
-					text
-				});
+				if (!engine || !mentionsEmails(edit.text) || !await mayPost(caller, { re: edit.id }, signal)) return send(edit);
 				return send({
-					id,
-					text: await withEmails(text)
+					...edit,
+					text: await withEmails(edit.text)
 				});
 			}
 			case "syncImport": return syncImport(caller, input, signal);
 			case "schedule": {
 				const body = input;
+				const schedule = (made) => backend.sendsSchedulesHere === false ? screenSchedule(caller, made, signal) : backend.schedule(caller, made, signal);
 				const allowed = engine && mentionsEmails(body.text) ? await mayPost(caller, body, signal) : null;
-				if (!allowed) return backend.schedule(caller, body, signal);
+				if (!allowed) return schedule(body);
 				const text = await withEmails(body.text);
-				const answer = await backend.schedule(caller, {
+				const answer = await schedule({
 					...body,
 					text
-				}, signal);
+				});
 				const { access } = allowed;
 				return text !== body.text && access !== null && !access.readable(answer.schedule.channel) ? {
 					...answer,

package/dist/exports-CrGA5_yN.d.mts

@@ -0,0 +1,5 @@
+import "./auth-CU56Q2Xh.mjs";
+import "./folds-8wRRXjAt.mjs";
+import "./client-CjAatpV4.mjs";
+import "./backend-n3hajfrD.mjs";
+import "./errors-87TVtXeb.mjs";