@kidd-cli/bundler 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Joggr, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,300 @@
+import { AsyncResult, Result } from "@kidd-cli/utils/fp";
+import { InlineConfig, Rolldown } from "tsdown";
+import { BuildOptions, CompileOptions, CompileOptions as CompileOptions$1, CompileTarget, CompileTarget as CompileTarget$1, KiddConfig, KiddConfig as KiddConfig$1 } from "@kidd-cli/config";
+
+//#region src/autoload-plugin.d.ts
+/**
+* Parameters for creating the autoload plugin.
+*/
+interface CreateAutoloadPluginParams {
+  readonly commandsDir: string;
+  readonly tagModulePath: string;
+}
+/**
+* Create a rolldown plugin that replaces the runtime autoloader with a static version.
+*
+* Uses a three-hook approach to break the circular dependency between kidd's
+* dist and user command files (which `import { command } from 'kidd'`):
+*
+* 1. `transform` — detects kidd'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 kidd'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.
+*/
+declare function createAutoloadPlugin(params: CreateAutoloadPluginParams): Rolldown.Plugin;
+//#endregion
+//#region src/types.d.ts
+/**
+* Fully resolved build options with all defaults applied.
+*/
+interface ResolvedBuildOptions {
+  readonly target: string;
+  readonly minify: boolean;
+  readonly sourcemap: boolean;
+  readonly external: readonly string[];
+}
+/**
+* Fully resolved compile options with all defaults applied.
+*/
+interface ResolvedCompileOptions {
+  readonly targets: readonly CompileTarget[];
+  readonly name: string;
+}
+/**
+* Fully resolved bundler configuration with absolute paths and all defaults filled.
+*/
+interface ResolvedBundlerConfig {
+  readonly entry: string;
+  readonly commands: string;
+  readonly buildOutDir: string;
+  readonly compileOutDir: string;
+  readonly build: ResolvedBuildOptions;
+  readonly compile: ResolvedCompileOptions;
+  readonly include: readonly string[];
+  readonly cwd: string;
+}
+/**
+* Synchronous result from a bundler operation.
+*/
+type BundlerResult<T> = Result<T, Error>;
+/**
+* Asynchronous result from a bundler operation.
+*/
+type AsyncBundlerResult<T> = AsyncResult<T, Error>;
+/**
+* Output of a successful build operation.
+*/
+interface BuildOutput {
+  readonly outDir: string;
+  readonly entryFile: string;
+}
+/**
+* A single compiled binary for a specific target platform.
+*/
+interface CompiledBinary {
+  readonly target: CompileTarget;
+  readonly label: string;
+  readonly path: string;
+}
+/**
+* Output of a successful compile operation.
+*/
+interface CompileOutput {
+  readonly binaries: readonly CompiledBinary[];
+}
+/**
+* Parameters for the build function.
+*/
+interface BuildParams {
+  readonly config: KiddConfig;
+  readonly cwd: string;
+}
+/**
+* Parameters for the watch function.
+*/
+interface WatchParams {
+  readonly config: KiddConfig;
+  readonly cwd: string;
+  readonly onSuccess?: () => void | Promise<void>;
+}
+/**
+* Parameters for the compile function.
+*/
+interface CompileParams {
+  readonly config: KiddConfig;
+  readonly cwd: string;
+  readonly onTargetStart?: (target: CompileTarget) => void | Promise<void>;
+  readonly onTargetComplete?: (target: CompileTarget) => void | Promise<void>;
+}
+/**
+* A single command file discovered during a directory scan.
+*/
+interface ScannedFile {
+  readonly name: string;
+  readonly filePath: string;
+}
+/**
+* A subdirectory of commands discovered during a directory scan.
+*/
+interface ScannedDir {
+  readonly name: string;
+  readonly index?: string;
+  readonly files: readonly ScannedFile[];
+  readonly dirs: readonly ScannedDir[];
+}
+/**
+* The result of scanning a commands directory tree.
+*/
+interface ScanResult {
+  readonly files: readonly ScannedFile[];
+  readonly dirs: readonly ScannedDir[];
+}
+//#endregion
+//#region src/build.d.ts
+/**
+* Build a kidd CLI tool using tsdown.
+*
+* Resolves defaults, maps the config to tsdown's InlineConfig, and invokes the build.
+*
+* @param params - The build parameters including config and working directory.
+* @returns A result tuple with build output on success or an Error on failure.
+*/
+declare function build(params: BuildParams): AsyncBundlerResult<BuildOutput>;
+//#endregion
+//#region src/compile.d.ts
+/**
+* Compile a kidd 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 the current platform if none
+* specified), spawns `bun build --compile` to produce a self-contained binary.
+*
+* @param params - The compile parameters including config and working directory.
+* @returns A result tuple with compile output on success or an Error on failure.
+*/
+declare function compile(params: CompileParams): AsyncResult<CompileOutput>;
+/**
+* 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").
+*/
+declare function resolveTargetLabel(target: CompileTarget$1): string;
+//#endregion
+//#region src/generate-autoloader.d.ts
+/**
+* Parameters for generating a static autoloader module.
+*/
+interface GenerateStaticAutoloaderParams {
+  readonly scan: ScanResult;
+  readonly tagModulePath: string;
+}
+/**
+* The two parts of a static autoloader transform: import statements to
+* prepend and the replacement code for the autoloader region.
+*/
+interface StaticAutoloaderParts {
+  readonly imports: string;
+  readonly region: string;
+}
+/**
+* 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.
+*/
+declare function generateStaticAutoloader(params: GenerateStaticAutoloaderParams): string;
+/**
+* Generate the two parts needed to transform kidd's bundled dist.
+*
+* Returns an empty imports string (no prepended imports needed) and a
+* replacement autoloader region that uses dynamic `import()` calls inside
+* the async `autoload()` function. This avoids circular dependency issues:
+* command files import `command` from `kidd`, so static imports would be
+* hoisted above kidd's own initialization code, causing `TAG` to be
+* accessed before initialization.
+*
+* By deferring to dynamic imports, kidd fully initializes first, then
+* command files are loaded when `autoload()` is called at CLI startup.
+*
+* @param params - The scan result and path to the tag utility module.
+* @returns Import statements (empty) and the replacement autoloader region.
+*/
+declare function generateAutoloaderParts(params: GenerateStaticAutoloaderParams): StaticAutoloaderParts;
+//#endregion
+//#region src/map-config.d.ts
+/**
+* Map a resolved bundler config to a tsdown InlineConfig for production builds.
+*
+* @param config - The fully resolved bundler config.
+* @returns A tsdown InlineConfig ready for `build()`.
+*/
+declare function mapToBuildConfig(config: ResolvedBundlerConfig): InlineConfig;
+/**
+* Map a resolved bundler config to a tsdown InlineConfig for watch mode.
+*
+* @param params - The resolved config and optional success callback.
+* @returns A tsdown InlineConfig with `watch: true`.
+*/
+declare function mapToWatchConfig(params: {
+  readonly config: ResolvedBundlerConfig;
+  readonly onSuccess?: () => void | Promise<void>;
+}): InlineConfig;
+//#endregion
+//#region src/resolve-config.d.ts
+/**
+* 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.
+*/
+declare function normalizeCompileOptions(value: boolean | CompileOptions$1 | undefined): CompileOptions$1;
+/**
+* Fill defaults and resolve relative paths against `cwd`.
+*
+* This is a pure function — the incoming config is already validated by `@kidd-cli/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.
+*/
+declare function resolveConfig(params: {
+  readonly config: KiddConfig$1;
+  readonly cwd: string;
+}): ResolvedBundlerConfig;
+/**
+* Detect 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.
+*/
+declare function detectBuildEntry(outDir: string): string | undefined;
+//#endregion
+//#region src/scan-commands.d.ts
+/**
+* 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.
+*/
+declare function scanCommandsDir(dir: string): Promise<ScanResult>;
+//#endregion
+//#region src/watch.d.ts
+/**
+* Start a watch-mode build for a kidd CLI tool using tsdown.
+*
+* The returned promise resolves only when tsdown's watch terminates (typically on process exit).
+* tsdown's `build()` with `watch: true` runs indefinitely.
+*
+* @param params - The watch parameters including config, working directory, and optional success callback.
+* @returns A result tuple with void on success or an Error on failure.
+*/
+declare function watch(params: WatchParams): AsyncBundlerResult<void>;
+//#endregion
+export { type AsyncBundlerResult, type BuildOptions, type BuildOutput, type BuildParams, type BundlerResult, type CompileOptions, type CompileOutput, type CompileParams, type CompileTarget, type CompiledBinary, type KiddConfig, type ResolvedBuildOptions, type ResolvedBundlerConfig, type ResolvedCompileOptions, type ScanResult, type ScannedDir, type ScannedFile, type StaticAutoloaderParts, type WatchParams, build, compile, createAutoloadPlugin, detectBuildEntry, generateAutoloaderParts, generateStaticAutoloader, mapToBuildConfig, mapToWatchConfig, normalizeCompileOptions, resolveConfig, resolveTargetLabel, scanCommandsDir, watch };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/autoload-plugin.ts","../src/types.ts","../src/build.ts","../src/compile.ts","../src/generate-autoloader.ts","../src/map-config.ts","../src/resolve-config.ts","../src/scan-commands.ts","../src/watch.ts"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,849 @@
+import { builtinModules, createRequire } from "node:module";
+import { readdir } from "node:fs/promises";
+import { basename, extname, join, resolve } from "node:path";
+import { err, ok } from "@kidd-cli/utils/fp";
+import { build as build$1 } from "tsdown";
+import { existsSync, readdirSync, unlinkSync } from "node:fs";
+import { execFile } from "node:child_process";
+
+//#region src/generate-autoloader.ts
+/**
+* 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");
+}
+/**
+* Generate the two parts needed to transform kidd's bundled dist.
+*
+* Returns an empty imports string (no prepended imports needed) and a
+* replacement autoloader region that uses dynamic `import()` calls inside
+* the async `autoload()` function. This avoids circular dependency issues:
+* command files import `command` from `kidd`, so static imports would be
+* hoisted above kidd's own initialization code, causing `TAG` to be
+* accessed before initialization.
+*
+* By deferring to dynamic imports, kidd fully initializes first, then
+* command files are loaded when `autoload()` is called at CLI startup.
+*
+* @param params - The scan result and path to the tag utility module.
+* @returns Import statements (empty) and the replacement autoloader region.
+*/
+function generateAutoloaderParts(params) {
+	const imports = collectImports(params.scan);
+	if (imports.length === 0) return {
+		imports: "",
+		region: buildEmptyAutoloaderRegion()
+	};
+	return {
+		imports: "",
+		region: buildDynamicAutoloaderRegion(imports, buildCommandsObject(params.scan))
+	};
+}
+/**
+* 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 '${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 '${tagModulePath}'`];
+}
+/**
+* Build the autoloader region for an empty scan result.
+*
+* @private
+* @returns A region string with an autoloader that returns an empty object.
+*/
+function buildEmptyAutoloaderRegion() {
+	return [
+		"//#region src/autoloader.ts (static)",
+		"async function autoload() {",
+		"  return {}",
+		"}",
+		"//#endregion"
+	].join("\n");
+}
+/**
+* Build the autoloader region using dynamic `import()` calls.
+*
+* Uses `Promise.all` with array destructuring to load all command files
+* in parallel. The dynamic imports defer execution until `autoload()` is
+* called, avoiding circular dependency issues with kidd's own initialization.
+*
+* @private
+* @param imports - The collected import entries.
+* @param commandsObject - The commands object literal string.
+* @returns A region string with the full dynamic autoloader.
+*/
+function buildDynamicAutoloaderRegion(imports, commandsObject) {
+	return [
+		"//#region src/autoloader.ts (static)",
+		"async function autoload() {",
+		"  const [",
+		imports.map((entry) => `    { default: ${entry.identifier} },`).join("\n"),
+		"  ] = await Promise.all([",
+		imports.map((entry) => `    import('${entry.filePath}'),`).join("\n"),
+		"  ])",
+		`  return ${commandsObject}`,
+		"}",
+		"//#endregion"
+	].join("\n");
+}
+/**
+* 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}`;
+}
+
+//#endregion
+//#region src/scan-commands.ts
+const VALID_EXTENSIONS = new Set([
+	".ts",
+	".js",
+	".mjs"
+]);
+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() && 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 (!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);
+}
+
+//#endregion
+//#region src/autoload-plugin.ts
+const VIRTUAL_MODULE_ID = "virtual:kidd-static-commands";
+const RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_MODULE_ID}`;
+const AUTOLOADER_REGION_START = "//#region src/autoloader.ts";
+const AUTOLOADER_REGION_END = "//#endregion";
+const KIDD_DIST_PATTERN = /\/kidd\/dist\/index\.js$/;
+/**
+* Create a rolldown plugin that replaces the runtime autoloader with a static version.
+*
+* Uses a three-hook approach to break the circular dependency between kidd's
+* dist and user command files (which `import { command } from 'kidd'`):
+*
+* 1. `transform` — detects kidd'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 kidd'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: "kidd-static-autoloader",
+		resolveId(source) {
+			if (source === VIRTUAL_MODULE_ID) return RESOLVED_VIRTUAL_ID;
+			return null;
+		},
+		transform(code, id) {
+			if (!KIDD_DIST_PATTERN.test(id)) return null;
+			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/autoloader.ts (static)",
+		"async function autoload() {",
+		`  const mod = await import('${VIRTUAL_MODULE_ID}')`,
+		"  return mod.autoload()",
+		"}",
+		"//#endregion"
+	].join("\n");
+}
+
+//#endregion
+//#region src/constants.ts
+/**
+* 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";
+/**
+* Default build output directory.
+*/
+const DEFAULT_OUT_DIR = "./dist";
+/**
+* Default Node.js target version for builds.
+*/
+const DEFAULT_TARGET = "node18";
+/**
+* Default minification setting.
+*/
+const DEFAULT_MINIFY = false;
+/**
+* Default source map generation setting.
+*/
+const DEFAULT_SOURCEMAP = true;
+/**
+* Default binary name for compiled SEA output.
+*/
+const DEFAULT_BINARY_NAME = "cli";
+/**
+* Default compile targets when none are explicitly configured.
+*
+* Covers Linux servers/CI, modern and Intel Macs, and Windows — roughly 95%
+* of developer environments.
+*/
+const DEFAULT_COMPILE_TARGETS = [
+	"darwin-arm64",
+	"darwin-x64",
+	"linux-x64",
+	"windows-x64"
+];
+/**
+* Packages that must always be bundled into the output.
+*
+* The `kidd` framework and its internal `@kidd-cli/*` 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 = [/^@?kidd/];
+/**
+* Node.js builtin modules in both bare and `node:` prefixed forms.
+*/
+const NODE_BUILTINS = [...builtinModules, ...builtinModules.map((m) => `node:${m}`)];
+
+//#endregion
+//#region src/map-config.ts
+/**
+* Map a resolved bundler config to a tsdown InlineConfig for production builds.
+*
+* @param config - The fully resolved bundler config.
+* @returns A tsdown InlineConfig ready for `build()`.
+*/
+function mapToBuildConfig(config) {
+	return {
+		banner: SHEBANG,
+		clean: true,
+		config: false,
+		cwd: config.cwd,
+		deps: {
+			alwaysBundle: ALWAYS_BUNDLE,
+			neverBundle: buildExternals(config.build.external)
+		},
+		dts: false,
+		entry: { index: config.entry },
+		format: "esm",
+		inputOptions: { resolve: { mainFields: ["module", "main"] } },
+		logLevel: "info",
+		minify: config.build.minify,
+		outDir: config.buildOutDir,
+		outputOptions: { codeSplitting: false },
+		platform: "node",
+		plugins: [createAutoloadPlugin({
+			commandsDir: config.commands,
+			tagModulePath: resolveTagModulePath()
+		})],
+		sourcemap: config.build.sourcemap,
+		target: config.build.target,
+		treeshake: true
+	};
+}
+/**
+* Map a resolved bundler config to a tsdown InlineConfig for watch mode.
+*
+* @param params - The resolved config and optional success callback.
+* @returns A tsdown InlineConfig with `watch: true`.
+*/
+function mapToWatchConfig(params) {
+	return {
+		...mapToBuildConfig(params.config),
+		onSuccess: params.onSuccess,
+		watch: true
+	};
+}
+/**
+* Combine Node.js builtins with user-specified externals.
+*
+* @private
+* @param userExternals - Additional packages to mark as external.
+* @returns Combined array of externals for tsdown's `deps.neverBundle`.
+*/
+function buildExternals(userExternals) {
+	return [...NODE_BUILTINS, ...userExternals];
+}
+/**
+* Resolve the absolute file path to the `@kidd-cli/utils/tag` module.
+*
+* The static autoloader virtual module imports `withTag` via this path.
+* Using an absolute path ensures rolldown can resolve the import from
+* inside the virtual module without relying on tsdown's `alwaysBundle`
+* heuristic, which virtual modules may bypass.
+*
+* @private
+* @returns The absolute file path to the tag module.
+*/
+function resolveTagModulePath() {
+	return createRequire(import.meta.url).resolve("@kidd-cli/utils/tag");
+}
+
+//#endregion
+//#region src/resolve-config.ts
+/**
+* Known entry file names produced by tsdown for ESM builds, in preference order.
+*/
+const ENTRY_CANDIDATES = ["index.mjs", "index.js"];
+/**
+* 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 `@kidd-cli/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 ?? DEFAULT_ENTRY);
+	const commands = resolve(cwd, config.commands ?? DEFAULT_COMMANDS);
+	const buildOpts = config.build ?? {};
+	const compileOpts = normalizeCompileOptions(config.compile);
+	const buildOutDir = resolve(cwd, buildOpts.out ?? DEFAULT_OUT_DIR);
+	const compileOutDir = resolve(cwd, compileOpts.out ?? DEFAULT_OUT_DIR);
+	return {
+		build: {
+			external: buildOpts.external ?? [],
+			minify: buildOpts.minify ?? DEFAULT_MINIFY,
+			sourcemap: buildOpts.sourcemap ?? DEFAULT_SOURCEMAP,
+			target: buildOpts.target ?? DEFAULT_TARGET
+		},
+		buildOutDir,
+		commands,
+		compile: {
+			name: compileOpts.name ?? DEFAULT_BINARY_NAME,
+			targets: compileOpts.targets ?? []
+		},
+		compileOutDir,
+		cwd,
+		entry,
+		include: config.include ?? []
+	};
+}
+/**
+* Detect 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.
+*/
+function detectBuildEntry(outDir) {
+	return ENTRY_CANDIDATES.map((name) => join(outDir, name)).find(existsSync);
+}
+
+//#endregion
+//#region src/build.ts
+/**
+* Build a kidd CLI tool using tsdown.
+*
+* Resolves defaults, maps the config to tsdown's InlineConfig, and invokes the build.
+*
+* @param params - The build parameters including config and working directory.
+* @returns A result tuple with build output on success or an Error on failure.
+*/
+async function build(params) {
+	const resolved = resolveConfig(params);
+	const inlineConfig = mapToBuildConfig(resolved);
+	try {
+		await build$1(inlineConfig);
+	} catch (error) {
+		console.error("[kidd-bundler] build error:", error);
+		return err(new Error("tsdown build failed", { cause: error }));
+	}
+	const entryFile = detectBuildEntry(resolved.buildOutDir);
+	if (!entryFile) return err(/* @__PURE__ */ new Error(`build produced no entry file in ${resolved.buildOutDir}`));
+	return ok({
+		entryFile,
+		outDir: resolved.buildOutDir
+	});
+}
+
+//#endregion
+//#region src/compile.ts
+/**
+* Packages to externalize during `bun build --compile`.
+*
+* These are optional peer dependencies of `c12` (the config loader) that bun
+* eagerly tries to resolve even though they are behind dynamic `import()` calls
+* that never execute at runtime in a compiled CLI.
+*/
+const COMPILE_EXTERNALS = [
+	"chokidar",
+	"magicast",
+	"giget"
+];
+/**
+* Human-readable labels for each compile target.
+*/
+const COMPILE_TARGET_LABELS = {
+	"darwin-arm64": "macOS Apple Silicon",
+	"darwin-x64": "macOS Intel",
+	"linux-arm64": "Linux ARM64",
+	"linux-x64": "Linux x64",
+	"linux-x64-musl": "Linux x64 (musl)",
+	"windows-arm64": "Windows ARM64",
+	"windows-x64": "Windows x64"
+};
+/**
+* Compile a kidd 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 the current platform if none
+* specified), spawns `bun build --compile` to produce a self-contained binary.
+*
+* @param params - The compile parameters including config and working directory.
+* @returns A result tuple with compile output on success or an Error on failure.
+*/
+async function compile(params) {
+	const resolved = resolveConfig(params);
+	const bundledEntry = detectBuildEntry(resolved.buildOutDir);
+	if (!bundledEntry) return err(/* @__PURE__ */ new Error(`bundled entry not found in ${resolved.buildOutDir} — run build() first`));
+	const targets = resolveTargets(resolved.compile.targets);
+	const isMultiTarget = targets.length > 1;
+	const results = await Promise.all(targets.map(async (target) => {
+		if (params.onTargetStart) await params.onTargetStart(target);
+		const result = await compileSingleTarget({
+			bundledEntry,
+			isMultiTarget,
+			name: resolved.compile.name,
+			outDir: resolved.compileOutDir,
+			target
+		});
+		if (params.onTargetComplete) await params.onTargetComplete(target);
+		return result;
+	}));
+	cleanBunBuildArtifacts(resolved.cwd);
+	const failedResult = results.find((r) => r[0] !== null);
+	if (failedResult) {
+		const [failedError] = failedResult;
+		if (failedError) return err(failedError);
+	}
+	return ok({ binaries: results.filter((r) => r[1] !== null).map(([, binary]) => binary) });
+}
+/**
+* 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(params.name, params.target, params.isMultiTarget);
+	const outfile = join(params.outDir, binaryName);
+	const [execError] = await execBunBuild([
+		"build",
+		"--compile",
+		params.bundledEntry,
+		"--outfile",
+		outfile,
+		"--target",
+		mapCompileTarget(params.target),
+		...COMPILE_EXTERNALS.flatMap((pkg) => ["--external", pkg])
+	]);
+	if (execError) return err(new Error(`bun build --compile failed for target ${params.target}`, { 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.
+*
+* When no targets are explicitly configured, defaults to linux-x64,
+* darwin-arm64, darwin-x64, and windows-x64 to cover ~95% of developers.
+*
+* @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 DEFAULT_COMPILE_TARGETS;
+}
+/**
+* Build the output binary name, appending the target suffix for multi-target builds.
+*
+* @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(name, target, isMultiTarget) {
+	if (isMultiTarget) return `${name}-${target}`;
+	return name;
+}
+/**
+* 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) {
+	return COMPILE_TARGET_LABELS[target];
+}
+/**
+* Map a `CompileTarget` to Bun's `--target` string.
+*
+* Note: `linux-x64-musl` maps to `bun-linux-x64` because Bun's Linux
+* builds natively handle musl — there is no separate musl target.
+*
+* @private
+* @param target - The kidd compile target.
+* @returns The Bun target string (e.g., `'bun-darwin-arm64'`).
+*/
+function mapCompileTarget(target) {
+	if (target === "linux-x64-musl") return "bun-linux-x64";
+	return `bun-${target}`;
+}
+/**
+* Promisified wrapper around `execFile` to invoke `bun build`.
+*
+* @private
+* @param args - Arguments to pass to `bun`.
+* @returns A result tuple with stdout on success or an Error on failure.
+*/
+function execBunBuild(args) {
+	return new Promise((resolve) => {
+		execFile("bun", [...args], (error, stdout) => {
+			if (error) {
+				resolve(err(error));
+				return;
+			}
+			resolve(ok(stdout));
+		});
+	});
+}
+/**
+* Remove temporary `.bun-build` files that `bun build --compile` leaves behind.
+*
+* @private
+* @param cwd - The working directory to clean.
+*/
+function cleanBunBuildArtifacts(cwd) {
+	readdirSync(cwd).filter((name) => name.endsWith(".bun-build")).map((name) => join(cwd, name)).map(unlinkSync);
+}
+
+//#endregion
+//#region src/watch.ts
+/**
+* Start a watch-mode build for a kidd CLI tool using tsdown.
+*
+* The returned promise resolves only when tsdown's watch terminates (typically on process exit).
+* tsdown's `build()` with `watch: true` runs indefinitely.
+*
+* @param params - The watch parameters including config, working directory, and optional success callback.
+* @returns A result tuple with void on success or an Error on failure.
+*/
+async function watch(params) {
+	const watchConfig = mapToWatchConfig({
+		config: resolveConfig(params),
+		onSuccess: params.onSuccess
+	});
+	try {
+		await build$1(watchConfig);
+	} catch (error) {
+		return err(new Error("tsdown watch failed", { cause: error }));
+	}
+	return ok();
+}
+
+//#endregion
+export { build, compile, createAutoloadPlugin, detectBuildEntry, generateAutoloaderParts, generateStaticAutoloader, mapToBuildConfig, mapToWatchConfig, normalizeCompileOptions, resolveConfig, resolveTargetLabel, scanCommandsDir, watch };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["tsdownBuild","tsdownBuild"],"sources":["../src/generate-autoloader.ts","../src/scan-commands.ts","../src/autoload-plugin.ts","../src/constants.ts","../src/map-config.ts","../src/resolve-config.ts","../src/build.ts","../src/compile.ts","../src/watch.ts"],"sourcesContent":["import type { ScanResult, ScannedDir, ScannedFile } from './types.js'\n\n/**\n * Parameters for generating a static autoloader module.\n */\ninterface GenerateStaticAutoloaderParams {\n  readonly scan: ScanResult\n  readonly tagModulePath: string\n}\n\n/**\n * The two parts of a static autoloader transform: import statements to\n * prepend and the replacement code for the autoloader region.\n */\nexport interface StaticAutoloaderParts {\n  readonly imports: string\n  readonly region: string\n}\n\n/**\n * Generate JavaScript source code for a static autoloader virtual module.\n *\n * The generated module statically imports every discovered command file and\n * exports an `autoload()` function that returns the pre-built CommandMap.\n * Directory commands that merge a parent handler with subcommands are re-tagged\n * via `withTag` because the TAG symbol is non-enumerable and lost on spread.\n *\n * @param params - The scan result and path to the tag utility module.\n * @returns JavaScript source code for the static autoloader.\n */\nexport function generateStaticAutoloader(params: GenerateStaticAutoloaderParams): string {\n  const imports = collectImports(params.scan)\n  const importLines = buildImportStatements(imports, params.tagModulePath)\n  const commandsObject = buildCommandsObject(params.scan)\n\n  return [\n    ...importLines,\n    '',\n    `const commands = ${commandsObject}`,\n    '',\n    'export async function autoload() {',\n    '  return commands',\n    '}',\n    '',\n  ].join('\\n')\n}\n\n/**\n * Generate the two parts needed to transform kidd's bundled dist.\n *\n * Returns an empty imports string (no prepended imports needed) and a\n * replacement autoloader region that uses dynamic `import()` calls inside\n * the async `autoload()` function. This avoids circular dependency issues:\n * command files import `command` from `kidd`, so static imports would be\n * hoisted above kidd's own initialization code, causing `TAG` to be\n * accessed before initialization.\n *\n * By deferring to dynamic imports, kidd fully initializes first, then\n * command files are loaded when `autoload()` is called at CLI startup.\n *\n * @param params - The scan result and path to the tag utility module.\n * @returns Import statements (empty) and the replacement autoloader region.\n */\nexport function generateAutoloaderParts(\n  params: GenerateStaticAutoloaderParams\n): StaticAutoloaderParts {\n  const imports = collectImports(params.scan)\n\n  if (imports.length === 0) {\n    return {\n      imports: '',\n      region: buildEmptyAutoloaderRegion(),\n    }\n  }\n\n  const commandsObject = buildCommandsObject(params.scan)\n  const region = buildDynamicAutoloaderRegion(imports, commandsObject)\n\n  return { imports: '', region }\n}\n\n// ---------------------------------------------------------------------------\n\n/**\n * A collected import entry with its identifier and absolute file path.\n *\n * @private\n */\ninterface ImportEntry {\n  readonly identifier: string\n  readonly filePath: string\n}\n\n/**\n * Collect all import entries from a scan result.\n *\n * @private\n * @param scan - The scan result to collect imports from.\n * @returns A flat array of all import entries.\n */\nfunction collectImports(scan: ScanResult): readonly ImportEntry[] {\n  return [\n    ...scan.files.map((file) => fileToImport(file, [])),\n    ...scan.dirs.flatMap((dir) => collectDirImports(dir, [])),\n  ]\n}\n\n/**\n * Recursively collect import entries from a scanned directory.\n *\n * @private\n * @param dir - The scanned directory.\n * @param parentPath - The path segments leading to this directory.\n * @returns A flat array of import entries for the directory and its children.\n */\nfunction collectDirImports(dir: ScannedDir, parentPath: readonly string[]): readonly ImportEntry[] {\n  const currentPath = [...parentPath, dir.name]\n  const indexImport: readonly ImportEntry[] = buildIndexImport(dir.index, currentPath)\n\n  return [\n    ...indexImport,\n    ...dir.files.map((file) => fileToImport(file, currentPath)),\n    ...dir.dirs.flatMap((sub) => collectDirImports(sub, currentPath)),\n  ]\n}\n\n/**\n * Create an import entry for a leaf command file.\n *\n * @private\n * @param file - The scanned file.\n * @param parentPath - The path segments leading to the file's parent directory.\n * @returns An import entry with a generated identifier.\n */\nfunction fileToImport(file: ScannedFile, parentPath: readonly string[]): ImportEntry {\n  return {\n    filePath: file.filePath,\n    identifier: toIdentifier([...parentPath, file.name]),\n  }\n}\n\n/**\n * Convert a path segment array to a valid JavaScript identifier.\n *\n * Joins segments with underscores and prefixes with `_`.\n * Example: `['deploy', 'preview']` becomes `_deploy_preview`.\n *\n * @private\n * @param segments - The path segments to convert.\n * @returns A valid JavaScript identifier string.\n */\nfunction toIdentifier(segments: readonly string[]): string {\n  return `_${segments.map((s) => s.replaceAll('-', '$')).join('_')}`\n}\n\n/**\n * Build the array of import statement lines.\n *\n * @private\n * @param imports - All collected import entries.\n * @param tagModulePath - Absolute path to the tag utility module.\n * @returns An array of import statement strings.\n */\nfunction buildImportStatements(\n  imports: readonly ImportEntry[],\n  tagModulePath: string\n): readonly string[] {\n  const tagLine = buildTagImportLine(imports, tagModulePath)\n\n  const importLines = imports.map((entry) => `import ${entry.identifier} from '${entry.filePath}'`)\n\n  return [...tagLine, '', ...importLines]\n}\n\n/**\n * Build the JavaScript object literal string for the top-level commands map.\n *\n * @private\n * @param scan - The scan result.\n * @returns A string representation of the commands object literal.\n */\nfunction buildCommandsObject(scan: ScanResult): string {\n  const entries = [\n    ...scan.files.map((file) => buildFileEntry(file, [])),\n    ...scan.dirs.map((dir) => buildDirEntry(dir, [])),\n  ]\n\n  return formatObject(entries)\n}\n\n/**\n * Build an object entry string for a leaf command file.\n *\n * @private\n * @param file - The scanned file.\n * @param parentPath - Path segments to the file's parent.\n * @returns A string like `'status': _status`.\n */\nfunction buildFileEntry(file: ScannedFile, parentPath: readonly string[]): string {\n  const identifier = toIdentifier([...parentPath, file.name])\n  return `'${file.name}': ${identifier}`\n}\n\n/**\n * Build an object entry string for a directory command (possibly with subcommands).\n *\n * @private\n * @param dir - The scanned directory.\n * @param parentPath - Path segments to the directory's parent.\n * @returns A string representing the directory command with withTag wrapping.\n */\nfunction buildDirEntry(dir: ScannedDir, parentPath: readonly string[]): string {\n  const currentPath = [...parentPath, dir.name]\n  const subEntries = [\n    ...dir.files.map((file) => buildFileEntry(file, currentPath)),\n    ...dir.dirs.map((sub) => buildDirEntry(sub, currentPath)),\n  ]\n  const commandsObj = formatObject(subEntries)\n\n  if (dir.index) {\n    const indexIdentifier = toIdentifier(currentPath)\n\n    return `'${dir.name}': withTag({ ...${indexIdentifier}, commands: ${commandsObj} }, 'Command')`\n  }\n\n  return `'${dir.name}': withTag({ commands: ${commandsObj} }, 'Command')`\n}\n\n/**\n * Build the import entry for an index file, if present.\n *\n * @private\n * @param index - The absolute path to the index file, or undefined.\n * @param currentPath - The current path segments for identifier generation.\n * @returns An array with zero or one import entries.\n */\nfunction buildIndexImport(\n  index: string | undefined,\n  currentPath: readonly string[]\n): readonly ImportEntry[] {\n  if (!index) {\n    return []\n  }\n  return [{ filePath: index, identifier: toIdentifier(currentPath) }]\n}\n\n/**\n * Build the tag import line if any imports exist.\n *\n * @private\n * @param imports - The collected import entries.\n * @param tagModulePath - The absolute path to the tag module.\n * @returns An array with zero or one import statement strings.\n */\nfunction buildTagImportLine(\n  imports: readonly ImportEntry[],\n  tagModulePath: string\n): readonly string[] {\n  if (imports.length === 0) {\n    return []\n  }\n  return [`import { withTag } from '${tagModulePath}'`]\n}\n\n/**\n * Build the autoloader region for an empty scan result.\n *\n * @private\n * @returns A region string with an autoloader that returns an empty object.\n */\nfunction buildEmptyAutoloaderRegion(): string {\n  return [\n    '//#region src/autoloader.ts (static)',\n    'async function autoload() {',\n    '  return {}',\n    '}',\n    '//#endregion',\n  ].join('\\n')\n}\n\n/**\n * Build the autoloader region using dynamic `import()` calls.\n *\n * Uses `Promise.all` with array destructuring to load all command files\n * in parallel. The dynamic imports defer execution until `autoload()` is\n * called, avoiding circular dependency issues with kidd's own initialization.\n *\n * @private\n * @param imports - The collected import entries.\n * @param commandsObject - The commands object literal string.\n * @returns A region string with the full dynamic autoloader.\n */\nfunction buildDynamicAutoloaderRegion(\n  imports: readonly ImportEntry[],\n  commandsObject: string\n): string {\n  const destructuring = imports.map((entry) => `    { default: ${entry.identifier} },`).join('\\n')\n\n  const importCalls = imports.map((entry) => `    import('${entry.filePath}'),`).join('\\n')\n\n  return [\n    '//#region src/autoloader.ts (static)',\n    'async function autoload() {',\n    '  const [',\n    destructuring,\n    '  ] = await Promise.all([',\n    importCalls,\n    '  ])',\n    `  return ${commandsObject}`,\n    '}',\n    '//#endregion',\n  ].join('\\n')\n}\n\n/**\n * Format an array of key-value strings as a JavaScript object literal.\n *\n * @private\n * @param entries - The key-value pair strings.\n * @returns A formatted object literal string.\n */\nfunction formatObject(entries: readonly string[]): string {\n  if (entries.length === 0) {\n    return '{}'\n  }\n\n  const body = entries.map((entry) => `  ${entry},`).join('\\n')\n  return `{\\n${body}\\n}`\n}\n","import type { Dirent } from 'node:fs'\nimport { readdir } from 'node:fs/promises'\nimport { basename, extname, join } from 'node:path'\n\nimport type { ScanResult, ScannedDir, ScannedFile } from './types.js'\n\nconst VALID_EXTENSIONS = new Set(['.ts', '.js', '.mjs'])\nconst INDEX_NAME = 'index'\n\n/**\n * Scan a commands directory and produce a tree structure for static code generation.\n *\n * Mirrors the runtime autoloader's rules: valid extensions are `.ts`, `.js`, `.mjs`;\n * files and directories starting with `_` or `.` are skipped; `index` files in\n * subdirectories become parent command handlers.\n *\n * @param dir - Absolute path to the commands directory.\n * @returns A tree of scanned files and directories.\n */\nexport async function scanCommandsDir(dir: string): Promise<ScanResult> {\n  const entries = await readdir(dir, { withFileTypes: true })\n\n  const files = entries.filter(isCommandFile).map((entry) => toScannedFile(dir, entry))\n\n  const dirs = await Promise.all(\n    entries.filter(isCommandDir).map((entry) => scanSubDir(join(dir, entry.name)))\n  )\n\n  return { dirs, files }\n}\n\n// ---------------------------------------------------------------------------\n\n/**\n * Recursively scan a subdirectory into a ScannedDir.\n *\n * @private\n * @param dir - Absolute path to the subdirectory.\n * @returns A ScannedDir representing the directory and its contents.\n */\nasync function scanSubDir(dir: string): Promise<ScannedDir> {\n  const name = basename(dir)\n  const entries = await readdir(dir, { withFileTypes: true })\n  const indexEntry = findIndexEntry(entries)\n\n  const files = entries.filter(isCommandFile).map((entry) => toScannedFile(dir, entry))\n\n  const dirs = await Promise.all(\n    entries.filter(isCommandDir).map((entry) => scanSubDir(join(dir, entry.name)))\n  )\n\n  return {\n    dirs,\n    files,\n    index: resolveIndexPath(dir, indexEntry),\n    name,\n  }\n}\n\n/**\n * Convert a directory entry into a ScannedFile.\n *\n * @private\n * @param dir - Parent directory absolute path.\n * @param entry - The directory entry for the file.\n * @returns A ScannedFile with name and absolute file path.\n */\nfunction toScannedFile(dir: string, entry: Dirent): ScannedFile {\n  return {\n    filePath: join(dir, entry.name),\n    name: basename(entry.name, extname(entry.name)),\n  }\n}\n\n/**\n * Find the index file entry among a list of directory entries.\n *\n * @private\n * @param entries - The directory entries to search.\n * @returns The Dirent for the index file, or undefined.\n */\nfunction findIndexEntry(entries: readonly Dirent[]): Dirent | undefined {\n  return entries.find(\n    (entry) =>\n      entry.isFile() &&\n      VALID_EXTENSIONS.has(extname(entry.name)) &&\n      basename(entry.name, extname(entry.name)) === INDEX_NAME\n  )\n}\n\n/**\n * Predicate: entry is a valid command file (not index, not hidden/private).\n *\n * @private\n * @param entry - The directory entry to check.\n * @returns True when the entry is a scannable command file.\n */\nfunction isCommandFile(entry: Dirent): boolean {\n  if (!entry.isFile()) {\n    return false\n  }\n  if (entry.name.startsWith('_') || entry.name.startsWith('.')) {\n    return false\n  }\n  if (!VALID_EXTENSIONS.has(extname(entry.name))) {\n    return false\n  }\n  return basename(entry.name, extname(entry.name)) !== INDEX_NAME\n}\n\n/**\n * Predicate: entry is a scannable command directory (not hidden/private).\n *\n * @private\n * @param entry - The directory entry to check.\n * @returns True when the entry is a scannable command directory.\n */\nfunction isCommandDir(entry: Dirent): boolean {\n  if (!entry.isDirectory()) {\n    return false\n  }\n  return !entry.name.startsWith('_') && !entry.name.startsWith('.')\n}\n\n/**\n * Resolve the absolute path to an index file entry, or undefined.\n *\n * @private\n * @param dir - The parent directory absolute path.\n * @param entry - The index file Dirent, or undefined.\n * @returns The absolute path to the index file, or undefined.\n */\nfunction resolveIndexPath(dir: string, entry: Dirent | undefined): string | undefined {\n  if (!entry) {\n    return undefined\n  }\n  return join(dir, entry.name)\n}\n","import type { Rolldown } from 'tsdown'\n\nimport { generateStaticAutoloader } from './generate-autoloader.js'\nimport { scanCommandsDir } from './scan-commands.js'\n\nconst VIRTUAL_MODULE_ID = 'virtual:kidd-static-commands'\nconst RESOLVED_VIRTUAL_ID = `\\0${VIRTUAL_MODULE_ID}`\n\nconst AUTOLOADER_REGION_START = '//#region src/autoloader.ts'\nconst AUTOLOADER_REGION_END = '//#endregion'\nconst KIDD_DIST_PATTERN = /\\/kidd\\/dist\\/index\\.js$/\n\n/**\n * Parameters for creating the autoload plugin.\n */\ninterface CreateAutoloadPluginParams {\n  readonly commandsDir: string\n  readonly tagModulePath: string\n}\n\n/**\n * Create a rolldown plugin that replaces the runtime autoloader with a static version.\n *\n * Uses a three-hook approach to break the circular dependency between kidd's\n * dist and user command files (which `import { command } from 'kidd'`):\n *\n * 1. `transform` — detects kidd's pre-bundled dist and replaces the autoloader\n *    region with a dynamic `import()` to a virtual module\n * 2. `resolveId` — resolves the virtual module identifier\n * 3. `load` — scans the commands directory and generates a static autoloader\n *    module with all command imports pre-resolved\n *\n * The dynamic import ensures command files execute after kidd's code is fully\n * initialized, avoiding `ReferenceError` from accessing `TAG` before its\n * declaration.\n *\n * @param params - The commands directory and tag module path.\n * @returns A rolldown plugin for static autoloading.\n */\nexport function createAutoloadPlugin(params: CreateAutoloadPluginParams): Rolldown.Plugin {\n  return {\n    async load(id) {\n      if (id !== RESOLVED_VIRTUAL_ID) {\n        return null\n      }\n\n      const scan = await scanCommandsDir(params.commandsDir)\n\n      return generateStaticAutoloader({\n        scan,\n        tagModulePath: params.tagModulePath,\n      })\n    },\n    name: 'kidd-static-autoloader',\n    resolveId(source) {\n      if (source === VIRTUAL_MODULE_ID) {\n        return RESOLVED_VIRTUAL_ID\n      }\n\n      return null\n    },\n    transform(code, id) {\n      if (!KIDD_DIST_PATTERN.test(id)) {\n        return null\n      }\n\n      const regionStart = code.indexOf(AUTOLOADER_REGION_START)\n      if (regionStart === -1) {\n        return null\n      }\n\n      const regionEnd = code.indexOf(AUTOLOADER_REGION_END, regionStart)\n      if (regionEnd === -1) {\n        return null\n      }\n\n      const before = code.slice(0, regionStart)\n      const after = code.slice(regionEnd + AUTOLOADER_REGION_END.length)\n      const staticRegion = buildStaticRegion()\n\n      return `${before}${staticRegion}${after}`\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n\n/**\n * Build the replacement autoloader region that delegates to the virtual module.\n *\n * @private\n * @returns The replacement region string with dynamic import.\n */\nfunction buildStaticRegion(): string {\n  return [\n    '//#region src/autoloader.ts (static)',\n    'async function autoload() {',\n    `  const mod = await import('${VIRTUAL_MODULE_ID}')`,\n    '  return mod.autoload()',\n    '}',\n    '//#endregion',\n  ].join('\\n')\n}\n","import { builtinModules } from 'node:module'\n\nimport type { CompileTarget } from '@kidd-cli/config'\n\n/**\n * Shebang line prepended to CLI entry files.\n */\nexport const SHEBANG = '#!/usr/bin/env node\\n'\n\n/**\n * Default entry point for the CLI source.\n */\nexport const DEFAULT_ENTRY = './src/index.ts'\n\n/**\n * Default directory for CLI commands.\n */\nexport const DEFAULT_COMMANDS = './commands'\n\n/**\n * Default build output directory.\n */\nexport const DEFAULT_OUT_DIR = './dist'\n\n/**\n * Default Node.js target version for builds.\n */\nexport const DEFAULT_TARGET = 'node18'\n\n/**\n * Default minification setting.\n */\nexport const DEFAULT_MINIFY = false\n\n/**\n * Default source map generation setting.\n */\nexport const DEFAULT_SOURCEMAP = true\n\n/**\n * Default binary name for compiled SEA output.\n */\nexport const DEFAULT_BINARY_NAME = 'cli'\n\n/**\n * Default compile targets when none are explicitly configured.\n *\n * Covers Linux servers/CI, modern and Intel Macs, and Windows — roughly 95%\n * of developer environments.\n */\nexport const DEFAULT_COMPILE_TARGETS: readonly CompileTarget[] = [\n  'darwin-arm64',\n  'darwin-x64',\n  'linux-x64',\n  'windows-x64',\n]\n\n/**\n * Packages that must always be bundled into the output.\n *\n * The `kidd` framework and its internal `@kidd-cli/*` packages must be inlined\n * so the autoload plugin can intercept and replace the runtime autoloader\n * with a static version for compiled binaries.\n */\nexport const ALWAYS_BUNDLE: RegExp[] = [/^@?kidd/]\n\n/**\n * Node.js builtin modules in both bare and `node:` prefixed forms.\n */\nexport const NODE_BUILTINS: readonly string[] = [\n  ...builtinModules,\n  ...builtinModules.map((m) => `node:${m}`),\n]\n","import { createRequire } from 'node:module'\n\nimport type { InlineConfig } from 'tsdown'\n\nimport { createAutoloadPlugin } from './autoload-plugin.js'\nimport { ALWAYS_BUNDLE, NODE_BUILTINS, SHEBANG } from './constants.js'\nimport type { ResolvedBundlerConfig } from './types.js'\n\n/**\n * Map a resolved bundler config to a tsdown InlineConfig for production builds.\n *\n * @param config - The fully resolved bundler config.\n * @returns A tsdown InlineConfig ready for `build()`.\n */\nexport function mapToBuildConfig(config: ResolvedBundlerConfig): InlineConfig {\n  return {\n    banner: SHEBANG,\n    clean: true,\n    config: false,\n    cwd: config.cwd,\n    deps: {\n      alwaysBundle: ALWAYS_BUNDLE,\n      neverBundle: buildExternals(config.build.external),\n    },\n    dts: false,\n    entry: { index: config.entry },\n    format: 'esm',\n    inputOptions: {\n      resolve: {\n        mainFields: ['module', 'main'],\n      },\n    },\n    logLevel: 'info',\n    minify: config.build.minify,\n    outDir: config.buildOutDir,\n    outputOptions: {\n      codeSplitting: false,\n    },\n    platform: 'node',\n    plugins: [\n      createAutoloadPlugin({\n        commandsDir: config.commands,\n        tagModulePath: resolveTagModulePath(),\n      }),\n    ],\n    sourcemap: config.build.sourcemap,\n    target: config.build.target,\n    treeshake: true,\n  }\n}\n\n/**\n * Map a resolved bundler config to a tsdown InlineConfig for watch mode.\n *\n * @param params - The resolved config and optional success callback.\n * @returns A tsdown InlineConfig with `watch: true`.\n */\nexport function mapToWatchConfig(params: {\n  readonly config: ResolvedBundlerConfig\n  readonly onSuccess?: () => void | Promise<void>\n}): InlineConfig {\n  const buildConfig = mapToBuildConfig(params.config)\n\n  return {\n    ...buildConfig,\n    onSuccess: params.onSuccess,\n    watch: true,\n  }\n}\n\n// ---------------------------------------------------------------------------\n\n/**\n * Combine Node.js builtins with user-specified externals.\n *\n * @private\n * @param userExternals - Additional packages to mark as external.\n * @returns Combined array of externals for tsdown's `deps.neverBundle`.\n */\nfunction buildExternals(userExternals: readonly string[]): (string | RegExp)[] {\n  return [...NODE_BUILTINS, ...userExternals]\n}\n\n/**\n * Resolve the absolute file path to the `@kidd-cli/utils/tag` module.\n *\n * The static autoloader virtual module imports `withTag` via this path.\n * Using an absolute path ensures rolldown can resolve the import from\n * inside the virtual module without relying on tsdown's `alwaysBundle`\n * heuristic, which virtual modules may bypass.\n *\n * @private\n * @returns The absolute file path to the tag module.\n */\nfunction resolveTagModulePath(): string {\n  const require = createRequire(import.meta.url)\n  return require.resolve('@kidd-cli/utils/tag')\n}\n","import { existsSync } from 'node:fs'\nimport { join, resolve } from 'node:path'\n\nimport type { CompileOptions, KiddConfig } from '@kidd-cli/config'\n\nimport {\n  DEFAULT_BINARY_NAME,\n  DEFAULT_COMMANDS,\n  DEFAULT_ENTRY,\n  DEFAULT_MINIFY,\n  DEFAULT_OUT_DIR,\n  DEFAULT_SOURCEMAP,\n  DEFAULT_TARGET,\n} from './constants.js'\nimport type { ResolvedBundlerConfig } from './types.js'\n\n/**\n * Known entry file names produced by tsdown for ESM builds, in preference order.\n */\nconst ENTRY_CANDIDATES = ['index.mjs', 'index.js'] as const\n\n/**\n * Normalize the `compile` config field from `boolean | CompileOptions | undefined` to `CompileOptions`.\n *\n * - `true` → `{}` (compile with defaults)\n * - `false` / `undefined` → `{}` (no explicit options, caller decides whether to compile)\n * - object → pass through\n *\n * @param value - The raw compile config value.\n * @returns A normalized CompileOptions object.\n */\nexport function normalizeCompileOptions(\n  value: boolean | CompileOptions | undefined\n): CompileOptions {\n  if (typeof value === 'object') {\n    return value\n  }\n\n  return {}\n}\n\n/**\n * Fill defaults and resolve relative paths against `cwd`.\n *\n * This is a pure function — the incoming config is already validated by `@kidd-cli/config`.\n * It only fills missing optional fields with defaults and resolves paths to absolute.\n *\n * @param params - The raw config and working directory.\n * @returns A fully resolved bundler configuration.\n */\nexport function resolveConfig(params: {\n  readonly config: KiddConfig\n  readonly cwd: string\n}): ResolvedBundlerConfig {\n  const { config, cwd } = params\n\n  const entry = resolve(cwd, config.entry ?? DEFAULT_ENTRY)\n  const commands = resolve(cwd, config.commands ?? DEFAULT_COMMANDS)\n\n  const buildOpts = config.build ?? {}\n  const compileOpts = normalizeCompileOptions(config.compile)\n\n  const buildOutDir = resolve(cwd, buildOpts.out ?? DEFAULT_OUT_DIR)\n  const compileOutDir = resolve(cwd, compileOpts.out ?? DEFAULT_OUT_DIR)\n\n  return {\n    build: {\n      external: buildOpts.external ?? [],\n      minify: buildOpts.minify ?? DEFAULT_MINIFY,\n      sourcemap: buildOpts.sourcemap ?? DEFAULT_SOURCEMAP,\n      target: buildOpts.target ?? DEFAULT_TARGET,\n    },\n    buildOutDir,\n    commands,\n    compile: {\n      name: compileOpts.name ?? DEFAULT_BINARY_NAME,\n      targets: compileOpts.targets ?? [],\n    },\n    compileOutDir,\n    cwd,\n    entry,\n    include: config.include ?? [],\n  }\n}\n\n/**\n * Detect the bundled entry file in a build output directory.\n *\n * tsdown may produce `index.mjs` or `index.js` depending on the project's\n * `package.json` `type` field and tsdown configuration. This function checks\n * for both candidates and returns the first one that exists on disk.\n *\n * @param outDir - Absolute path to the build output directory.\n * @returns The absolute path to the entry file, or `undefined` when none is found.\n */\nexport function detectBuildEntry(outDir: string): string | undefined {\n  return ENTRY_CANDIDATES.map((name) => join(outDir, name)).find(existsSync)\n}\n","import { err, ok } from '@kidd-cli/utils/fp'\nimport { build as tsdownBuild } from 'tsdown'\n\nimport { mapToBuildConfig } from './map-config.js'\nimport { detectBuildEntry, resolveConfig } from './resolve-config.js'\nimport type { AsyncBundlerResult, BuildOutput, BuildParams } from './types.js'\n\n/**\n * Build a kidd CLI tool using tsdown.\n *\n * Resolves defaults, maps the config to tsdown's InlineConfig, and invokes the build.\n *\n * @param params - The build parameters including config and working directory.\n * @returns A result tuple with build output on success or an Error on failure.\n */\nexport async function build(params: BuildParams): AsyncBundlerResult<BuildOutput> {\n  const resolved = resolveConfig(params)\n  const inlineConfig = mapToBuildConfig(resolved)\n\n  try {\n    await tsdownBuild(inlineConfig)\n  } catch (error: unknown) {\n    console.error('[kidd-bundler] build error:', error)\n    return err(new Error('tsdown build failed', { cause: error }))\n  }\n\n  const entryFile = detectBuildEntry(resolved.buildOutDir)\n\n  if (!entryFile) {\n    return err(new Error(`build produced no entry file in ${resolved.buildOutDir}`))\n  }\n\n  return ok({\n    entryFile,\n    outDir: resolved.buildOutDir,\n  })\n}\n","import { execFile as execFileCb } from 'node:child_process'\nimport { readdirSync, unlinkSync } from 'node:fs'\nimport { join } from 'node:path'\n\nimport type { CompileTarget } from '@kidd-cli/config'\nimport { err, ok } from '@kidd-cli/utils/fp'\nimport type { AsyncResult } from '@kidd-cli/utils/fp'\n\nimport { DEFAULT_COMPILE_TARGETS } from './constants.js'\nimport { detectBuildEntry, resolveConfig } from './resolve-config.js'\nimport type { CompileOutput, CompileParams, CompiledBinary } from './types.js'\n\n/**\n * Packages to externalize during `bun build --compile`.\n *\n * These are optional peer dependencies of `c12` (the config loader) that bun\n * eagerly tries to resolve even though they are behind dynamic `import()` calls\n * that never execute at runtime in a compiled CLI.\n */\nconst COMPILE_EXTERNALS: readonly string[] = ['chokidar', 'magicast', 'giget']\n\n/**\n * Human-readable labels for each compile target.\n */\nconst COMPILE_TARGET_LABELS: Readonly<Record<CompileTarget, string>> = {\n  'darwin-arm64': 'macOS Apple Silicon',\n  'darwin-x64': 'macOS Intel',\n  'linux-arm64': 'Linux ARM64',\n  'linux-x64': 'Linux x64',\n  'linux-x64-musl': 'Linux x64 (musl)',\n  'windows-arm64': 'Windows ARM64',\n  'windows-x64': 'Windows x64',\n}\n\n/**\n * Compile a kidd CLI tool into standalone binaries using `bun build --compile`.\n *\n * Expects the bundled entry to already exist in `outDir` (i.e., `build()` must\n * be run first). For each requested target (or the current platform if none\n * specified), spawns `bun build --compile` to produce a self-contained binary.\n *\n * @param params - The compile parameters including config and working directory.\n * @returns A result tuple with compile output on success or an Error on failure.\n */\nexport async function compile(params: CompileParams): AsyncResult<CompileOutput> {\n  const resolved = resolveConfig(params)\n  const bundledEntry = detectBuildEntry(resolved.buildOutDir)\n\n  if (!bundledEntry) {\n    return err(new Error(`bundled entry not found in ${resolved.buildOutDir} — run build() first`))\n  }\n\n  const targets: readonly CompileTarget[] = resolveTargets(resolved.compile.targets)\n  const isMultiTarget = targets.length > 1\n\n  const results = await Promise.all(\n    targets.map(async (target) => {\n      if (params.onTargetStart) {\n        await params.onTargetStart(target)\n      }\n\n      const result = await compileSingleTarget({\n        bundledEntry,\n        isMultiTarget,\n        name: resolved.compile.name,\n        outDir: resolved.compileOutDir,\n        target,\n      })\n\n      if (params.onTargetComplete) {\n        await params.onTargetComplete(target)\n      }\n\n      return result\n    })\n  )\n\n  cleanBunBuildArtifacts(resolved.cwd)\n\n  const failedResult = results.find((r) => r[0] !== null)\n  if (failedResult) {\n    const [failedError] = failedResult\n    if (failedError) {\n      return err(failedError)\n    }\n  }\n\n  const binaries: readonly CompiledBinary[] = results\n    .filter((r): r is readonly [null, CompiledBinary] => r[1] !== null)\n    .map(([, binary]) => binary)\n\n  return ok({ binaries })\n}\n\n// ---------------------------------------------------------------------------\n\n/**\n * Compile a single target via `bun build --compile`.\n *\n * @private\n * @param params - Target compilation parameters.\n * @returns A result tuple with the compiled binary info or an error.\n */\nasync function compileSingleTarget(params: {\n  readonly bundledEntry: string\n  readonly outDir: string\n  readonly name: string\n  readonly target: CompileTarget\n  readonly isMultiTarget: boolean\n}): AsyncResult<CompiledBinary> {\n  const binaryName = resolveBinaryName(params.name, params.target, params.isMultiTarget)\n  const outfile = join(params.outDir, binaryName)\n\n  const args = [\n    'build',\n    '--compile',\n    params.bundledEntry,\n    '--outfile',\n    outfile,\n    '--target',\n    mapCompileTarget(params.target),\n    ...COMPILE_EXTERNALS.flatMap((pkg) => ['--external', pkg]),\n  ]\n\n  const [execError] = await execBunBuild(args)\n  if (execError) {\n    return err(\n      new Error(`bun build --compile failed for target ${params.target}`, { cause: execError })\n    )\n  }\n\n  return ok({ label: resolveTargetLabel(params.target), path: outfile, target: params.target })\n}\n\n/**\n * Resolve the list of compile targets, falling back to the default set.\n *\n * When no targets are explicitly configured, defaults to linux-x64,\n * darwin-arm64, darwin-x64, and windows-x64 to cover ~95% of developers.\n *\n * @private\n * @param explicit - User-specified targets (may be empty).\n * @returns The targets to compile for.\n */\nfunction resolveTargets(explicit: readonly CompileTarget[]): readonly CompileTarget[] {\n  if (explicit.length > 0) {\n    return explicit\n  }\n\n  return DEFAULT_COMPILE_TARGETS\n}\n\n/**\n * Build the output binary name, appending the target suffix for multi-target builds.\n *\n * @private\n * @param name - Base binary name.\n * @param target - The compile target.\n * @param isMultiTarget - Whether multiple targets are being compiled.\n * @returns The resolved binary file name.\n */\nfunction resolveBinaryName(name: string, target: CompileTarget, isMultiTarget: boolean): string {\n  if (isMultiTarget) {\n    return `${name}-${target}`\n  }\n\n  return name\n}\n\n/**\n * Look up the human-readable label for a compile target.\n *\n * @param target - The compile target identifier.\n * @returns A descriptive label (e.g., \"macOS Apple Silicon\").\n */\nexport function resolveTargetLabel(target: CompileTarget): string {\n  return COMPILE_TARGET_LABELS[target]\n}\n\n/**\n * Map a `CompileTarget` to Bun's `--target` string.\n *\n * Note: `linux-x64-musl` maps to `bun-linux-x64` because Bun's Linux\n * builds natively handle musl — there is no separate musl target.\n *\n * @private\n * @param target - The kidd compile target.\n * @returns The Bun target string (e.g., `'bun-darwin-arm64'`).\n */\nfunction mapCompileTarget(target: CompileTarget): string {\n  if (target === 'linux-x64-musl') {\n    return 'bun-linux-x64'\n  }\n\n  return `bun-${target}`\n}\n\n/**\n * Promisified wrapper around `execFile` to invoke `bun build`.\n *\n * @private\n * @param args - Arguments to pass to `bun`.\n * @returns A result tuple with stdout on success or an Error on failure.\n */\nfunction execBunBuild(args: readonly string[]): AsyncResult<string> {\n  return new Promise((resolve) => {\n    execFileCb('bun', [...args], (error, stdout) => {\n      if (error) {\n        resolve(err(error))\n        return\n      }\n\n      resolve(ok(stdout))\n    })\n  })\n}\n\n/**\n * Remove temporary `.bun-build` files that `bun build --compile` leaves behind.\n *\n * @private\n * @param cwd - The working directory to clean.\n */\nfunction cleanBunBuildArtifacts(cwd: string): void {\n  readdirSync(cwd)\n    .filter((name) => name.endsWith('.bun-build'))\n    .map((name) => join(cwd, name))\n    .map(unlinkSync)\n}\n","import { err, ok } from '@kidd-cli/utils/fp'\nimport { build as tsdownBuild } from 'tsdown'\n\nimport { mapToWatchConfig } from './map-config.js'\nimport { resolveConfig } from './resolve-config.js'\nimport type { AsyncBundlerResult, WatchParams } from './types.js'\n\n/**\n * Start a watch-mode build for a kidd CLI tool using tsdown.\n *\n * The returned promise resolves only when tsdown's watch terminates (typically on process exit).\n * tsdown's `build()` with `watch: true` runs indefinitely.\n *\n * @param params - The watch parameters including config, working directory, and optional success callback.\n * @returns A result tuple with void on success or an Error on failure.\n */\nexport async function watch(params: WatchParams): AsyncBundlerResult<void> {\n  const resolved = resolveConfig(params)\n  const watchConfig = mapToWatchConfig({\n    config: resolved,\n    onSuccess: params.onSuccess,\n  })\n\n  try {\n    await tsdownBuild(watchConfig)\n  } catch (error: unknown) {\n    return err(new Error('tsdown watch failed', { cause: error }))\n  }\n\n  return ok()\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@kidd-cli/bundler",
+  "version": "0.1.0",
+  "description": "Programmatic bundler for kidd CLI tools powered by tsdown",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "es-toolkit": "^1.45.0",
+    "ts-pattern": "^5.9.0",
+    "tsdown": "0.21.0-beta.2",
+    "zod": "^4.3.6",
+    "@kidd-cli/config": "0.1.0",
+    "@kidd-cli/utils": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsgo --noEmit",
+    "lint": "oxlint --ignore-pattern node_modules",
+    "lint:fix": "oxlint --fix --ignore-pattern node_modules",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}