@fedify/init 2.4.0-pr.934.40 → 2.4.0

package/dist/json/rt.js

@@ -3,27 +3,20 @@ var rt_default = {
 	deno: {
 		"label": "Deno",
 		"checkCommand": ["deno", "--version"],
-		"outputPattern": "^deno\\s+\\d+\\.\\d+\\.\\d+\\b"
+		"outputPattern": "^deno\\s+(\\d+\\.\\d+\\.\\d+\\b)",
+		"minVersion": "2.0.0"
 	},
 	bun: {
 		"label": "Bun",
 		"checkCommand": ["bun", "--version"],
-		"outputPattern": "^\\d+\\.\\d+\\.\\d+$"
+		"outputPattern": "^(\\d+\\.\\d+\\.\\d+\\b)",
+		"minVersion": "1.1.0"
 	},
-	pnpm: {
+	node: {
 		"label": "Node.js",
 		"checkCommand": ["node", "--version"],
-		"outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
-	},
-	yarn: {
-		"label": "Node.js",
-		"checkCommand": ["node", "--version"],
-		"outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
-	},
-	npm: {
-		"label": "Node.js",
-		"checkCommand": ["node", "--version"],
-		"outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
+		"outputPattern": "^v(\\d+\\.\\d+\\.\\d+\\b)",
+		"minVersion": "22.0.0"
 	}
 };
 //#endregion

package/dist/json/rt.json

@@ -5,7 +5,8 @@
       "deno",
       "--version"
     ],
-    "outputPattern": "^deno\\s+\\d+\\.\\d+\\.\\d+\\b"
+    "outputPattern": "^deno\\s+(\\d+\\.\\d+\\.\\d+\\b)",
+    "minVersion": "2.0.0"
   },
   "bun": {
     "label": "Bun",
@@ -13,30 +14,16 @@
       "bun",
       "--version"
     ],
-    "outputPattern": "^\\d+\\.\\d+\\.\\d+$"
+    "outputPattern": "^(\\d+\\.\\d+\\.\\d+\\b)",
+    "minVersion": "1.1.0"
   },
-  "pnpm": {
+  "node": {
     "label": "Node.js",
     "checkCommand": [
       "node",
       "--version"
     ],
-    "outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
-  },
-  "yarn": {
-    "label": "Node.js",
-    "checkCommand": [
-      "node",
-      "--version"
-    ],
-    "outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
-  },
-  "npm": {
-    "label": "Node.js",
-    "checkCommand": [
-      "node",
-      "--version"
-    ],
-    "outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
+    "outputPattern": "^v(\\d+\\.\\d+\\.\\d+\\b)",
+    "minVersion": "22.0.0"
   }
 }

package/dist/lib.js

@@ -1,8 +1,9 @@
 import { version } from "./deno.js";
 import kv_default from "./json/kv.js";
 import mq_default from "./json/mq.js";
-import pm_default from "./json/pm.js";
 import rt_default from "./json/rt.js";
+import { RUNTIME } from "./const.js";
+import pm_default from "./json/pm.js";
 import { CommandError, isNotFoundError, runSubCommand } from "./utils.js";
 import { entries, evolve, fromEntries, isObject, map, negate, pipe, throwIf } from "@fxts/core";
 import process from "node:process";
