@vercel/board 0.28.0 → 0.30.0

package/dist/{commands-BFookFtn.mjs → commands-B5DHjZKK.mjs}

@@ -120,6 +120,23 @@ const options = {
 		value: "k",
 		description: "remove a label"
 	},
+	if: {
+		type: "string",
+		multiple: true,
+		value: "k=v",
+		description: "only while the message has this label now"
+	},
+	"if-unset": {
+		type: "string",
+		multiple: true,
+		value: "k",
+		description: "only while the message doesn't have this label"
+	},
+	"if-revision": {
+		type: "string",
+		value: "N",
+		description: "only if it is still at this revision, as read --json shows it"
+	},
 	channel: {
 		type: "string",
 		value: "c",
@@ -243,6 +260,8 @@ const text = (description = "what it says: - reads it from stdin, and it may be
 	required: false,
 	description
 });
+/** What `--after` means on a reply: a precondition, where on a read it's a position. */
+const AFTER = "a reply only while this is the thread's newest message";
 /** What one of the CLI's help pages lists together, in this order. */
 const groups = [
 	"you",
@@ -369,7 +388,8 @@ const commands = [
 			option("attach"),
 			option("sync"),
 			option("no-sync"),
-			option("idempotency-key")
+			option("idempotency-key"),
+			option("after", AFTER)
 		],
 		examples: [{
 			name: "start a thread",
@@ -387,11 +407,15 @@ const commands = [
 		options: [
 			option("attach"),
 			option("idempotency-key"),
-			option("no-sync")
+			option("no-sync"),
+			option("after", AFTER)
 		],
 		examples: [{
 			name: "reply in a thread",
 			value: "reply 812 \"on it\""
+		}, {
+			name: "reply only if #815 is still the thread's newest",
+			value: "reply 812 \"on it\" --after 815"
 		}]
 	},
 	{
@@ -465,10 +489,13 @@ const commands = [
 			required: true,
 			description: "its new text: - reads it from stdin"
 		}],
-		options: [],
+		options: [option("if-revision")],
 		examples: [{
 			name: "fix a typo",
 			value: "edit 812 \"deploys are green again\""
+		}, {
+			name: "only if no one changed it since you read it",
+			value: "edit 812 \"step 3 of 5\" --if-revision 820"
 		}]
 	},
 	{
@@ -477,7 +504,7 @@ const commands = [
 		aliases: ["rm", "del"],
 		description: "delete a message, leaving a tombstone",
 		arguments: [id()],
-		options: [],
+		options: [option("if-revision")],
 		examples: [{
 			name: "delete a message",
 			value: "delete 812"
@@ -508,11 +535,25 @@ const commands = [
 			multiple: true,
 			description: "a label to set"
 		}],
-		options: [option("unset")],
-		examples: [{
-			name: "mark a bug fixed",
-			value: "label 812 state=fixed --unset wip"
-		}]
+		options: [
+			option("unset"),
+			option("if"),
+			option("if-unset")
+		],
+		examples: [
+			{
+				name: "mark a bug fixed",
+				value: "label 812 state=fixed --unset wip"
+			},
+			{
+				name: "claim a thread, unless someone has",
+				value: "label 812 owner=claude --if-unset owner"
+			},
+			{
+				name: "move it on from open only",
+				value: "label 812 state=fixing --if state=open"
+			}
+		]
 	},
 	{
 		group: "messages",
@@ -590,10 +631,13 @@ const commands = [
 				required: true,
 				description: "a channel ('#general'), a thread, or a message link"
 			}],
-			options: [option("limit", "messages to read")],
+			options: [option("limit", "messages to read"), option("after", "where the last read left off: the cursor it printed")],
 			examples: [{
 				name: "read a Slack channel",
 				value: "sources slack read '#general'"
+			}, {
+				name: "read a Linear project's issues",
+				value: "sources linear read https://linear.app/acme/project/checkout-a1b2c3"
 			}]
 		}, {
 			name: "join",

package/dist/{commands-D6gvrOh3.d.mts → commands-BtH69yqt.d.mts}

@@ -166,6 +166,23 @@ declare const options: {
     readonly value: 'k';
     readonly description: 'remove a label';
   };
+  readonly if: {
+    readonly type: 'string';
+    readonly multiple: true;
+    readonly value: 'k=v';
+    readonly description: 'only while the message has this label now';
+  };
+  readonly 'if-unset': {
+    readonly type: 'string';
+    readonly multiple: true;
+    readonly value: 'k';
+    readonly description: "only while the message doesn't have this label";
+  };
+  readonly 'if-revision': {
+    readonly type: 'string';
+    readonly value: 'N';
+    readonly description: 'only if it is still at this revision, as read --json shows it';
+  };
   readonly channel: {
     readonly type: 'string';
     readonly value: 'c';

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

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

package/dist/conformance.d.mts

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

package/dist/conformance.mjs

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

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

@@ -1,14 +1,14 @@
 import { a as typeOf, i as fileSize, r as IMPORT_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
-import { C as toStorable, c as ChannelPath, m as MESSAGE_TEXT_MAX } from "./schemas-Be08nyfW.mjs";
-import { c as externalMessageKey, l as isThreadTarget, s as channelOf } from "./external-BV_cUncs.mjs";
+import { C as toStorable, c as ChannelPath, m as MESSAGE_TEXT_MAX } from "./schemas-DBmUO6pr.mjs";
+import { c as externalMessageKey, l as isThreadTarget, s as channelOf } from "./external-D3p5T57R.mjs";
 import { t as canonicalEmoji } from "./emoji-CTLpvH-A.mjs";
+import { r as badRequest, s as notFound, t as HttpError } from "./errors-C_5rB8Iz.mjs";
 import { r as derivedId, t as waitUntil } from "./wait-until-Dw4XrIDQ.mjs";
-import { r as badRequest, s as notFound, t as HttpError } from "./errors-CusN4x2l.mjs";
 import { n as replaceMentions } from "./mentions-CB6ShY4R.mjs";
-import { t as DroppedError } from "./middleware-ChKM1zuu.mjs";
+import { t as DroppedError } from "./middleware-DlJQYiwV.mjs";
 import { t as afterRetry } from "./attempts-HXcskN1w.mjs";
-import { a as channelMissing, i as UnreadableError, n as ResolvedTarget, o as routesFor, t as ReceivedEvent } from "./provider-poIkXapd.mjs";
-import { a as immutable, n as SyncOverrides } from "./events-CewD4kw7.mjs";
+import { a as channelMissing, i as UnreadableError, n as ResolvedTarget, o as routesFor, t as ReceivedEvent } from "./provider-BaVmi4Hi.mjs";
+import { a as immutable, n as SyncOverrides } from "./events-qf5XG5VQ.mjs";
 import { t as displayText } from "./bots-CGkO76qH.mjs";
 //#region src/sync/engine.ts
 /** `files`: a message with files may have no text. */
@@ -872,7 +872,7 @@ function createSyncEngine(entries) {
 					const root = await messageOf(rootId);
 					const createdHere = root?.origin?.message === `lifecycle:${meta.id}`;
 					const desired = labels((createdHere ? rootDraft({
-						text: event.url ? `${event.title}\n${event.url}` : event.title,
+						text: lifecycleText(event),
 						labels: event.labels,
 						author: event.author,
 						raw
@@ -883,7 +883,7 @@ function createSyncEngine(entries) {
 					if (root && !root.deleted && (Object.keys(set).length || unset.length)) await setLabels(event.author, set, unset);
 					if (event.retitled && root && !root.deleted && root.from === key && root.origin?.thread === event.thread) {
 						const text = clampText(overrides.text ?? rootDraft({
-							text: event.url ? `${event.title}\n${event.url}` : event.title,
+							text: lifecycleText(event),
 							labels: root.labels,
 							author: event.author,
 							raw
@@ -916,7 +916,7 @@ function createSyncEngine(entries) {
 					message: null
 				};
 				const draft = rootDraft({
-					text: event.url ? `${event.title}\n${event.url}` : event.title,
+					text: lifecycleText(event),
 					labels: event.labels,
 					author: event.author,
 					raw
@@ -1289,14 +1289,14 @@ function createSyncEngine(entries) {
 						postedAsPerson = true;
 						return asPerson;
 					}
-					return platform.post(native(target), "channel", body);
+					if (root.attachments.length === 0 || !platform.startsThreadsWithFiles) return platform.post(native(target), "channel", body);
 				}
 				try {
 					const sent = await platform.post(native(target), "channel", {
 						...body,
 						files: await messageFiles(root)
 					});
-					uploaded = sent.files ?? [];
+					uploaded = mediaOnly ? sent.files ?? [] : sent.files;
 					return sent;
 				} catch (error) {
 					if (!platform.refusesFiles(error) && !keepsNoFiles(error)) throw error;
@@ -1500,10 +1500,13 @@ function createSyncEngine(entries) {
 		return 403;
 	};
 	/** A platform channel or thread, read for the caller: nothing is synced, stored, or joined. */
-	async function readSource(key, target, limit) {
+	async function readSource(key, target, limit, after) {
 		const platform = platformOf(key);
 		try {
-			return await platform.read(target, { limit });
+			return await platform.read(target, {
+				limit,
+				after
+			});
 		} catch (error) {
 			if (error instanceof UnreadableError) throw new HttpError(unreadableStatus(error.code), error.code, error.message);
 			throw badRequest(`can't read ${target} from ${key}: ${describe(error)}`, "platform_error");
@@ -1542,5 +1545,10 @@ function createSyncEngine(entries) {
 		joinSource
 	};
 }
+/** A lifecycle root's text: the title, its link, and what the PR or issue says. */
+function lifecycleText(event) {
+	const head = event.url ? `${event.title}\n${event.url}` : event.title;
+	return event.body ? `${head}\n\n${event.body}` : head;
+}
 //#endregion
 export { createSyncEngine };

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

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