@fedify/cli 2.3.0-dev.1219 → 2.3.0-dev.1273

package/dist/bench/template/generate.js

@@ -0,0 +1,90 @@
+import "@js-temporal/polyfill";
+//#region src/bench/template/generate.ts
+/**
+* Typed payload-generation directives for the scenario format.
+*
+* Rather than templating payload bodies as strings, the format uses typed
+* directives such as `content: { generate: lorem, size: 2KB }`, which are
+* JSON-Schema-validatable and produce deterministic output of a given byte
+* size.
+* @since 2.3.0
+* @module
+*/
+/**
+* The largest payload {@link resolveGenerate} will produce (100 MiB).  A
+* generated payload is held in memory as a single string, so a much larger size
+* would exhaust memory or overflow `String.repeat`; a realistic benchmark body
+* is far smaller.  (`parseSize` itself stays a plain parser with no limit.)
+*/
+const MAX_PAYLOAD_SIZE = 100 * 1024 * 1024;
+/** Multipliers for the size units accepted by {@link parseSize}. */
+const SIZE_UNITS = {
+	b: 1,
+	kb: 1024,
+	kib: 1024,
+	mb: 1024 ** 2,
+	mib: 1024 ** 2,
+	gb: 1024 ** 3,
+	gib: 1024 ** 3
+};
+const SIZE_RE = /^\s*(\d+(?:\.\d+)?)\s*(b|kb|kib|mb|mib|gb|gib)?\s*$/i;
+/**
+* Parses a human-friendly byte size such as `"2KB"`, `"1.5MiB"`, or `512` into
+* a number of bytes.  Units are binary (`KB` = 1024 bytes); a bare number is
+* interpreted as bytes.
+* @param value A size string or a plain number of bytes.
+* @returns The size in bytes, as a non-negative integer.
+* @throws {RangeError} If the value cannot be parsed or is negative.
+*/
+function parseSize(value) {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value < 0) throw new RangeError(`Invalid size: ${value}.`);
+		return ensureSafe(Math.floor(value), value);
+	}
+	const match = value.match(SIZE_RE);
+	if (match == null) throw new RangeError(`Invalid size: ${JSON.stringify(value)}.`);
+	const amount = Number.parseFloat(match[1]);
+	const unit = (match[2] ?? "b").toLowerCase();
+	return ensureSafe(Math.floor(amount * SIZE_UNITS[unit]), value);
+}
+function ensureSafe(bytes, original) {
+	if (!Number.isSafeInteger(bytes)) throw new RangeError(`Size out of range: ${JSON.stringify(original)}.`);
+	return bytes;
+}
+/**
+* Determines whether a value is a {@link GenerateDirective} rather than a plain
+* literal (such as a string content body).
+* @param value The value to test.
+* @returns `true` if the value is a generate directive.
+*/
+function isGenerateDirective(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value) && Object.hasOwn(value, "generate") && typeof value.generate === "string";
+}
+/** A fixed lorem ipsum corpus used by the `lorem` generator. */
+const LOREM = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. ";
+/**
+* Resolves a {@link GenerateDirective} into a deterministic payload string.
+*
+* The output is exactly the requested number of bytes (ASCII, so bytes equal
+* characters) and is identical across calls for the same directive, which keeps
+* benchmark payloads reproducible.
+* @param directive The directive to resolve.
+* @returns The generated payload string.
+* @throws {RangeError} If the generator is unknown or the size is invalid.
+*/
+function resolveGenerate(directive) {
+	const size = directive.size == null ? 0 : parseSize(directive.size);
+	if (size > MAX_PAYLOAD_SIZE) throw new RangeError(`Payload size ${JSON.stringify(directive.size)} exceeds the maximum of ${MAX_PAYLOAD_SIZE} bytes.`);
+	switch (directive.generate) {
+		case "lorem": return generateLorem(size);
+		default: throw new RangeError(`Unknown payload generator: ${JSON.stringify(directive.generate)}.`);
+	}
+}
+function generateLorem(size) {
+	if (size <= 0) return "";
+	let out = LOREM.repeat(Math.ceil(size / 335));
+	if (out.length > size) out = out.slice(0, size);
+	return out;
+}
+//#endregion
+export { isGenerateDirective, resolveGenerate };

package/dist/bench/template/helpers.js

