@fedify/cli 2.3.0-dev.994 → 2.4.0-dev.1417

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";
+import { mkdir } from "node:fs/promises";
 //#region src/cache.ts
 /**
 * Returns the default cache directory path.

package/dist/commands.js

@@ -0,0 +1,110 @@
+import "@js-temporal/polyfill";
+import { benchMetadata, benchOptions } from "./bench/command.js";
+import { generateVocabMetadata, generateVocabOptions } from "./generate-vocab/command.js";
+import { inboxMetadata, inboxOptions } from "./inbox/command.js";
+import { lookupMetadata, lookupOptions } from "./lookup/command.js";
+import { nodeInfoMetadata, nodeInfoOptions, runNodeInfo } from "./nodeinfo.js";
+import { relayMetadata, relayOptions } from "./relay/command.js";
+import { runTunnel, tunnelMetadata, tunnelOptions } from "./tunnel.js";
+import { webFingerMetadata, webFingerOptions } from "./webfinger/command.js";
+import { constant, merge, message, object, optionNames } from "@optique/core";
+import { initOptions, runInit } from "@fedify/init";
+import { defineCommand } from "@optique/discover";
+//#region src/commands.ts
+function defineCliCommand(command) {
+	const { run, ...definition } = command;
+	return {
+		...defineCommand({
+			...definition,
+			handler: (_value) => {}
+		}),
+		run
+	};
+}
+const generatingCommands = [defineCliCommand({
+	path: ["init"],
+	parser: merge(initOptions, object({ command: constant("init") })),
+	metadata: {
+		brief: message`Initialize a new Fedify project directory.`,
+		description: message`Initialize a new Fedify project directory.
+
+By default, it initializes the current directory.  You can specify a different directory as an argument.
+
+Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${optionNames(["-p", "--package-manager"])}, ${optionNames(["-k", "--kv-store"])}, and ${optionNames(["-m", "--message-queue"])}), it will prompt you to select the options interactively.`
+	},
+	run: runInit
+}), defineCliCommand({
+	path: ["generate-vocab"],
+	parser: generateVocabOptions,
+	metadata: generateVocabMetadata,
+	run: async (value) => {
+		const { default: runGenerateVocab } = await import("./generate-vocab/action.js");
+		return await runGenerateVocab(value);
+	}
+})];
+const activityPubCommands = [
+	defineCliCommand({
+		path: ["webfinger"],
+		parser: webFingerOptions,
+		metadata: webFingerMetadata,
+		run: async (value) => {
+			const { default: runWebFinger } = await import("./webfinger/action.js");
+			return await runWebFinger(value);
+		}
+	}),
+	defineCliCommand({
+		path: ["lookup"],
+		parser: lookupOptions,
+		metadata: lookupMetadata,
+		run: async (value) => {
+			const { runLookup } = await import("./lookup.js");
+			return await runLookup(value);
+		}
+	}),
+	defineCliCommand({
+		path: ["inbox"],
+		parser: inboxOptions,
+		metadata: inboxMetadata,
+		run: async (value) => {
+			const { runInbox } = await import("./inbox.js");
+			return await runInbox(value);
+		}
+	}),
+	defineCliCommand({
+		path: ["nodeinfo"],
+		parser: nodeInfoOptions,
+		metadata: nodeInfoMetadata,
+		run: runNodeInfo
+	}),
+	defineCliCommand({
+		path: ["relay"],
+		parser: relayOptions,
+		metadata: relayMetadata,
+		run: async (value) => {
+			const { runRelay } = await import("./relay.js");
+			return await runRelay(value);
+		}
+	}),
+	defineCliCommand({
+		path: ["bench"],
+		parser: benchOptions,
+		metadata: benchMetadata,
+		run: async (value) => {
+			const { runBench } = await import("./bench/mod.js");
+			return await runBench(value);
+		}
+	})
+];
+const networkCommands = [defineCliCommand({
+	path: ["tunnel"],
+	parser: tunnelOptions,
+	metadata: tunnelMetadata,
+	run: runTunnel
+})];
+[
+	...generatingCommands,
+	...activityPubCommands,
+	...networkCommands
+];
+//#endregion
+export { activityPubCommands, generatingCommands, networkCommands };

package/dist/config.js

@@ -1,9 +1,9 @@
 import "@js-temporal/polyfill";
-import { printError } from "@optique/run";
 import { message } from "@optique/core";
-import { createConfigContext } from "@optique/config";
+import { printError } from "@optique/run";
 import { readFileSync } from "node:fs";
 import { parse } from "smol-toml";
+import { createConfigContext } from "@optique/config";
 import { array, boolean, check, forward, integer as integer$1, minValue, number, object as object$1, optional as optional$1, picklist, pipe, string as string$1 } from "valibot";
 //#region src/config.ts
 /**
@@ -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.994+9071ca0a";
+var version = "2.4.0-dev.1417+43d75b89";
 //#endregion
 export { version };

package/dist/docloader.js

@@ -1,6 +1,6 @@
 import "@js-temporal/polyfill";
-import { kvCache } from "@fedify/fedify";
 import { getDocumentLoader } from "@fedify/vocab-runtime";
+import { kvCache } from "@fedify/fedify";
 import { getKvStore } from "#kv";
 //#region src/docloader.ts
 const documentLoaders = {};

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 process from "node:process";
 import { printError } from "@optique/run";
 import { stat } from "node:fs/promises";
-import process from "node:process";
+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",
@@ -12,10 +12,12 @@ const generatedPath = argument(path({
 	type: "file",
 	allowCreate: true
 }), { description: message`Path to output the generated vocabulary classes.  Should end with ${".ts"} suffix.` });
-const generateVocabCommand = command("generate-vocab", object("Generation options", {
+const generateVocabOptions = object("Generation options", {
 	command: constant("generate-vocab"),
 	schemaDir,
 	generatedPath
-}), { description: message`Generate vocabulary classes from schema files.` });
+});
+const generateVocabMetadata = { description: message`Generate vocabulary classes from schema files.` };
+command("generate-vocab", generateVocabOptions, generateVocabMetadata);
 //#endregion
-export { generateVocabCommand as default };
+export { generateVocabMetadata, generateVocabOptions };

package/dist/imagerenderer.js

@@ -1,11 +1,11 @@
 import "@js-temporal/polyfill";
 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 { validatePublicUrl } from "@fedify/vocab-runtime";
+import fs from "node:fs/promises";
 import { encodeBase64 } from "byte-encodings/base64";
-import os from "node:os";
 //#region src/imagerenderer.ts
 const KITTY_IDENTIFIERS = [
 	"kitty",

package/dist/inbox/command.js

@@ -6,7 +6,7 @@ import { bindConfig } from "@optique/config";
 //#region src/inbox/command.ts
 const DEFAULT_EPHEMERAL_INBOX_NAME = "Fedify Ephemeral Inbox";
 const DEFAULT_EPHEMERAL_INBOX_SUMMARY = "An ephemeral ActivityPub inbox for testing purposes.";
-const inboxCommand = command("inbox", merge(object("Inbox options", {
+const inboxOptions = merge(object("Inbox options", {
 	command: constant("inbox"),
 	follow: bindConfig(multiple(option("-f", "--follow", string({ metavar: "URI" }), { description: message`Follow the given actor. The argument can be either an actor URI or a handle. Can be specified multiple times.` })), {
 		context: configContext,
@@ -33,9 +33,11 @@ const inboxCommand = command("inbox", merge(object("Inbox options", {
 		key: (config) => config.inbox?.authorizedFetch ?? false,
 		default: false
 	})
-}), group("Tunnel options", createTunnelOption("inbox"))), {
+}), group("Tunnel options", createTunnelOption("inbox")));
+const inboxMetadata = {
 	brief: message`Run an ephemeral ActivityPub inbox server.`,
 	description: message`Spins up an ephemeral server that serves the ActivityPub inbox with a one-time actor, through a short-lived public DNS with HTTPS. You can monitor the incoming activities in real-time.`
-});
+};
+command("inbox", inboxOptions, inboxMetadata);
 //#endregion
-export { inboxCommand };
+export { inboxMetadata, inboxOptions };

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,18 +1,18 @@
 import { Temporal } from "@js-temporal/polyfill";
+import { colors, matchesActor } from "./utils.js";
+import { configureLogging, recordingSink } from "./log.js";
 import { version } from "./deno.js";
 import { getDocumentLoader } from "./docloader.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";
 import { getLogger } from "@logtape/logtape";
+import ora from "ora";
+import { Accept, Activity, Application, Delete, Endpoints, Follow, Image, PUBLIC_COLLECTION, isActor, lookupObject } from "@fedify/vocab";
 import Table from "cli-table3";
 import { Hono } from "hono";
-import ora from "ora";
 import { jsx } from "hono/jsx/jsx-runtime";
 //#region src/inbox.tsx
 /** @jsx react-jsx */

