@maltty/cli 1.0.0-rc.0

package/dist/dist-DW_gRP7_.js

@@ -0,0 +1,1119 @@
+import { i as toError, n as err, r as ok, t as attemptAsync } from "./attemptAsync-BdXzRSIT.js";
+import { a as z, i as M, n as process_exports, r as fs_exports, t as path_exports } from "./node-C91xGGqn.js";
+import { t as readManifest } from "./manifest-BIKVDJML.js";
+import { t as compileTargets } from "./utils-DlIJNGLQ.js";
+import { builtinModules, createRequire } from "node:module";
+import { basename, extname, join, resolve } from "node:path";
+import { readdir } from "node:fs/promises";
+import { build } from "tsdown";
+//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/function/noop.mjs
+function noop() {}
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/predicate/isNil.mjs
+function isNil(x) {
+	return x == null;
+}
+//#endregion
+//#region ../bundler/dist/index.js
+/**
+* Generate JavaScript source code for a static autoloader virtual module.
+*
+* The generated module statically imports every discovered command file and
+* exports an `autoload()` function that returns the pre-built CommandMap.
+* Directory commands that merge a parent handler with subcommands are re-tagged
+* via `withTag` because the TAG symbol is non-enumerable and lost on spread.
+*
+* @param params - The scan result and path to the tag utility module.
+* @returns JavaScript source code for the static autoloader.
+*/
+function generateStaticAutoloader(params) {
+	const importLines = buildImportStatements(collectImports(params.scan), params.tagModulePath);
+	const commandsObject = buildCommandsObject(params.scan);
+	return [
+		...importLines,
+		"",
+		`const commands = ${commandsObject}`,
+		"",
+		"export async function autoload() {",
+		"  return commands",
+		"}",
+		""
+	].join("\n");
+}
+/**
+* Collect all import entries from a scan result.
+*
+* @private
+* @param scan - The scan result to collect imports from.
+* @returns A flat array of all import entries.
+*/
+function collectImports(scan) {
+	return [...scan.files.map((file) => fileToImport(file, [])), ...scan.dirs.flatMap((dir) => collectDirImports(dir, []))];
+}
+/**
+* Recursively collect import entries from a scanned directory.
+*
+* @private
+* @param dir - The scanned directory.
+* @param parentPath - The path segments leading to this directory.
+* @returns A flat array of import entries for the directory and its children.
+*/
+function collectDirImports(dir, parentPath) {
+	const currentPath = [...parentPath, dir.name];
+	return [
+		...buildIndexImport(dir.index, currentPath),
+		...dir.files.map((file) => fileToImport(file, currentPath)),
+		...dir.dirs.flatMap((sub) => collectDirImports(sub, currentPath))
+	];
+}
+/**
+* Create an import entry for a leaf command file.
+*
+* @private
+* @param file - The scanned file.
+* @param parentPath - The path segments leading to the file's parent directory.
+* @returns An import entry with a generated identifier.
+*/
+function fileToImport(file, parentPath) {
+	return {
+		filePath: file.filePath,
+		identifier: toIdentifier([...parentPath, file.name])
+	};
+}
+/**
+* Convert a path segment array to a valid JavaScript identifier.
+*
+* Joins segments with underscores and prefixes with `_`.
+* Example: `['deploy', 'preview']` becomes `_deploy_preview`.
+*
+* @private
+* @param segments - The path segments to convert.
+* @returns A valid JavaScript identifier string.
+*/
+function toIdentifier(segments) {
+	return `_${segments.map((s) => s.replaceAll("-", "$")).join("_")}`;
+}
+/**
+* Build the array of import statement lines.
+*
+* @private
+* @param imports - All collected import entries.
+* @param tagModulePath - Absolute path to the tag utility module.
+* @returns An array of import statement strings.
+*/
+function buildImportStatements(imports, tagModulePath) {
+	const tagLine = buildTagImportLine(imports, tagModulePath);
+	const importLines = imports.map((entry) => `import ${entry.identifier} from '${path_exports.toImportUrl(entry.filePath)}'`);
+	return [
+		...tagLine,
+		"",
+		...importLines
+	];
+}
+/**
+* Build the JavaScript object literal string for the top-level commands map.
+*
+* @private
+* @param scan - The scan result.
+* @returns A string representation of the commands object literal.
+*/
+function buildCommandsObject(scan) {
+	return formatObject([...scan.files.map((file) => buildFileEntry(file, [])), ...scan.dirs.map((dir) => buildDirEntry(dir, []))]);
+}
+/**
+* Build an object entry string for a leaf command file.
+*
+* @private
+* @param file - The scanned file.
+* @param parentPath - Path segments to the file's parent.
+* @returns A string like `'status': _status`.
+*/
+function buildFileEntry(file, parentPath) {
+	const identifier = toIdentifier([...parentPath, file.name]);
+	return `'${file.name}': ${identifier}`;
+}
+/**
+* Build an object entry string for a directory command (possibly with subcommands).
+*
+* @private
+* @param dir - The scanned directory.
+* @param parentPath - Path segments to the directory's parent.
+* @returns A string representing the directory command with withTag wrapping.
+*/
+function buildDirEntry(dir, parentPath) {
+	const currentPath = [...parentPath, dir.name];
+	const commandsObj = formatObject([...dir.files.map((file) => buildFileEntry(file, currentPath)), ...dir.dirs.map((sub) => buildDirEntry(sub, currentPath))]);
+	if (dir.index) {
+		const indexIdentifier = toIdentifier(currentPath);
+		return `'${dir.name}': withTag({ ...${indexIdentifier}, commands: ${commandsObj} }, 'Command')`;
+	}
+	return `'${dir.name}': withTag({ commands: ${commandsObj} }, 'Command')`;
+}
+/**
+* Build the import entry for an index file, if present.
+*
+* @private
+* @param index - The absolute path to the index file, or undefined.
+* @param currentPath - The current path segments for identifier generation.
+* @returns An array with zero or one import entries.
+*/
+function buildIndexImport(index, currentPath) {
+	if (!index) return [];
+	return [{
+		filePath: index,
+		identifier: toIdentifier(currentPath)
+	}];
+}
+/**
+* Build the tag import line if any imports exist.
+*
+* @private
+* @param imports - The collected import entries.
+* @param tagModulePath - The absolute path to the tag module.
+* @returns An array with zero or one import statement strings.
+*/
+function buildTagImportLine(imports, tagModulePath) {
+	if (imports.length === 0) return [];
+	return [`import { withTag } from '${path_exports.toImportUrl(tagModulePath)}'`];
+}
+/**
+* Format an array of key-value strings as a JavaScript object literal.
+*
+* @private
+* @param entries - The key-value pair strings.
+* @returns A formatted object literal string.
+*/
+function formatObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `  ${entry},`).join("\n")}\n}`;
+}
+const VALID_EXTENSIONS = new Set([
+	".ts",
+	".js",
+	".mjs",
+	".tsx",
+	".jsx"
+]);
+const INDEX_NAME = "index";
+/**
+* Scan a commands directory and produce a tree structure for static code generation.
+*
+* Mirrors the runtime autoloader's rules: valid extensions are `.ts`, `.js`, `.mjs`;
+* files and directories starting with `_` or `.` are skipped; `index` files in
+* subdirectories become parent command handlers.
+*
+* @param dir - Absolute path to the commands directory.
+* @returns A tree of scanned files and directories.
+*/
+async function scanCommandsDir(dir) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	const files = entries.filter(isCommandFile).map((entry) => toScannedFile(dir, entry));
+	return {
+		dirs: await Promise.all(entries.filter(isCommandDir).map((entry) => scanSubDir(join(dir, entry.name)))),
+		files
+	};
+}
+/**
+* Recursively scan a subdirectory into a ScannedDir.
+*
+* @private
+* @param dir - Absolute path to the subdirectory.
+* @returns A ScannedDir representing the directory and its contents.
+*/
+async function scanSubDir(dir) {
+	const name = basename(dir);
+	const entries = await readdir(dir, { withFileTypes: true });
+	const indexEntry = findIndexEntry(entries);
+	const files = entries.filter(isCommandFile).map((entry) => toScannedFile(dir, entry));
+	return {
+		dirs: await Promise.all(entries.filter(isCommandDir).map((entry) => scanSubDir(join(dir, entry.name)))),
+		files,
+		index: resolveIndexPath(dir, indexEntry),
+		name
+	};
+}
+/**
+* Convert a directory entry into a ScannedFile.
+*
+* @private
+* @param dir - Parent directory absolute path.
+* @param entry - The directory entry for the file.
+* @returns A ScannedFile with name and absolute file path.
+*/
+function toScannedFile(dir, entry) {
+	return {
+		filePath: join(dir, entry.name),
+		name: basename(entry.name, extname(entry.name))
+	};
+}
+/**
+* Find the index file entry among a list of directory entries.
+*
+* @private
+* @param entries - The directory entries to search.
+* @returns The Dirent for the index file, or undefined.
+*/
+function findIndexEntry(entries) {
+	return entries.find((entry) => entry.isFile() && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".d.tsx") && VALID_EXTENSIONS.has(extname(entry.name)) && basename(entry.name, extname(entry.name)) === INDEX_NAME);
+}
+/**
+* Predicate: entry is a valid command file (not index, not hidden/private).
+*
+* @private
+* @param entry - The directory entry to check.
+* @returns True when the entry is a scannable command file.
+*/
+function isCommandFile(entry) {
+	if (!entry.isFile()) return false;
+	if (entry.name.startsWith("_") || entry.name.startsWith(".")) return false;
+	if (entry.name.endsWith(".d.ts") || entry.name.endsWith(".d.tsx")) return false;
+	if (!VALID_EXTENSIONS.has(extname(entry.name))) return false;
+	return basename(entry.name, extname(entry.name)) !== INDEX_NAME;
+}
+/**
+* Predicate: entry is a scannable command directory (not hidden/private).
+*
+* @private
+* @param entry - The directory entry to check.
+* @returns True when the entry is a scannable command directory.
+*/
+function isCommandDir(entry) {
+	if (!entry.isDirectory()) return false;
+	return !entry.name.startsWith("_") && !entry.name.startsWith(".");
+}
+/**
+* Resolve the absolute path to an index file entry, or undefined.
+*
+* @private
+* @param dir - The parent directory absolute path.
+* @param entry - The index file Dirent, or undefined.
+* @returns The absolute path to the index file, or undefined.
+*/
+function resolveIndexPath(dir, entry) {
+	if (!entry) return;
+	return join(dir, entry.name);
+}
+const VIRTUAL_MODULE_ID = "virtual:maltty-static-commands";
+const RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_MODULE_ID}`;
+const AUTOLOADER_REGION_START = "//#region src/autoload.ts";
+const AUTOLOADER_REGION_END = "//#endregion";
+/**
+* Create a rolldown plugin that replaces the runtime autoloader with a static version.
+*
+* Uses a three-hook approach to break the circular dependency between maltty's
+* dist and user command files (which `import { command } from 'maltty'`):
+*
+* 1. `transform` — detects maltty's pre-bundled dist and replaces the autoloader
+*    region with a dynamic `import()` to a virtual module
+* 2. `resolveId` — resolves the virtual module identifier
+* 3. `load` — scans the commands directory and generates a static autoloader
+*    module with all command imports pre-resolved
+*
+* The dynamic import ensures command files execute after maltty's code is fully
+* initialized, avoiding `ReferenceError` from accessing `TAG` before its
+* declaration.
+*
+* @param params - The commands directory and tag module path.
+* @returns A rolldown plugin for static autoloading.
+*/
+function createAutoloadPlugin(params) {
+	return {
+		async load(id) {
+			if (id !== RESOLVED_VIRTUAL_ID) return null;
+			return generateStaticAutoloader({
+				scan: await scanCommandsDir(params.commandsDir),
+				tagModulePath: params.tagModulePath
+			});
+		},
+		name: "maltty-static-autoloader",
+		resolveId(source) {
+			if (source === VIRTUAL_MODULE_ID) return RESOLVED_VIRTUAL_ID;
+			return null;
+		},
+		transform(code, _id) {
+			const regionStart = code.indexOf(AUTOLOADER_REGION_START);
+			if (regionStart === -1) return null;
+			const regionEnd = code.indexOf(AUTOLOADER_REGION_END, regionStart);
+			if (regionEnd === -1) return null;
+			const before = code.slice(0, regionStart);
+			const after = code.slice(regionEnd + 12);
+			return `${before}${buildStaticRegion()}${after}`;
+		}
+	};
+}
+/**
+* Build the replacement autoloader region that delegates to the virtual module.
+*
+* @private
+* @returns The replacement region string with dynamic import.
+*/
+function buildStaticRegion() {
+	return [
+		"//#region src/autoload.ts (static)",
+		"async function autoload() {",
+		`  const mod = await import('${VIRTUAL_MODULE_ID}')`,
+		"  return mod.autoload()",
+		"}",
+		"//#endregion"
+	].join("\n");
+}
+/**
+* Shebang line prepended to CLI entry files.
+*/
+const SHEBANG = "#!/usr/bin/env node\n";
+/**
+* Default entry point for the CLI source.
+*/
+const DEFAULT_ENTRY = "./src/index.ts";
+/**
+* Default directory for CLI commands.
+*/
+const DEFAULT_COMMANDS = "./commands";
+/**
+* File extensions produced by maltty builds that are safe to remove during clean.
+*/
+const BUILD_ARTIFACT_EXTENSIONS = [
+	".js",
+	".mjs",
+	".js.map",
+	".mjs.map"
+];
+/**
+* Packages that must always be bundled into the output.
+*
+* The `maltty` framework and its internal `@maltty/*` packages must be inlined
+* so the autoload plugin can intercept and replace the runtime autoloader
+* with a static version for compiled binaries.
+*/
+const ALWAYS_BUNDLE = [/^@?maltty/];
+/**
+* Packages that are optional or conditional dependencies of bundled libraries
+* (c12, ink) that must be stubbed during compile-mode builds. These are behind
+* dynamic `import()` calls or runtime guards that never execute in production,
+* but when all deps are inlined, rolldown traces into them statically.
+*/
+const STUB_PACKAGES = [
+	"chokidar",
+	"magicast",
+	"giget",
+	"react-devtools-core"
+];
+/**
+* Node.js builtin modules in both bare and `node:` prefixed forms.
+*/
+const NODE_BUILTINS = [...builtinModules, ...builtinModules.map((m) => `node:${m}`)];
+const TAG_MODULE_PATH = createRequire(import.meta.url).resolve("@maltty/utils/tag");
+/**
+* Convert a resolved bundler config to a tsdown InlineConfig for production builds.
+*
+* @param params - The resolved config and optional version for compile-time injection.
+* @returns A tsdown InlineConfig ready for `build()`.
+*/
+function toTsdownBuildConfig(params) {
+	return {
+		banner: SHEBANG,
+		clean: false,
+		config: false,
+		cwd: params.config.cwd,
+		define: buildDefine({
+			define: params.config.build.define,
+			version: params.config.version
+		}),
+		deps: buildDeps(params.config.build.external, params.compile ?? false),
+		dts: false,
+		entry: { index: params.config.entry },
+		format: "esm",
+		inputOptions: { resolve: { mainFields: ["module", "main"] } },
+		logLevel: "silent",
+		minify: params.config.build.minify,
+		outDir: params.config.buildOutDir,
+		outputOptions: { codeSplitting: false },
+		platform: "node",
+		plugins: [createAutoloadPlugin({
+			commandsDir: params.config.commands,
+			tagModulePath: TAG_MODULE_PATH
+		}), ...buildPlugins(params.compile ?? false)],
+		sourcemap: params.config.build.sourcemap,
+		target: params.config.build.target,
+		treeshake: true
+	};
+}
+/**
+* Convert a resolved bundler config to a tsdown InlineConfig for watch mode.
+*
+* @param params - The resolved config, optional version, and optional success callback.
+* @returns A tsdown InlineConfig with `watch: true`.
+*/
+function toTsdownWatchConfig(params) {
+	return {
+		...toTsdownBuildConfig({ config: params.config }),
+		logLevel: "error",
+		onSuccess: params.onSuccess,
+		watch: true
+	};
+}
+/**
+* Build the `deps` configuration for tsdown.
+*
+* When compiling to a standalone binary, all dependencies must be inlined so
+* `bun build --compile` never encounters unresolvable bare imports. Only
+* Node.js builtins and explicit user externals are kept external.
+*
+* In normal (non-compile) mode, only `@maltty/*` packages are force-bundled
+* and everything else in `node_modules` is left external by tsdown's default.
+*
+* @private
+* @param userExternals - Additional packages the user explicitly marked external.
+* @param compile - Whether the build targets a compiled binary.
+* @returns A tsdown `deps` configuration object.
+*/
+function buildDeps(userExternals, compile) {
+	return {
+		alwaysBundle: resolveAlwaysBundle(compile),
+		neverBundle: [...NODE_BUILTINS, ...userExternals]
+	};
+}
+/**
+* Resolve the `alwaysBundle` rule list based on whether we're compiling.
+*
+* @private
+* @param compile - Whether the build targets a compiled binary.
+* @returns The matchers tsdown should always bundle.
+*/
+function resolveAlwaysBundle(compile) {
+	if (compile) return [/./];
+	return [...ALWAYS_BUNDLE];
+}
+/**
+* Build the `define` map for tsdown/rolldown.
+*
+* Merges three sources (lowest to highest precedence):
+* 1. `MALTTY_PUBLIC_*` env vars — prefixed with `process.env.` for rolldown replacement
+* 2. `__MALTTY_VERSION__` — injected when a version string is available
+* 3. Explicit `define` from `maltty.config.ts` — user overrides win
+*
+* @private
+* @param params - The version and user-defined constants.
+* @returns A define map for tsdown/rolldown.
+*/
+function buildDefine(params) {
+	const envVars = resolveBuildVars();
+	const envDefines = Object.fromEntries(Object.entries(envVars).map(([key, value]) => [`process.env.${key}`, value]));
+	const versionDefine = M(params.version).with(void 0, () => ({})).otherwise((v) => ({ __MALTTY_VERSION__: JSON.stringify(v) }));
+	return {
+		...envDefines,
+		...versionDefine,
+		...params.define
+	};
+}
+/**
+* Resolve `MALTTY_PUBLIC_*` environment variables into a define map.
+*
+* Scans `process.env` for keys prefixed with `MALTTY_PUBLIC_` and returns
+* clean key-value pairs with JSON-stringified values.
+*
+* @param env - The environment variables to scan (defaults to `process.env`).
+* @returns A define map with clean keys (no `process.env.` prefix).
+*/
+function resolveBuildVars(env = process.env) {
+	return Object.fromEntries(Object.entries(env).filter(([key]) => key.startsWith("MALTTY_PUBLIC_")).map(([key, value]) => [key, JSON.stringify(value ?? "")]));
+}
+/**
+* Build additional plugins needed when compiling to a standalone binary.
+*
+* When `compile` is true, includes a stub plugin that replaces optional/conditional
+* dependencies with empty modules so rolldown (and subsequently bun compile) never
+* attempts to resolve packages that don't exist at runtime.
+*
+* @private
+* @param compile - Whether the build targets a compiled binary.
+* @returns An array of rolldown plugins (empty when not compiling).
+*/
+function buildPlugins(compile) {
+	if (compile) return [createStubPlugin(STUB_PACKAGES)];
+	return [];
+}
+/**
+* Create a rolldown plugin that replaces specified packages with empty modules.
+*
+* Libraries like c12 and ink have optional/conditional dependencies behind
+* dynamic `import()` calls or runtime guards (e.g. `isDev()`). When all deps
+* are inlined for compile mode, rolldown traces into these statically. Stubbing
+* at the resolve level ensures the real package is never loaded.
+*
+* @private
+* @param packages - Package names to replace with empty modules.
+* @returns A rolldown plugin.
+*/
+function createStubPlugin(packages) {
+	const stubbed = new Set(packages);
+	const STUB_PREFIX = "\0stub:";
+	return {
+		name: "maltty-stub-packages",
+		resolveId(source) {
+			if (stubbed.has(source)) return `${STUB_PREFIX}${source}`;
+			return null;
+		},
+		load(id) {
+			if (id.startsWith(STUB_PREFIX)) return "export default undefined;";
+			return null;
+		}
+	};
+}
+/**
+* Remove maltty build artifacts from the output directory.
+*
+* Removes files matching known build artifact extensions (`.js`, `.mjs`,
+* `.js.map`, `.mjs.map`). When compile mode is active, also removes the
+* exact binary files that would be produced based on the resolved compile
+* name and targets.
+*
+* @param params - The resolved config and whether compile mode is active.
+* @returns A {@link CleanResult} describing what was removed and what was skipped.
+*/
+async function clean(params) {
+	const [listError, entries] = await fs_exports.list(params.resolved.buildOutDir);
+	if (listError) return {
+		foreign: [],
+		removed: []
+	};
+	const binaryNames = M(params).with({ compile: true }, ({ resolved }) => buildBinaryNames(resolved.compile.name, resolved.compile.targets)).otherwise(() => /* @__PURE__ */ new Set());
+	const results = await Promise.all(entries.map(async (name) => {
+		if (isBuildArtifact(name) || binaryNames.has(name)) {
+			const [removeError] = await fs_exports.remove(join(params.resolved.buildOutDir, name));
+			if (removeError) return {
+				type: "foreign",
+				name
+			};
+			return {
+				type: "removed",
+				name
+			};
+		}
+		return {
+			type: "foreign",
+			name
+		};
+	}));
+	return {
+		removed: results.filter((r) => r.type === "removed").map((r) => r.name),
+		foreign: results.filter((r) => r.type === "foreign").map((r) => r.name)
+	};
+}
+/**
+* Check whether a filename matches a known build artifact extension.
+*
+* @private
+* @param filename - The filename to check.
+* @returns `true` when the file ends with a known build artifact extension.
+*/
+function isBuildArtifact(filename) {
+	return BUILD_ARTIFACT_EXTENSIONS.some((ext) => filename.endsWith(ext));
+}
+/**
+* Build the set of exact binary filenames that compile would produce.
+*
+* Single-target builds produce `{name}`, multi-target builds produce
+* `{name}-{target}`. Windows targets append `.exe` to match the file bun
+* actually creates on disk.
+*
+* @private
+* @param name - The resolved binary base name.
+* @param targets - The resolved compile targets (may be empty → defaults used).
+* @returns A set of filenames to remove.
+*/
+function buildBinaryNames(name, targets) {
+	const resolvedTargets = M(targets).with([], () => compileTargets.filter((t) => t.default).map((t) => t.target)).otherwise(() => targets);
+	const names = resolvedTargets.map((target) => {
+		const base = M(resolvedTargets.length).with(1, () => name).otherwise(() => `${name}-${target}`);
+		if (target.startsWith("windows-")) return `${base}.exe`;
+		return base;
+	});
+	return new Set(names);
+}
+/**
+* Build a descriptive error message for a failed tsdown operation.
+*
+* When verbose is false only a short header is returned. When verbose is true
+* the underlying error message is appended so callers get actionable detail.
+*
+* @param params - The phase, error, and verbose flag.
+* @returns A formatted error message.
+*/
+function formatBuildError(params) {
+	const header = `tsdown ${params.phase} failed`;
+	const detail = toError(params.error).message.trim();
+	if (params.verbose && detail.length > 0) return `${header}\n${detail}`;
+	return header;
+}
+/**
+* Known entry file names produced by tsdown for ESM builds, in preference order.
+*/
+const ENTRY_CANDIDATES = ["index.mjs", "index.js"];
+/**
+* Resolve the bundled entry file in a build output directory.
+*
+* tsdown may produce `index.mjs` or `index.js` depending on the project's
+* `package.json` `type` field and tsdown configuration. This function checks
+* for both candidates and returns the first one that exists on disk.
+*
+* @param outDir - Absolute path to the build output directory.
+* @returns The absolute path to the entry file, or `undefined` when none is found.
+*/
+async function resolveBuildEntry(outDir) {
+	const candidates = ENTRY_CANDIDATES.map((name) => join(outDir, name));
+	return M((await Promise.all(candidates.map(async (path) => ({
+		path,
+		found: await fs_exports.exists(path)
+	})))).find((r) => r.found)).with(void 0, () => void 0).otherwise((entry) => entry.path);
+}
+/**
+* Run the tsdown build with a resolved config.
+*
+* Cleans artifacts when enabled, maps to a tsdown InlineConfig, and invokes
+* tsdown's build API.
+*
+* @param params - The resolved config and whether compile mode is active.
+* @returns A result tuple with build output on success or an Error on failure.
+*/
+async function build$1(params) {
+	if (params.resolved.build.clean) await clean({
+		resolved: params.resolved,
+		compile: params.compile
+	});
+	const inlineConfig = toTsdownBuildConfig({
+		compile: params.compile,
+		config: params.resolved
+	});
+	const [buildError] = await attemptAsync(() => build(inlineConfig));
+	if (buildError) return err(new Error(formatBuildError({
+		phase: "build",
+		error: buildError,
+		verbose: params.verbose ?? false
+	}), { cause: buildError }));
+	const entryFile = await resolveBuildEntry(params.resolved.buildOutDir);
+	if (!entryFile) return err(/* @__PURE__ */ new Error(`build produced no entry file in ${params.resolved.buildOutDir}`));
+	return ok({
+		define: {
+			...resolveBuildVars(),
+			...params.resolved.build.define
+		},
+		entryFile,
+		outDir: params.resolved.buildOutDir,
+		version: params.resolved.version
+	});
+}
+/**
+* Start a watch-mode build using tsdown.
+*
+* The returned promise resolves only when tsdown's watch terminates (typically on process exit).
+*
+* @param params - The resolved config, optional success callback, and verbose flag.
+* @returns A result tuple with void on success or an Error on failure.
+*/
+async function watch(params) {
+	const watchConfig = toTsdownWatchConfig({
+		config: params.resolved,
+		onSuccess: params.onSuccess
+	});
+	const [watchError] = await attemptAsync(() => build(watchConfig));
+	if (watchError) return err(new Error(formatBuildError({
+		phase: "watch",
+		error: watchError,
+		verbose: params.verbose ?? false
+	}), { cause: watchError }));
+	return ok();
+}
+/**
+* Compile a maltty CLI tool into standalone binaries using `bun build --compile`.
+*
+* Expects the bundled entry to already exist in `outDir` (i.e., `build()` must
+* be run first). For each requested target (or defaults when none configured),
+* spawns `bun build --compile` to produce a self-contained binary.
+*
+* @param params - The resolved config, lifecycle hooks, and verbose flag.
+* @returns A result tuple with compile output on success or an Error on failure.
+*/
+async function compile(params) {
+	if (!await process_exports.exists("bun")) return err(/* @__PURE__ */ new Error("bun is not installed or not found in PATH. Install it from https://bun.sh to use compile."));
+	const bundledEntry = await resolveBuildEntry(params.resolved.buildOutDir);
+	if (!bundledEntry) return err(/* @__PURE__ */ new Error(`bundled entry not found in ${params.resolved.buildOutDir} — run build() first`));
+	const targets = resolveTargets(params.resolved.compile.targets);
+	const isMultiTarget = targets.length > 1;
+	const results = await compileTargetsSequentially({
+		autoloadDotenv: params.resolved.compile.autoloadDotenv,
+		bundledEntry,
+		cwd: params.resolved.cwd,
+		isMultiTarget,
+		lifecycle: params.lifecycle,
+		name: params.resolved.compile.name,
+		outDir: params.resolved.compileOutDir,
+		targets,
+		verbose: params.verbose ?? false
+	});
+	await cleanBunBuildArtifacts(params.resolved.cwd);
+	const failedResult = results.find((r) => r[0] !== null);
+	if (failedResult) return err(failedResult[0]);
+	return ok({ binaries: results.filter((r) => r[1] !== null).map(([, binary]) => binary) });
+}
+/**
+* Look up the human-readable label for a compile target.
+*
+* @param target - The compile target identifier.
+* @returns A descriptive label (e.g., "macOS Apple Silicon").
+*/
+function resolveTargetLabel(target) {
+	const entry = compileTargets.find((t) => t.target === target);
+	if (entry) return entry.label;
+	return target;
+}
+/**
+* Compile targets one at a time to avoid overwhelming bun with concurrent processes.
+*
+* @private
+* @param params - The targets and compilation parameters.
+* @returns The accumulated result tuples for each target.
+*/
+async function compileTargetsSequentially(params) {
+	return params.targets.reduce(async (accPromise, target) => {
+		const acc = await accPromise;
+		const meta = {
+			target,
+			label: resolveTargetLabel(target)
+		};
+		if (params.lifecycle.onStepStart) await params.lifecycle.onStepStart({
+			phase: "compile",
+			step: "target",
+			meta
+		});
+		const result = await compileSingleTarget({
+			autoloadDotenv: params.autoloadDotenv,
+			bundledEntry: params.bundledEntry,
+			cwd: params.cwd,
+			isMultiTarget: params.isMultiTarget,
+			name: params.name,
+			outDir: params.outDir,
+			target,
+			verbose: params.verbose
+		});
+		if (params.lifecycle.onStepFinish) await params.lifecycle.onStepFinish({
+			phase: "compile",
+			step: "target",
+			meta
+		});
+		return [...acc, result];
+	}, Promise.resolve([]));
+}
+/**
+* Compile a single target via `bun build --compile`.
+*
+* @private
+* @param params - Target compilation parameters.
+* @returns A result tuple with the compiled binary info or an error.
+*/
+async function compileSingleTarget(params) {
+	const binaryName = resolveBinaryName$1(params.name, params.target, params.isMultiTarget);
+	const outfile = join(params.outDir, binaryName);
+	const [mapError, bunTarget] = mapCompileTarget(params.target);
+	if (mapError) return err(mapError);
+	const args = [
+		"build",
+		"--compile",
+		...resolveAutoloadFlags({ autoloadDotenv: params.autoloadDotenv }),
+		params.bundledEntry,
+		"--outfile",
+		outfile,
+		"--target",
+		bunTarget
+	];
+	const [execError] = await process_exports.exec({
+		cmd: "bun",
+		args,
+		cwd: params.cwd
+	});
+	if (execError) return err(new Error(formatCompileError(params.target, execError, params.verbose), { cause: execError }));
+	return ok({
+		label: resolveTargetLabel(params.target),
+		path: outfile,
+		target: params.target
+	});
+}
+/**
+* Resolve the list of compile targets, falling back to the default set.
+*
+* @private
+* @param explicit - User-specified targets (may be empty).
+* @returns The targets to compile for.
+*/
+function resolveTargets(explicit) {
+	if (explicit.length > 0) return explicit;
+	return compileTargets.filter((t) => t.default).map((t) => t.target);
+}
+/**
+* Build the output binary name, appending the target suffix for multi-target
+* builds and the `.exe` extension for Windows targets.
+*
+* Windows targets must end with `.exe` because that is the file bun actually
+* produces (bun auto-appends `.exe` for any `bun-windows-*` target). Recording
+* the path without `.exe` would cause filesystem operations on the recorded
+* path to fail and would diverge from what is on disk.
+*
+* @private
+* @param name - Base binary name.
+* @param target - The compile target.
+* @param isMultiTarget - Whether multiple targets are being compiled.
+* @returns The resolved binary file name.
+*/
+function resolveBinaryName$1(name, target, isMultiTarget) {
+	return appendBinaryExtension(buildBaseBinaryName(name, target, isMultiTarget), target);
+}
+/**
+* Build the base name without the platform extension.
+*
+* @private
+* @param name - Base binary name.
+* @param target - The compile target.
+* @param isMultiTarget - Whether multiple targets are being compiled.
+* @returns The base binary name with optional target suffix.
+*/
+function buildBaseBinaryName(name, target, isMultiTarget) {
+	if (isMultiTarget) return `${name}-${target}`;
+	return name;
+}
+/**
+* Append the `.exe` extension to Windows binary names.
+*
+* @private
+* @param base - The base binary name.
+* @param target - The compile target.
+* @returns The base name plus `.exe` for Windows targets, or the base unchanged.
+*/
+function appendBinaryExtension(base, target) {
+	if (target.startsWith("windows-")) return `${base}.exe`;
+	return base;
+}
+/**
+* Map a `CompileTarget` to Bun's `--target` string.
+*
+* Every supported maltty target must have an explicit mapping. An unrecognized
+* target is a fatal error — it means `compileTargets` was extended without
+* updating this function.
+*
+* @private
+* @param target - The maltty compile target.
+* @returns A result with the Bun target string, or an Error for unknown targets.
+*/
+function mapCompileTarget(target) {
+	return M(target).with("darwin-arm64", () => ok("bun-darwin-arm64")).with("darwin-x64", () => ok("bun-darwin-x64")).with("linux-arm64", () => ok("bun-linux-arm64")).with("linux-x64", () => ok("bun-linux-x64")).with("linux-x64-musl", () => ok("bun-linux-x64-musl")).with("windows-arm64", () => ok("bun-windows-arm64")).with("windows-x64", () => ok("bun-windows-x64")).otherwise(() => err(/* @__PURE__ */ new Error(`unknown compile target: ${target}`)));
+}
+/**
+* Build a descriptive error message for a failed compile target.
+*
+* @private
+* @param target - The compile target that failed.
+* @param execError - The error returned by execFile.
+* @param verbose - Whether to include stderr output in the message.
+* @returns A formatted error message.
+*/
+function formatCompileError(target, execError, verbose) {
+	const header = `bun build --compile failed for target ${target}`;
+	if (!verbose) return header;
+	const { stderr } = execError;
+	if (stderr && stderr.trim().length > 0) return `${header}\n${stderr.trim()}`;
+	return header;
+}
+/**
+* Build the CLI flags that control Bun's compile-time config autoloading.
+*
+* `bunfig.toml` loading is always disabled — maltty CLIs should never load
+* Bun runtime config. `.env` loading is controlled by the `autoloadDotenv`
+* option (disabled by default).
+*
+* @private
+* @param params - The autoload settings.
+* @returns An array of CLI flag strings.
+*/
+function resolveAutoloadFlags(params) {
+	return [{
+		enabled: false,
+		flag: "--no-compile-autoload-bunfig"
+	}, {
+		enabled: params.autoloadDotenv,
+		flag: "--no-compile-autoload-dotenv"
+	}].filter((c) => !c.enabled).map((c) => c.flag);
+}
+/**
+* Remove temporary `.bun-build` files that `bun build --compile` leaves behind.
+*
+* @private
+* @param cwd - The working directory to clean.
+*/
+async function cleanBunBuildArtifacts(cwd) {
+	const [listError, entries] = await fs_exports.list(cwd);
+	if (listError) return;
+	const artifacts = entries.filter((name) => name.endsWith(".bun-build")).map((name) => join(cwd, name));
+	await Promise.allSettled(artifacts.map(fs_exports.remove));
+}
+/**
+* Normalize the `compile` config field from `boolean | CompileOptions | undefined` to `CompileOptions`.
+*
+* - `true` → `{}` (compile with defaults)
+* - `false` / `undefined` → `{}` (no explicit options, caller decides whether to compile)
+* - object → pass through
+*
+* @param value - The raw compile config value.
+* @returns A normalized CompileOptions object.
+*/
+function normalizeCompileOptions(value) {
+	if (typeof value === "object") return value;
+	return {};
+}
+/**
+* Fill defaults and resolve relative paths against `cwd`.
+*
+* This is a pure function — the incoming config is already validated by `@maltty/config`.
+* It only fills missing optional fields with defaults and resolves paths to absolute.
+*
+* @param params - The raw config and working directory.
+* @returns A fully resolved bundler configuration.
+*/
+function resolveConfig(params) {
+	const { config, cwd } = params;
+	const entry = resolve(cwd, config.entry ?? "./src/index.ts");
+	const commands = resolve(cwd, config.commands ?? "./commands");
+	const buildOpts = config.build ?? {};
+	const compileOpts = normalizeCompileOptions(config.compile);
+	const buildOutDir = resolve(cwd, buildOpts.out ?? "./dist");
+	const compileOutDir = resolve(cwd, compileOpts.out ?? "./dist");
+	return {
+		build: {
+			clean: buildOpts.clean ?? true,
+			define: buildOpts.define ?? {},
+			external: buildOpts.external ?? [],
+			minify: buildOpts.minify ?? true,
+			sourcemap: buildOpts.sourcemap ?? true,
+			target: buildOpts.target ?? "node18"
+		},
+		buildOutDir,
+		commands,
+		compile: {
+			autoloadDotenv: compileOpts.autoloadDotenv ?? false,
+			name: compileOpts.name ?? params.binaryName,
+			targets: compileOpts.targets ?? []
+		},
+		compileOutDir,
+		cwd,
+		entry,
+		include: config.include ?? [],
+		version: params.version
+	};
+}
+/**
+* Create a bundler instance for a maltty CLI project.
+*
+* Reads the project manifest once, resolves config, and returns methods
+* that share the resolved state. Lifecycle hooks fire at phase boundaries.
+* Per-call overrides replace base hooks for that invocation.
+*
+* @param params - The config, working directory, and optional lifecycle hooks.
+* @returns A bundler with build, watch, and compile methods.
+*/
+async function createBundler(params) {
+	const [, manifest] = await readManifest(params.cwd);
+	const { version, name: packageName } = manifest ?? {};
+	const binaryName = M(params.config.compile).with({ name: z.string }, (c) => c.name).otherwise(() => resolveBinaryName(packageName));
+	const resolved = resolveConfig({
+		config: params.config,
+		cwd: params.cwd,
+		version,
+		binaryName
+	});
+	const hasCompile = !isNil(params.config.compile);
+	const baseLifecycle = {
+		onFinish: params.onFinish,
+		onStart: params.onStart,
+		onStepFinish: params.onStepFinish,
+		onStepStart: params.onStepStart
+	};
+	return {
+		build: async (overrides = {}) => {
+			const lifecycle = resolveLifecycle(baseLifecycle, overrides);
+			await lifecycle.onStart({ phase: "build" });
+			const result = await build$1({
+				compile: hasCompile,
+				resolved,
+				verbose: overrides.verbose
+			});
+			await lifecycle.onFinish({ phase: "build" });
+			return result;
+		},
+		watch: async (overrides = {}) => {
+			const lifecycle = resolveLifecycle(baseLifecycle, overrides);
+			await lifecycle.onStart({ phase: "watch" });
+			const result = await watch({
+				onSuccess: overrides.onSuccess,
+				resolved,
+				verbose: overrides.verbose
+			});
+			await lifecycle.onFinish({ phase: "watch" });
+			return result;
+		},
+		compile: async (overrides = {}) => {
+			const lifecycle = resolveLifecycle(baseLifecycle, overrides);
+			await lifecycle.onStart({ phase: "compile" });
+			const result = await compile({
+				lifecycle,
+				resolved,
+				verbose: overrides.verbose
+			});
+			await lifecycle.onFinish({ phase: "compile" });
+			return result;
+		}
+	};
+}
+/**
+* Derive the binary name from the package.json name, stripping scope.
+*
+* @private
+* @param packageName - The package name from manifest, or undefined.
+* @returns The binary name.
+*/
+function resolveBinaryName(packageName) {
+	if (!packageName) return "cli";
+	return stripScope(packageName);
+}
+/**
+* Strip the npm scope prefix from a package name.
+*
+* @private
+* @param name - The package name (e.g. `@scope/my-cli`).
+* @returns The unscoped name (e.g. `my-cli`).
+*/
+function stripScope(name) {
+	const slashIndex = name.indexOf("/");
+	if (name.startsWith("@") && slashIndex > 0) return name.slice(slashIndex + 1);
+	return name;
+}
+/**
+* Merge base lifecycle hooks with per-call overrides.
+*
+* Per-call hooks replace base hooks (no chaining). Missing hooks
+* are filled with no-ops so callers don't need null checks.
+*
+* @private
+* @param base - The base lifecycle hooks from the factory.
+* @param overrides - Per-call hook overrides.
+* @returns A lifecycle with all hooks guaranteed to be defined.
+*/
+function resolveLifecycle(base, overrides = {}) {
+	return {
+		onFinish: overrides.onFinish ?? base.onFinish ?? noop,
+		onStart: overrides.onStart ?? base.onStart ?? noop,
+		onStepFinish: overrides.onStepFinish ?? base.onStepFinish ?? noop,
+		onStepStart: overrides.onStepStart ?? base.onStepStart ?? noop
+	};
+}
+//#endregion
+export { normalizeCompileOptions as i, DEFAULT_ENTRY as n, createBundler as r, DEFAULT_COMMANDS as t };
+
+//# sourceMappingURL=dist-DW_gRP7_.js.map