@vercel/board 0.21.1 → 0.22.0

package/dist/{a2-_m1s1wSE.mjs → a2--b1bfuDd.mjs}

@@ -1,7 +1,7 @@
 import { n as DIRECT_UPLOAD_BYTES_MAX, r as IMPORT_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import { _ as RemoteWatcherId, b as actorKind, i as Attachment, x as platformAvatar } from "./schemas-Be08nyfW.mjs";
 import "./external-BV_cUncs.mjs";
-import { f as VERSION, n as compileWatcher, o as METHODS, p as SYNC, r as hasCriteria, t as canonicalWatchers } from "./watchers-hash-BMvgVhPV.mjs";
+import { a as METHODS, d as VERSION, f as SYNC, n as compileWatcher, r as hasCriteria, t as canonicalWatchers } from "./watchers-hash-D_VYDwvu.mjs";
 import { r as duration, t as BoardError } from "./client-ClznIBMg.mjs";
 import { n as derivedId, r as isKeyIdOf } from "./ids-C6AYo1bu.mjs";
 import { a as forbidden, c as toErrorResponse, i as duplicateId, r as badRequest, s as notFound, t as HttpError } from "./errors-CQ-fwxM3.mjs";

package/dist/backend-a2.mjs

@@ -1,2 +1,2 @@
-import { n as fsBlob, r as memoryBlob, t as a2 } from "./a2-_m1s1wSE.mjs";
+import { n as fsBlob, r as memoryBlob, t as a2 } from "./a2--b1bfuDd.mjs";
 export { a2, fsBlob, memoryBlob };

package/dist/{backend-http-BvZqHIkS.mjs → backend-http-C8Qyk3vj.mjs}

@@ -1,6 +1,6 @@
 import "./files-SniSmeEr.mjs";
 import "./schemas-Be08nyfW.mjs";
-import { k as RegisterBody, n as compileWatcher, o as METHODS, q as routes, t as canonicalWatchers } from "./watchers-hash-BMvgVhPV.mjs";
+import { K as routes, O as RegisterBody, a as METHODS, n as compileWatcher, t as canonicalWatchers } from "./watchers-hash-D_VYDwvu.mjs";
 import { n as createBoardClient, t as BoardError } from "./client-ClznIBMg.mjs";
 import { a as sha256, i as keyId, n as derivedId, t as DERIVED_ID } from "./ids-C6AYo1bu.mjs";
 import { a as forbidden, o as json, t as HttpError } from "./errors-CQ-fwxM3.mjs";

package/dist/{backend-http-BYfh45ZM.mjs → backend-http-DM1T_CP6.mjs}

@@ -1,4 +1,4 @@
-import { r as createHttp } from "./backend-http-BvZqHIkS.mjs";
+import { r as createHttp } from "./backend-http-C8Qyk3vj.mjs";
 import { i as environmentProfile, r as connect, t as boardUrl } from "./node-BeKPcokJ.mjs";
 //#region src/backend-http/index.ts
 const environment = {

package/dist/backend-http.mjs

@@ -1,2 +1,2 @@
-import { t as http } from "./index.default-B0rK6NS5.mjs";
+import { t as http } from "./index.default-B8R696fX.mjs";
 export { http };

package/dist/backend-http.node.mjs

@@ -1,2 +1,2 @@
-import { t as http } from "./backend-http-BYfh45ZM.mjs";
+import { t as http } from "./backend-http-DM1T_CP6.mjs";
 export { http };

package/dist/{backend-vercel-C-AGfm88.mjs → backend-vercel-IEtvtvuH.mjs}

@@ -1,6 +1,6 @@
 import { t as HttpError } from "./errors-CQ-fwxM3.mjs";
 import { c as vercelLogin, i as environmentProfile, l as vercelProjectFile } from "./node-BeKPcokJ.mjs";
-import { t as createVercel } from "./backend-vercel-DRl9xzAj.mjs";
+import { t as createVercel } from "./backend-vercel-zo3wg4nM.mjs";
 import { readFile } from "node:fs/promises";
 import { decodeJwt } from "jose";
 import { getVercelOidcToken } from "@vercel/oidc";

package/dist/{backend-vercel-DRl9xzAj.mjs → backend-vercel-zo3wg4nM.mjs}

@@ -1,8 +1,8 @@
 import { _ as RemoteWatcherId } from "./schemas-Be08nyfW.mjs";
-import { f as VERSION, k as RegisterBody, n as compileWatcher, o as METHODS, t as canonicalWatchers } from "./watchers-hash-BMvgVhPV.mjs";
+import { O as RegisterBody, a as METHODS, d as VERSION, n as compileWatcher, t as canonicalWatchers } from "./watchers-hash-D_VYDwvu.mjs";
 import { a as sha256, n as derivedId } from "./ids-C6AYo1bu.mjs";
 import { a as forbidden, o as json, s as notFound, t as HttpError } from "./errors-CQ-fwxM3.mjs";
-import { a as wakePath, i as registrant, n as callerProfile, t as PROJECTS_OWN } from "./backend-http-BvZqHIkS.mjs";
+import { a as wakePath, i as registrant, n as callerProfile, t as PROJECTS_OWN } from "./backend-http-C8Qyk3vj.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}$/;
@@ -253,6 +253,51 @@ function createVercel(options, environment) {
 		for (const reaction of await all(who, path, "reactions")) (out[reaction.emoji] ??= []).push(reaction.actor.id);
 		return out;
 	}
+	/** Who's written here, by actor ID, as the API names them: messages carry only the actor. */
+	let actorNames = null;
+	/** How long names are kept before they're read again: someone renamed shows by their new name after this. */
+	const NAMES_FRESH_MS = 3e5;
+	/** Actors a list read again for them didn't have: it isn't read again for them. */
+	const unlisted = /* @__PURE__ */ new Set();
+	/** Reads the list, kept as the current one; a read that fails isn't kept, so the next name tries again. */
+	const readNames = (who) => {
+		const views = (async () => new Map((await all(who, await onBoard(who, "/actors"), "actors")).map((view) => [view.id, view])))();
+		const read = {
+			at: Date.now(),
+			views
+		};
+		actorNames = read;
+		views.catch(() => {
+			if (actorNames === read) actorNames = null;
+		});
+		return read;
+	};
+	/** The actor in a read of the list, or undefined when it doesn't have them or failed. */
+	const inList = (read, id) => read.views.then((views) => views.get(id), () => void 0);
+	/**
+	* An actor as board shows them: a person by their Vercel username and name, and an agent acting
+	* for a person by its profile under them, as the API names them; anyone else (a project, an app,
+	* an agent of one), or someone the API doesn't list, by their principal. The list is read again
+	* every few minutes, and at once for someone who wrote since it was.
+	*/
+	async function nameOf(who, actor) {
+		const current = !actorNames || Date.now() - actorNames.at > NAMES_FRESH_MS ? readNames(who) : actorNames;
+		let found = await inList(current, actor.id);
+		if (!found && !unlisted.has(actor.id)) {
+			const again = actorNames && actorNames !== current ? actorNames : readNames(who);
+			found = await inList(again, actor.id);
+			if (!found && await again.views.then(() => true, () => false)) unlisted.add(actor.id);
+		}
+		const kind = found && apiKind(found.kind);
+		if (!found || !(kind === "person" || kind === "agent" && actor.principal.type === "user")) return actorView(actor);
+		return {
+			id: actor.id,
+			kind,
+			handle: found.handle,
+			name: found.name ?? found.handle,
+			avatar: found.avatar ?? null
+		};
+	}
 	async function view(who, message, channel) {
 		const root = message.sequence === 1;
 		return {
@@ -276,7 +321,7 @@ function createVercel(options, environment) {
 			attachments: [],
 			links: [],
 			version: message.version,
-			author: actorView(message.createdBy)
+			author: await nameOf(who, message.createdBy)
 		};
 	}
 	const positions = /* @__PURE__ */ new Map();
@@ -566,7 +611,7 @@ function createVercel(options, environment) {
 			createdAt: iso(change.createdAt),
 			payload,
 			message,
-			actor: actorView(change.actor)
+			actor: await nameOf(who, change.actor)
 		};
 	}
 	/**
@@ -930,11 +975,13 @@ function createVercel(options, environment) {
 				session: null
 			};
 			const team = await teamId();
+			if (options.board) await api(who, "GET", await onBoard(who));
+			const id = team?.startsWith("team_") ? team : (await self(who)).teamId;
 			return {
 				version: VERSION,
-				url: `${origin}/v1/messageboard${await onBoard(who)}`,
+				url: `${origin}/v1/messageboard${await onBoard(who)}?teamId=${encodeURIComponent(id)}`,
 				audience: origin,
-				team_id: team?.startsWith("team_") ? team : (await self(who)).teamId,
+				team_id: id,
 				project_id: null,
 				sync: [],
 				wake_by_path: true

package/dist/backend-vercel.mjs

@@ -1,4 +1,4 @@
-import { t as createVercel } from "./backend-vercel-DRl9xzAj.mjs";
+import { t as createVercel } from "./backend-vercel-zo3wg4nM.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.mjs

@@ -1,2 +1,2 @@
-import { n as vercel, t as credentialSource } from "./backend-vercel-C-AGfm88.mjs";
+import { n as vercel, t as credentialSource } from "./backend-vercel-IEtvtvuH.mjs";
 export { credentialSource, vercel };

package/dist/cli-commands.d.mts

@@ -0,0 +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-D0wXq6CY.mjs";
+export { CliArgument, CliCommand, CliExample, CliOption, OptionName, commands, filters, globalOptions, groups, option, options, usage };

package/dist/cli-commands.mjs

@@ -0,0 +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-D_ODblQY.mjs";
+export { commands, filters, globalOptions, groups, option, options, usage };

package/dist/cli-embedded.d.mts

@@ -1,7 +1,11 @@
 import { d as Board } from "./backend-CWmd4UH-.mjs";
 import "./index-DsMPCv_K.mjs";
 //#region src/cli/main.d.ts
-/** The command word: the first argument that isn't a flag or a string flag's value (a bare `--mentions` takes none). */
+/**
+ * The command `argv` runs, by its own name (`delete` for `rm`), as the parser reads it: the
+ * first positional, past every flag and value however they're written (`-an 1`, `--limit=1`). A
+ * bare `--mentions` takes none.
+ */
 export declare function commandWord(argv: string[]): string | undefined;
 //#endregion
 //#region src/cli/embedded.d.ts

package/dist/cli-embedded.mjs

@@ -1,4 +1,4 @@
-import { n as main, r as mainWith, t as commandWord } from "./main-CkGrzdD4.mjs";
+import { n as main, r as mainWith, t as commandWord } from "./main-CI5fjlpN.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,8 +1,9 @@
 #!/usr/bin/env node
 import { t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import "./schemas-Be08nyfW.mjs";
+import { a as option } from "./commands-D_ODblQY.mjs";
 import { o as projectDir, s as projectUrl } from "./node-BeKPcokJ.mjs";
-import { i as who, n as main } from "./main-CkGrzdD4.mjs";
+import { i as who, n as main } from "./main-CI5fjlpN.mjs";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -604,68 +605,90 @@ const stopped = () => new Promise((resolve) => {
 	process.once("SIGINT", done);
 	process.once("SIGTERM", done);
 });
-//#endregion
-//#region src/cli/bin.ts
-main(process.argv.slice(2), {
-	name: "board",
-	commands: {
-		inspect: {
-			help: "  inspect [--port N] [--no-open]           the board in your browser, as you: read, post, react (local only)",
-			async run(_args, { flags, out, portFlag, client, openBrowser }) {
-				const port = portFlag();
-				const inspector = await startInspector({
-					client: client(),
-					...port !== void 0 ? { port } : {}
-				});
-				out(`inspecting ${inspector.board} as ${who(inspector.me)} at ${inspector.url}  (Ctrl-C to stop)`);
-				if (!flags["no-open"]) openBrowser(inspector.url);
-				await stopped();
-				await inspector.close();
-				return 0;
-			}
+/** The commands only the standalone `board` has, in the order its help lists them. */
+const local = {
+	inspect: {
+		spec: {
+			name: "inspect",
+			description: "the board in your browser, as you: read, post, react (local only)",
+			arguments: [],
+			options: [option("port", "the port to listen on (default: a free one)"), option("no-open")],
+			examples: [{
+				name: "open the board in your browser",
+				value: "inspect"
+			}]
 		},
-		serve: {
-			help: `  serve [--port N] [--dir <dir>] [--no-inspect] [--no-open]
-                                           run a board on this machine (127.0.0.1:4100, no sync), link this
-                                           project to it, and open the inspector; its log lives in .board/,
-                                           and you're local:user:<your OS user> (or --handle)`,
-			async run(args, { flags, out, usage, portFlag, connection, openBrowser, saveLink, linkedByServe }) {
-				if (args.length > 0) throw usage("usage: board serve [--port N] [--dir <dir>] [--no-inspect] [--no-open]");
-				const port = portFlag();
-				const root = projectDir();
-				const { localHandle, serveLocal } = await import("./serve-C-Ppvvu2.mjs");
-				const handle = flags.handle ?? process.env.BOARD_HANDLE;
-				const local = await serveLocal({
-					dir: flags.dir ?? join(root, ".board"),
-					...port !== void 0 ? { port } : {},
-					...handle ? { handle: localHandle(handle) } : {}
-				});
-				let inspector = null;
-				try {
-					const linked = projectUrl();
-					if (linked === void 0 || linked === local.url || linkedByServe(root)) {
-						await saveLink(root, local.url, { serve: true });
-						if (linked !== local.url) out(`linked ${root} to ${local.url}`);
-					} else out(`${root} stays linked to ${linked}; reach this board with BOARD_URL=${local.url}`);
-					out(`serving a local board at ${local.url} as ${local.principal}, its log in ${local.dir}  (Ctrl-C to stop)`);
-					if (!flags["no-inspect"]) {
-						const { board } = connection(local.url, {
-							token: local.token,
-							handle: local.handle
-						});
-						inspector = await startInspector({ client: board.as(null) });
-						out(`inspector at ${inspector.url}`);
-						if (!flags["no-open"]) openBrowser(inspector.url);
-					}
-					await stopped();
-				} finally {
-					await inspector?.close();
-					await local.close();
+		async run(_args, { flags, out, portFlag, client, openBrowser }) {
+			const port = portFlag();
+			const inspector = await startInspector({
+				client: client(),
+				...port !== void 0 ? { port } : {}
+			});
+			out(`inspecting ${inspector.board} as ${who(inspector.me)} at ${inspector.url}  (Ctrl-C to stop)`);
+			if (!flags["no-open"]) openBrowser(inspector.url);
+			await stopped();
+			await inspector.close();
+			return 0;
+		}
+	},
+	serve: {
+		spec: {
+			name: "serve",
+			description: "run a board on this machine (127.0.0.1:4100, no sync), link this project to it, and open the inspector; its log lives in .board/, and you're local:user:<your OS user> (or --handle)",
+			arguments: [],
+			options: [
+				option("port", "the port to listen on (default: 4100)"),
+				option("dir"),
+				option("no-inspect"),
+				option("no-open")
+			],
+			examples: [{
+				name: "run a board here, and open it",
+				value: "serve"
+			}]
+		},
+		async run(args, { flags, out, usage, portFlag, connection, openBrowser, saveLink, linkedByServe }) {
+			if (args.length > 0) throw usage("usage: board serve [--port N] [--dir <dir>] [--no-inspect] [--no-open]");
+			const port = portFlag();
+			const root = projectDir();
+			const { localHandle, serveLocal } = await import("./serve-DjnbMvu9.mjs");
+			const handle = flags.handle ?? process.env.BOARD_HANDLE;
+			const local = await serveLocal({
+				dir: flags.dir ?? join(root, ".board"),
+				...port !== void 0 ? { port } : {},
+				...handle ? { handle: localHandle(handle) } : {}
+			});
+			let inspector = null;
+			try {
+				const linked = projectUrl();
+				if (linked === void 0 || linked === local.url || linkedByServe(root)) {
+					await saveLink(root, local.url, { serve: true });
+					if (linked !== local.url) out(`linked ${root} to ${local.url}`);
+				} else out(`${root} stays linked to ${linked}; reach this board with BOARD_URL=${local.url}`);
+				out(`serving a local board at ${local.url} as ${local.principal}, its log in ${local.dir}  (Ctrl-C to stop)`);
+				if (!flags["no-inspect"]) {
+					const { board } = connection(local.url, {
+						token: local.token,
+						handle: local.handle
+					});
+					inspector = await startInspector({ client: board.as(null) });
+					out(`inspector at ${inspector.url}`);
+					if (!flags["no-open"]) openBrowser(inspector.url);
 				}
-				return 0;
+				await stopped();
+			} finally {
+				await inspector?.close();
+				await local.close();
 			}
+			return 0;
 		}
 	}
+};
+//#endregion
+//#region src/cli/bin.ts
+main(process.argv.slice(2), {
+	name: "board",
+	commands: local
 }).then(exit, (error) => {
 	process.stderr.write(`error: ${error.message}\n`);
 	exit(1);

package/dist/commands-D0wXq6CY.d.mts

@@ -0,0 +1,268 @@
+//#region src/cli/commands.d.ts
+/** An option, as the parser takes it (`type`, `short`, `multiple`) and as help shows it. */
+type CliOption = {
+  readonly name: string;
+  readonly type: 'string' | 'boolean';
+  readonly short?: string;
+  /** It can be given more than once; each adds a value. */
+  readonly multiple?: true;
+  /** What it takes, as help shows it: `N`, `k=v`. A boolean takes nothing. */
+  readonly value?: string;
+  /** It may be given alone, without its value, as a bare `--mentions` means mentions of you. */
+  readonly optionalValue?: true;
+  readonly description: string;
+  /** Kept for what still passes it, out of help. */
+  readonly hidden?: true;
+};
+type CliArgument = {
+  readonly name: string;
+  readonly required: boolean;
+  /** It takes one or more (or, optional, zero or more). */
+  readonly multiple?: true;
+  readonly description?: string;
+};
+/** A command line that does a job, as it follows the CLI's name (`read dev`). */
+type CliExample = {
+  readonly name: string;
+  readonly value: string;
+};
+type CliCommand = {
+  readonly name: string;
+  /** Other names it runs by: `rm` for `delete`. */
+  readonly aliases?: readonly string[];
+  readonly description: string;
+  readonly arguments: readonly CliArgument[];
+  /** Its own options: the filters (with `filters`) and the global options apply too. */
+  readonly options: readonly CliOption[];
+  /** It takes the filters (`--re`, `--by`, `--label`, …) as well. */
+  readonly filters?: true;
+  readonly examples: readonly CliExample[];
+  readonly subcommands?: readonly CliCommand[];
+  /** Its arguments come before its subcommand, as in `sources <key> read <target>`. */
+  readonly argumentsBeforeSubcommand?: true;
+  /** It does something without a subcommand too, as `identity` lists your links. */
+  readonly runsWithoutSubcommand?: true;
+  /** Out of help: it still runs, for what calls it. */
+  readonly hidden?: true;
+};
+/** Every option, by name: what the parser accepts, and what each means where a command doesn't say more. */
+declare const options: {
+  readonly re: {
+    readonly type: 'string';
+    readonly value: 'id';
+    readonly description: "in a thread: its root's ID";
+  };
+  readonly by: {
+    readonly type: 'string';
+    readonly value: 'handle';
+    readonly description: 'by an author: a handle, me, or an actor ID';
+  };
+  readonly mentions: {
+    readonly type: 'string';
+    readonly value: '@handle';
+    readonly optionalValue: true;
+    readonly description: 'mentioning a handle, or you without one';
+  };
+  readonly label: {
+    readonly type: 'string';
+    readonly multiple: true;
+    readonly value: 'k[=v|w]';
+    readonly description: "with a label on the message or its thread's root";
+  };
+  readonly from: {
+    readonly type: 'string';
+    readonly value: 'source';
+    readonly description: 'from a source: a sync key such as slack, or board';
+  };
+  readonly text: {
+    readonly type: 'string';
+    readonly value: 'words';
+    readonly description: 'containing these words';
+  };
+  readonly after: {
+    readonly type: 'string';
+    readonly value: 'id';
+    readonly description: 'after a message or a cursor';
+  };
+  readonly url: {
+    readonly type: 'string';
+    readonly value: 'url';
+    readonly description: "the board at this URL, not the one the environment points at";
+  };
+  readonly scope: {
+    readonly type: 'string';
+    readonly value: 'team';
+    readonly description: "a team's board in Vercel's API, by its slug or ID";
+  };
+  readonly team: {
+    readonly type: 'string';
+    readonly value: 'team';
+    readonly description: 'the same as --scope';
+    readonly hidden: true;
+  };
+  readonly as: {
+    readonly type: 'string';
+    readonly value: 'profile';
+    readonly description: "write as a profile, such as an agent's name";
+  };
+  readonly avatar: {
+    readonly type: 'string';
+    readonly value: 'url';
+    readonly description: "the profile's avatar, with --as";
+  };
+  readonly human: {
+    readonly type: 'boolean';
+    readonly description: 'write as yourself, with no profile or session';
+  };
+  readonly handle: {
+    readonly type: 'string';
+    readonly value: 'h';
+    readonly description: 'your handle (default: your Vercel username)';
+  };
+  readonly json: {
+    readonly type: 'boolean';
+    readonly description: 'one JSON object per line, for programs';
+  };
+  readonly help: {
+    readonly type: 'boolean';
+    readonly short: 'h';
+    readonly description: "this help, or a command's";
+  };
+  readonly version: {
+    readonly type: 'boolean';
+    readonly short: 'v';
+    readonly description: "the CLI's version";
+  };
+  readonly limit: {
+    readonly type: 'string';
+    readonly short: 'n';
+    readonly value: 'N';
+    readonly description: 'how many';
+  };
+  readonly id: {
+    readonly type: 'string';
+    readonly value: 'key';
+    readonly description: 'a client ID: sending the same one again posts once';
+  };
+  readonly sync: {
+    readonly type: 'string';
+    readonly multiple: true;
+    readonly value: 'target';
+    readonly description: 'sync the new thread to a target too, e.g. slack:#incidents';
+  };
+  readonly 'no-sync': {
+    readonly type: 'boolean';
+    readonly description: 'keep it on the board: sync it nowhere';
+  };
+  readonly attach: {
+    readonly type: 'string';
+    readonly multiple: true;
+    readonly value: 'file';
+    readonly description: 'attach a file';
+  };
+  readonly unset: {
+    readonly type: 'string';
+    readonly multiple: true;
+    readonly value: 'k';
+    readonly description: 'remove a label';
+  };
+  readonly channel: {
+    readonly type: 'string';
+    readonly value: 'c';
+    readonly description: 'in a channel';
+  };
+  readonly remove: {
+    readonly type: 'boolean';
+    readonly description: 'take the reaction back';
+  };
+  readonly all: {
+    readonly type: 'boolean';
+    readonly short: 'a';
+    readonly description: 'everything, not only what most want';
+  };
+  readonly timeout: {
+    readonly type: 'string';
+    readonly value: 'duration';
+    readonly description: 'how long to wait (default: 30m)';
+  };
+  readonly code: {
+    readonly type: 'boolean';
+    readonly description: 'post a code from your account instead of signing in';
+  };
+  readonly 'no-wait': {
+    readonly type: 'boolean';
+    readonly description: "start linking, and don't wait for it to finish";
+  };
+  readonly 'no-open': {
+    readonly type: 'boolean';
+    readonly description: "don't open the browser";
+  };
+  readonly in: {
+    readonly type: 'string';
+    readonly value: 'duration';
+    readonly description: 'once, this long from now, e.g. 1d';
+  };
+  readonly at: {
+    readonly type: 'string';
+    readonly value: 'time';
+    readonly description: 'at a time: once, or with --every, the first';
+  };
+  readonly every: {
+    readonly type: 'string';
+    readonly value: 'duration';
+    readonly description: 'repeating at this interval, e.g. 30m';
+  };
+  readonly until: {
+    readonly type: 'string';
+    readonly short: 'u';
+    readonly value: 'time';
+    readonly description: 'repeating until a time';
+  };
+  readonly for: {
+    readonly type: 'string';
+    readonly value: 'duration';
+    readonly description: 'repeating for this long, e.g. 24h';
+  };
+  readonly times: {
+    readonly type: 'string';
+    readonly value: 'N';
+    readonly description: 'repeating this many times';
+  };
+  readonly port: {
+    readonly type: 'string';
+    readonly value: 'N';
+    readonly description: 'the port to listen on';
+  };
+  readonly dir: {
+    readonly type: 'string';
+    readonly value: 'dir';
+    readonly description: 'where the board keeps its log (default: .board/)';
+  };
+  readonly 'no-inspect': {
+    readonly type: 'boolean';
+    readonly description: "don't start the inspector";
+  };
+  readonly agent: {
+    readonly type: 'string';
+    readonly value: 'name';
+    readonly description: "the agent whose turn ended";
+    readonly hidden: true;
+  };
+};
+type OptionName = keyof typeof options;
+/** The option `name`, saying `description` (and taking `value`) where it means something particular to a command. */
+declare const option: (name: OptionName, description?: string, value?: string) => CliOption;
+/** What `read`, `tail`, and `wait` match: every one given must hold. */
+declare const filters: readonly CliOption[];
+/** What every command takes. */
+declare const globalOptions: readonly CliOption[];
+/** What one of the CLI's help pages lists together, in this order. */
+declare const groups: readonly ['you', 'the board', 'messages', 'agents', 'live'];
+/** Board's commands, by `groups`, in the order its help lists them. */
+declare const commands: readonly (CliCommand & {
+  readonly group: (typeof groups)[number];
+})[];
+/** One line of `usage`: a command's path and its arguments, as `<required>` and `[optional]`. */
+declare function usage(path: readonly CliCommand[]): string;
+//#endregion
+export { OptionName as a, globalOptions as c, options as d, usage as f, CliOption as i, groups as l, CliCommand as n, commands as o, CliExample as r, filters as s, CliArgument as t, option as u };