@vercel/board 0.0.0 → 0.15.0

package/dist/reducers-mUPFuFJV.mjs

@@ -0,0 +1,293 @@
+import { b as actorKind } from "./schemas-Be08nyfW.mjs";
+import { f as boardContract, p as identityContract } from "./contract-CuJmlrhw.mjs";
+import { t as canonicalEmoji } from "./emoji-CTLpvH-A.mjs";
+import { n as setOwn, t as own } from "./own-OwgPWdmh.mjs";
+import { reducer } from "experimental-a2";
+//#region src/contract/reducers.ts
+const iso = (date) => typeof date === "string" ? date : date.toISOString();
+function foldMessages(state, event) {
+	const changed = foldMessage(state, event);
+	if (changed) changed.version = event.index;
+	return state;
+}
+/** Applies `event`, and returns the message it changed: none for an event that changes nothing. */
+function foldMessage(state, event) {
+	switch (event.type) {
+		case "message.posted": {
+			const { payload } = event;
+			const message = {
+				id: event.index,
+				channel: payload.channel,
+				text: payload.text,
+				re: payload.re,
+				replyTo: payload.replyTo,
+				thread: payload.thread,
+				labels: { ...payload.labels },
+				reactions: {},
+				mentions: payload.mentions,
+				by: payload.by,
+				noSync: payload.noSync,
+				origin: payload.origin,
+				from: payload.from,
+				createdAt: iso(event.createdAt),
+				editedAt: null,
+				deleted: false,
+				undelivered: {},
+				attachments: payload.attachments ?? [],
+				links: payload.links ?? [],
+				...payload.schedule ? { schedule: { ...payload.schedule } } : {},
+				...payload.blind ? { blind: true } : {}
+			};
+			state.byId[event.index] = message;
+			if (payload.re !== null) (state.replies[payload.re] ??= []).push(event.index);
+			return message;
+		}
+		case "message.edited": {
+			const message = state.byId[event.payload.id];
+			if (!message || message.deleted) return void 0;
+			message.text = event.payload.text;
+			message.mentions = event.payload.mentions;
+			message.editedAt = iso(event.createdAt);
+			return message;
+		}
+		case "message.deleted": {
+			const message = state.byId[event.payload.id];
+			if (!message || message.deleted) return void 0;
+			message.deleted = true;
+			message.text = "";
+			message.reactions = {};
+			message.mentions = [];
+			message.attachments = [];
+			message.links = [];
+			return message;
+		}
+		case "reaction.added": {
+			const message = state.byId[event.payload.id];
+			if (!message || message.deleted) return void 0;
+			const emoji = canonicalEmoji(event.payload.emoji);
+			const actors = own(message.reactions, emoji);
+			if (actors?.includes(event.payload.by.actor)) return void 0;
+			if (actors) actors.push(event.payload.by.actor);
+			else setOwn(message.reactions, emoji, [event.payload.by.actor]);
+			return message;
+		}
+		case "reaction.removed": {
+			const message = state.byId[event.payload.id];
+			if (!message || message.deleted) return void 0;
+			const { by } = event.payload;
+			const emoji = canonicalEmoji(event.payload.emoji);
+			const had = own(message.reactions, emoji);
+			if (!had?.includes(by.actor)) return void 0;
+			const actors = had.filter((a) => a !== by.actor);
+			if (actors.length > 0) setOwn(message.reactions, emoji, actors);
+			else delete message.reactions[emoji];
+			return message;
+		}
+		case "labels.changed": {
+			const message = state.byId[event.payload.id];
+			if (!message || message.deleted) return void 0;
+			for (const [key, value] of Object.entries(event.payload.set)) setOwn(message.labels, key, value);
+			for (const key of event.payload.unset) delete message.labels[key];
+			return message;
+		}
+		case "message.linked": {
+			const message = state.byId[event.payload.id];
+			if (!message || message.deleted) return void 0;
+			message.links = event.payload.links;
+			return message;
+		}
+		case "message.sync_failed": {
+			const message = state.byId[event.payload.id];
+			if (!message) return void 0;
+			setOwn(message.undelivered, event.payload.target, event.payload.error);
+			return message;
+		}
+		case "message.synced": {
+			const message = state.byId[event.payload.id];
+			if (!message || !Object.hasOwn(message.undelivered, event.payload.target)) return void 0;
+			delete message.undelivered[event.payload.target];
+			return message;
+		}
+		default: return;
+	}
+}
+const messagesReducer = reducer({
+	contract: boardContract,
+	name: "board.messages.v5",
+	initialState: {
+		byId: {},
+		replies: {}
+	}
+}).fold(foldMessages);
+reducer({
+	contract: boardContract,
+	name: "board.posted.v1",
+	initialState: {}
+}).fold((state, event) => {
+	if (event.type === "message.posted") setOwn(state, event.id, event.index);
+	return state;
+});
+const channelsReducer = reducer({
+	contract: boardContract,
+	name: "board.channels.v1",
+	initialState: {}
+}).fold((state, event) => {
+	if (event.type !== "message.posted") return state;
+	const { channel, re } = event.payload;
+	const entry = own(state, channel) ?? setOwn(state, channel, {
+		path: channel,
+		lastIndex: 0,
+		messages: 0,
+		threads: 0
+	});
+	entry.lastIndex = event.index;
+	entry.messages += 1;
+	if (re === null) entry.threads += 1;
+	return state;
+});
+/** The principal an actor belongs to: its link, its own principal for a profile (`…+claude`), or itself. */
+function personOf(actors, actor) {
+	const linked = own(actors.links, actor)?.to;
+	if (linked) return linked;
+	const plus = actor.indexOf("+");
+	return plus === -1 ? actor : actor.slice(0, plus);
+}
+/** The platform actors linked to `principal`. */
+const linkedTo = (actors, principal) => Object.entries(actors.links).filter(([, link]) => link.to === principal).map(([actor]) => actor);
+function foldActors(state, event) {
+	if (event.type === "actor.linked") {
+		setOwn(state.links, event.payload.actor, {
+			to: event.payload.to,
+			method: event.payload.method,
+			at: iso(event.createdAt)
+		});
+		return state;
+	}
+	if (event.type === "actor.unlinked") {
+		delete state.links[event.payload.actor];
+		return state;
+	}
+	if (event.type !== "actor.seen") return state;
+	const { actor, kind, handle, name, avatar, host } = event.payload;
+	const previous = own(state.byId, actor);
+	if (previous) {
+		const key = previous.handle.toLowerCase();
+		const remaining = (own(state.byHandle, key) ?? []).filter((id) => id !== actor);
+		if (remaining.length > 0) setOwn(state.byHandle, key, remaining);
+		else delete state.byHandle[key];
+	}
+	setOwn(state.byId, actor, {
+		id: actor,
+		kind: actorKind(kind),
+		handle,
+		name,
+		avatar,
+		...host || previous?.host ? { host: true } : {}
+	});
+	const key = handle.toLowerCase();
+	const ids = own(state.byHandle, key) ?? setOwn(state.byHandle, key, []);
+	if (!ids.includes(actor)) ids.push(actor);
+	return state;
+}
+const actorsReducer = reducer({
+	contract: boardContract,
+	name: "board.actors.v2",
+	initialState: {
+		byId: {},
+		byHandle: {},
+		links: {}
+	}
+}).fold(foldActors);
+/** `slack:C0123ABC:1727.1234` is a thread; `slack:C0123ABC` and `github:owner/repo` are channels. */
+const isThreadTarget = (target) => target.slice(target.indexOf(":") + 1).includes(":");
+const externalMessageKey = (thread, message) => `${thread}|${message}`;
+const addTarget = (thread, target) => {
+	if (!thread.targets.includes(target)) thread.targets.push(target);
+};
+function foldSync(state, event) {
+	switch (event.type) {
+		case "message.posted": {
+			const { payload } = event;
+			if (payload.re === null) setOwn(state.threads, payload.thread, {
+				root: event.index,
+				channel: payload.channel,
+				targets: [],
+				external: {}
+			});
+			const origin = payload.origin;
+			if (!origin) return state;
+			const thread = own(state.threads, payload.thread);
+			if (thread && payload.re === null) {
+				addTarget(thread, origin.thread);
+				setOwn(thread.kinds ??= {}, origin.thread, "thread");
+				setOwn(thread.external, origin.thread, origin.thread);
+				setOwn(state.byExternalThread, origin.thread, payload.thread);
+			}
+			const precise = origin.subthread ?? origin.thread;
+			setOwn(state.copies[event.index] ??= {}, origin.thread, {
+				thread: precise,
+				message: origin.message,
+				...payload.importedBy ? { by: payload.importedBy } : {}
+			});
+			state.byExternalMessage[externalMessageKey(precise, origin.message)] = event.index;
+			return state;
+		}
+		case "thread.synced": {
+			const thread = own(state.threads, event.payload.thread);
+			if (!thread) return state;
+			addTarget(thread, event.payload.target);
+			if (event.payload.kind) setOwn(thread.kinds ??= {}, event.payload.target, event.payload.kind);
+			if ((event.payload.kind ?? (isThreadTarget(event.payload.target) ? "thread" : "channel")) === "thread") {
+				setOwn(thread.external, event.payload.target, event.payload.target);
+				setOwn(state.byExternalThread, event.payload.target, event.payload.thread);
+			}
+			return state;
+		}
+		case "message.files_synced": {
+			const copies = state.copies[event.payload.id];
+			const copy = copies && own(copies, event.payload.target);
+			if (copy && copy.by === event.payload.syncedBy) copy.files = event.payload.files;
+			return state;
+		}
+		case "message.synced": {
+			const { id, target, external, syncedBy } = event.payload;
+			setOwn(state.copies[id] ??= {}, target, {
+				...external,
+				...syncedBy ? { by: syncedBy } : {}
+			});
+			state.byExternalMessage[externalMessageKey(external.thread, external.message)] = id;
+			const thread = own(state.threads, event.payload.thread);
+			if (thread && thread.root === id && ((thread.kinds && own(thread.kinds, target)) ?? (isThreadTarget(target) ? "thread" : "channel")) === "channel") {
+				setOwn(thread.external, target, external.thread);
+				setOwn(state.byExternalThread, external.thread, event.payload.thread);
+			}
+			return state;
+		}
+		default: return state;
+	}
+}
+const identityCodesReducer = reducer({
+	contract: identityContract,
+	name: "board.identity-codes.v1",
+	initialState: {}
+}).fold((state, event) => {
+	if (event.type === "identity.code_issued") {
+		const { hash, principal, sync, expiresAt } = event.payload;
+		state[hash] ??= {
+			principal,
+			sync,
+			expiresAt,
+			usedBy: null,
+			usedIn: null
+		};
+	} else if (event.type === "identity.code_used") {
+		const code = state[event.payload.hash];
+		if (code && code.usedBy === null) {
+			code.usedBy = event.payload.actor;
+			code.usedIn = event.payload.message ?? null;
+		}
+	}
+	return state;
+});
+//#endregion
+export { foldMessages as a, isThreadTarget as c, messagesReducer as d, personOf as f, foldActors as i, iso as l, channelsReducer as n, foldSync as o, externalMessageKey as r, identityCodesReducer as s, actorsReducer as t, linkedTo as u };

