@fedify/cli 2.3.0-dev.1336 → 2.3.0-dev.1344

package/dist/bench/action.js

@@ -1,6 +1,6 @@
 import "@js-temporal/polyfill";
-import { getContextLoader, getDocumentLoader } from "../docloader.js";
 import { describeError } from "../utils.js";
+import { getContextLoader, getDocumentLoader } from "../docloader.js";
 import { buildFleet } from "./actor/fleet.js";
 import { convertUrlIfHandle } from "../webfinger/lib.js";
 import { discoverInbox, selectInbox } from "./discovery/discover.js";
@@ -16,8 +16,8 @@ import { UnsafeTargetError, assertInboxDestinationAllowed, assertTargetAllowed,
 import { classifyResolvedTarget } from "./safety/tiers.js";
 import { resolveAdvertiseHost, spawnSyntheticServer } from "./server/synthetic.js";
 import { runnerFor } from "./scenarios/registry.js";
-import { writeFile } from "node:fs/promises";
 import process from "node:process";
+import { writeFile } from "node:fs/promises";
 //#region src/bench/action.ts
 /**
 * Runs the `fedify bench` command: load and validate the suite, gate the

package/dist/bench/command.js

@@ -34,7 +34,7 @@ sending load.` }), false),
 	advertiseHost: advertiseHostOption,
 	allowUnsafeTarget
 }), userAgentOption);
-const benchCommand = command("bench", or(command("compare", merge("Compare options", object({
+const benchOptions = or(command("compare", merge("Compare options", object({
 	command: constant("bench"),
 	mode: constant("compare"),
 	base: option("--base", string({ metavar: "REF" }), { description: message`The base git ref to benchmark.` }),
@@ -56,7 +56,8 @@ checked-out worktree.` }),
 	description: message`Run the same benchmark suite against two git revisions on the \
 same runner, then fail when the head revision regresses beyond the configured \
 tolerance and measured noise band.`
-}), runParser), {
+}), runParser);
+const benchMetadata = {
 	brief: message`Benchmark a Fedify federation workload.`,
 	description: message`Run an ActivityPub-specific load benchmark against a \
 cooperative Fedify target running in benchmark mode.
@@ -65,6 +66,7 @@ The suite file declares the target, actors, and scenarios.  This version \
 executes the \`inbox\`, \`webfinger\`, \`actor\`, \`object\`, \`fanout\`, \
 \`failure\`, and \`mixed\` scenario types; \`collection\` remains reserved by \
 the suite format.`
-});
+};
+command("bench", benchOptions, benchMetadata);
 //#endregion
-export { benchCommand };
+export { benchMetadata, benchOptions };

package/dist/bench/compare.js

@@ -4,11 +4,11 @@ import { metricUnit } from "./result/expect/metrics.js";
 import { parseDuration } from "./scenario/units.js";
 import runBench from "./action.js";
 import { COMPARE_REPORT_SCHEMA_ID } from "./compare/schema.js";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import process from "node:process";
-import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
 //#region src/bench/compare.ts
 const ZERO_BASE_LATENCY_ALLOWANCE_MS = 1;
 /** Runs `fedify bench compare`. */

package/dist/bench/mod.js

@@ -1,7 +1,7 @@
 import "@js-temporal/polyfill";
+import "./command.js";
 import runBench$1 from "./action.js";
 import { runBenchCompare } from "./compare.js";
-import "./command.js";
 //#region src/bench/mod.ts
 /** Runs a parsed benchmark command. */
 function runBench(command) {

package/dist/bench/result/build.js

@@ -3,8 +3,8 @@ import { version } from "../../deno.js";
 import { evaluateExpect } from "./expect/evaluate.js";
 import { REPORT_SCHEMA_ID } from "./schema.js";
 import process from "node:process";
-import { createHash } from "node:crypto";
 import { cpus } from "node:os";
+import { createHash } from "node:crypto";
 //#region src/bench/result/build.ts
 /**
 * Assembly of the canonical benchmark report from measured scenario data.

package/dist/cache.js

@@ -1,8 +1,8 @@
 import "@js-temporal/polyfill";
-import { mkdir } from "node:fs/promises";
 import process from "node:process";
 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 { message } from "@optique/core";
 import { printError } from "@optique/run";
-import { createConfigContext } from "@optique/config";
 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
 /**

package/dist/deno.js

@@ -1,5 +1,5 @@
 import "@js-temporal/polyfill";
 //#region deno.json
-var version = "2.3.0-dev.1336+fbc00626";
+var version = "2.3.0-dev.1344+d573d413";
 //#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,7 +1,7 @@
 import "@js-temporal/polyfill";
-import { stat } from "node:fs/promises";
 import process from "node:process";
 import { printError } from "@optique/run";
+import { stat } from "node:fs/promises";
 import { generateVocab } from "@fedify/vocab-tools";
 import { message } from "@optique/core/message";
 //#region src/generate-vocab/action.ts

package/dist/generate-vocab/command.js

@@ -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,10 +1,10 @@
 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";
 //#region src/imagerenderer.ts
 const KITTY_IDENTIFIERS = [

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.js

@@ -1,18 +1,18 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { getDocumentLoader } from "./docloader.js";
 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 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,8 +1,8 @@
 import "@js-temporal/polyfill";
-import { mkdir } from "node:fs/promises";
 import process from "node:process";
-import { configure, getConsoleSink } from "@logtape/logtape";
 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";
 //#region src/log.ts

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 };

package/dist/lookup.js

@@ -1,22 +1,20 @@
 import "@js-temporal/polyfill";
-import { getContextLoader, getDocumentLoader as getDocumentLoader$1 } from "./docloader.js";
+import { FEDIBIRD_QUOTE_IRI, IN_REPLY_TO_IRI, MISSKEY_QUOTE_IRI, QUOTE_IRI, QUOTE_URL_IRI } from "./lookup/command.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 { getContextLoader, getDocumentLoader as getDocumentLoader$1 } from "./docloader.js";
 import { spawnTemporaryServer } from "./tempserver.js";
 import { renderImages } from "./imagerenderer.js";
 import process from "node:process";
-import { generateCryptoKeyPair, getAuthenticatedDocumentLoader, respondWithObject } from "@fedify/fedify";
+import { message, optionNames } from "@optique/core";
+import { printError } from "@optique/run";
+import { createWriteStream } from "node:fs";
 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 { generateCryptoKeyPair, getAuthenticatedDocumentLoader, respondWithObject } from "@fedify/fedify";
 import { getLogger } from "@logtape/logtape";
-import { bindConfig } from "@optique/config";
-import { createWriteStream } from "node:fs";
-import { url } from "@optique/core/message";
 import ora from "ora";
+import { Application, Collection, CryptographicKey, Object as Object$1, lookupObject, traverseCollection } from "@fedify/vocab";
+import { url } from "@optique/core/message";
 import { isIP } from "node:net";
 //#region src/lookup.ts
 const logger = getLogger([
@@ -24,116 +22,6 @@ const logger = getLogger([
 	"cli",
 	"lookup"
 ]);
-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 lookupCommand = command("lookup", 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.` }))
-})), {
-	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.`
-});
 var TimeoutError = class extends Error {
 	name = "TimeoutError";
 	constructor(message) {
@@ -472,6 +360,7 @@ async function runLookup(command, deps = {}) {
 		effectiveDeps.exit(cleanupFailed && code === 0 ? 1 : code);
 	};
 	if (command.authorizedFetch) {
+		const firstKnock = command.firstKnock ?? "draft-cavage-http-signatures-12";
 		spinner.text = "Generating a one-time key pair...";
 		const key = await generateCryptoKeyPair();
 		spinner.text = "Spinning up a temporary ActivityPub server...";
@@ -511,7 +400,7 @@ async function runLookup(command, deps = {}) {
 			userAgent: command.userAgent,
 			specDeterminer: {
 				determineSpec() {
-					return command.firstKnock;
+					return firstKnock;
 				},
 				rememberSpec() {}
 			}
@@ -521,7 +410,7 @@ async function runLookup(command, deps = {}) {
 			userAgent: command.userAgent,
 			specDeterminer: {
 				determineSpec() {
-					return command.firstKnock;
+					return firstKnock;
 				},
 				rememberSpec() {}
 			}
@@ -818,4 +707,4 @@ async function runLookup(command, deps = {}) {
 	if (success && command.output) spinner.succeed(`Successfully wrote output to ${colors.green(command.output)}.`);
 }
 //#endregion
-export { lookupCommand, runLookup };
+export { runLookup };

package/dist/mod.js

@@ -1,30 +1,10 @@
 #!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 import "@js-temporal/polyfill";
-import { runBench } from "./bench/mod.js";
-import runGenerateVocab from "./generate-vocab/action.js";
-import "./generate-vocab/mod.js";
-import { runInbox } from "./inbox.js";
-import { runInit } from "./init/mod.js";
-import { runNodeInfo } from "./nodeinfo.js";
-import { runLookup } from "./lookup.js";
-import { runRelay } from "./relay.js";
-import { runTunnel } from "./tunnel.js";
-import runWebFinger from "./webfinger/action.js";
-import "./webfinger/mod.js";
-import { runCli } from "./runner.js";
+import { parseCliProgram } from "./runner.js";
 import process from "node:process";
 //#region src/mod.ts
 async function main() {
-	const result = await runCli(process.argv.slice(2));
-	if (result.command === "init") await runInit(result);
-	else if (result.command === "lookup") await runLookup(result);
-	else if (result.command === "webfinger") await runWebFinger(result);
-	else if (result.command === "inbox") await runInbox(result);
-	else if (result.command === "nodeinfo") await runNodeInfo(result);
-	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 (await parseCliProgram(process.argv.slice(2))).run();
 }
 await main();
 //#endregion

package/dist/nodeinfo.js

@@ -1,20 +1,20 @@
 import "@js-temporal/polyfill";
-import { colors, formatObject } from "./utils.js";
 import { configContext } from "./config.js";
 import { userAgentOption } from "./options.js";
+import { colors, formatObject } from "./utils.js";
 import process from "node:process";
-import { getNodeInfo } from "@fedify/fedify";
-import { getUserAgent } from "@fedify/vocab-runtime";
 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 { getUserAgent } from "@fedify/vocab-runtime";
+import { getNodeInfo } from "@fedify/fedify";
 import { createJimp } from "@jimp/core";
 import webp from "@jimp/wasm-webp";
+import { getLogger } from "@logtape/logtape";
 import { isICO, parseICO } from "icojs";
 import { defaultFormats, defaultPlugins, intToRGBA } from "jimp";
+import ora from "ora";
 //#region src/nodeinfo.ts
 const logger = getLogger([
 	"fedify",
@@ -46,15 +46,17 @@ const nodeInfoOption = merge(object("Display options", {
 	key: (config) => config.nodeinfo?.bestEffort ?? false,
 	default: false
 }) }));
-const nodeInfoCommand = command("nodeinfo", merge(object("Arguments", {
+const nodeInfoOptions = merge(object("Arguments", {
 	command: constant("nodeinfo"),
 	host: argument(string({ metavar: "HOST" }), { description: message`Bare hostname or a full URL of the instance` })
-}), nodeInfoOption, group("Network options", userAgentOption)), {
+}), nodeInfoOption, group("Network options", userAgentOption));
+const nodeInfoMetadata = {
 	brief: message`Get information about a remote node using the NodeInfo protocol`,
 	description: message`Get information about a remote node using the NodeInfo protocol.
 
 The argument is the hostname of the remote node, or the URL of the remote node.`
-});
+};
+command("nodeinfo", nodeInfoOptions, nodeInfoMetadata);
 async function runNodeInfo(command) {
 	const spinner = ora({
 		text: "Fetching a NodeInfo document...",
@@ -270,4 +272,4 @@ function getAsciiArt(image, width = DEFAULT_IMAGE_WIDTH, colorSupport, colors) {
 	return art;
 }
 //#endregion
-export { Jimp, nodeInfoCommand, runNodeInfo };
+export { Jimp, nodeInfoMetadata, nodeInfoOptions, runNodeInfo };

package/dist/options.js

@@ -1,8 +1,8 @@
 import "@js-temporal/polyfill";
 import { configContext } from "./config.js";
-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";
+import { getUserAgent } from "@fedify/vocab-runtime";
 //#region src/options.ts
 /**
 * Available tunneling services for exposing local servers to the public internet.

package/dist/relay/command.js

@@ -5,7 +5,7 @@ import { command, constant, group, integer, merge, message, multiple, object, op
 import { bindConfig } from "@optique/config";
 import { choice as choice$1 } from "@optique/core/valueparser";
 //#region src/relay/command.ts
-const relayCommand = command("relay", merge(object("Relay options", {
+const relayOptions = merge(object("Relay options", {
 	command: constant("relay"),
 	protocol: bindConfig(option("-p", "--protocol", choice$1(["mastodon", "litepub"], { metavar: "TYPE" }), { description: message`The relay protocol to use. ${value("mastodon")} for Mastodon-compatible relay, ${value("litepub")} for LitePub-compatible relay.` }), {
 		context: configContext,
@@ -40,11 +40,13 @@ const relayCommand = command("relay", merge(object("Relay options", {
 		key: (config) => config.relay?.rejectFollow ?? [],
 		default: []
 	})
-}), group("Tunnel options", createTunnelOption("relay"))), {
+}), group("Tunnel options", createTunnelOption("relay")));
+const relayMetadata = {
 	brief: message`Run an ephemeral ActivityPub relay server.`,
 	description: message`Spins up an ActivityPub relay server that forwards activities between federated instances. The server can use either Mastodon or LitePub compatible relay protocol.
 
 By default, the server is tunneled to the public internet for external access. Use ${optionName("--no-tunnel")} to run locally only.`
-});
+};
+command("relay", relayOptions, relayMetadata);
 //#endregion
-export { relayCommand };
+export { relayMetadata, relayOptions };

package/dist/relay.js

@@ -6,11 +6,11 @@ import { spawnTemporaryServer } from "./tempserver.js";
 import process from "node:process";
 import { MemoryKvStore } from "@fedify/fedify";
 import { getLogger } from "@logtape/logtape";
-import Table from "cli-table3";
 import ora from "ora";
-import { createRelay } from "@fedify/relay";
 import { SqliteKvStore } from "@fedify/sqlite";
 import { DatabaseSync } from "node:sqlite";
+import Table from "cli-table3";
+import { createRelay } from "@fedify/relay";
 //#region src/relay.ts
 const logger = getLogger([
 	"fedify",

package/dist/runner.js

@@ -1,26 +1,16 @@
 import "@js-temporal/polyfill";
-import { describeError } from "./utils.js";
-import { version } from "./deno.js";
 import { configContext, tryLoadToml } from "./config.js";
 import { globalOptions } from "./options.js";
-import { benchCommand } from "./bench/command.js";
-import generateVocabCommand from "./generate-vocab/command.js";
-import "./generate-vocab/mod.js";
-import { initCommand } from "./init/mod.js";
-import { nodeInfoCommand } from "./nodeinfo.js";
-import { lookupCommand } from "./lookup.js";
-import { inboxCommand } from "./inbox/command.js";
-import { relayCommand } from "./relay/command.js";
-import { tunnelCommand } from "./tunnel.js";
-import { webFingerCommand } from "./webfinger/command.js";
-import "./webfinger/mod.js";
+import { describeError } from "./utils.js";
+import { activityPubCommands, generatingCommands, networkCommands } from "./commands.js";
+import { version } from "./deno.js";
 import process from "node:process";
-import { group, merge, message, or } from "@optique/core";
+import { command, group, map, merge, message, or } from "@optique/core";
 import { printError, run } from "@optique/run";
 import { merge as merge$1 } from "es-toolkit";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { readFileSync } from "node:fs";
 import { parse } from "smol-toml";
 //#region src/runner.ts
 /**
@@ -41,36 +31,35 @@ function getUserConfigPath() {
 	if (process.platform === "win32") return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "fedify", "config.toml");
 	return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "fedify", "config.toml");
 }
-const command$1 = merge(or(group("Generating code", or(initCommand, generateVocabCommand)), group("ActivityPub tools", or(webFingerCommand, lookupCommand, inboxCommand, nodeInfoCommand, relayCommand, benchCommand)), group("Network tools", tunnelCommand)), globalOptions);
-function loadConfig(parsed) {
-	if (parsed.ignoreConfig) return void 0;
-	const system = getSystemConfigPaths().map(tryLoadToml).reduce((acc, config) => merge$1(acc, config), {});
-	const user = tryLoadToml(getUserConfigPath());
-	const project = tryLoadToml(join(process.cwd(), ".fedify.toml"));
-	let custom = {};
-	if (parsed.configPath) try {
-		custom = parse(readFileSync(parsed.configPath, "utf-8"));
-	} catch (error) {
-		printError(message`Could not load config file at ${parsed.configPath}: ${describeError(error)}`);
-		process.exit(1);
+const selectedCommand = "__fedifyCliSelectedCommand";
+const selectedRun = "__fedifyCliRunCommand";
+function staticCommandParser(staticCommand) {
+	if (staticCommand.path.length < 1) throw new TypeError("Static command path must not be empty.");
+	let parser = staticCommand.parser;
+	for (let i = staticCommand.path.length - 1; i >= 0; i--) {
+		const name = staticCommand.path[i];
+		if (name == null) throw new TypeError("Static command path contains an empty segment.");
+		parser = command(name, parser, i === staticCommand.path.length - 1 ? staticCommand.metadata : void 0);
 	}
-	return {
-		config: [
-			system,
-			user,
-			project,
-			custom
-		].reduce((acc, config) => merge$1(acc, config), {}),
-		meta: void 0
-	};
+	const runCommand = staticCommand.run;
+	return map(parser, (value) => ({
+		...value,
+		[selectedCommand]: staticCommand,
+		[selectedRun]: (globalOptions) => runCommand({
+			...value,
+			...globalOptions
+		})
+	}));
 }
-/**
-* Runs the Fedify CLI with the given command-line arguments.
-* @param args Command-line arguments, usually `process.argv.slice(2)`.
-* @returns The parsed command result from Optique's runner.
-*/
-function runCli(args) {
-	return run(command$1, {
+function staticCommandsParser(commands) {
+	const parsers = commands.map(staticCommandParser);
+	if (parsers.length < 1) throw new TypeError("Static command group must not be empty.");
+	return parsers.length === 1 ? parsers[0] : or(...parsers);
+}
+const runnableCommand = merge(or(group("Generating code", staticCommandsParser(generatingCommands)), group("ActivityPub tools", staticCommandsParser(activityPubCommands)), group("Network tools", staticCommandsParser(networkCommands))), globalOptions);
+map(runnableCommand, ({ [selectedCommand]: _selectedCommand, [selectedRun]: _selectedRun, ...value }) => value);
+function getRunOptions(args) {
+	return {
 		contexts: [configContext],
 		contextOptions: { load: loadConfig },
 		programName: "fedify",
@@ -92,7 +81,41 @@ function runCli(args) {
 		maxWidth: process.stdout.columns,
 		showDefault: true,
 		showChoices: true
-	});
+	};
+}
+function loadConfig(parsed) {
+	if (parsed.ignoreConfig) return void 0;
+	const system = getSystemConfigPaths().map(tryLoadToml).reduce((acc, config) => merge$1(acc, config), {});
+	const user = tryLoadToml(getUserConfigPath());
+	const project = tryLoadToml(join(process.cwd(), ".fedify.toml"));
+	let custom = {};
+	if (parsed.configPath) try {
+		custom = parse(readFileSync(parsed.configPath, "utf-8"));
+	} catch (error) {
+		printError(message`Could not load config file at ${parsed.configPath}: ${describeError(error)}`);
+		process.exit(1);
+	}
+	return {
+		config: [
+			system,
+			user,
+			project,
+			custom
+		].reduce((acc, config) => merge$1(acc, config), {}),
+		meta: void 0
+	};
+}
+function toCliProgram(parsed) {
+	const { [selectedCommand]: command, [selectedRun]: runCommand, ...value } = parsed;
+	const publicValue = value;
+	return {
+		command,
+		value: publicValue,
+		run: () => runCommand(publicValue)
+	};
+}
+async function parseCliProgram(args) {
+	return toCliProgram(await run(runnableCommand, getRunOptions(args)));
 }
 //#endregion
-export { runCli };
+export { parseCliProgram };

package/dist/tempserver.js

@@ -1,7 +1,7 @@
 import "@js-temporal/polyfill";
 import { getLogger } from "@logtape/logtape";
-import { serve } from "srvx";
 import { openTunnel } from "@hongminhee/localtunnel";
+import { serve } from "srvx";
 //#region src/tempserver.ts
 const logger = getLogger([
 	"fedify",

package/dist/tunnel.js

@@ -7,19 +7,21 @@ import { print, printError } from "@optique/run";
 import ora from "ora";
 import { openTunnel } from "@hongminhee/localtunnel";
 //#region src/tunnel.ts
-const tunnelCommand = command("tunnel", merge("Tunnel options", object({ command: constant("tunnel") }), object({
+const tunnelOptions = merge("Tunnel options", object({ command: constant("tunnel") }), object({
 	port: argument(integer({
 		metavar: "PORT",
 		min: 0,
 		max: 65535
 	}), { description: message`The local port number to expose.` }),
 	service: createTunnelServiceOption(["-s", "--service"])
-})), {
+}));
+const tunnelMetadata = {
 	brief: message`Expose a local HTTP server to the public internet using a secure tunnel.`,
 	description: message`Expose a local HTTP server to the public internet using a secure tunnel.
 
 Note that the HTTP requests through the tunnel have X-Forwarded-* headers.`
-});
+};
+command("tunnel", tunnelOptions, tunnelMetadata);
 async function runTunnel(command, deps = {
 	openTunnel,
 	ora,
@@ -49,4 +51,4 @@ async function runTunnel(command, deps = {
 	});
 }
 //#endregion
-export { runTunnel, tunnelCommand };
+export { runTunnel, tunnelMetadata, tunnelOptions };

package/dist/utils.js

@@ -1,14 +1,14 @@
 import "@js-temporal/polyfill";
-import "node:fs/promises";
 import process from "node:process";
-import { getActorHandle } from "@fedify/vocab";
-import "@fxts/core";
 import { message } from "@optique/core";
 import { print, printError } from "@optique/run";
+import { flow } from "es-toolkit";
+import { getActorHandle } from "@fedify/vocab";
+import "@fxts/core";
 import { Chalk } from "chalk";
 import { highlight } from "cli-highlight";
-import { flow } from "es-toolkit";
 import "node:child_process";
+import "node:fs/promises";
 import util from "node:util";
 //#region src/utils.ts
 const colorEnabled = process.stdout.isTTY && !("NO_COLOR" in process.env && process.env.NO_COLOR !== "");

package/dist/webfinger/action.js

@@ -3,8 +3,8 @@ import { formatObject } from "../utils.js";
 import { NotFoundError, getErrorMessage } from "./error.js";
 import { convertUrlIfHandle } from "./lib.js";
 import { print } from "@optique/run";
-import { formatMessage, message } from "@optique/core/message";
 import ora from "ora";
+import { formatMessage, message } from "@optique/core/message";
 import { lookupWebFinger } from "@fedify/webfinger";
 //#region src/webfinger/action.ts
 async function runWebFinger({ command: _, resources, ...options }) {

package/dist/webfinger/command.js

@@ -14,16 +14,18 @@ const maxRedirection = bindConfig(option("--max-redirection", integer({ min: 0 }
 	key: (config) => config.webfinger?.maxRedirection ?? 5,
 	default: 5
 });
-const webFingerCommand = command("webfinger", merge("Network options", object({
+const webFingerOptions = merge("Network options", object({
 	command: constant("webfinger"),
 	resources: group("Arguments", multiple(argument(string({ metavar: "RESOURCE" }), { description: message`WebFinger resource(s) to look up.` }), { min: 1 })),
 	allowPrivateAddresses,
 	maxRedirection
-}), userAgentOption), {
+}), userAgentOption);
+const webFingerMetadata = {
 	brief: message`Look up WebFinger resources.`,
 	description: message`Look up WebFinger resources.
 
 The argument can be multiple.`
-});
+};
+command("webfinger", webFingerOptions, webFingerMetadata);
 //#endregion
-export { webFingerCommand };
+export { webFingerMetadata, webFingerOptions };

package/dist/webfinger/lib.js

@@ -1,7 +1,7 @@
 import "@js-temporal/polyfill";
 import { InvalidHandleError } from "./error.js";
-import { toAcctUrl } from "@fedify/vocab";
 import { getLogger } from "@logtape/logtape";
+import { toAcctUrl } from "@fedify/vocab";
 getLogger([
 	"fedify",
 	"cli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/cli",
-  "version": "2.3.0-dev.1336+fbc00626",
+  "version": "2.3.0-dev.1344+d573d413",
   "type": "module",
   "files": [
     "README.md",
@@ -59,9 +59,10 @@
   "dependencies": {
     "@cfworker/json-schema": "^4.1.1",
     "@fxts/core": "^1.20.0",
-    "@optique/config": "^1.0.2",
-    "@optique/core": "^1.0.2",
-    "@optique/run": "^1.0.2",
+    "@optique/config": "^1.1.0",
+    "@optique/core": "^1.1.0",
+    "@optique/discover": "^1.1.0",
+    "@optique/run": "^1.1.0",
     "@standard-schema/spec": "^1.1.0",
     "@hongminhee/localtunnel": "^0.3.0",
     "@inquirer/prompts": "^7.8.4",
@@ -89,14 +90,14 @@
     "srvx": "^0.8.7",
     "valibot": "^1.4.0",
     "yaml": "^2.9.0",
-    "@fedify/fedify": "2.3.0-dev.1336+fbc00626",
-    "@fedify/sqlite": "2.3.0-dev.1336+fbc00626",
-    "@fedify/init": "2.3.0-dev.1336+fbc00626",
-    "@fedify/vocab": "2.3.0-dev.1336+fbc00626",
-    "@fedify/vocab-runtime": "2.3.0-dev.1336+fbc00626",
-    "@fedify/relay": "2.3.0-dev.1336+fbc00626",
-    "@fedify/vocab-tools": "2.3.0-dev.1336+fbc00626",
-    "@fedify/webfinger": "2.3.0-dev.1336+fbc00626"
+    "@fedify/fedify": "2.3.0-dev.1344+d573d413",
+    "@fedify/init": "2.3.0-dev.1344+d573d413",
+    "@fedify/sqlite": "2.3.0-dev.1344+d573d413",
+    "@fedify/relay": "2.3.0-dev.1344+d573d413",
+    "@fedify/vocab": "2.3.0-dev.1344+d573d413",
+    "@fedify/vocab-tools": "2.3.0-dev.1344+d573d413",
+    "@fedify/webfinger": "2.3.0-dev.1344+d573d413",
+    "@fedify/vocab-runtime": "2.3.0-dev.1344+d573d413"
   },
   "devDependencies": {
     "@types/bun": "^1.2.23",

package/dist/generate-vocab/mod.js

@@ -1,4 +0,0 @@
-import "@js-temporal/polyfill";
-import "./action.js";
-import "./command.js";
-export {};

package/dist/init/mod.js

@@ -1,3 +0,0 @@
-import "@js-temporal/polyfill";
-import { initCommand, runInit } from "@fedify/init";
-export { initCommand, runInit };

package/dist/webfinger/mod.js

@@ -1,4 +0,0 @@
-import "@js-temporal/polyfill";
-import "./action.js";
-import "./command.js";
-export {};