@@ -0,0 +1,19 @@
+import "@js-temporal/polyfill";
+//#region src/bench/template/helpers.ts
+/**
+* Returns a fresh registry of the default template helpers:
+*
+*  -  `uuid()` — a random UUID string.
+*  -  `upper(value)` — the uppercase form of the argument.
+*  -  `lower(value)` — the lowercase form of the argument.
+* @returns A new record of helper functions.
+*/
+function defaultHelpers() {
+	return {
+		uuid: () => crypto.randomUUID(),
+		upper: (value) => String(value).toUpperCase(),
+		lower: (value) => String(value).toLowerCase()
+	};
+}
+//#endregion
+export { defaultHelpers };

package/dist/bench/template/template.js

@@ -0,0 +1,132 @@
+import "@js-temporal/polyfill";
+//#region src/bench/template/template.ts
+/** An error raised while rendering a `${{ ... }}` template expression. */
+var TemplateError = class extends Error {};
+const EXPR_RE = /\$\{\{([\s\S]*?)\}\}/g;
+const CALL_RE = /^([A-Za-z_]\w*)\s*\(([\s\S]*)\)$/;
+const IDENT_RE = /^[A-Za-z_]\w*$/;
+/** Property names that must never be resolved, to avoid prototype access. */
+const FORBIDDEN = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+/** A guard against unbounded recursion on pathologically nested input. */
+const MAX_DEPTH = 100;
+/**
+* Recursively renders every `${{ ... }}` expression in a value.
+*
+* When a string consists of a single expression, the raw evaluated value is
+* returned (so `${{ count }}` can yield a number).  When an expression is
+* embedded in surrounding text, its result is stringified and interpolated.
+* Objects and arrays are walked recursively; other scalars pass through.
+* @typeParam T The value type.
+* @param value The value to render.
+* @param context The evaluation context.
+* @returns The rendered value, of the same shape as the input.
+*/
+function renderTemplates(value, context = {}) {
+	return renderValue(value, context);
+}
+function renderValue(value, ctx, depth = 0) {
+	if (depth > MAX_DEPTH) throw new TemplateError("Maximum template nesting depth exceeded.");
+	if (typeof value === "string") return renderString(value, ctx);
+	if (Array.isArray(value)) {
+		let out;
+		for (let i = 0; i < value.length; i++) {
+			const item = value[i];
+			const rendered = renderValue(item, ctx, depth + 1);
+			if (out == null && rendered !== item) out = value.slice(0, i);
+			if (out != null) out.push(rendered);
+		}
+		return out ?? value;
+	}
+	if (value != null && typeof value === "object") {
+		const entries = Object.entries(value);
+		let out;
+		for (let i = 0; i < entries.length; i++) {
+			const [key, item] = entries[i];
+			const rendered = renderValue(item, ctx, depth + 1);
+			if (out == null && rendered !== item) {
+				out = {};
+				for (let j = 0; j < i; j++) out[entries[j][0]] = entries[j][1];
+			}
+			if (out != null) out[key] = rendered;
+		}
+		return out ?? value;
+	}
+	return value;
+}
+function renderString(str, ctx) {
+	const matches = [...str.matchAll(EXPR_RE)];
+	if (str.split("${{").length - 1 !== matches.length) throw new TemplateError(`Unclosed \${{ }} expression: ${str}`);
+	if (matches.length === 0) return str;
+	const only = matches[0];
+	if (matches.length === 1 && str.slice(0, only.index).trim() === "" && str.slice(only.index + only[0].length).trim() === "") return evalExpr(only[1], ctx);
+	return str.replace(EXPR_RE, (_match, expr) => stringify(evalExpr(expr, ctx)));
+}
+function evalExpr(source, ctx) {
+	const expr = source.trim();
+	if (expr === "") throw new TemplateError("Empty ${{ }} expression.");
+	const call = expr.match(CALL_RE);
+	if (call != null) {
+		const name = call[1];
+		const helper = FORBIDDEN.has(name) || ctx.helpers == null || !Object.hasOwn(ctx.helpers, name) ? void 0 : ctx.helpers[name];
+		if (typeof helper !== "function") throw new TemplateError(`Unknown helper: ${name}.`);
+		return helper(...parseArgs(call[2], ctx));
+	}
+	return resolvePath(expr, ctx.values ?? {});
+}
+function parseArgs(source, ctx) {
+	const trimmed = source.trim();
+	if (trimmed === "") return [];
+	return splitTopLevel(trimmed).map((arg) => parseArg(arg.trim(), ctx));
+}
+function splitTopLevel(source) {
+	const parts = [];
+	let current = "";
+	let quote = null;
+	let escaped = false;
+	for (const char of source) if (escaped) {
+		current += char;
+		escaped = false;
+	} else if (char === "\\") {
+		current += char;
+		escaped = true;
+	} else if (quote != null) {
+		if (char === quote) quote = null;
+		current += char;
+	} else if (char === "'" || char === "\"") {
+		quote = char;
+		current += char;
+	} else if (char === ",") {
+		parts.push(current);
+		current = "";
+	} else current += char;
+	if (quote != null) throw new TemplateError("Unbalanced quote in helper arguments.");
+	parts.push(current);
+	return parts;
+}
+function parseArg(arg, ctx) {
+	const str = arg.match(/^'([\s\S]*)'$/) ?? arg.match(/^"([\s\S]*)"$/);
+	if (str != null) return str[1].replace(/\\(.)/g, "$1");
+	if (/^-?\d+(?:\.\d+)?$/.test(arg)) return Number(arg);
+	if (arg === "true") return true;
+	if (arg === "false") return false;
+	if (arg === "null") return null;
+	return resolvePath(arg, ctx.values ?? {});
+}
+function resolvePath(path, values) {
+	let current = values;
+	for (const part of path.split(".")) {
+		if (!IDENT_RE.test(part) || FORBIDDEN.has(part)) throw new TemplateError(`Invalid reference: ${path}.`);
+		if (current == null || typeof current !== "object" || !Object.hasOwn(current, part)) throw new TemplateError(`Unknown reference: ${path}.`);
+		current = current[part];
+	}
+	return current;
+}
+function stringify(value) {
+	return value == null ? "" : String(value);
+}
+//#endregion
+export { renderTemplates };