package/dist/schemas-Be08nyfW.mjs

@@ -0,0 +1,74 @@
+import { z } from "zod";
+//#region src/contract/schemas.ts
+const CHANNEL_PATH_MAX = 80;
+const MESSAGE_TEXT_MAX = 1e4;
+/** The longest `x-board-scope` header the board reads; a schedule keeps its creator's. */
+const SCOPE_MAX = 4e3;
+const ATTACHMENTS_PER_MESSAGE_MAX = 10;
+const segment = "[a-z0-9][a-z0-9_-]*";
+/** `errors-www`, `www/production`: lowercase segments joined by `/`. */
+const ChannelPath = z.string().max(80).regex(new RegExp(`^${segment}(?:/${segment})*$`), "invalid channel path");
+/**
+* No board string holds a NUL, which Postgres can't store, or a lone surrogate,
+* which no store keeps as it was: requests with one are refused, and sync
+* cleans what platforms send.
+*/
+const storable = (value) => !value.includes("\0") && value.isWellFormed();
+/** `value` as the board keeps it, for what comes in from a platform: without NUL, and a lone surrogate as U+FFFD. */
+const toStorable = (value) => value.replaceAll("\0", "").toWellFormed();
+const MessageText = z.string().max(MESSAGE_TEXT_MAX).refine((text) => text.trim().length > 0, "message text is empty").refine(storable, "message text has a NUL character or a lone surrogate");
+/** A message is named by the log index of its `message.posted` event. */
+const MessageId = z.number().int().positive();
+/**
+* Names every object has (`constructor`, `__proto__`), and `prototype`. Emoji and label keys are
+* keys of plain objects, where these would read what an object inherits, so neither takes one.
+*/
+const INHERITED = /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(Object.prototype), "prototype"]);
+const notInherited = (name) => !INHERITED.has(name);
+const LabelKey = z.string().max(64).regex(/^[a-z0-9][a-z0-9_.-]*$/, "invalid label key").refine(notInherited, "label key is a reserved name");
+const LabelValue = z.string().max(256).refine(storable, "label value has a NUL character or a lone surrogate");
+const Labels = z.record(LabelKey, LabelValue);
+/** Normalized short names, as Chat SDK names them: `eyes`, `check`, `thumbs_up`. */
+const Emoji = z.string().max(64).regex(/^[a-z0-9_+-]+$/, "invalid emoji name").refine(notInherited, "emoji name is a reserved name");
+/** `vercel:user:u_abc123`, or `vercel:user:u_abc123+claude` for a profile. */
+const ActorId = z.string().min(1).max(256);
+/** What an actor is: a `person`, an `agent` acting for a principal (`--as claude`), a deployment, a workflow, or a platform user (`external`). */
+const ActorKind = z.enum([
+	"person",
+	"agent",
+	"deployment",
+	"workflow",
+	"external"
+]);
+/** `actor.seen` events written before agents were called agents say `profile`. */
+const SeenActorKind = z.union([ActorKind, z.literal("profile")]);
+const actorKind = (kind) => kind === "profile" ? "agent" : kind;
+const Handle = z.string().min(1).max(128).refine(storable, "handle has a NUL character or a lone surrogate");
+/** A platform user's avatar as the board keeps it: an https URL, or none. Anything else shows nowhere. */
+function platformAvatar(avatar) {
+	if (avatar === null) return null;
+	try {
+		return new URL(avatar).protocol === "https:" ? avatar : null;
+	} catch {
+		return null;
+	}
+}
+const Author = z.object({
+	actor: ActorId,
+	principal: z.string().min(1),
+	profile: z.string().nullable(),
+	session: z.string().nullable()
+});
+/** 128 random bits, base64url: an attachment is named by an ID nobody can guess. */
+const AttachmentId = z.string().regex(/^[A-Za-z0-9_-]{22}$/, "invalid attachment id");
+/** A file on a message. The board records `type` and `size` from what it stored, never from the request. */
+const Attachment = z.object({
+	id: AttachmentId,
+	name: z.string().min(1).max(255),
+	type: z.string().min(1).max(255),
+	size: z.number().int().nonnegative()
+});
+/** A registered watcher's ID: a profile name, since its writes are by that profile. */
+const RemoteWatcherId = z.string().regex(/^[A-Za-z][A-Za-z0-9-]{0,31}$/, "ids start with a letter and use up to 32 letters, numbers, and hyphens");
+//#endregion
+export { toStorable as C, storable as S, RemoteWatcherId as _, AttachmentId as a, actorKind as b, ChannelPath as c, LabelKey as d, LabelValue as f, MessageText as g, MessageId as h, Attachment as i, Emoji as l, MESSAGE_TEXT_MAX as m, ActorId as n, Author as o, Labels as p, ActorKind as r, CHANNEL_PATH_MAX as s, ATTACHMENTS_PER_MESSAGE_MAX as t, Handle as u, SCOPE_MAX as v, platformAvatar as x, SeenActorKind as y };