package/dist/log.js

@@ -1,10 +1,10 @@
 import "@js-temporal/polyfill";
-import { mkdir } from "node:fs/promises";
 import process from "node:process";
+import { dirname } from "node:path";
 import { configure, getConsoleSink } from "@logtape/logtape";
+import { mkdir } from "node:fs/promises";
 import { getFileSink } from "@logtape/file";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { dirname } from "node:path";
 //#region src/log.ts
 function getRecordingSink() {
 	let records = [];

package/dist/lookup/command.js

@@ -0,0 +1,121 @@
+import "@js-temporal/polyfill";
+import { configContext } from "../config.js";
+import { createTunnelServiceOption, userAgentOption } from "../options.js";
+import { argument, choice, command, constant, flag, float, integer, map, merge, message, multiple, object, option, optionNames, optional, or, string, withDefault } from "@optique/core";
+import { path } from "@optique/run";
+import { bindConfig } from "@optique/config";
+//#region src/lookup/command.ts
+const IN_REPLY_TO_IRI = "https://www.w3.org/ns/activitystreams#inReplyTo";
+const QUOTE_IRI = "https://w3id.org/fep/044f#quote";
+const QUOTE_URL_IRI = "https://www.w3.org/ns/activitystreams#quoteUrl";
+const MISSKEY_QUOTE_IRI = "https://misskey-hub.net/ns#_misskey_quote";
+const FEDIBIRD_QUOTE_IRI = "http://fedibird.com/ns#quoteUri";
+const recurseProperties = [
+	"replyTarget",
+	"quote",
+	"quoteUrl",
+	IN_REPLY_TO_IRI,
+	QUOTE_IRI,
+	QUOTE_URL_IRI,
+	MISSKEY_QUOTE_IRI,
+	FEDIBIRD_QUOTE_IRI
+];
+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`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.` }), {
+	context: configContext,
+	key: (config) => config.lookup?.allowPrivateAddress ?? false,
+	default: false
+});
+const authorizedFetchOption = withDefault(object("Authorized fetch options", {
+	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`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"
+	}),
+	tunnelService: optional(createTunnelServiceOption())
+}), {
+	authorizedFetch: false,
+	firstKnock: void 0,
+	tunnelService: void 0
+});
+const lookupModeOption = withDefault(or(object("Recurse options", {
+	traverse: constant(false),
+	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`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`Traverse the given collection(s) to fetch all items.` }), {
+		context: configContext,
+		key: (config) => config.lookup?.traverse ?? false,
+		default: false
+	}),
+	recurse: constant(void 0),
+	recurseDepth: constant(void 0),
+	suppressErrors: suppressErrorsOption
+})), {
+	traverse: false,
+	recurse: void 0,
+	recurseDepth: void 0,
+	suppressErrors: false
+});
+const lookupOptions = merge(object({ command: constant("lookup") }), lookupModeOption, authorizedFetchOption, merge("Network options", userAgentOption, object({
+	allowPrivateAddress: allowPrivateAddressOption,
+	timeout: optional(bindConfig(option("-T", "--timeout", float({
+		min: 0,
+		metavar: "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`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`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`Specify the separator between adjacent output objects or collection items.` }), {
+		context: configContext,
+		key: (config) => config.lookup?.separator ?? "----",
+		default: "----"
+	}),
+	output: optional(option("-o", "--output", path({
+		metavar: "OUTPUT_PATH",
+		type: "file",
+		allowCreate: true
+	}), { description: message`Specify the output file path.` }))
+}));
+const lookupMetadata = {
+	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.`
+};
+command("lookup", lookupOptions, lookupMetadata);
+//#endregion
+export { FEDIBIRD_QUOTE_IRI, IN_REPLY_TO_IRI, MISSKEY_QUOTE_IRI, QUOTE_IRI, QUOTE_URL_IRI, authorizedFetchOption, lookupMetadata, lookupOptions };