@vercel/board 0.29.0 → 0.31.0

package/dist/{backend-vercel-BNauAs7w.mjs → backend-vercel-CmY9yZ9m.mjs}

@@ -1,10 +1,10 @@
 import { r as IMPORT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import { _ as RemoteWatcherId } from "./schemas-DBmUO6pr.mjs";
-import { O as RegisterBody, a as METHODS, d as VERSION, n as compileWatcher, t as canonicalWatchers } from "./watchers-hash-BDhLVkV5.mjs";
+import { A as RegisterBody, a as METHODS, d as VERSION, n as compileWatcher, t as canonicalWatchers } from "./watchers-hash-BjwlnGD9.mjs";
+import { a as forbidden, f as duration, o as json, r as badRequest, s as notFound, t as HttpError } from "./errors-CJXhhzvT.mjs";
 import { o as sha256, r as derivedId } from "./wait-until-Dw4XrIDQ.mjs";
-import { a as forbidden, o as json, s as notFound, t as HttpError } from "./errors-CusN4x2l.mjs";
-import { a as wakePath, i as registrant, n as callerProfile, t as PROJECTS_OWN } from "./backend-http-CzIJMm58.mjs";
-import { o as mediaType, r as fileName } from "./blob-DdbpJqN1.mjs";
+import { a as wakePath, i as registrant, n as callerProfile, t as PROJECTS_OWN } from "./backend-http-CvUKOn-m.mjs";
+import { o as mediaType, r as fileName } from "./blob-WbB2DJKn.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}$/;
@@ -19,14 +19,6 @@ 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"],
-	uploadStart: ["no_direct_uploads", "Vercel's boards take files up to 4 MB in one upload for now"],
-	uploadFinish: ["no_direct_uploads", "Vercel's boards take files up to 4 MB in one upload for now"]
-};
 /** A file as the board names it. */
 const fileOf = ({ id, name, type, size }) => ({
 	id,
@@ -74,6 +66,13 @@ const authorOf = (actor) => ({
 	profile: actor.profile?.name ?? null,
 	session: actor.session ?? null
 });
+/** Who cancels a schedule when no one did: the API, once its creator can no longer post it, as a2()'s scheduler. */
+const SCHEDULER = {
+	actor: "board:schedule",
+	principal: "board:schedule",
+	profile: null,
+	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;
@@ -90,8 +89,8 @@ function actorView(actor) {
 }
 /**
 * 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.
+* it as itself, its people as themselves. Messages, threads, reactions, labels, a channel's
+* changes, schedules, files, and watchers work; what the API keeps none of yet (sync) answers 501.
 */
 function createVercel(options, environment) {
 	const origin = (options.api ?? "https://api.vercel.com").replace(/\/+$/, "");
@@ -192,10 +191,13 @@ function createVercel(options, environment) {
 		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) {
+	/** The channel by `name`, made if it isn't there: `created` says whether this made it. */
+	async function ensureChannel(who, name) {
 		const found = await channelNamed(who, name);
-		if (found) return found;
+		if (found) return {
+			channel: found,
+			created: false
+		};
 		try {
 			const { channel } = await api(who, "POST", await onBoard(who, "/channels"), { body: {
 				operationId: operationId(),
@@ -203,15 +205,23 @@ function createVercel(options, environment) {
 			} });
 			channels = null;
 			named.set(name, channel);
-			return channel;
+			return {
+				channel,
+				created: true
+			};
 		} catch (error) {
 			if (error instanceof HttpError && error.code === "channel_name_taken") {
 				const made = await channelNamed(who, name);
-				if (made) return made;
+				if (made) return {
+					channel: made,
+					created: false
+				};
 			}
 			throw error;
 		}
 	}
+	/** A channel to post in, made the first time something posts to it, as on any board. */
+	const channelToPost = async (who, name) => (await ensureChannel(who, name)).channel;
 	/** 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);
@@ -331,7 +341,39 @@ function createVercel(options, environment) {
 			attachments: message.attachments ?? [],
 			links: [],
 			version: message.version,
-			author: await nameOf(who, message.createdBy)
+			revision: message.revision,
+			author: await nameOf(who, message.createdBy),
+			...message.schedule ? { schedule: {
+				id: message.schedule.id,
+				n: message.schedule.n
+			} } : {}
+		};
+	}
+	async function scheduleView(who, schedule) {
+		const { canceled } = schedule;
+		return {
+			id: schedule.id,
+			channel: (await channelById(who, schedule.channelId)).name,
+			re: schedule.threadId === void 0 ? null : idAt(schedule.threadId, 1),
+			text: schedule.text,
+			labels: { ...schedule.labels },
+			noSync: false,
+			attachments: [],
+			first: iso(schedule.firstAt),
+			every: schedule.every ?? null,
+			until: schedule.until === void 0 ? null : iso(schedule.until),
+			times: schedule.times ?? null,
+			sent: schedule.sent,
+			next: schedule.nextAt === null ? null : iso(schedule.nextAt),
+			last: schedule.lastMessageId ?? null,
+			state: schedule.state,
+			canceled: canceled ? {
+				by: canceled.by ? authorOf(canceled.by) : SCHEDULER,
+				reason: canceled.reason === "disabled" ? "revoked" : canceled.reason
+			} : null,
+			by: authorOf(schedule.createdBy),
+			author: await nameOf(who, schedule.createdBy),
+			createdAt: iso(schedule.createdAt)
 		};
 	}
 	const positions = /* @__PURE__ */ new Map();
@@ -796,6 +838,22 @@ function createVercel(options, environment) {
 	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`);
 	}
+	/**
+	* The API owns messages and schedules by principal, and sees every caller here as this project:
+	* a caller that is the project (its own deployment's token) changes what it wrote, as on any
+	* board, and anyone else would be changing what the project wrote for others.
+	*/
+	/** Whether a caller is this project: the deployment's own code, or a caller verified as its principal. */
+	const isProject = async (caller, who) => !("identity" in caller) || caller.identity.principal.id === principalId((await self(who)).actor.principal);
+	async function checkOwner(what, caller, who) {
+		if (!await isProject(caller, who)) throw forbidden(`this board's callers act as its project on Vercel's board, which owns what any of them wrote: only the project itself may ${what} there`);
+	}
+	/** A file is no use until a post or an import carries it, so uploading takes `post` or `sync` somewhere, as on a2(). */
+	async function checkUploader(caller, who) {
+		await checkOwner("upload", caller, who);
+		const access = accessOf(caller);
+		if (access && !access.anywhere("post") && !access.anywhere("sync")) throw forbidden("this token can't post anywhere, so it can't upload");
+	}
 	const meOf = (identity) => {
 		const { principal, author, actor } = identity;
 		return {
@@ -975,8 +1033,6 @@ function createVercel(options, environment) {
 	});
 	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() {
@@ -1027,18 +1083,24 @@ function createVercel(options, environment) {
 		},
 		async channels(caller) {
 			return {
-				channels: (await channelsFor(whoOf(caller), void 0, accessOf(caller))).map((channel) => ({
-					path: channel.name,
-					lastIndex: 0,
-					messages: 0,
-					threads: 0
-				})),
+				channels: (await channelsFor(whoOf(caller), void 0, accessOf(caller))).map((channel) => ({ path: channel.name })).sort((a, b) => a.path.localeCompare(b.path)),
 				cursor: cursorOf({
 					t: Date.now(),
 					feeds: {}
 				})
 			};
 		},
+		async createChannel(caller, { path }) {
+			checkCaller("createChannel", caller);
+			const access = accessOf(caller);
+			need(access, "read", path);
+			need(access, "post", path);
+			const { created } = await ensureChannel(whoOf(caller), path);
+			return {
+				channel: { path },
+				created
+			};
+		},
 		async actors(caller, _input, signal) {
 			const who = whoOf(caller);
 			const listed = (await all(who, await onBoard(who, "/actors"), "actors", {}, signal)).map((actor) => ({
@@ -1155,10 +1217,10 @@ function createVercel(options, environment) {
 			};
 		},
 		async upload(caller, { data, name, type }) {
-			checkCaller("upload", caller);
+			const who = whoOf(caller);
+			await checkUploader(caller, who);
 			if (data.byteLength === 0) throw new HttpError(400, "bad_request", "the file is empty");
 			if (data.byteLength > 26214400) throw new HttpError(413, "too_large", `attachments are at most ${IMPORT_BYTES_MAX / 1024 / 1024} MB`);
-			const who = whoOf(caller);
 			const bytes = new Uint8Array(data);
 			const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
 			const started = await api(who, "POST", await onBoard(who, "/attachments"), { body: {
@@ -1178,12 +1240,37 @@ function createVercel(options, environment) {
 			const { attachment } = await api(who, "POST", await onBoard(who, `/attachments/${encodeURIComponent(started.attachment.id)}/complete`));
 			return { attachment: fileOf(attachment) };
 		},
+		async uploadStart(caller, { name, type, size, sha256 }) {
+			const who = whoOf(caller);
+			await checkUploader(caller, who);
+			if (sha256 === void 0) throw new HttpError(400, "invalid_request", "Vercel's API signs a direct upload for its bytes' SHA-256: send `sha256`, as board's client does");
+			const started = await api(who, "POST", await onBoard(who, "/attachments"), { body: {
+				operationId: operationId(),
+				name: fileName(name ?? null),
+				type: mediaType(type ?? null),
+				size,
+				sha256
+			} });
+			return {
+				id: started.attachment.id,
+				url: started.upload.url,
+				headers: started.upload.headers,
+				expiresAt: iso(started.upload.expiresAt)
+			};
+		},
+		async uploadFinish(caller, { id }) {
+			const who = whoOf(caller);
+			await checkUploader(caller, who);
+			const { attachment } = await api(who, "POST", await onBoard(who, `/attachments/${encodeURIComponent(id)}/complete`));
+			return { attachment: fileOf(attachment) };
+		},
 		async attachment(caller, { id }, signal) {
 			const who = whoOf(caller);
 			const access = accessOf(caller);
 			const found = await api(who, "GET", await onBoard(who, `/attachments/${encodeURIComponent(id)}`), signal ? { signal } : {});
-			if (access) {
-				if (!found.attachment.messageId) throw notFound(`no attachment: ${id}`, "attachment_not_found");
+			if (access && !found.attachment.messageId) {
+				if (!await isProject(caller, who)) throw notFound(`no attachment: ${id}`, "attachment_not_found");
+			} else if (access) {
 				const { message } = await readableMessage(who, access, found.attachment.messageId, signal).catch((error) => {
 					if (error instanceof HttpError && error.status === 404) throw notFound(`no attachment: ${id}`, "attachment_not_found");
 					throw error;
@@ -1205,7 +1292,7 @@ function createVercel(options, environment) {
 			if (input.sync?.length) throw notSupported("sync");
 			const who = whoOf(caller);
 			const access = accessOf(caller);
-			if (access && input.attachments?.length) throw forbidden("this board's callers act as its project on Vercel's board, which can't tell them apart: only the project's own code posts files there");
+			if (input.attachments?.length) await checkOwner("post files", caller, who);
 			const labeled = Object.keys(input.labels ?? {}).length > 0;
 			const clientId = input.id !== void 0 ? await postId(caller, input.id) : void 0;
 			let made;
@@ -1228,15 +1315,25 @@ function createVercel(options, environment) {
 				const { thread, message: to, channel } = await readableMessage(who, access, input.re, signal);
 				need(access, "post", channel.name);
 				if (labeled) need(access, "label", channel.name);
+				const after = input.after === void 0 ? void 0 : locate(input.after);
+				if (after !== void 0 && after?.threadId !== thread.id) {
+					const landed = clientId ? await api(who, "GET", await onBoard(who, `/posts/${encodeURIComponent(clientId)}`), { signal }).catch(() => null) : null;
+					if (landed?.thread.id === thread.id) return { message: await view(who, landed.message, channel.name) };
+					throw badRequest(`after: ${input.after} isn't in ${input.re}'s thread`, "invalid_after");
+				}
 				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 } : {},
-						...input.attachments?.length ? { attachments: input.attachments } : {}
+						...input.attachments?.length ? { attachments: input.attachments } : {},
+						...after ? { after: after.sequence } : {}
 					},
 					signal
+				}).catch((error) => {
+					if (error instanceof HttpError && error.code === "newer_message") throw new HttpError(409, "newer_message", `a message came after ${input.after}`);
+					throw error;
 				});
 				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`), {
@@ -1268,27 +1365,35 @@ function createVercel(options, environment) {
 			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);
+		async edit(caller, { id, text, revision }, signal) {
 			const who = whoOf(caller);
+			await checkOwner("edit", caller, who);
 			const at = locate(id);
 			if (!at) throw notFound(`message not found: ${id}`, "message_not_found");
+			const access = accessOf(caller);
+			if (access) need(access, "post", (await readableMessage(who, access, id, signal)).channel.name);
 			await api(who, "PATCH", await onBoard(who, `/threads/${encodeURIComponent(at.threadId)}/messages/${at.sequence}`), {
 				body: {
 					operationId: operationId(),
-					text
+					text,
+					...revision !== void 0 ? { revision } : {}
 				},
 				signal
 			});
 			return { ok: true };
 		},
-		async delete(caller, { id }, signal) {
-			checkCaller("delete", caller);
+		async delete(caller, { id, revision }, signal) {
 			const who = whoOf(caller);
+			await checkOwner("delete", caller, who);
 			const at = locate(id);
 			if (!at) throw notFound(`message not found: ${id}`, "message_not_found");
+			const access = accessOf(caller);
+			if (access) need(access, "post", (await readableMessage(who, access, id, signal)).channel.name);
 			await api(who, "POST", await onBoard(who, `/threads/${encodeURIComponent(at.threadId)}/messages/${at.sequence}/delete`), {
-				body: { operationId: operationId() },
+				body: {
+					operationId: operationId(),
+					...revision !== void 0 ? { revision } : {}
+				},
 				signal
 			});
 			return { ok: true };
@@ -1310,7 +1415,7 @@ function createVercel(options, environment) {
 			});
 			return { ok: true };
 		},
-		async label(caller, { id, set, unset }, signal) {
+		async label(caller, { id, set, unset, if: expected }, signal) {
 			checkCaller("label", caller);
 			const who = whoOf(caller);
 			const at = locate(id);
@@ -1321,12 +1426,143 @@ function createVercel(options, environment) {
 				body: {
 					operationId: operationId(),
 					...set ? { set } : {},
-					...unset ? { unset } : {}
+					...unset ? { unset } : {},
+					...expected && Object.keys(expected).length ? { if: expected } : {}
 				},
 				signal
 			});
 			return { ok: true };
 		},
+		async grants(caller, _input, signal) {
+			checkCaller("grants", caller);
+			const who = whoOf(caller);
+			return api(who, "GET", await onBoard(who, "/grants"), signal ? { signal } : {});
+		},
+		async createGrant(caller, input, signal) {
+			checkCaller("createGrant", caller);
+			const who = whoOf(caller);
+			return api(who, "POST", await onBoard(who, "/grants"), {
+				body: {
+					operationId: operationId(),
+					...input
+				},
+				...signal ? { signal } : {}
+			});
+		},
+		async revokeGrant(caller, { id }, signal) {
+			checkCaller("revokeGrant", caller);
+			const who = whoOf(caller);
+			return api(who, "POST", await onBoard(who, `/grants/${encodeURIComponent(id)}/revoke`), {
+				body: { operationId: operationId() },
+				...signal ? { signal } : {}
+			});
+		},
+		async tokens(caller, _input, signal) {
+			checkCaller("tokens", caller);
+			const who = whoOf(caller);
+			return api(who, "GET", await onBoard(who, "/tokens"), signal ? { signal } : {});
+		},
+		async createToken(caller, input, signal) {
+			checkCaller("createToken", caller);
+			const who = whoOf(caller);
+			return api(who, "POST", await onBoard(who, "/tokens"), {
+				body: {
+					operationId: operationId(),
+					...input
+				},
+				...signal ? { signal } : {}
+			});
+		},
+		async revokeToken(caller, { id }, signal) {
+			checkCaller("revokeToken", caller);
+			const who = whoOf(caller);
+			return api(who, "POST", await onBoard(who, `/tokens/${encodeURIComponent(id)}/revoke`), {
+				body: { operationId: operationId() },
+				...signal ? { signal } : {}
+			});
+		},
+		async schedule(caller, input, signal) {
+			if (input.attachments?.length) throw notSupported("files on scheduled messages");
+			const who = whoOf(caller);
+			await checkOwner("schedule", caller, who);
+			const access = accessOf(caller);
+			const labels = input.labels && Object.keys(input.labels).length ? input.labels : void 0;
+			let target;
+			if (input.channel !== void 0) {
+				need(access, "post", input.channel);
+				if (labels) need(access, "label", input.channel);
+				target = { channelId: (await channelToPost(who, input.channel)).id };
+			} else {
+				if (labels) throw notSupported("labels on a scheduled reply");
+				const { thread, channel } = await readableMessage(who, access, input.re, signal);
+				need(access, "post", channel.name);
+				target = { threadId: thread.id };
+			}
+			const ms = (value) => Math.round(duration(value));
+			const firstAt = input.at !== void 0 ? Date.parse(input.at) : Date.now() + ms(input.in ?? input.every);
+			const until = input.until !== void 0 ? Date.parse(input.until) : input.for !== void 0 ? firstAt + ms(input.for) : void 0;
+			const { schedule } = await api(who, "POST", await onBoard(who, "/schedules"), {
+				body: {
+					operationId: operationId(),
+					...target,
+					text: input.text,
+					...labels ? { labels } : {},
+					firstAt,
+					...input.every !== void 0 ? { every: ms(input.every) } : {},
+					...until !== void 0 ? { until } : {},
+					...input.times !== void 0 ? { times: input.times } : {}
+				},
+				signal
+			});
+			return { schedule: await scheduleView(who, schedule) };
+		},
+		async schedules(caller, query, signal) {
+			const who = whoOf(caller);
+			const access = accessOf(caller);
+			const filter = { state: query.all ? void 0 : "pending" };
+			if (query.re !== void 0) {
+				const found = await readableMessage(who, access, query.re, signal).catch((error) => {
+					if (error instanceof HttpError && error.status === 404) return null;
+					throw error;
+				});
+				if (!found) return { schedules: [] };
+				filter.threadId = found.thread.id;
+			}
+			if (query.channel !== void 0) {
+				const channel = await channelNamed(who, query.channel);
+				if (!channel) return { schedules: [] };
+				filter.channelId = channel.id;
+			}
+			const me = query.by === "me" ? await actorOf(who) : void 0;
+			const by = me ?? query.by;
+			if (by?.startsWith("vercel:")) filter.createdBy = by;
+			const created = (actor) => by === void 0 || (me ? actor.id === me : [
+				actor.id,
+				principalId(actor.principal),
+				actor.profile?.name
+			].includes(by));
+			const listed = await all(who, await onBoard(who, "/schedules"), "schedules", filter, signal);
+			return { schedules: (await Promise.all(listed.filter((schedule) => created(schedule.createdBy)).map((schedule) => scheduleView(who, schedule)))).filter((schedule) => access === null || access.readable(schedule.channel)) };
+		},
+		async cancelSchedule(caller, { id }, signal) {
+			const who = whoOf(caller);
+			await checkOwner("cancelSchedule", caller, who);
+			const access = accessOf(caller);
+			if (access) {
+				const found = (await all(who, await onBoard(who, "/schedules"), "schedules", {}, signal)).find((schedule) => schedule.id === id);
+				const channel = found && await channelById(who, found.channelId);
+				if (!channel || !access.readable(channel.name)) throw notFound(`no schedule: ${id}`, "schedule_not_found");
+				need(access, "post", channel.name);
+			}
+			const { schedule, canceled } = await api(who, "POST", await onBoard(who, `/schedules/${encodeURIComponent(id)}/cancel`), {
+				body: { operationId: operationId() },
+				signal
+			});
+			return {
+				schedule: await scheduleView(who, schedule),
+				canceled
+			};
+		},
 		async events(caller, query, signal) {
 			checkCaller("events", caller);
 			const who = whoOf(caller);
@@ -1399,6 +1635,7 @@ function createVercel(options, environment) {
 		}])),
 		routes: runner.routes,
 		keeps: false,
+		sendsSchedulesHere: 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");

package/dist/backend-vercel.d.mts

@@ -1,4 +1,4 @@
-import { n as VercelOptions, t as VercelBackend } from "./backend-vercel-4tvcPKqX.mjs";
+import { n as VercelOptions, t as VercelBackend } from "./backend-vercel-BaSEUdwg.mjs";
 //#region src/backend-vercel/index.default.d.ts
 /**
  * Your team's board, in Vercel's API. Outside Node there's no environment to find credentials or

package/dist/backend-vercel.mjs

@@ -1,4 +1,4 @@
-import { t as createVercel } from "./backend-vercel-BNauAs7w.mjs";
+import { t as createVercel } from "./backend-vercel-CmY9yZ9m.mjs";
 //#region src/backend-vercel/index.default.ts
 /**
 * Your team's board, in Vercel's API. Outside Node there's no environment to find credentials or

package/dist/backend-vercel.node.d.mts

@@ -1,4 +1,4 @@
-import { n as VercelOptions, t as VercelBackend } from "./backend-vercel-4tvcPKqX.mjs";
+import { n as VercelOptions, t as VercelBackend } from "./backend-vercel-BaSEUdwg.mjs";
 //#region src/backend-vercel/index.d.ts
 /** Where `token` comes from, in words: what `vb whoami` says. */
 export declare function credentialSource(): string;

package/dist/backend-vercel.node.mjs

@@ -1,2 +1,2 @@
-import { n as handTeam, r as vercel, t as credentialSource } from "./backend-vercel-DQc_TaHp.mjs";
+import { n as handTeam, r as vercel, t as credentialSource } from "./backend-vercel-Ba8JDtqW.mjs";
 export { credentialSource, handTeam, vercel };

package/dist/{blob-DmiQjrYy.d.mts → blob-Bx8QPWEd.d.mts}

@@ -1,5 +1,5 @@
-import "./folds-ZkHM4M-v.mjs";
-import "./errors-DDktVeUa.mjs";
+import "./folds-DLUzfibJ.mjs";
+import "./errors-2vGs49Db.mjs";
 //#region src/server/blob.d.ts
 /**
  * Where attachments' bytes live. The board writes each file once, under a key

package/dist/{blob-DdbpJqN1.mjs → blob-WbB2DJKn.mjs}

@@ -1,6 +1,6 @@
 import { n as DIRECT_UPLOAD_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import { i as Attachment } from "./schemas-DBmUO6pr.mjs";
-import { r as badRequest, s as notFound, t as HttpError } from "./errors-CusN4x2l.mjs";
+import { r as badRequest, s as notFound, t as HttpError } from "./errors-CJXhhzvT.mjs";
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -61,8 +61,19 @@ function attachmentId() {
 	}
 }
 /**
+* Whether an upload is the caller's own, to read and attach before a message carries it: its
+* principal sent it, and the caller holds no board token, or holds the one it came with or one
+* that token was minted with. A token acts as its minter, so the principal alone would hand it
+* every file its minter, or another of its minter's tokens, uploaded.
+*/
+function ownUpload(upload, caller) {
+	if (upload.uploadedBy !== caller.id) return false;
+	return caller.token === void 0 || (upload.uploadedWith?.includes(caller.token) ?? false);
+}
+/**
 * Stores an upload under a fresh ID, with its metadata beside it. `uploadedBy`
-* is the principal that sent it, who can read it before any message carries it.
+* is the principal that sent it, who can read it before any message carries it,
+* and `uploadedWith` the board tokens it came with (`ownUpload`).
 * `max` is the most it can be: `ATTACHMENT_BYTES_MAX` unless the board's own sync imports it.
 */
 async function writeUpload(blob, input, max = ATTACHMENT_BYTES_MAX) {
@@ -78,7 +89,8 @@ async function writeUpload(blob, input, max = ATTACHMENT_BYTES_MAX) {
 	await blob.put(dataKey(attachment.id), input.data, attachment.type);
 	const meta = input.uploadedBy === void 0 ? attachment : {
 		...attachment,
-		uploadedBy: input.uploadedBy
+		uploadedBy: input.uploadedBy,
+		...input.uploadedWith ? { uploadedWith: input.uploadedWith } : {}
 	};
 	await blob.put(metaKey(attachment.id), new TextEncoder().encode(JSON.stringify(meta)), "application/json");
 	return attachment;
@@ -97,9 +109,11 @@ async function readUpload(blob, id) {
 	const found = Attachment.shape.id.safeParse(id).success ? await blob.get(metaKey(id)) : null;
 	if (!found) throw attachmentNotFound(id);
 	const meta = JSON.parse(new TextDecoder().decode(await bytes(found.data)));
+	const tokens = Array.isArray(meta.uploadedWith) && meta.uploadedWith.every((token) => typeof token === "string") ? meta.uploadedWith : null;
 	return {
 		attachment: Attachment.parse(meta),
-		uploadedBy: typeof meta.uploadedBy === "string" ? meta.uploadedBy : null
+		uploadedBy: typeof meta.uploadedBy === "string" ? meta.uploadedBy : null,
+		uploadedWith: tokens
 	};
 }
 /** An attachment's bytes as the store keeps them, a stream or the bytes, for board() to serve. */
@@ -127,6 +141,7 @@ async function startUpload(blob, input) {
 		type: mediaType(input.type),
 		size: input.size,
 		uploadedBy: input.uploadedBy,
+		...input.uploadedWith ? { uploadedWith: input.uploadedWith } : {},
 		expiresAt: expires.toISOString()
 	};
 	await blob.put(ticketKey(ticket.id), new TextEncoder().encode(JSON.stringify(ticket)), "application/json");
@@ -147,15 +162,15 @@ async function startUpload(blob, input) {
 }
 /**
 * Finishes a direct upload: once the store has exactly the bytes its start said, the board records
-* the attachment, as `writeUpload` does. Only its uploader may finish it; a second finish answers
-* the same attachment. It never reads the record before writing it: a store with a cache (Vercel
-* Blob's CDN) would keep that miss, and the post that names the file would find nothing.
+* the attachment, as `writeUpload` does. Only its uploader may finish it (`ownUpload`); a second
+* finish answers the same attachment. It never reads the record before writing it: a store with a
+* cache (Vercel Blob's CDN) would keep that miss, and the post that names the file would find nothing.
 */
-async function finishUpload(blob, id, principal) {
+async function finishUpload(blob, id, caller) {
 	if (!blob) throw noBlob();
 	const found = Attachment.shape.id.safeParse(id).success ? await blob.get(ticketKey(id)) : null;
 	const ticket = found ? JSON.parse(new TextDecoder().decode(await bytes(found.data))) : null;
-	if (!ticket || ticket.uploadedBy !== principal) throw notFound(`no upload: ${id}`, "upload_not_found");
+	if (!ticket || !ownUpload(ticket, caller)) throw notFound(`no upload: ${id}`, "upload_not_found");
 	if (!blob.head) throw noDirectUploads();
 	const stored = await blob.head(dataKey(id));
 	if (!stored) throw new HttpError(409, "not_uploaded", `nothing's been uploaded for ${id} yet: PUT the file to its URL first`);
@@ -167,9 +182,13 @@ async function finishUpload(blob, id, principal) {
 		size: stored.size
 	};
 	try {
+		const uploader = {
+			uploadedBy: ticket.uploadedBy,
+			...ticket.uploadedWith ? { uploadedWith: ticket.uploadedWith } : {}
+		};
 		await blob.put(metaKey(id), new TextEncoder().encode(JSON.stringify({
 			...attachment,
-			uploadedBy: principal
+			...uploader
 		})), "application/json");
 	} catch (error) {
 		const done = await blob.get(metaKey(id)).catch(() => null);
@@ -179,4 +198,4 @@ async function finishUpload(blob, id, principal) {
 	return attachment;
 }
 //#endregion
-export { fsBlob as a, readUpload as c, finishUpload as i, startUpload as l, attachmentNotFound as n, mediaType as o, fileName as r, memoryBlob as s, attachmentBody as t, writeUpload as u };
+export { fsBlob as a, ownUpload as c, writeUpload as d, finishUpload as i, readUpload as l, attachmentNotFound as n, mediaType as o, fileName as r, memoryBlob as s, attachmentBody as t, startUpload as u };