package/dist/schemas-CWxs3ECJ.d.mts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+//#region src/contract/schemas.d.ts
+declare const CHANNEL_PATH_MAX = 80;
+declare const MESSAGE_TEXT_MAX = 10000;
+declare const ATTACHMENTS_PER_MESSAGE_MAX = 10;
+/** `errors-www`, `www/production`: lowercase segments joined by `/`. */
+declare const ChannelPath: z.ZodString;
+declare const MessageText: z.ZodString;
+/** A message is named by the log index of its `message.posted` event. */
+declare const MessageId: z.ZodNumber;
+declare const LabelKey: z.ZodString;
+declare const LabelValue: z.ZodString;
+declare const Labels: z.ZodRecord<z.ZodString, z.ZodString>;
+/** Normalized short names, as Chat SDK names them: `eyes`, `check`, `thumbs_up`. */
+declare const Emoji: z.ZodString;
+/** `vercel:user:u_abc123`, or `vercel:user:u_abc123+claude` for a profile. */
+declare const ActorId: z.ZodString;
+/** What an actor is: a `person`, an `agent` acting for a principal (`--as claude`), a deployment, a workflow, or a platform user (`external`). */
+declare const ActorKind: z.ZodEnum<{
+  agent: "agent";
+  deployment: "deployment";
+  external: "external";
+  person: "person";
+  workflow: "workflow";
+}>;
+declare const Handle: z.ZodString;
+declare const Author: z.ZodObject<{
+  actor: z.ZodString;
+  principal: z.ZodString;
+  profile: z.ZodNullable<z.ZodString>;
+  session: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** 128 random bits, base64url: an attachment is named by an ID nobody can guess. */
+declare const AttachmentId: z.ZodString;
+/** A file on a message. The board records `type` and `size` from what it stored, never from the request. */
+declare const Attachment: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodString;
+  size: z.ZodNumber;
+}, z.core.$strip>;
+type ChannelPath = z.infer<typeof ChannelPath>;
+type MessageId = z.infer<typeof MessageId>;
+type Labels = z.infer<typeof Labels>;
+type ActorId = z.infer<typeof ActorId>;
+type ActorKind = z.infer<typeof ActorKind>;
+type Author = z.infer<typeof Author>;
+type Attachment = z.infer<typeof Attachment>;
+//#endregion
+export { AttachmentId as a, ChannelPath as c, LabelKey as d, LabelValue as f, MessageText as g, MessageId as h, Attachment as i, Emoji as l, MESSAGE_TEXT_MAX as m, ActorId as n, Author as o, Labels as p, ActorKind as r, CHANNEL_PATH_MAX as s, ATTACHMENTS_PER_MESSAGE_MAX as t, Handle as u };

