@vercel/board 0.30.0 → 0.31.0

package/dist/{blob-DQK5prXT.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-C_5rB8Iz.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 };

package/dist/{chat-provider-D6jVT4wS.d.mts → chat-provider-BChYrrA7.d.mts}

@@ -1,10 +1,7 @@
-import { d as ExternalFile, f as ExternalLink, l as ExternalAuthor, t as Actor } from "./folds-8wRRXjAt.mjs";
-import { ft as SourceJoin, ht as SourceRead } from "./client-CjAatpV4.mjs";
-import { M as SyncRoot, O as ProviderEvent, a as ProviderOptions, c as ReceivedEvent, d as ResolvedTarget, i as ProviderFile, n as FileDelivery, o as ProviderPost, p as SyncProvider, r as ProviderDelivery, s as Receive, t as FetchedLink, y as SyncFn } from "./provider-Bm46LAdp.mjs";
-import { Adapter, Author, FileUpload, Message, ReactionEvent } from "chat";
-//#region src/sync/types.d.ts
-declare function externalAuthor(platform: string, author: Author): ExternalAuthor;
-//#endregion
+import { d as ExternalFile, f as ExternalLink, l as ExternalAuthor, t as Actor } from "./folds-DLUzfibJ.mjs";
+import { dt as SourceJoin, mt as SourceRead } from "./client-COfYrgfV.mjs";
+import { T as ProviderEvent, a as ProviderOptions, c as ReceivedEvent, d as ResolvedTarget, g as SyncFn, i as ProviderFile, k as SyncRoot, n as FileDelivery, o as ProviderPost, p as SyncProvider, r as ProviderDelivery, s as Receive, t as FetchedLink } from "./provider-gynDUoyW.mjs";
+import { Adapter, Author, FileUpload, Message, ReactionEvent, StateAdapter } from "chat";
 //#region src/sync/chat-provider.d.ts
 type ChatInput = {
   kind: 'message' | 'edited';
@@ -20,11 +17,21 @@ type ChatInput = {
 };
 type ChatTransport = Omit<ProviderOptions, 'uploadsFiles'> & {
   adapter: Adapter;
+  /**
+   * Where Chat SDK and the adapter keep their state, like `createRedisState()`. In memory unless
+   * given, which is enough when the board's log is all an adapter needs to last.
+   */
+  state?: StateAdapter;
   findByEmail?(email: string): Promise<ExternalAuthor | null>;
   mention?(actor: Actor): string | null;
   author?(author: Author, raw: unknown): ExternalAuthor;
-  resolveChannel(key: string): Promise<string>;
-  resolveTarget(target: string): Promise<ResolvedTarget>;
+  /** A channel's name as its native ID. Without it, a name is the ID. */
+  resolveChannel?(key: string): Promise<string>;
+  /**
+   * A target's channel and kind, called on the provider. Without it, the adapter reads the target
+   * as a thread: one it reads as its own channel, or can't read, is a channel.
+   */
+  resolveTarget?(this: SyncProvider, target: string): Promise<ResolvedTarget>;
   groupThread?(thread: string): string;
   channelOf?(thread: string): string;
   isRoot?(thread: string, message: string): boolean;
@@ -34,7 +41,10 @@ type ChatTransport = Omit<ProviderOptions, 'uploadsFiles'> & {
   markdown?(message: Message): string;
   /** Platform messages a message links to, located under sync key `key`. */
   links?(key: string, message: Message): ExternalLink[];
-  fetchLink?(link: ExternalLink): Promise<FetchedLink>;
+  fetchLink?(link: ExternalLink, linker: {
+    thread: string;
+    message: string;
+  }): Promise<FetchedLink>;
   /** The message a URL of the platform's names, by its own IDs: `SyncProvider.locate`. */
   locate?(url: string): {
     thread: string;
@@ -65,14 +75,11 @@ type ChatTransport = Omit<ProviderOptions, 'uploadsFiles'> & {
   /** What the adapter needs to fetch a file again, if not everything the event carried. */
   fileToFetch?(file: ExternalFile): ExternalFile;
   startTyping?(thread: string, latest: string | null, status?: string): Promise<void>;
-  /** Runs adapter calls with a person's token instead of the bot's: how a message posts as them. */
-  runAs?<T>(token: string, fn: () => Promise<T>): Promise<T>;
-  /** The platform account a person's token belongs to. */
-  whoAmI?(token: string): Promise<ExternalAuthor>;
 };
 declare abstract class ChatSyncProvider<E extends ProviderEvent = ProviderEvent> extends SyncProvider<E> {
   protected readonly transport: ChatTransport;
   private readonly chat;
+  private readonly state;
   private readonly receiving;
   private initialized;
   constructor(transport: ChatTransport, sync: SyncFn<E>);
@@ -101,7 +108,11 @@ declare abstract class ChatSyncProvider<E extends ProviderEvent = ProviderEvent>
   }>;
   protected normalize(key: string, input: ChatInput): Promise<ReceivedEvent>;
   private emit;
+  /** The body of the webhook being handled, as the platform sent it: the same on a redelivery. */
+  protected delivery(): string | null;
   receive(key: string, request: Request, emit: Receive): Promise<Response>;
+  /** `state`, noting each first claim (`setIfNotExists`) made while a webhook is handled. */
+  private claiming;
   private receiveRequest;
   protected ready(): Promise<Adapter<unknown, unknown>>;
   resolveChannel(key: string): Promise<string>;
@@ -110,6 +121,8 @@ declare abstract class ChatSyncProvider<E extends ProviderEvent = ProviderEvent>
     channel: string;
     kind: "channel" | "thread";
   }>;
+  /** A target as the adapter reads it: a thread in its channel, or a channel. */
+  private targetOf;
   findByEmail(email: string): Promise<{
     id: string;
     handle: string;
@@ -119,7 +132,10 @@ declare abstract class ChatSyncProvider<E extends ProviderEvent = ProviderEvent>
   } | null>;
   mention(actor: Actor): string | null;
   fetchRoot(thread: string): Promise<SyncRoot | null>;
-  fetchLink(link: ExternalLink): Promise<FetchedLink>;
+  fetchLink(link: ExternalLink, linker: {
+    thread: string;
+    message: string;
+  }): Promise<FetchedLink>;
   locate(url: string): {
     thread: string;
     message: string | null;
@@ -132,18 +148,6 @@ declare abstract class ChatSyncProvider<E extends ProviderEvent = ProviderEvent>
   join(target: string): Promise<SourceJoin>;
   fetchFile(file: ExternalFile): Promise<Uint8Array | null>;
   post(target: string, kind: ResolvedTarget['kind'], { as: _sender, files, ...body }: ProviderPost): Promise<ProviderDelivery>;
-  whoAmI(token: string): Promise<{
-    id: string;
-    handle: string;
-    name: string;
-    avatar: string | null;
-    isBot: boolean;
-  }>;
-  /** As the person: ready first, so the adapter learns its own identity with the bot's token, never theirs. */
-  private as;
-  postAs(token: string, target: string, kind: ResolvedTarget['kind'], body: ProviderPost): Promise<ProviderDelivery>;
-  editAs(token: string, thread: string, message: string, body: ProviderPost): Promise<void>;
-  deleteAs(token: string, thread: string, message: string): Promise<void>;
   edit(thread: string, message: string, { as: _sender, files, ...body }: ProviderPost): Promise<void>;
   delete(thread: string, message: string): Promise<void>;
   react(thread: string, message: string, emoji: string, added: boolean): Promise<void>;
@@ -155,4 +159,4 @@ declare abstract class ChatSyncProvider<E extends ProviderEvent = ProviderEvent>
   deleteFiles(ids: string[]): Promise<void>;
 }
 //#endregion
-export { externalAuthor as i, ChatSyncProvider as n, ChatTransport as r, ChatInput as t };
+export { ChatSyncProvider as n, ChatTransport as r, ChatInput as t };

package/dist/{chat-provider-COtsU5jB.mjs → chat-provider-DkFp2hrh.mjs}

@@ -1,8 +1,28 @@
 import "./external-D3p5T57R.mjs";
-import { n as ResolvedTarget, r as SyncProvider } from "./provider-BaVmi4Hi.mjs";
-import { n as userTokensOf } from "./users-yryHKFMo.mjs";
+import { c as SyncProvider, s as ResolvedTarget } from "./events-lujPA3gQ.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Chat, stringifyMarkdown } from "chat";
+//#region src/sync/chat.ts
+/**
+* One Chat SDK instance per sync entry. Platform modules call this, so
+* the board (`@vercel/board`) never loads Chat SDK unless sync is configured.
+*/
+const createChat = (adapter, state) => new Chat({
+	userName: "board",
+	adapters: { [adapter.name]: adapter },
+	state,
+	concurrency: "concurrent",
+	logger: "warn"
+});
+/** A message as markdown, the board's text format: Chat SDK parses every platform's own. */
+function markdownOf(message) {
+	try {
+		return stringifyMarkdown(message.formatted).trim() || message.text;
+	} catch {
+		return message.text;
+	}
+}
+//#endregion
 //#region src/sync/state.ts
 /**
 * Chat SDK state for sync. Correctness comes from the board log (deterministic
@@ -81,27 +101,6 @@ function ephemeralState() {
 	};
 }
 //#endregion
-//#region src/sync/chat.ts
-/**
-* One Chat SDK instance per sync entry. Platform modules call this, so
-* the board (`@vercel/board`) never loads Chat SDK unless sync is configured.
-*/
-const createChat = (adapter) => new Chat({
-	userName: "board",
-	adapters: { [adapter.name]: adapter },
-	state: ephemeralState(),
-	concurrency: "concurrent",
-	logger: "warn"
-});
-/** A message as markdown, the board's text format: Chat SDK parses every platform's own. */
-function markdownOf(message) {
-	try {
-		return stringifyMarkdown(message.formatted).trim() || message.text;
-	} catch {
-		return message.text;
-	}
-}
-//#endregion
 //#region src/sync/types.ts
 function externalAuthor(platform, author) {
 	const handle = author.userName || author.userId;
@@ -126,16 +125,32 @@ const externalFile = (file) => ({
 var ChatSyncProvider = class extends SyncProvider {
 	transport;
 	chat;
+	state;
 	receiving = new AsyncLocalStorage();
 	initialized;
 	constructor(transport, sync) {
 		super({
 			...transport,
-			users: transport.users ?? userTokensOf(transport.adapter),
 			uploadsFiles: !!transport.uploadFiles
 		}, sync);
 		this.transport = transport;
-		this.chat = createChat(transport.adapter);
+		this.state = transport.state ?? ephemeralState();
+		this.chat = createChat(transport.adapter, this.claiming(this.state));
+		const chat = this.chat;
+		for (const name of [
+			"processMessage",
+			"processMessageUpdated",
+			"processMessageDeleted",
+			"processReaction"
+		]) {
+			const original = chat[name];
+			if (typeof original !== "function") throw new Error(`Chat SDK has no ${name}: board can't wait for what it processes`);
+			chat[name] = (...args) => {
+				const task = original.apply(this.chat, args);
+				if (task instanceof Promise) this.receiving.getStore()?.tasks.push(task.catch(() => {}));
+				return task;
+			};
+		}
 		const onMessage = async (_thread, message) => this.emit({
 			kind: "message",
 			message
@@ -251,23 +266,55 @@ var ChatSyncProvider = class extends SyncProvider {
 	async emit(input) {
 		const context = this.receiving.getStore();
 		if (!context) throw new Error("Chat SDK emitted an event outside a verified request");
-		await context.emit(await this.normalize(context.key, input));
+		try {
+			await context.emit(await this.normalize(context.key, input));
+		} catch (error) {
+			context.failures.push(error);
+			throw error;
+		}
 	}
-	receive(key, request, emit) {
-		return this.receiving.run({
-			key,
-			emit
-		}, () => this.receiveRequest(key, request, emit));
+	/** The body of the webhook being handled, as the platform sent it: the same on a redelivery. */
+	delivery() {
+		return this.receiving.getStore()?.body ?? null;
+	}
+	async receive(key, request, emit) {
+		const claims = [];
+		const body = await request.clone().text();
+		try {
+			return await this.receiving.run({
+				key,
+				emit,
+				body,
+				claims,
+				failures: [],
+				tasks: []
+			}, () => this.receiveRequest(key, request, emit));
+		} catch (error) {
+			await Promise.allSettled(claims.map((claim) => this.state.delete(claim)));
+			throw error;
+		}
+	}
+	/** `state`, noting each first claim (`setIfNotExists`) made while a webhook is handled. */
+	claiming(state) {
+		return new Proxy(state, { get: (target, property) => {
+			if (property === "setIfNotExists") return async (key, value, ttlMs) => {
+				const claimed = await target.setIfNotExists(key, value, ttlMs);
+				if (claimed) this.receiving.getStore()?.claims.push(key);
+				return claimed;
+			};
+			const value = Reflect.get(target, property, target);
+			return typeof value === "function" ? value.bind(target) : value;
+		} });
 	}
 	async receiveRequest(key, request, emit) {
-		const body = this.transport.intercept || this.transport.missed ? await request.clone().text() : null;
-		const tasks = [];
+		const { body, tasks, failures } = this.receiving.getStore();
 		const response = await this.chat.webhooks[this.transport.adapter.name](request, { waitUntil: (task) => void tasks.push(task) });
 		const results = [];
 		while (tasks.length) results.push(...await Promise.allSettled(tasks.splice(0)));
+		if (failures.length) throw failures[0];
 		const failed = results.find((result) => result.status === "rejected");
 		if (failed) throw failed.reason;
-		if (response.ok && body !== null) {
+		if (response.ok && (this.transport.intercept || this.transport.missed)) {
 			for (const input of this.transport.missed?.(request.headers, body) ?? []) await emit(await this.normalize(key, input));
 			for (const received of this.transport.intercept?.(key, request.headers, body) ?? []) await emit(received);
 		}
@@ -281,11 +328,29 @@ var ChatSyncProvider = class extends SyncProvider {
 		await this.initialized;
 		return this.transport.adapter;
 	}
-	resolveChannel(key) {
-		return this.transport.resolveChannel(key);
+	async resolveChannel(key) {
+		return this.transport.resolveChannel ? this.transport.resolveChannel(key) : key;
 	}
 	async resolveTarget(target) {
-		return ResolvedTarget.parse(await this.transport.resolveTarget.call(this, target));
+		return ResolvedTarget.parse(this.transport.resolveTarget ? await this.transport.resolveTarget.call(this, target) : this.targetOf(target));
+	}
+	/** A target as the adapter reads it: a thread in its channel, or a channel. */
+	targetOf(target) {
+		let channel;
+		try {
+			channel = this.transport.channelOf?.(target) ?? this.toNative(this.transport.adapter.channelIdFromThreadId(this.toChat(target)));
+		} catch {
+			return {
+				target,
+				channel: target,
+				kind: "channel"
+			};
+		}
+		return {
+			target,
+			channel,
+			kind: channel === target ? "channel" : "thread"
+		};
 	}
 	async findByEmail(email) {
 		return this.transport.findByEmail?.(email) ?? null;
@@ -300,8 +365,8 @@ var ChatSyncProvider = class extends SyncProvider {
 			raw: root.raw ?? null
 		} : null;
 	}
-	async fetchLink(link) {
-		return this.transport.fetchLink ? this.transport.fetchLink(link) : super.fetchLink(link);
+	async fetchLink(link, linker) {
+		return this.transport.fetchLink ? this.transport.fetchLink(link, linker) : super.fetchLink(link, linker);
 	}
 	locate(url) {
 		return this.transport.locate ? this.transport.locate(url) : super.locate(url);
@@ -334,26 +399,6 @@ var ChatSyncProvider = class extends SyncProvider {
 			...files?.length ? { files: this.transport.fileIds?.(sent.raw) ?? [] } : {}
 		};
 	}
-	async whoAmI(token) {
-		if (!this.transport.whoAmI) return super.whoAmI(token);
-		await this.ready();
-		return this.transport.whoAmI(token);
-	}
-	/** As the person: ready first, so the adapter learns its own identity with the bot's token, never theirs. */
-	async as(token, fn) {
-		if (!this.transport.runAs) throw new Error(`${this.platform} can't post as a person`);
-		await this.ready();
-		return this.transport.runAs(token, fn);
-	}
-	async postAs(token, target, kind, body) {
-		return this.as(token, () => this.post(target, kind, body));
-	}
-	async editAs(token, thread, message, body) {
-		await this.as(token, () => this.edit(thread, message, body));
-	}
-	async deleteAs(token, thread, message) {
-		await this.as(token, () => this.delete(thread, message));
-	}
 	async edit(thread, message, { as: _sender, files, ...body }) {
 		await (await this.ready()).editMessage(this.toChat(thread), message, files ? {
 			...body,
@@ -395,4 +440,4 @@ var ChatSyncProvider = class extends SyncProvider {
 	}
 };
 //#endregion
-export { externalAuthor as n, markdownOf as r, ChatSyncProvider as t };
+export { markdownOf as n, ChatSyncProvider as t };

package/dist/cli-commands.d.mts

@@ -1,2 +1,2 @@
-import { a as OptionName, c as globalOptions, d as options, f as usage, i as CliOption, l as groups, n as CliCommand, o as commands, r as CliExample, s as filters, t as CliArgument, u as option } from "./commands-BtH69yqt.mjs";
+import { a as OptionName, c as globalOptions, d as options, f as usage, i as CliOption, l as groups, n as CliCommand, o as commands, r as CliExample, s as filters, t as CliArgument, u as option } from "./commands-DK4W3HCJ.mjs";
 export { CliArgument, CliCommand, CliExample, CliOption, OptionName, commands, filters, globalOptions, groups, option, options, usage };

package/dist/cli-commands.mjs

@@ -1,2 +1,2 @@
-import { a as option, i as groups, n as filters, o as options, r as globalOptions, s as usage, t as commands } from "./commands-B5DHjZKK.mjs";
+import { a as option, i as groups, n as filters, o as options, r as globalOptions, s as usage, t as commands } from "./commands-L1JSGz2Z.mjs";
 export { commands, filters, globalOptions, groups, option, options, usage };

package/dist/cli-embedded.d.mts

@@ -1,5 +1,5 @@
-import { d as Board } from "./backend-n3hajfrD.mjs";
-import "./index-BygAXP7t.mjs";
+import { f as Board } from "./backend-Bob-5CM7.mjs";
+import "./index-Ho-ayyQL.mjs";
 //#region src/cli/failure.d.ts
 /**
  * What kind of failure it is, which fixes the exit code: 2 for `usage` and `missing_input`, 130

package/dist/cli-embedded.mjs

@@ -1,4 +1,4 @@
-import { a as commandLine, c as failureLines, i as mainWith, l as formatFailure, n as commandWord, o as exitCode, r as main, s as failureDocument, t as Failed } from "./main-D2s-QBOK.mjs";
+import { a as commandLine, c as failureLines, i as mainWith, l as formatFailure, n as commandWord, o as exitCode, r as main, s as failureDocument, t as Failed } from "./main-Dz-8komG.mjs";
 //#region src/cli/embedded.ts
 /**
 * Board's CLI as `appName` names it in help, usage, and errors (`vercel board`). With no board

package/dist/cli.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import "./schemas-DBmUO6pr.mjs";
-import { a as option } from "./commands-B5DHjZKK.mjs";
-import { l as projectDir } from "./node-D8Rtg1su.mjs";
-import { r as main, u as who } from "./main-D2s-QBOK.mjs";
+import { a as option } from "./commands-L1JSGz2Z.mjs";
+import { l as projectDir } from "./node-BgeGcwX0.mjs";
+import { r as main, u as who } from "./main-Dz-8komG.mjs";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { appendFile, readFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -661,7 +661,7 @@ const local = {
 			if (args.length > 0) throw usage("serve takes no arguments: pass its port with --port, and its directory with --dir.");
 			const port = portFlag();
 			const root = projectDir();
-			const { localHandle, serveLocal } = await import("./serve-lPoBDEds.mjs");
+			const { localHandle, serveLocal } = await import("./serve-CTmow-YH.mjs");
 			const handle = flags.handle ?? process.env.BOARD_HANDLE;
 			const local = await serveLocal({
 				dir: flags.dir ?? join(root, ".board"),