package/dist/cache.js

@@ -1,8 +1,8 @@
 import "@js-temporal/polyfill";
 import { mkdir } from "node:fs/promises";
 import process from "node:process";
-import { join } from "node:path";
 import { homedir } from "node:os";
+import { join } from "node:path";
 //#region src/cache.ts
 /**
 * Returns the default cache directory path.

package/dist/config.js

@@ -1,6 +1,6 @@
 import "@js-temporal/polyfill";
-import { printError } from "@optique/run";
 import { message } from "@optique/core";
+import { printError } from "@optique/run";
 import { createConfigContext } from "@optique/config";
 import { readFileSync } from "node:fs";
 import { parse } from "smol-toml";
@@ -76,6 +76,17 @@ const nodeinfoSchema = object$1({
 	showMetadata: optional$1(boolean())
 });
 /**
+* Schema for the bench command configuration.
+*
+* `allowUnsafeTarget` is intentionally absent: the unsafe-target override is a
+* CLI-only, per-run acknowledgment, never a persisted default.
+*/
+const benchSchema = object$1({ format: optional$1(picklist([
+	"text",
+	"json",
+	"markdown"
+])) });
+/**
 * Config context for use with bindConfig().
 */
 const configContext = createConfigContext({ schema: object$1({
@@ -90,7 +101,8 @@ const configContext = createConfigContext({ schema: object$1({
 	lookup: optional$1(lookupSchema),
 	inbox: optional$1(inboxSchema),
 	relay: optional$1(relaySchema),
-	nodeinfo: optional$1(nodeinfoSchema)
+	nodeinfo: optional$1(nodeinfoSchema),
+	bench: optional$1(benchSchema)
 }) });
 /**
 * Try to load and parse a TOML config file.

package/dist/deno.js

@@ -1,5 +1,5 @@
 import "@js-temporal/polyfill";
 //#region deno.json
-var version = "2.3.0-dev.1219+e9ad1fa3";
+var version = "2.3.0-dev.1273+6b46a8b5";
 //#endregion
 export { version };

package/dist/generate-vocab/action.js

@@ -1,9 +1,9 @@
 import "@js-temporal/polyfill";
-import { generateVocab } from "@fedify/vocab-tools";
-import { message } from "@optique/core/message";
-import { printError } from "@optique/run";
 import { stat } from "node:fs/promises";
 import process from "node:process";
+import { printError } from "@optique/run";
+import { generateVocab } from "@fedify/vocab-tools";
+import { message } from "@optique/core/message";
 //#region src/generate-vocab/action.ts
 async function runGenerateVocab({ schemaDir, generatedPath }) {
 	if (!(await stat(schemaDir)).isDirectory()) {

package/dist/generate-vocab/command.js

@@ -1,6 +1,6 @@
 import "@js-temporal/polyfill";
-import { path } from "@optique/run";
 import { argument, command, constant, message, object, option, withDefault } from "@optique/core";
+import { path } from "@optique/run";
 //#region src/generate-vocab/command.ts
 const schemaDir = withDefault(option("-i", "--input", path({
 	metavar: "DIR",

package/dist/imagerenderer.js

@@ -3,9 +3,9 @@ import { Jimp } from "./nodeinfo.js";
 import fs from "node:fs/promises";
 import process from "node:process";
 import { validatePublicUrl } from "@fedify/vocab-runtime";
+import os from "node:os";
 import path from "node:path";
 import { encodeBase64 } from "byte-encodings/base64";
-import os from "node:os";
 //#region src/imagerenderer.ts
 const KITTY_IDENTIFIERS = [
 	"kitty",

package/dist/inbox/view.js

@@ -1,9 +1,9 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { renderActivity, renderRawActivity, renderRequest, renderResponse } from "./rendercode.js";
+import util from "node:util";
 import { getStatusText } from "@poppanator/http-constants";
 import { Fragment } from "hono/jsx";
 import { getSingletonHighlighter } from "shiki";
-import util from "node:util";
 import { jsx, jsxs } from "hono/jsx/jsx-runtime";
 //#region src/inbox/view.tsx
 const Layout = (props) => {

package/dist/inbox.js

@@ -1,11 +1,11 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { version } from "./deno.js";
 import { getDocumentLoader } from "./docloader.js";
+import { colors, matchesActor } from "./utils.js";
+import { version } from "./deno.js";
 import { ActivityEntryPage, ActivityListPage } from "./inbox/view.js";
 import { configureLogging, recordingSink } from "./log.js";
 import { tableStyle } from "./table.js";
 import { spawnTemporaryServer } from "./tempserver.js";
-import { colors, matchesActor } from "./utils.js";
 import process from "node:process";
 import { MemoryKvStore, createFederation, generateCryptoKeyPair } from "@fedify/fedify";
 import { Accept, Activity, Application, Delete, Endpoints, Follow, Image, PUBLIC_COLLECTION, isActor, lookupObject } from "@fedify/vocab";

package/dist/lookup.js

@@ -1,22 +1,22 @@
 import "@js-temporal/polyfill";
 import { getContextLoader, getDocumentLoader as getDocumentLoader$1 } from "./docloader.js";
-import { configureLogging } from "./log.js";
-import { spawnTemporaryServer } from "./tempserver.js";
-import { colorEnabled, colors, formatObject } from "./utils.js";
+import { colorEnabled, colors, describeError, formatObject } from "./utils.js";
 import { configContext } from "./config.js";
 import { createTunnelServiceOption, userAgentOption } from "./options.js";
+import { configureLogging } from "./log.js";
+import { spawnTemporaryServer } from "./tempserver.js";
 import { renderImages } from "./imagerenderer.js";
-import { url } from "@optique/core/message";
-import { path, printError } from "@optique/run";
 import process from "node:process";
-import { argument, choice, command, constant, flag, float, integer, map, merge, message as message$1, multiple, object, option, optionNames, optional, or, string, withDefault } from "@optique/core";
 import { generateCryptoKeyPair, getAuthenticatedDocumentLoader, respondWithObject } from "@fedify/fedify";
+import { UrlError, expandIPv6Address, isValidPublicIPv4Address, isValidPublicIPv6Address } from "@fedify/vocab-runtime";
 import { Application, Collection, CryptographicKey, Object as Object$1, lookupObject, traverseCollection } from "@fedify/vocab";
+import { argument, choice, command, constant, flag, float, integer, map, merge, message, multiple, object, option, optionNames, optional, or, string, withDefault } from "@optique/core";
+import { path, printError } from "@optique/run";
 import { getLogger } from "@logtape/logtape";
-import ora from "ora";
-import { UrlError, expandIPv6Address, isValidPublicIPv4Address, isValidPublicIPv6Address } from "@fedify/vocab-runtime";
 import { bindConfig } from "@optique/config";
 import { createWriteStream } from "node:fs";
+import { url } from "@optique/core/message";
+import ora from "ora";
 import { isIP } from "node:net";
 //#region src/lookup.ts
 const logger = getLogger([
@@ -39,12 +39,12 @@ const recurseProperties = [
 	MISSKEY_QUOTE_IRI,
 	FEDIBIRD_QUOTE_IRI
 ];
-const suppressErrorsOption = bindConfig(flag("-S", "--suppress-errors", { description: message$1`Suppress partial errors during traversal or recursion.` }), {
+const suppressErrorsOption = bindConfig(flag("-S", "--suppress-errors", { description: message`Suppress partial errors during traversal or recursion.` }), {
 	context: configContext,
 	key: (config) => config.lookup?.suppressErrors ?? false,
 	default: false
 });
-const allowPrivateAddressOption = bindConfig(flag("-p", "--allow-private-address", { description: message$1`Allow private IP addresses for URLs discovered \
+const allowPrivateAddressOption = bindConfig(flag("-p", "--allow-private-address", { description: message`Allow private IP addresses for URLs discovered \
 during traversal or recursive object fetches. Recursive JSON-LD \
 context URLs always remain blocked. URLs explicitly provided on the \
 command line always allow private addresses.` }), {
@@ -53,11 +53,11 @@ command line always allow private addresses.` }), {
 	default: false
 });
 const authorizedFetchOption = withDefault(object("Authorized fetch options", {
-	authorizedFetch: bindConfig(map(flag("-a", "--authorized-fetch", { description: message$1`Sign the request with an one-time key.` }), () => true), {
+	authorizedFetch: bindConfig(map(flag("-a", "--authorized-fetch", { description: message`Sign the request with an one-time key.` }), () => true), {
 		context: configContext,
 		key: (config) => config.lookup?.authorizedFetch ? true : void 0
 	}),
-	firstKnock: bindConfig(option("--first-knock", choice(["draft-cavage-http-signatures-12", "rfc9421"]), { description: message$1`The first-knock spec for ${optionNames(["-a", "--authorized-fetch"])}. It is used for the double-knocking technique.` }), {
+	firstKnock: bindConfig(option("--first-knock", choice(["draft-cavage-http-signatures-12", "rfc9421"]), { description: message`The first-knock spec for ${optionNames(["-a", "--authorized-fetch"])}. It is used for the double-knocking technique.` }), {
 		context: configContext,
 		key: (config) => config.lookup?.firstKnock ?? "draft-cavage-http-signatures-12",
 		default: "draft-cavage-http-signatures-12"
@@ -70,21 +70,21 @@ const authorizedFetchOption = withDefault(object("Authorized fetch options", {
 });
 const lookupModeOption = withDefault(or(object("Recurse options", {
 	traverse: constant(false),
-	recurse: bindConfig(option("--recurse", choice(recurseProperties, { metavar: "PROPERTY" }), { description: message$1`Recursively follow a relationship property.` }), {
+	recurse: bindConfig(option("--recurse", choice(recurseProperties, { metavar: "PROPERTY" }), { description: message`Recursively follow a relationship property.` }), {
 		context: configContext,
 		key: (config) => config.lookup?.recurse
 	}),
 	recurseDepth: bindConfig(option("--recurse-depth", integer({
 		min: 1,
 		metavar: "DEPTH"
-	}), { description: message$1`Maximum recursion depth for ${optionNames(["--recurse"])}.` }), {
+	}), { description: message`Maximum recursion depth for ${optionNames(["--recurse"])}.` }), {
 		context: configContext,
 		key: (config) => config.lookup?.recurseDepth,
 		default: 20
 	}),
 	suppressErrors: suppressErrorsOption
 }), object("Traverse options", {
-	traverse: bindConfig(flag("-t", "--traverse", { description: message$1`Traverse the given collection(s) to fetch all items.` }), {
+	traverse: bindConfig(flag("-t", "--traverse", { description: message`Traverse the given collection(s) to fetch all items.` }), {
 		context: configContext,
 		key: (config) => config.lookup?.traverse ?? false,
 		default: false
@@ -103,22 +103,22 @@ const lookupCommand = command("lookup", merge(object({ command: constant("lookup
 	timeout: optional(bindConfig(option("-T", "--timeout", float({
 		min: 0,
 		metavar: "SECONDS"
-	}), { description: message$1`Set timeout for network requests in seconds.` }), {
+	}), { description: message`Set timeout for network requests in seconds.` }), {
 		context: configContext,
 		key: (config) => config.lookup?.timeout
 	}))
-})), object("Arguments", { urls: multiple(argument(string({ metavar: "URL_OR_HANDLE" }), { description: message$1`One or more URLs or handles to look up.` }), { min: 1 }) }), object("Output options", {
-	reverse: bindConfig(flag("--reverse", { description: message$1`Reverse the output order of fetched objects or items.` }), {
+})), object("Arguments", { urls: multiple(argument(string({ metavar: "URL_OR_HANDLE" }), { description: message`One or more URLs or handles to look up.` }), { min: 1 }) }), object("Output options", {
+	reverse: bindConfig(flag("--reverse", { description: message`Reverse the output order of fetched objects or items.` }), {
 		context: configContext,
 		key: (config) => config.lookup?.reverse ?? false,
 		default: false
 	}),
-	format: bindConfig(optional(or(map(flag("-r", "--raw", { description: message$1`Print the fetched JSON-LD document as is.` }), () => "raw"), map(flag("-C", "--compact", { description: message$1`Compact the fetched JSON-LD document.` }), () => "compact"), map(flag("-e", "--expand", { description: message$1`Expand the fetched JSON-LD document.` }), () => "expand"))), {
+	format: bindConfig(optional(or(map(flag("-r", "--raw", { description: message`Print the fetched JSON-LD document as is.` }), () => "raw"), map(flag("-C", "--compact", { description: message`Compact the fetched JSON-LD document.` }), () => "compact"), map(flag("-e", "--expand", { description: message`Expand the fetched JSON-LD document.` }), () => "expand"))), {
 		context: configContext,
 		key: (config) => config.lookup?.defaultFormat ?? "default",
 		default: "default"
 	}),
-	separator: bindConfig(option("-s", "--separator", string({ metavar: "SEPARATOR" }), { description: message$1`Specify the separator between adjacent output objects or collection items.` }), {
+	separator: bindConfig(option("-s", "--separator", string({ metavar: "SEPARATOR" }), { description: message`Specify the separator between adjacent output objects or collection items.` }), {
 		context: configContext,
 		key: (config) => config.lookup?.separator ?? "----",
 		default: "----"
@@ -127,10 +127,10 @@ const lookupCommand = command("lookup", merge(object({ command: constant("lookup
 		metavar: "OUTPUT_PATH",
 		type: "file",
 		allowCreate: true
-	}), { description: message$1`Specify the output file path.` }))
+	}), { description: message`Specify the output file path.` }))
 })), {
-	brief: message$1`Look up Activity Streams objects.`,
-	description: message$1`Look up Activity Streams objects by URL or actor handle.
+	brief: message`Look up Activity Streams objects.`,
+	description: message`Look up Activity Streams objects by URL or actor handle.
 
 The arguments can be either URLs or actor handles (e.g., ${"@username@domain"}), and they can be multiple.`
 });
@@ -282,10 +282,10 @@ function wrapDocumentLoaderWithTimeout(loader, timeoutSeconds) {
 function handleTimeoutError(spinner, timeoutSeconds, url) {
 	const urlText = url ? ` for: ${colors.red(url)}` : "";
 	spinner.fail(`Request timed out after ${timeoutSeconds} seconds${urlText}.`);
-	printError(message$1`Try increasing the timeout with ${optionNames(["-T", "--timeout"])} option or check network connectivity.`);
+	printError(message`Try increasing the timeout with ${optionNames(["-T", "--timeout"])} option or check network connectivity.`);
 }
 function isPrivateAddressError(error) {
-	const lowerMessage = (error instanceof Error ? error.message : String(error)).toLowerCase();
+	const lowerMessage = describeError(error).toLowerCase();
 	if (error instanceof UrlError) return lowerMessage.includes("invalid or private address") || lowerMessage.includes("localhost is not allowed");
 	return lowerMessage.includes("private address") || lowerMessage.includes("private ip") || lowerMessage.includes("localhost") || lowerMessage.includes("loopback");
 }
@@ -308,7 +308,7 @@ function isPrivateAddressTarget(target) {
 	return getPrivateUrlCandidate(target) != null;
 }
 function getPrivateContextUrl(error) {
-	const errorMessage = error instanceof Error ? error.message : String(error);
+	const errorMessage = describeError(error);
 	if (!(error instanceof Error) || error.name !== "jsonld.InvalidUrl" || !errorMessage.includes("valid JSON-LD object")) return null;
 	const structuredError = error;
 	const structuredUrl = getPrivateUrlCandidate(structuredError.details?.url) ?? getPrivateUrlCandidate(structuredError.url);
@@ -318,10 +318,10 @@ function getPrivateContextUrl(error) {
 	return getPrivateUrlCandidate(match[1]);
 }
 function printRecursivePrivateAddressHint() {
-	printError(message$1`The recursive target appears to be private or localhost.  Try with ${optionNames(["-p", "--allow-private-address"])}, or use ${optionNames(["-S", "--suppress-errors"])} to skip blocked steps.`);
+	printError(message`The recursive target appears to be private or localhost.  Try with ${optionNames(["-p", "--allow-private-address"])}, or use ${optionNames(["-S", "--suppress-errors"])} to skip blocked steps.`);
 }
 function printRecursivePrivateContextHint(privateContextUrl) {
-	printError(message$1`Recursive JSON-LD context URL ${url(privateContextUrl)} is always blocked, even with ${optionNames(["-p", "--allow-private-address"])}.  Use ${optionNames(["-S", "--suppress-errors"])} to skip blocked steps.`);
+	printError(message`Recursive JSON-LD context URL ${url(privateContextUrl)} is always blocked, even with ${optionNames(["-p", "--allow-private-address"])}.  Use ${optionNames(["-S", "--suppress-errors"])} to skip blocked steps.`);
 }
 function getLookupFailureHint(error, options = {}) {
 	if (isPrivateAddressError(error)) return options.recursive ? "recursive-private-address" : "private-address";
@@ -338,13 +338,13 @@ function printLookupFailureHint(authLoader, error, options = {}) {
 	if (!shouldPrintLookupFailureHint(authLoader, hint)) return;
 	switch (hint) {
 		case "private-address":
-			printError(message$1`The URL appears to be private or localhost.  Try with ${optionNames(["-p", "--allow-private-address"])}.`);
+			printError(message`The URL appears to be private or localhost.  Try with ${optionNames(["-p", "--allow-private-address"])}.`);
 			return;
 		case "recursive-private-address":
 			printRecursivePrivateAddressHint();
 			return;
 		case "authorized-fetch":
-			printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+			printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 			return;
 	}
 }
@@ -418,7 +418,7 @@ async function runLookup(command, deps = {}) {
 		...deps
 	};
 	if (command.urls.length < 1) {
-		printError(message$1`At least one URL or actor handle must be provided.`);
+		printError(message`At least one URL or actor handle must be provided.`);
 		effectiveDeps.exit(1);
 	}
 	if (command.debug) await configureLogging();
@@ -559,7 +559,7 @@ async function runLookup(command, deps = {}) {
 			}
 			if (current == null) {
 				spinner.fail(`Failed to fetch object: ${colors.red(url)}.`);
-				if (authLoader == null) printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+				if (authLoader == null) printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 				await finalizeAndExit(1);
 				return;
 			}
@@ -601,7 +601,7 @@ async function runLookup(command, deps = {}) {
 				else if (error instanceof RecursiveLookupError) {
 					spinner.fail(`Failed to recursively fetch object: ${colors.red(error.target)}.`);
 					if (!command.allowPrivateAddress && isPrivateAddressTarget(error.target)) printRecursivePrivateAddressHint();
-					else if (authLoader == null) printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+					else if (authLoader == null) printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 				} else {
 					spinner.fail("Failed to recursively fetch object.");
 					const privateContextUrl = getPrivateContextUrl(error);
@@ -611,7 +611,7 @@ async function runLookup(command, deps = {}) {
 						return;
 					}
 					const hint = getLookupFailureHint(error, { recursive: true });
-					if (shouldSuggestSuppressErrorsForLookupFailure(authLoader, hint)) printError(message$1`Use the ${optionNames(["-S", "--suppress-errors"])} option to suppress partial errors.`);
+					if (shouldSuggestSuppressErrorsForLookupFailure(authLoader, hint)) printError(message`Use the ${optionNames(["-S", "--suppress-errors"])} option to suppress partial errors.`);
 					else printLookupFailureHint(authLoader, error, { recursive: true });
 				}
 				await finalizeAndExit(1);
@@ -685,7 +685,7 @@ async function runLookup(command, deps = {}) {
 			}
 			if (collection == null) {
 				spinner.fail(`Failed to fetch object: ${colors.red(url)}.`);
-				if (authLoader == null) printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+				if (authLoader == null) printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 				await finalizeAndExit(1);
 				return;
 			}
@@ -747,7 +747,7 @@ async function runLookup(command, deps = {}) {
 				else {
 					spinner.fail(`Failed to complete the traversal for: ${colors.red(url)}.`);
 					const hint = getLookupFailureHint(error);
-					if (shouldSuggestSuppressErrorsForLookupFailure(authLoader, hint)) printError(message$1`Use the ${optionNames(["-S", "--suppress-errors"])} option to suppress partial errors.`);
+					if (shouldSuggestSuppressErrorsForLookupFailure(authLoader, hint)) printError(message`Use the ${optionNames(["-S", "--suppress-errors"])} option to suppress partial errors.`);
 					else printLookupFailureHint(authLoader, error);
 				}
 				await finalizeAndExit(1);
@@ -782,7 +782,7 @@ async function runLookup(command, deps = {}) {
 		const url = command.urls[i];
 		if (obj == null) {
 			spinner.fail(`Failed to fetch ${colors.red(url)}`);
-			if (authLoader == null) printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+			if (authLoader == null) printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 			success = false;
 		} else {
 			spinner.succeed(`Fetched object: ${colors.green(url)}`);

package/dist/mod.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 import "@js-temporal/polyfill";
+import runBench from "./bench/action.js";
+import "./bench/mod.js";
 import runGenerateVocab from "./generate-vocab/action.js";
 import "./generate-vocab/mod.js";
 import { runInbox } from "./inbox.js";
@@ -23,6 +25,7 @@ async function main() {
 	else if (result.command === "tunnel") await runTunnel(result);
 	else if (result.command === "generate-vocab") await runGenerateVocab(result);
 	else if (result.command === "relay") await runRelay(result);
+	else if (result.command === "bench") await runBench(result);
 }
 await main();
 //#endregion

package/dist/nodeinfo.js

@@ -2,15 +2,15 @@ import "@js-temporal/polyfill";
 import { colors, formatObject } from "./utils.js";
 import { configContext } from "./config.js";
 import { userAgentOption } from "./options.js";
-import { print, printError } from "@optique/run";
 import process from "node:process";
-import { argument, command, constant, flag, group, merge, message, object, string, text } from "@optique/core";
 import { getNodeInfo } from "@fedify/fedify";
-import { getLogger } from "@logtape/logtape";
-import ora from "ora";
 import { getUserAgent } from "@fedify/vocab-runtime";
-import { bindConfig } from "@optique/config";
+import { argument, command, constant, flag, group, merge, message, object, string, text } from "@optique/core";
+import { print, printError } from "@optique/run";
+import { getLogger } from "@logtape/logtape";
 import os from "node:os";
+import { bindConfig } from "@optique/config";
+import ora from "ora";
 import { createJimp } from "@jimp/core";
 import webp from "@jimp/wasm-webp";
 import { isICO, parseICO } from "icojs";

package/dist/options.js

@@ -1,7 +1,7 @@
 import "@js-temporal/polyfill";
 import { configContext } from "./config.js";
-import { choice, constant, flag, map, merge, message, object, option, optional, or, string, withDefault } from "@optique/core";
 import { getUserAgent } from "@fedify/vocab-runtime";
+import { choice, constant, flag, map, merge, message, object, option, optional, or, string, withDefault } from "@optique/core";
 import { bindConfig } from "@optique/config";
 //#region src/options.ts
 /**