@@ -87,6 +88,20 @@ const readTemplate = async (templatePath) => {
 * package manager (e.g., `"deno task dev"`, `"bun dev"`, `"npm run dev"`).
 */
 const getDevCommand = (pm) => pm === "deno" ? "deno task dev" : pm === "bun" ? "bun dev" : `${pm} run dev`;
+/** Returns the command to build for the given package manager. */
+const getBuildCommand = (pm) => pm === "deno" ? [
+	"deno",
+	"task",
+	"build"
+] : pm === "bun" ? [
+	"bun",
+	"run",
+	"build"
+] : [
+	pm,
+	"run",
+	"build"
+];
 async function isCommandAvailable({ checkCommand, outputPattern }) {
 	try {
 		const { stdout } = await $`${checkCommand}`.stdout("piped").spawn();
@@ -105,6 +120,81 @@ async function isCommandAvailable({ checkCommand, outputPattern }) {
 	}
 }
 /**
+* Compares two dotted version strings segment by segment and returns whether
+* `detected` is higher than or equal to `required`.
+*/
+function verifyRuntimeVersion(detected, required) {
+	const detectedParts = detected.split(".").map(Number);
+	const requiredParts = required.split(".").map(Number);
+	for (let i = 0; i < Math.max(detectedParts.length, requiredParts.length); i++) {
+		const detectedPart = detectedParts[i] ?? 0;
+		const requiredPart = requiredParts[i] ?? 0;
+		if (detectedPart > requiredPart) return true;
+		if (detectedPart < requiredPart) return false;
+	}
+	return true;
+}
+/**
+* Runs a runtime's version command and classifies the result as `"ok"`,
+* `"unsupported"`, `"missing"`, or `"malformed"` against its `minVersion`.
+*/
+async function checkRuntimeVersion({ checkCommand, outputPattern, minVersion }) {
+	try {
+		const { stdout } = await $`${checkCommand}`.stdout("piped").spawn();
+		logger.debug("The stdout of the command {command} is: {stdout}", {
+			command: checkCommand,
+			stdout
+		});
+		const detected = outputPattern.exec(stdout.trim())?.[1] ?? null;
+		if (detected == null) return {
+			status: "malformed",
+			detected: null,
+			required: minVersion
+		};
+		if (!verifyRuntimeVersion(detected, minVersion)) return {
+			status: "unsupported",
+			detected,
+			required: minVersion
+		};
+		return {
+			status: "ok",
+			detected,
+			required: minVersion
+		};
+	} catch (error) {
+		if (isNotFoundError(error)) return {
+			status: "missing",
+			detected: null,
+			required: minVersion
+		};
+		logger.debug("The command {command} failed with the error: {error}", {
+			command: checkCommand,
+			error
+		});
+		throw error;
+	}
+}
+/**
+* Resolves the required version for `runtime` as the higher of its base minimum
+* and an optional framework `override`.
+*/
+function resolveRequiredVersion(runtime, override) {
+	const base = runtimes[runtime].minVersion;
+	return override != null && verifyRuntimeVersion(override, base) ? override : base;
+}
+/**
+* Checks every supported runtime once and returns a map from each runtime
+* identifier to its version-check result, applying framework `overrides` on
+* top of each runtime's base minimum.
+*/
+async function checkAllRuntimes(overrides = {}) {
+	const checked = await Promise.all(RUNTIME.map(async (runtime) => [runtime, await checkRuntimeVersion({
+		...runtimes[runtime],
+		minVersion: resolveRequiredVersion(runtime, overrides[runtime])
+	})]));
+	return Object.fromEntries(checked);
+}
+/**
 * Creates a file at the given path with the given content, creating
 * any necessary parent directories along the way.
 */
@@ -277,4 +367,4 @@ const isDirectory = async (path) => {
 /** Returns `true` if the current run is in test mode. */
 const isTest = ({ testMode }) => testMode;
 //#endregion
-export { PACKAGE_VERSION, createFile, getDevCommand, getInstallUrl, isDirectoryEmpty, isPackageManagerAvailable, isTest, kvStores, logger, messageQueues, packageManagers, readTemplate, runtimes, throwUnlessNotExists };
+export { PACKAGE_VERSION, checkAllRuntimes, createFile, getBuildCommand, getDevCommand, getInstallUrl, isDirectoryEmpty, isPackageManagerAvailable, isTest, kvStores, logger, messageQueues, packageManagers, readTemplate, resolveRequiredVersion, runtimes, throwUnlessNotExists, verifyRuntimeVersion };

package/dist/mod.d.ts

@@ -1,3 +1,3 @@
 import { initCommand, initOptions } from "./command.js";
-import { runInit } from "./action/mod.js";
+import runInit from "./action/mod.js";
 export { initCommand, initOptions, runInit };

package/dist/templates/astro/astro.config.bun.ts.tpl

@@ -1,4 +1,4 @@
-import bun from "@nurodev/astro-bun";
+import node from "@astrojs/node";
 import { fedifyIntegration } from "@fedify/astro";
 import { defineConfig } from "astro/config";
 
@@ -6,5 +6,5 @@ import { defineConfig } from "astro/config";
 export default defineConfig({
   integrations: [fedifyIntegration()],
   output: "server",
-  adapter: bun(),
+  adapter: node({ mode: "standalone" }),
 });

package/dist/templates/defaults/smoke.test.ts.tpl

@@ -0,0 +1,170 @@
+import { getDocumentLoader } from "@fedify/fedify";
+import { type Actor, isActor, lookupObject } from "@fedify/vocab";
+import { spawn, spawnSync } from "node:child_process";
+import type { Readable } from "node:stream";
+
+const DEV_COMMAND: string[] = /* dev command */;
+const HANDLE = "john";
+const STARTUP_TIMEOUT = 15_000;
+const IS_WINDOWS = process.platform === "win32";
+
+async function main(): Promise<void> {
+  const [command, ...args] = DEV_COMMAND;
+  const server = spawn(command, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: IS_WINDOWS,
+    windowsHide: true,
+    detached: !IS_WINDOWS,
+  });
+  server.on("error", () => {});
+
+  const exitOnSignal = () => {
+    stopServer(server);
+    process.exit(1);
+  };
+  process.once("SIGINT", exitOnSignal);
+  process.once("SIGTERM", exitOnSignal);
+
+  let output = "";
+  const collectOutput = (stream: Readable | null) => {
+    const decoder = new TextDecoder();
+    stream?.on("data", (chunk: Buffer) => {
+      output += decoder.decode(chunk, { stream: true });
+    });
+  };
+  collectOutput(server.stdout);
+  collectOutput(server.stderr);
+
+  try {
+    const port = await determinePort(server);
+    const target = `http://localhost:${port}/users/${HANDLE}`;
+    await waitForServer(target);
+    console.log(`Server is up at http://localhost:${port}.`);
+    const actor = await checkActor(target);
+    console.log(actor);
+    console.log(`Smoke test passed: ${target} resolved to an actor.`);
+  } catch (error) {
+    console.error("Smoke test failed:", error instanceof Error ? error.message : error);
+    if (output.trim() !== "") {
+      console.error(`\nDev server output:\n${output}`);
+    }
+    process.exitCode = 1;
+  } finally {
+    stopServer(server);
+  }
+}
+
+function stripEscape(text: string): string {
+  return text.replace(new RegExp("\\u001B\\[[0-9;]*[A-Za-z]", "g"), "");
+}
+
+function determinePort(server: ReturnType<typeof spawn>): Promise<number> {
+  const portPatterns = [
+    /listening on.*:(\d+)/i,
+    /server.*:(\d+)/i,
+    /https?:\/\/localhost:(\d+)/i,
+    /https?:\/\/0\.0\.0\.0:(\d+)/i,
+    /https?:\/\/127\.0\.0\.1:(\d+)/i,
+    /https?:\/\/[^:]+:(\d+)/i,
+  ];
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(
+        new Error(
+          `Timeout: Could not determine port from server output within ${STARTUP_TIMEOUT}ms.`,
+        ),
+      );
+    }, STARTUP_TIMEOUT);
+
+    const findPort = (text: string) => {
+      for (const pattern of portPatterns) {
+        const match = text.match(pattern);
+        if (match && match[1]) {
+          const port = Number.parseInt(match[1], 10);
+          if (port > 0 && port < 65536) return port;
+        }
+      }
+      return null;
+    };
+
+    const scan = (stream: Readable | null) => {
+      const decoder = new TextDecoder();
+      let text = "";
+      stream?.on("data", (chunk: Buffer) => {
+        text += decoder.decode(chunk, { stream: true });
+        const port = findPort(stripEscape(text));
+        if (port != null) {
+          clearTimeout(timeout);
+          resolve(port);
+        }
+      });
+    };
+
+    scan(server.stdout);
+    scan(server.stderr);
+    server.once("exit", (code) => {
+      clearTimeout(timeout);
+      reject(new Error(`The dev server exited early with code ${String(code)}.`));
+    });
+  });
+}
+
+async function waitForServer(url: string): Promise<void> {
+  const startTime = Date.now();
+  let lastStatus: number | undefined;
+
+  while (Date.now() - startTime < STARTUP_TIMEOUT) {
+    try {
+      const response = await fetch(url, {
+        headers: { Accept: "application/activity+json" },
+        signal: AbortSignal.timeout(1000),
+      });
+      await response.body?.cancel();
+      if (response.ok) return;
+      lastStatus = response.status;
+    } catch {
+      // Server not ready yet, continue waiting
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  throw new Error(
+    `The server did not become ready within ${STARTUP_TIMEOUT}ms.` +
+      (lastStatus == null ? "" : `  Last response status: ${lastStatus}.`),
+  );
+}
+
+async function checkActor(url: string): Promise<Actor> {
+  const object = await lookupObject(url, {
+    documentLoader: getDocumentLoader({ allowPrivateAddress: true }),
+  });
+  if (object == null) {
+    throw new Error(`Could not resolve an actor at ${url}.`);
+  }
+  if (!isActor(object)) {
+    throw new Error(`Expected an actor at ${url}, but got a non-actor object.`);
+  }
+  return object;
+}
+
+function stopServer(server: ReturnType<typeof spawn>): void {
+  if (server.pid == null) return;
+  if (IS_WINDOWS) {
+    spawnSync("taskkill", ["/pid", String(server.pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    return;
+  }
+  try {
+    process.kill(-server.pid, "SIGKILL");
+  } catch {
+    // Process group already exited.
+  }
+  try {
+    server.kill("SIGKILL");
+  } catch {
+    // Process already exited.
+  }
+}
+
+await main();

package/dist/templates/next/middleware.ts.tpl

@@ -13,8 +13,12 @@ export default fedifyWith(federation)(
 */
 );
 
-// This config needs because middleware process only requests with the
-// "Accept" header matching the federation accept regex.
+// This config makes the middleware run only for requests that may be
+// federation requests: requests whose "Accept" or "Content-Type" header
+// has a federation media type, NodeInfo requests, and FEP-ef61 gateway
+// requests such as hashlink media, which clients fetch with, e.g.,
+// "Accept: image/*".  fedifyWith() then decides which of them Fedify
+// handles.
 // More details: https://nextjs.org/docs/app/api-reference/file-conventions/middleware#config-object-optional
 export const config = {
   runtime: "nodejs",
@@ -41,5 +45,6 @@ export const config = {
     },
     { source: "/.well-known/nodeinfo" },
     { source: "/.well-known/x-nodeinfo2" },
+    { source: "/.well-known/apgateway/:path*" },
   ],
 };

package/dist/templates/sveltekit/hooks.server.ts.tpl

@@ -0,0 +1,7 @@
+import { fedifyHook } from "@fedify/sveltekit";
+import { sequence } from "@sveltejs/kit/hooks";
+import federation from "$lib/federation";
+
+export const handle = sequence(
+  fedifyHook(federation),
+);

package/dist/test/create.js

@@ -1,12 +1,12 @@
 import pm_default from "../json/pm.js";
 import { printErrorMessage, printMessage, product } from "../utils.js";
-import { kvStores, messageQueues } from "../lib.js";
+import { getBuildCommand, kvStores, messageQueues } from "../lib.js";
 import webFrameworks from "../webframeworks/mod.js";
 import { filter, isEmpty, pipe, toArray } from "@fxts/core";
 import process from "node:process";
 import $ from "@david/dax";
-import { appendFile, mkdir, stat } from "node:fs/promises";
-import { join as join$1, sep } from "node:path";
+import { appendFile, lstat, mkdir, readFile, stat, symlink } from "node:fs/promises";
+import { dirname, join as join$1, resolve, sep } from "node:path";
 import { values } from "@optique/core";
 //#region src/test/create.ts
 const BANNED_PMS = ["bun", "yarn"];
@@ -16,7 +16,7 @@ const createTestApp = (testDirPrefix, dry) => async (options) => {
 	const result = await $`${toArray(genInitCommand(testDir, dry, options))}`.cwd(join$1(import.meta.dirname, "..", "..")).stdin("null").stdout("piped").stderr("piped").noThrow().spawn();
 	await saveOutputs(testDir, result);
 	if (result.code === 0) {
-		if (!dry && !await validateDevToolScripts(testDir, options)) {
+		if (!dry && (!await validateDevToolScripts(testDir, options) || !await validateFrameworkBuild(testDir, options))) {
 			printMessage`  Fail: ${vals}`;
 			printMessage`    Check out these files for more details: \
 ${join$1(testDir, "out.txt")} and \
@@ -74,17 +74,21 @@ const saveOutputs = async (dirPath, { stdout, stderr }) => {
 	if (stderr) await appendFile(join$1(dirPath, "err.txt"), stderr + "\n", "utf8");
 };
 async function validateDevToolScripts(dir, options) {
-	const [, packageManager] = options;
+	const [_, packageManager] = options;
 	if (packageManager === "deno") return true;
 	if (!await hasInstalledNodeDependencies(dir)) return true;
-	for (const script of ["format:check", "lint"]) {
+	for (const script of [
+		"format",
+		"format:check",
+		"lint"
+	]) {
 		const result = await $`${[
 			packageManager,
 			"run",
 			script
 		]}`.cwd(dir).stdin("null").stdout("piped").stderr("piped").noThrow().spawn();
 		await saveOutputs(dir, result);
-		if (result.code !== 0) return false;
+		if (result.code !== 0) printMessage`    Warning: ${script} failed, continuing anyway.`;
 	}
 	return true;
 }
@@ -95,6 +99,27 @@ async function hasInstalledNodeDependencies(dir) {
 		return false;
 	}
 }
+async function validateFrameworkBuild(dir, options) {
+	const [webFramework, packageManager] = options;
+	if (webFramework !== "astro") return true;
+	if (packageManager === "deno") await linkDenoWorkspacePackages(dir);
+	const result = await $`${getBuildCommand(packageManager)}`.cwd(dir).stdin("null").stdout("piped").stderr("piped").noThrow().spawn();
+	await saveOutputs(dir, result);
+	return result.code === 0;
+}
+async function linkDenoWorkspacePackages(dir) {
+	const config = JSON.parse(await readFile(join$1(dir, "deno.json"), "utf8"));
+	for (const link of config.links ?? []) {
+		const packageDir = resolve(dir, link);
+		const target = join$1(dir, "node_modules", ...JSON.parse(await readFile(join$1(packageDir, "package.json"), "utf8")).name.split("/"));
+		await mkdir(dirname(target), { recursive: true });
+		try {
+			await lstat(target);
+		} catch {
+			await symlink(packageDir, target, "junction");
+		}
+	}
+}
 function filterOptions(options) {
 	const [wf, pm, kv, mq] = options;
 	return [

package/dist/test/db.js

@@ -1,5 +1,5 @@
-import { printErrorMessage, printMessage } from "../utils.js";
 import { DB_TO_CHECK } from "../const.js";
+import { printErrorMessage, printMessage } from "../utils.js";
 import db_to_check_default from "../json/db-to-check.js";
 import { concat, filter, pipe, toArray, uniq } from "@fxts/core";
 import { createConnection } from "node:net";

package/dist/test/lookup.js

@@ -13,7 +13,8 @@ const BANNED_LOOKUP_REASONS = {
 	"next,*,*,*": "Next.js doesn't support remote packages",
 	"solidstart,deno,*,*": "Error occurred while loading submodules in Deno",
 	"astro,deno,*,*": "Astro doesn't support remote packages in Deno",
-	"nuxt,deno,*,*": "Nuxt doesn't support remote packages in Deno"
+	"nuxt,deno,*,*": "Nuxt doesn't support remote packages in Deno",
+	"sveltekit,deno,*,*": "SvelteKit doesn't support remote packages in Deno"
 };
 const BANNED_LOOKUP_CASES = Object.keys(BANNED_LOOKUP_REASONS).map((key) => key.split(","));
 /**
@@ -109,4 +110,4 @@ async function sendLookup(port) {
 	return false;
 }
 //#endregion
-export { runServerAndLookupUser as default };
+export { runServerAndLookupUser as default, isTestable, matchesLookupCasePattern, parseLookupCase };

package/dist/test/port.js

@@ -90,7 +90,7 @@ const ENTRY_FILES = {
 	hono: "src/index.ts",
 	elysia: "src/index.ts"
 };
-const WF_READ_PORT_FROM_ENV = new Set([
+const WF_READ_PORT_FROM_ENV = /* @__PURE__ */ new Set([
 	"nuxt",
 	"nitro",
 	"solidstart"
@@ -108,8 +108,8 @@ async function replacePortInApp(dir, wf, defaultPort, newPort) {
 		await writeFile(filePath, (await readFile(filePath, "utf8")).replaceAll(String(defaultPort), String(newPort)));
 		return;
 	}
-	if (wf === "astro") {
-		const configPath = join(dir, "astro.config.ts");
+	if (wf === "astro" || wf === "sveltekit") {
+		const configPath = join(dir, wf === "astro" ? "astro.config.ts" : "vite.config.ts");
 		await writeFile(configPath, (await readFile(configPath, "utf8")).replace("defineConfig({", `defineConfig({\n  server: { port: ${newPort} },`));
 		return;
 	}
@@ -127,4 +127,4 @@ async function ensurePortReleased(port) {
 	}
 }
 //#endregion
-export { ensurePortReleased, killProcessOnPort, replacePortInApp, reservePort };
+export { ensurePortReleased, isPortInUse, killProcessOnPort, replacePortInApp, reservePort, waitForPortRelease };

package/dist/types.d.ts

@@ -30,6 +30,8 @@ interface WebFrameworkInitializer {
   federationFile: string;
   /** Relative path where the logging configuration file will be created. */
   loggingFile: string;
+  /** Relative path where the smoke-test script file will be created. */
+  testFile: string;
   /** Optional template path for the logging configuration file. */
   loggingTemplate?: string;
   /**
@@ -125,4 +127,4 @@ interface InitCommandData extends InitCommandOptions {
   readonly env: Record<string, string>;
 }
 //#endregion
-export { InitCommandData };
+export { InitCommandData, InitCommandOptions, KvStoreDescription, MessageQueueDescription, PackageManager, WebFrameworkInitializer };

package/dist/utils.js

@@ -5,8 +5,14 @@ import { flow, toMerged } from "es-toolkit";
 import { message } from "@optique/core";
 import { Chalk } from "chalk";
 import { spawn } from "node:child_process";
+//#region src/utils.ts
+/**
+* Whether terminal color output is enabled.
+* `true` when stdout is a TTY and the `NO_COLOR` environment variable is not set.
+*/
+const colorEnabled = process.stdout.isTTY && !("NO_COLOR" in process.env && process.env.NO_COLOR !== "");
 /** Chalk instance configured based on {@link colorEnabled}. */
-const colors = new Chalk(process.stdout.isTTY && !("NO_COLOR" in process.env && process.env.NO_COLOR !== "") ? {} : { level: 0 });
+const colors = new Chalk(colorEnabled ? {} : { level: 0 });
 /** Type guard that checks whether a value is a `Promise`. */
 const isPromise = (value) => value instanceof Promise;
 /**
@@ -59,7 +65,7 @@ const createJsonDepthGuard = () => {
 /** Checks whether a string or array-like value has a length greater than zero. */
 const notEmpty = (s) => s.length > 0;
 /** Type guard that checks whether an error is a "file not found" (`ENOENT`) error. */
-const isNotFoundError = (e) => isObject(e) && "code" in e && e.code === "ENOENT";
+const isNotFoundError = (e) => isObject(e) && ("code" in e && e.code === "ENOENT" || "exitCode" in e && e.exitCode === 127);
 /**
 * Error thrown when a spawned shell command exits with a non-zero code.
 * Captures stdout, stderr, exit code, and the original command array.
@@ -160,4 +166,4 @@ const printMessage = flow(message, print);
 /** Prints a formatted error message to stderr using `@optique/run`'s `printError`. */
 const printErrorMessage = flow(message, printError);
 //#endregion
-export { CommandError, colors, formatJson, getCwd, getOsType, isNotFoundError, merge$1 as merge, notEmpty, printErrorMessage, printMessage, product, replace, runSubCommand, set };
+export { CommandError, colorEnabled, colors, formatJson, getCwd, getOsType, isNotFoundError, isPromise, merge$1 as merge, notEmpty, printErrorMessage, printMessage, product, replace, runSubCommand, set };