package/dist/serve-Ccbb2LSb.mjs

@@ -0,0 +1,170 @@
+import { o as localTokenFile } from "./backend-http-BsDSgmeo.mjs";
+import { t as board } from "./server-Cxey38B-.mjs";
+import { t as oidcTokens } from "./tokens-DKLn5P9B.mjs";
+import { n as fsBlob, t as a2 } from "./a2-DYGYankn.mjs";
+import { t as localScheduler } from "./local-Cr_dSjvs.mjs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { SignJWT, createLocalJWKSet, exportJWK, generateKeyPair } from "jose";
+import { createServer } from "node:http";
+const ISSUER = "board:local";
+const BODY_MAX = 8388608;
+/** Your OS username as a handle: lowercase letters, digits, `.`, `_`, `-`. */
+function localHandle(name = safeUsername()) {
+	return name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, "").slice(0, 64).replace(/[^a-z0-9]+$/, "") || "me";
+}
+function safeUsername() {
+	try {
+		return userInfo().username;
+	} catch {
+		return process.env.USER || process.env.USERNAME || "me";
+	}
+}
+/**
+* A board on this machine, for agents and people sharing one computer: a log in
+* SQLite under `dir`, attachments next to it, a scheduler in this process, no sync,
+* on 127.0.0.1 only. Its
+* keys live in memory for this run; it signs one token, for you, into a file
+* only you can read (`localTokenFile`), which `vb` on this machine picks up.
+*/
+async function serveLocal(options) {
+	const dir = resolve(options.dir);
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	quietSqliteWarning();
+	const { sqlite } = await import("./backend-a2/store-sqlite.mjs");
+	const store = sqlite({ path: join(dir, "board.db") });
+	const { publicKey, privateKey } = await generateKeyPair("ES256");
+	const jwks = createLocalJWKSet({ keys: [{
+		...await exportJWK(publicKey),
+		kid: "local",
+		alg: "ES256"
+	}] });
+	let handler = null;
+	const server = createServer((request, response) => {
+		if (!handler) return void response.writeHead(503).end();
+		forward(handler, request, response);
+	});
+	let port;
+	try {
+		port = await listen(server, options.port ?? 4100);
+	} catch (error) {
+		await store.close();
+		if (error.code === "EADDRINUSE") throw new Error(`port ${options.port ?? 4100} is taken: is a board already running? Pick another with --port`);
+		throw error;
+	}
+	const url = `http://127.0.0.1:${port}/api/board`;
+	handler = board({
+		backend: a2({
+			store,
+			scheduler: localScheduler(),
+			blob: fsBlob(join(dir, "attachments"))
+		}),
+		authenticate: oidcTokens({ local: {
+			issuer: ISSUER,
+			jwks
+		} }),
+		url,
+		basePath: "/api/board"
+	}).fetch;
+	const handle = options.handle ?? localHandle();
+	const token = await new SignJWT({}).setProtectedHeader({
+		alg: "ES256",
+		kid: "local"
+	}).setIssuer(ISSUER).setAudience(url).setSubject(handle).setIssuedAt().setExpirationTime("30d").sign(privateKey);
+	const file = localTokenFile(url);
+	await mkdir(dirname(file), {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(file, JSON.stringify({
+		url,
+		token,
+		handle
+	}), { mode: 384 });
+	return {
+		url,
+		principal: `local:user:${handle}`,
+		handle,
+		token,
+		dir,
+		async close() {
+			await rm(file, { force: true });
+			server.closeAllConnections();
+			await new Promise((done) => server.close(() => done()));
+			await store.close();
+		}
+	};
+}
+/** Node flags `node:sqlite` as experimental on stderr, which would be the CLI's only stderr line. */
+function quietSqliteWarning() {
+	const emit = process.emitWarning;
+	process.emitWarning = ((warning, ...rest) => {
+		const text = typeof warning === "string" ? warning : warning.message;
+		if (/SQLite is an experimental feature/.test(text)) return;
+		return emit.call(process, warning, ...rest);
+	});
+}
+function listen(server, port) {
+	return new Promise((done, fail) => {
+		server.once("error", fail);
+		server.listen(port, "127.0.0.1", () => {
+			server.off("error", fail);
+			done(server.address().port);
+		});
+	});
+}
+async function forward(handler, req, res) {
+	const controller = new AbortController();
+	res.on("close", () => controller.abort());
+	try {
+		let body;
+		if (req.method !== "GET" && req.method !== "HEAD") {
+			const chunks = [];
+			let size = 0;
+			for await (const chunk of req) {
+				size += chunk.length;
+				if (size > BODY_MAX) {
+					res.writeHead(413, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: {
+						code: "too_large",
+						message: "request too large"
+					} }));
+					return;
+				}
+				chunks.push(chunk);
+			}
+			body = new Uint8Array(Buffer.concat(chunks));
+		}
+		const headers = new Headers();
+		for (const [key, value] of Object.entries(req.headers)) if (typeof value === "string") headers.set(key, value);
+		else if (Array.isArray(value)) for (const item of value) headers.append(key, item);
+		const response = await handler(new Request(`http://${req.headers.host ?? "127.0.0.1"}${req.url ?? "/"}`, {
+			method: req.method ?? "GET",
+			headers,
+			...body && body.length > 0 ? { body } : {},
+			signal: controller.signal
+		}));
+		const out = {};
+		response.headers.forEach((value, key) => {
+			if (key === "set-cookie") return;
+			out[key] = value;
+		});
+		res.writeHead(response.status, out);
+		if (response.body) try {
+			for await (const chunk of response.body) res.write(chunk);
+		} catch {}
+		res.end();
+	} catch (error) {
+		if (!res.headersSent) res.writeHead(500, { "content-type": "application/json" });
+		res.end(JSON.stringify({ error: {
+			code: "internal",
+			message: error.message
+		} }));
+	}
+}
+//#endregion
+export { localHandle, serveLocal };

package/dist/server-Cxey38B-.mjs

@@ -0,0 +1,17 @@
+import { t as createBoard } from "./exports-CyY3_FjZ.mjs";
+import { t as http } from "./backend-http-BsDSgmeo.mjs";
+//#region src/server/index.ts
+/**
+* The handle on a board. With a `backend`, the board lives there: `a2()` keeps it in this
+* deployment, `http(url)` uses another. Without one, it's `http()` to the board the environment
+* points at: `BOARD_URL`, then the repo's link (`vb link`, `vb serve`), then `vb use`'s.
+*/
+function board(options = {}) {
+	return createBoard(options, {
+		http: () => http(),
+		sync: () => import("./engine-3EvQ8idk.mjs"),
+		serving: () => import("./serving-BNbzc96L.mjs")
+	});
+}
+//#endregion
+export { board as t };

package/dist/serving-BNbzc96L.mjs

@@ -0,0 +1,2 @@
+import { i as ownTeamId, n as discoveryIdentity, r as ownProjectId, t as oidcTokens } from "./tokens-DKLn5P9B.mjs";
+export { discoveryIdentity, oidcTokens, ownProjectId, ownTeamId };