@maltty/cli 1.0.0-rc.0

package/dist/commands/run.js

@@ -0,0 +1,478 @@
+import { i as M, n as process_exports } from "../node-C91xGGqn.js";
+import { i as normalizeCompileOptions, r as createBundler } from "../dist-DW_gRP7_.js";
+import { n as loadConfig, t as compileTargets } from "../utils-DlIJNGLQ.js";
+import { t as extractConfig } from "../config-helpers-pv_2Spux.js";
+import { command } from "maltty";
+import { resolve } from "node:path";
+import { z } from "zod";
+//#region src/commands/run.ts
+const EngineSchema = z.enum([
+	"node",
+	"tsx",
+	"binary"
+]);
+const compileTargetValues = compileTargets.map((entry) => entry.target);
+const TargetSchema = z.enum(compileTargetValues);
+/**
+* Run the current maltty CLI project.
+*
+* Supports three engines:
+* - `node` (default) — builds first, then runs `node dist/index.js`
+* - `tsx` — runs the source entry file directly via `tsx`
+* - `binary` — builds and compiles, then executes the compiled binary
+*
+* All unknown flags are forwarded to the executed CLI. Supports
+* `--inspect`, `--inspect-brk`, `--inspect-wait`, and `--inspect-port`
+* for attaching a debugger (node and tsx engines only).
+*/
+const runCommand = command({
+	options: z.object({
+		engine: EngineSchema.default("node").describe("Runtime engine: node (built), tsx (source), or binary (compiled)"),
+		inspect: z.boolean().optional().describe("Enable the Node.js inspector (--inspect)"),
+		"inspect-brk": z.boolean().optional().describe("Enable the Node.js inspector and break before user code starts (--inspect-brk)"),
+		"inspect-port": z.number().optional().describe("Set the inspector port"),
+		"inspect-wait": z.boolean().optional().describe("Enable the Node.js inspector and wait for debugger to attach (--inspect-wait)"),
+		target: z.string().optional().describe("Compile target for binary engine (e.g. darwin-arm64)")
+	}),
+	strict: false,
+	description: "Run the current maltty CLI project",
+	handler: async (ctx) => {
+		const cwd = process.cwd();
+		const [configError, configResult] = await loadConfig({ cwd });
+		if (configError) return ctx.fail(configError.message);
+		const config = extractConfig(configResult);
+		if (ctx.args.engine === "binary" && hasInspectFlag(ctx.args)) return ctx.fail("Inspector flags are not supported with the binary engine. Use --engine=node or --engine=tsx instead.");
+		const passthroughArgs = extractPassthroughArgs();
+		const exitCode = await M(ctx.args.engine).with("node", () => runWithNode({
+			args: ctx.args,
+			config,
+			cwd,
+			passthroughArgs,
+			ctx
+		})).with("tsx", () => runWithTsx({
+			args: ctx.args,
+			config,
+			cwd,
+			passthroughArgs,
+			ctx
+		})).with("binary", () => runWithBinary({
+			args: ctx.args,
+			config,
+			cwd,
+			passthroughArgs,
+			ctx
+		})).exhaustive();
+		if (exitCode !== 0) return ctx.fail(`Process exited with code ${exitCode}`);
+	}
+});
+/**
+* Build the project and run the bundled entry file with `node`.
+*
+* @private
+* @param params - Engine execution parameters.
+* @returns The exit code of the spawned process.
+*/
+async function runWithNode(params) {
+	const buildOutput = await buildProject({
+		bundler: await createBundler({
+			config: params.config,
+			cwd: params.cwd
+		}),
+		ctx: params.ctx
+	});
+	return spawnProcess({
+		args: [
+			...buildInspectFlags(params.args),
+			buildOutput.entryFile,
+			...params.passthroughArgs
+		],
+		cmd: "node",
+		cwd: params.cwd
+	});
+}
+/**
+* Run the source entry file directly with `tsx`.
+*
+* @private
+* @param params - Engine execution parameters.
+* @returns The exit code of the spawned process.
+*/
+async function runWithTsx(params) {
+	const entryFile = resolve(params.cwd, params.config.entry ?? "./src/index.ts");
+	return spawnProcess({
+		args: [
+			...buildInspectFlags(params.args),
+			entryFile,
+			...params.passthroughArgs
+		],
+		cmd: "tsx",
+		cwd: params.cwd
+	});
+}
+/**
+* Build and compile the project, then execute the compiled binary.
+*
+* Requires compile targets to be configured in `maltty.config.ts` or
+* provided via `--target`. Resolves the current platform's binary
+* from the compile output.
+*
+* @private
+* @param params - Engine execution parameters.
+* @returns The exit code of the spawned process.
+*/
+async function runWithBinary(params) {
+	const validatedTarget = validateTarget({
+		ctx: params.ctx,
+		target: params.args.target
+	});
+	const configWithTarget = applyTargetOverride({
+		config: params.config,
+		target: validatedTarget
+	});
+	if (!hasCompileTargets(configWithTarget)) return params.ctx.fail("No compile targets configured. Set targets in maltty.config.ts or use --target.");
+	const bundler = await createBundler({
+		config: configWithTarget,
+		cwd: params.cwd
+	});
+	await buildProject({
+		bundler,
+		ctx: params.ctx
+	});
+	params.ctx.status.spinner.message("Compiling binary...");
+	const binary = resolveBinary({
+		compileOutput: await compileProject({
+			bundler,
+			ctx: params.ctx
+		}),
+		ctx: params.ctx,
+		target: params.args.target
+	});
+	params.ctx.status.spinner.stop("Build complete");
+	return spawnProcess({
+		args: params.passthroughArgs,
+		cmd: binary.path,
+		cwd: params.cwd
+	});
+}
+/**
+* Build the project using the bundler and return the build output.
+*
+* Starts a spinner, invokes the build, and fails the command on error.
+*
+* @private
+* @param params - The bundler instance and command context.
+* @returns The successful build output.
+*/
+async function buildProject(params) {
+	params.ctx.status.spinner.start("Building...");
+	const [buildError, buildOutput] = await params.bundler.build();
+	if (buildError) {
+		params.ctx.status.spinner.stop("Build failed");
+		return params.ctx.fail(buildError.message);
+	}
+	params.ctx.status.spinner.stop("Built");
+	return buildOutput;
+}
+/**
+* Compile the project into standalone binaries.
+*
+* @private
+* @param params - The bundler instance and command context.
+* @returns The successful compile output.
+*/
+async function compileProject(params) {
+	const [compileError, compileOutput] = await params.bundler.compile();
+	if (compileError) {
+		params.ctx.status.spinner.stop("Compile failed");
+		return params.ctx.fail(compileError.message);
+	}
+	return compileOutput;
+}
+/**
+* Resolve the binary to execute from compile output.
+*
+* When `--target` is provided, finds the matching binary. Otherwise
+* detects the host platform and architecture to find the correct binary.
+*
+* @private
+* @param params - The compile output, optional target, and command context.
+* @returns The resolved compiled binary.
+*/
+function resolveBinary(params) {
+	if (params.target) {
+		const binary = params.compileOutput.binaries.find((b) => b.target === params.target);
+		if (!binary) return params.ctx.fail(`No binary found for target "${params.target}"`);
+		return binary;
+	}
+	const hostTarget = resolveHostTarget();
+	const candidates = resolveHostTargetCandidates(hostTarget);
+	const binary = findFirstMatchingBinary(params.compileOutput.binaries, candidates);
+	if (!binary) return params.ctx.fail(`No binary found for target "${hostTarget}"`);
+	return binary;
+}
+/**
+* Build an ordered list of candidate targets for the current host.
+*
+* On Linux x64, includes both the musl variant (`linux-x64-musl`) and the
+* glibc variant (`linux-x64`) so the correct binary is found on Alpine-like
+* hosts. The musl variant is preferred when available.
+*
+* @private
+* @param hostTarget - The base host target string (e.g. `linux-x64`).
+* @returns An ordered list of candidate target strings to try.
+*/
+function resolveHostTargetCandidates(hostTarget) {
+	if (hostTarget === "linux-x64") return [`${hostTarget}-musl`, hostTarget];
+	return [hostTarget];
+}
+/**
+* Find the first binary matching any of the candidate targets.
+*
+* @private
+* @param binaries - The compiled binaries to search.
+* @param candidates - Ordered candidate target strings.
+* @returns The first matching binary, or `undefined`.
+*/
+function findFirstMatchingBinary(binaries, candidates) {
+	return candidates.reduce((found, candidate) => found ?? binaries.find((b) => b.target === candidate), void 0);
+}
+/**
+* Map from Node.js `process.platform` to compile target OS prefix.
+*
+* @private
+*/
+const PLATFORM_MAP = {
+	darwin: "darwin",
+	linux: "linux",
+	win32: "windows"
+};
+/**
+* Map from Node.js `process.arch` to compile target architecture suffix.
+*
+* @private
+*/
+const ARCH_MAP = {
+	arm64: "arm64",
+	x64: "x64"
+};
+/**
+* Detect the host platform and architecture, returning a compile target string.
+*
+* Combines `process.platform` and `process.arch` into a target like `darwin-arm64`.
+*
+* @private
+* @returns The compile target string for the current host.
+*/
+function resolveHostTarget() {
+	return `${PLATFORM_MAP[process.platform] ?? process.platform}-${ARCH_MAP[process.arch] ?? process.arch}`;
+}
+/**
+* Check whether a config has compilation enabled.
+*
+* Returns `true` for `compile: true` (boolean shorthand), for object configs
+* that omit `targets` (the bundler fills in defaults), and for object configs
+* with a non-empty `targets` array. Only returns `false` when compile is
+* `false`, `undefined`, or an object with an explicitly empty `targets` array.
+*
+* @private
+* @param config - The maltty config to check.
+* @returns `true` when compilation is enabled.
+*/
+function hasCompileTargets(config) {
+	if (config.compile === true) return true;
+	if (typeof config.compile !== "object") return false;
+	if (config.compile.targets === void 0) return true;
+	return config.compile.targets.length > 0;
+}
+/**
+* Validate a `--target` string against known compile targets.
+*
+* Returns the validated target when provided, or `undefined` when no target
+* was specified. Fails the command with a descriptive error for invalid values.
+*
+* @private
+* @param params - The target string and command context.
+* @returns The validated compile target, or `undefined`.
+*/
+function validateTarget(params) {
+	if (!params.target) return;
+	const parsed = TargetSchema.safeParse(params.target);
+	if (!parsed.success) {
+		const validTargets = TargetSchema.options.join(", ");
+		return params.ctx.fail(`Invalid compile target "${params.target}". Must be one of: ${validTargets}`);
+	}
+	return parsed.data;
+}
+/**
+* Apply a `--target` CLI override to the config's compile targets.
+*
+* @private
+* @param params - The config and optional validated target override.
+* @returns A config with the target override applied.
+*/
+function applyTargetOverride(params) {
+	if (!params.target) return params.config;
+	const existingCompile = normalizeCompileOptions(params.config.compile);
+	return {
+		...params.config,
+		compile: {
+			...existingCompile,
+			targets: [params.target]
+		}
+	};
+}
+/**
+* Extract passthrough arguments by sequentially walking argv tokens
+* and skipping known `maltty run` flags and their values.
+*
+* Uses positional parsing: when a known flag that takes a value is
+* encountered (e.g. `--engine`), the next token is also skipped.
+* This avoids the fragile value-based matching that could accidentally
+* consume user CLI arguments that happen to match a known flag's value.
+*
+* @private
+* @returns An array of arguments to forward to the user's CLI.
+*/
+function extractPassthroughArgs() {
+	const argv = process.argv.slice(2);
+	const runIndex = argv.indexOf("run");
+	if (runIndex === -1) return [];
+	return collectPassthroughTokens(argv.slice(runIndex + 1));
+}
+/**
+* Known boolean flags for the `maltty run` command (no value follows).
+*
+* @private
+*/
+const KNOWN_BOOLEAN_FLAGS = new Set([
+	"--inspect",
+	"--inspect-brk",
+	"--inspect-wait"
+]);
+/**
+* Known value flags for the `maltty run` command (next token is consumed as value).
+*
+* @private
+*/
+const KNOWN_VALUE_FLAGS = new Set([
+	"--engine",
+	"--inspect-port",
+	"--target"
+]);
+/**
+* Walk an array of CLI tokens sequentially and collect only passthrough args.
+*
+* Skips known boolean flags, known value flags (and their following value token),
+* and `--flag=value` forms. All other tokens are collected as passthrough.
+*
+* @private
+* @param tokens - The CLI tokens after the `run` subcommand.
+* @returns The filtered passthrough arguments.
+*/
+function collectPassthroughTokens(tokens) {
+	return tokens.reduce((acc, token) => {
+		if (acc.skip) return {
+			result: acc.result,
+			skip: false
+		};
+		if (KNOWN_BOOLEAN_FLAGS.has(token)) return {
+			result: acc.result,
+			skip: false
+		};
+		if (KNOWN_VALUE_FLAGS.has(token)) return {
+			result: acc.result,
+			skip: true
+		};
+		if (isKnownEqualsSyntax(token)) return {
+			result: acc.result,
+			skip: false
+		};
+		return {
+			result: [...acc.result, token],
+			skip: false
+		};
+	}, {
+		result: [],
+		skip: false
+	}).result;
+}
+/**
+* Check whether a token uses `--flag=value` syntax for a known flag.
+*
+* @private
+* @param token - The CLI token to check.
+* @returns `true` when the token is a known flag in `--flag=value` form.
+*/
+function isKnownEqualsSyntax(token) {
+	const eqIndex = token.indexOf("=");
+	if (eqIndex <= 0) return false;
+	const flagPart = token.slice(0, eqIndex);
+	return KNOWN_BOOLEAN_FLAGS.has(flagPart) || KNOWN_VALUE_FLAGS.has(flagPart);
+}
+/**
+* Check whether any inspector flag is set, including `--inspect-port`.
+*
+* @private
+* @param args - The parsed CLI args.
+* @returns `true` when any inspector flag is enabled.
+*/
+function hasInspectFlag(args) {
+	return args.inspect === true || args["inspect-brk"] === true || args["inspect-wait"] === true || args["inspect-port"] !== void 0;
+}
+/**
+* Build inspector-related Node.js flags from parsed CLI args.
+*
+* Only one inspector mode is active at a time, with `inspect-brk` taking
+* precedence over `inspect-wait`, which takes precedence over `inspect`.
+*
+* @private
+* @param args - The parsed CLI args.
+* @returns An array of inspector flags.
+*/
+function buildInspectFlags(args) {
+	const flag = resolveInspectMode(args);
+	if (!flag) return [];
+	return [formatInspectFlag(flag, args["inspect-port"])];
+}
+/**
+* Determine which inspector mode to use based on parsed CLI args.
+*
+* When only `--inspect-port` is provided without an explicit mode,
+* defaults to `'inspect'` so the port is not silently ignored.
+*
+* @private
+* @param args - The parsed CLI args.
+* @returns The inspector flag name, or `undefined` if none is active.
+*/
+function resolveInspectMode(args) {
+	if (args["inspect-brk"]) return "inspect-brk";
+	if (args["inspect-wait"]) return "inspect-wait";
+	if (args.inspect) return "inspect";
+	if (args["inspect-port"] !== void 0) return "inspect";
+}
+/**
+* Format an inspector flag with an optional port.
+*
+* @private
+* @param flag - The inspector flag name (e.g. 'inspect', 'inspect-brk').
+* @param port - Optional port number.
+* @returns The formatted flag string.
+*/
+function formatInspectFlag(flag, port) {
+	if (port !== void 0) return `--${flag}=${port}`;
+	return `--${flag}`;
+}
+/**
+* Spawn a process with the given command and arguments, inheriting stdio.
+*
+* @private
+* @param params - The command, arguments, and working directory.
+* @returns The exit code of the spawned process.
+*/
+function spawnProcess(params) {
+	return process_exports.spawn(params);
+}
+//#endregion
+export { runCommand as default };
+
+//# sourceMappingURL=run.js.map

package/dist/commands/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","names":["match","proc"],"sources":["../../src/commands/run.ts"],"sourcesContent":["import { resolve } from 'node:path'\n\nimport { createBundler, DEFAULT_ENTRY, normalizeCompileOptions } from '@maltty/bundler'\nimport type { BuildOutput, Bundler, CompileOutput, CompiledBinary } from '@maltty/bundler'\nimport type { CompileTarget, MalttyConfig } from '@maltty/config'\nimport { compileTargets, loadConfig } from '@maltty/config/utils'\nimport { process as proc } from '@maltty/utils/node'\nimport { command } from 'maltty'\nimport type { Command, CommandContext } from 'maltty'\nimport { match } from 'ts-pattern'\nimport { z } from 'zod'\n\nimport { extractConfig } from '../lib/config-helpers.js'\n\nconst EngineSchema = z.enum(['node', 'tsx', 'binary'])\n\nconst compileTargetValues = compileTargets.map((entry) => entry.target) as [\n  CompileTarget,\n  ...CompileTarget[],\n]\nconst TargetSchema = z.enum(compileTargetValues)\n\nconst options = z.object({\n  engine: EngineSchema.default('node').describe(\n    'Runtime engine: node (built), tsx (source), or binary (compiled)'\n  ),\n  inspect: z.boolean().optional().describe('Enable the Node.js inspector (--inspect)'),\n  'inspect-brk': z\n    .boolean()\n    .optional()\n    .describe('Enable the Node.js inspector and break before user code starts (--inspect-brk)'),\n  'inspect-port': z.number().optional().describe('Set the inspector port'),\n  'inspect-wait': z\n    .boolean()\n    .optional()\n    .describe('Enable the Node.js inspector and wait for debugger to attach (--inspect-wait)'),\n  target: z.string().optional().describe('Compile target for binary engine (e.g. darwin-arm64)'),\n})\n\ntype RunArgs = z.infer<typeof options>\n\n/**\n * Run the current maltty CLI project.\n *\n * Supports three engines:\n * - `node` (default) — builds first, then runs `node dist/index.js`\n * - `tsx` — runs the source entry file directly via `tsx`\n * - `binary` — builds and compiles, then executes the compiled binary\n *\n * All unknown flags are forwarded to the executed CLI. Supports\n * `--inspect`, `--inspect-brk`, `--inspect-wait`, and `--inspect-port`\n * for attaching a debugger (node and tsx engines only).\n */\nconst runCommand: Command = command({\n  options,\n  strict: false,\n  description: 'Run the current maltty CLI project',\n  handler: async (ctx: CommandContext<RunArgs>) => {\n    const cwd = process.cwd()\n\n    const [configError, configResult] = await loadConfig({ cwd })\n\n    if (configError) {\n      return ctx.fail(configError.message)\n    }\n\n    const config = extractConfig(configResult)\n\n    if (ctx.args.engine === 'binary' && hasInspectFlag(ctx.args)) {\n      return ctx.fail(\n        'Inspector flags are not supported with the binary engine. Use --engine=node or --engine=tsx instead.'\n      )\n    }\n\n    const passthroughArgs = extractPassthroughArgs()\n\n    const exitCode = await match(ctx.args.engine)\n      .with('node', () => runWithNode({ args: ctx.args, config, cwd, passthroughArgs, ctx }))\n      .with('tsx', () => runWithTsx({ args: ctx.args, config, cwd, passthroughArgs, ctx }))\n      .with('binary', () => runWithBinary({ args: ctx.args, config, cwd, passthroughArgs, ctx }))\n      .exhaustive()\n\n    if (exitCode !== 0) {\n      return ctx.fail(`Process exited with code ${exitCode}`)\n    }\n  },\n})\n\nexport default runCommand\n\n// ---------------------------------------------------------------------------\n\n/**\n * Build the project and run the bundled entry file with `node`.\n *\n * @private\n * @param params - Engine execution parameters.\n * @returns The exit code of the spawned process.\n */\nasync function runWithNode(params: EngineParams): Promise<number> {\n  const bundler = await createBundler({ config: params.config, cwd: params.cwd })\n  const buildOutput = await buildProject({ bundler, ctx: params.ctx })\n  const inspectFlags = buildInspectFlags(params.args)\n\n  return spawnProcess({\n    args: [...inspectFlags, buildOutput.entryFile, ...params.passthroughArgs],\n    cmd: 'node',\n    cwd: params.cwd,\n  })\n}\n\n/**\n * Run the source entry file directly with `tsx`.\n *\n * @private\n * @param params - Engine execution parameters.\n * @returns The exit code of the spawned process.\n */\nasync function runWithTsx(params: EngineParams): Promise<number> {\n  const entryFile = resolve(params.cwd, params.config.entry ?? DEFAULT_ENTRY)\n  const inspectFlags = buildInspectFlags(params.args)\n\n  return spawnProcess({\n    args: [...inspectFlags, entryFile, ...params.passthroughArgs],\n    cmd: 'tsx',\n    cwd: params.cwd,\n  })\n}\n\n/**\n * Build and compile the project, then execute the compiled binary.\n *\n * Requires compile targets to be configured in `maltty.config.ts` or\n * provided via `--target`. Resolves the current platform's binary\n * from the compile output.\n *\n * @private\n * @param params - Engine execution parameters.\n * @returns The exit code of the spawned process.\n */\nasync function runWithBinary(params: EngineParams): Promise<number> {\n  const validatedTarget = validateTarget({ ctx: params.ctx, target: params.args.target })\n\n  const configWithTarget = applyTargetOverride({\n    config: params.config,\n    target: validatedTarget,\n  })\n\n  if (!hasCompileTargets(configWithTarget)) {\n    return params.ctx.fail(\n      'No compile targets configured. Set targets in maltty.config.ts or use --target.'\n    )\n  }\n\n  const bundler = await createBundler({ config: configWithTarget, cwd: params.cwd })\n\n  await buildProject({ bundler, ctx: params.ctx })\n\n  params.ctx.status.spinner.message('Compiling binary...')\n\n  const compileOutput = await compileProject({ bundler, ctx: params.ctx })\n\n  const binary = resolveBinary({\n    compileOutput,\n    ctx: params.ctx,\n    target: params.args.target,\n  })\n\n  params.ctx.status.spinner.stop('Build complete')\n\n  return spawnProcess({\n    args: params.passthroughArgs,\n    cmd: binary.path,\n    cwd: params.cwd,\n  })\n}\n\n/**\n * Parameters shared across all engine execution functions.\n *\n * @private\n */\ninterface EngineParams {\n  readonly args: RunArgs\n  readonly config: MalttyConfig\n  readonly ctx: CommandContext<RunArgs>\n  readonly cwd: string\n  readonly passthroughArgs: readonly string[]\n}\n\n/**\n * Build the project using the bundler and return the build output.\n *\n * Starts a spinner, invokes the build, and fails the command on error.\n *\n * @private\n * @param params - The bundler instance and command context.\n * @returns The successful build output.\n */\nasync function buildProject(params: {\n  readonly bundler: Bundler\n  readonly ctx: CommandContext<RunArgs>\n}): Promise<BuildOutput> {\n  params.ctx.status.spinner.start('Building...')\n\n  const [buildError, buildOutput] = await params.bundler.build()\n\n  if (buildError) {\n    params.ctx.status.spinner.stop('Build failed')\n    return params.ctx.fail(buildError.message)\n  }\n\n  params.ctx.status.spinner.stop('Built')\n\n  return buildOutput\n}\n\n/**\n * Compile the project into standalone binaries.\n *\n * @private\n * @param params - The bundler instance and command context.\n * @returns The successful compile output.\n */\nasync function compileProject(params: {\n  readonly bundler: Bundler\n  readonly ctx: CommandContext<RunArgs>\n}): Promise<CompileOutput> {\n  const [compileError, compileOutput] = await params.bundler.compile()\n\n  if (compileError) {\n    params.ctx.status.spinner.stop('Compile failed')\n    return params.ctx.fail(compileError.message)\n  }\n\n  return compileOutput\n}\n\n/**\n * Resolve the binary to execute from compile output.\n *\n * When `--target` is provided, finds the matching binary. Otherwise\n * detects the host platform and architecture to find the correct binary.\n *\n * @private\n * @param params - The compile output, optional target, and command context.\n * @returns The resolved compiled binary.\n */\nfunction resolveBinary(params: {\n  readonly compileOutput: CompileOutput\n  readonly ctx: CommandContext<RunArgs>\n  readonly target: string | undefined\n}): CompiledBinary {\n  if (params.target) {\n    const binary = params.compileOutput.binaries.find((b) => b.target === params.target)\n\n    if (!binary) {\n      return params.ctx.fail(`No binary found for target \"${params.target}\"`)\n    }\n\n    return binary\n  }\n\n  const hostTarget = resolveHostTarget()\n  const candidates = resolveHostTargetCandidates(hostTarget)\n  const binary = findFirstMatchingBinary(params.compileOutput.binaries, candidates)\n\n  if (!binary) {\n    return params.ctx.fail(`No binary found for target \"${hostTarget}\"`)\n  }\n\n  return binary\n}\n\n/**\n * Build an ordered list of candidate targets for the current host.\n *\n * On Linux x64, includes both the musl variant (`linux-x64-musl`) and the\n * glibc variant (`linux-x64`) so the correct binary is found on Alpine-like\n * hosts. The musl variant is preferred when available.\n *\n * @private\n * @param hostTarget - The base host target string (e.g. `linux-x64`).\n * @returns An ordered list of candidate target strings to try.\n */\nfunction resolveHostTargetCandidates(hostTarget: string): readonly string[] {\n  if (hostTarget === 'linux-x64') {\n    return [`${hostTarget}-musl`, hostTarget]\n  }\n\n  return [hostTarget]\n}\n\n/**\n * Find the first binary matching any of the candidate targets.\n *\n * @private\n * @param binaries - The compiled binaries to search.\n * @param candidates - Ordered candidate target strings.\n * @returns The first matching binary, or `undefined`.\n */\nfunction findFirstMatchingBinary(\n  binaries: readonly CompiledBinary[],\n  candidates: readonly string[]\n): CompiledBinary | undefined {\n  return candidates.reduce<CompiledBinary | undefined>(\n    (found, candidate) => found ?? binaries.find((b) => b.target === candidate),\n    undefined\n  )\n}\n\n/**\n * Map from Node.js `process.platform` to compile target OS prefix.\n *\n * @private\n */\nconst PLATFORM_MAP: Readonly<Record<string, string>> = {\n  darwin: 'darwin',\n  linux: 'linux',\n  win32: 'windows',\n}\n\n/**\n * Map from Node.js `process.arch` to compile target architecture suffix.\n *\n * @private\n */\nconst ARCH_MAP: Readonly<Record<string, string>> = {\n  arm64: 'arm64',\n  x64: 'x64',\n}\n\n/**\n * Detect the host platform and architecture, returning a compile target string.\n *\n * Combines `process.platform` and `process.arch` into a target like `darwin-arm64`.\n *\n * @private\n * @returns The compile target string for the current host.\n */\nfunction resolveHostTarget(): string {\n  const os = PLATFORM_MAP[process.platform] ?? process.platform\n  const arch = ARCH_MAP[process.arch] ?? process.arch\n  return `${os}-${arch}`\n}\n\n/**\n * Check whether a config has compilation enabled.\n *\n * Returns `true` for `compile: true` (boolean shorthand), for object configs\n * that omit `targets` (the bundler fills in defaults), and for object configs\n * with a non-empty `targets` array. Only returns `false` when compile is\n * `false`, `undefined`, or an object with an explicitly empty `targets` array.\n *\n * @private\n * @param config - The maltty config to check.\n * @returns `true` when compilation is enabled.\n */\nfunction hasCompileTargets(config: MalttyConfig): boolean {\n  if (config.compile === true) {\n    return true\n  }\n\n  if (typeof config.compile !== 'object') {\n    return false\n  }\n\n  if (config.compile.targets === undefined) {\n    return true\n  }\n\n  return config.compile.targets.length > 0\n}\n\n/**\n * Validate a `--target` string against known compile targets.\n *\n * Returns the validated target when provided, or `undefined` when no target\n * was specified. Fails the command with a descriptive error for invalid values.\n *\n * @private\n * @param params - The target string and command context.\n * @returns The validated compile target, or `undefined`.\n */\nfunction validateTarget(params: {\n  readonly ctx: CommandContext<RunArgs>\n  readonly target: string | undefined\n}): CompileTarget | undefined {\n  if (!params.target) {\n    return undefined\n  }\n\n  const parsed = TargetSchema.safeParse(params.target)\n\n  if (!parsed.success) {\n    const validTargets = TargetSchema.options.join(', ')\n    return params.ctx.fail(\n      `Invalid compile target \"${params.target}\". Must be one of: ${validTargets}`\n    )\n  }\n\n  return parsed.data\n}\n\n/**\n * Apply a `--target` CLI override to the config's compile targets.\n *\n * @private\n * @param params - The config and optional validated target override.\n * @returns A config with the target override applied.\n */\nfunction applyTargetOverride(params: {\n  readonly config: MalttyConfig\n  readonly target: CompileTarget | undefined\n}): MalttyConfig {\n  if (!params.target) {\n    return params.config\n  }\n\n  const existingCompile = normalizeCompileOptions(params.config.compile)\n\n  return {\n    ...params.config,\n    compile: {\n      ...existingCompile,\n      targets: [params.target],\n    },\n  }\n}\n\n/**\n * Extract passthrough arguments by sequentially walking argv tokens\n * and skipping known `maltty run` flags and their values.\n *\n * Uses positional parsing: when a known flag that takes a value is\n * encountered (e.g. `--engine`), the next token is also skipped.\n * This avoids the fragile value-based matching that could accidentally\n * consume user CLI arguments that happen to match a known flag's value.\n *\n * @private\n * @returns An array of arguments to forward to the user's CLI.\n */\nfunction extractPassthroughArgs(): readonly string[] {\n  const argv = process.argv.slice(2)\n  const runIndex = argv.indexOf('run')\n\n  if (runIndex === -1) {\n    return []\n  }\n\n  const afterRun = argv.slice(runIndex + 1)\n\n  return collectPassthroughTokens(afterRun)\n}\n\n/**\n * Known boolean flags for the `maltty run` command (no value follows).\n *\n * @private\n */\nconst KNOWN_BOOLEAN_FLAGS: ReadonlySet<string> = new Set([\n  '--inspect',\n  '--inspect-brk',\n  '--inspect-wait',\n])\n\n/**\n * Known value flags for the `maltty run` command (next token is consumed as value).\n *\n * @private\n */\nconst KNOWN_VALUE_FLAGS: ReadonlySet<string> = new Set(['--engine', '--inspect-port', '--target'])\n\n/**\n * Walk an array of CLI tokens sequentially and collect only passthrough args.\n *\n * Skips known boolean flags, known value flags (and their following value token),\n * and `--flag=value` forms. All other tokens are collected as passthrough.\n *\n * @private\n * @param tokens - The CLI tokens after the `run` subcommand.\n * @returns The filtered passthrough arguments.\n */\nfunction collectPassthroughTokens(tokens: readonly string[]): readonly string[] {\n  return tokens.reduce<{ readonly result: readonly string[]; readonly skip: boolean }>(\n    (acc, token) => {\n      if (acc.skip) {\n        return { result: acc.result, skip: false }\n      }\n\n      if (KNOWN_BOOLEAN_FLAGS.has(token)) {\n        return { result: acc.result, skip: false }\n      }\n\n      if (KNOWN_VALUE_FLAGS.has(token)) {\n        return { result: acc.result, skip: true }\n      }\n\n      if (isKnownEqualsSyntax(token)) {\n        return { result: acc.result, skip: false }\n      }\n\n      return { result: [...acc.result, token], skip: false }\n    },\n    { result: [], skip: false }\n  ).result\n}\n\n/**\n * Check whether a token uses `--flag=value` syntax for a known flag.\n *\n * @private\n * @param token - The CLI token to check.\n * @returns `true` when the token is a known flag in `--flag=value` form.\n */\nfunction isKnownEqualsSyntax(token: string): boolean {\n  const eqIndex = token.indexOf('=')\n  if (eqIndex <= 0) {\n    return false\n  }\n\n  const flagPart = token.slice(0, eqIndex)\n  return KNOWN_BOOLEAN_FLAGS.has(flagPart) || KNOWN_VALUE_FLAGS.has(flagPart)\n}\n\n/**\n * Check whether any inspector flag is set, including `--inspect-port`.\n *\n * @private\n * @param args - The parsed CLI args.\n * @returns `true` when any inspector flag is enabled.\n */\nfunction hasInspectFlag(args: RunArgs): boolean {\n  return (\n    args.inspect === true ||\n    args['inspect-brk'] === true ||\n    args['inspect-wait'] === true ||\n    args['inspect-port'] !== undefined\n  )\n}\n\n/**\n * Build inspector-related Node.js flags from parsed CLI args.\n *\n * Only one inspector mode is active at a time, with `inspect-brk` taking\n * precedence over `inspect-wait`, which takes precedence over `inspect`.\n *\n * @private\n * @param args - The parsed CLI args.\n * @returns An array of inspector flags.\n */\nfunction buildInspectFlags(args: RunArgs): readonly string[] {\n  const flag = resolveInspectMode(args)\n\n  if (!flag) {\n    return []\n  }\n\n  return [formatInspectFlag(flag, args['inspect-port'])]\n}\n\n/**\n * Determine which inspector mode to use based on parsed CLI args.\n *\n * When only `--inspect-port` is provided without an explicit mode,\n * defaults to `'inspect'` so the port is not silently ignored.\n *\n * @private\n * @param args - The parsed CLI args.\n * @returns The inspector flag name, or `undefined` if none is active.\n */\nfunction resolveInspectMode(args: RunArgs): string | undefined {\n  if (args['inspect-brk']) {\n    return 'inspect-brk'\n  }\n\n  if (args['inspect-wait']) {\n    return 'inspect-wait'\n  }\n\n  if (args.inspect) {\n    return 'inspect'\n  }\n\n  if (args['inspect-port'] !== undefined) {\n    return 'inspect'\n  }\n\n  return undefined\n}\n\n/**\n * Format an inspector flag with an optional port.\n *\n * @private\n * @param flag - The inspector flag name (e.g. 'inspect', 'inspect-brk').\n * @param port - Optional port number.\n * @returns The formatted flag string.\n */\nfunction formatInspectFlag(flag: string, port: number | undefined): string {\n  if (port !== undefined) {\n    return `--${flag}=${port}`\n  }\n\n  return `--${flag}`\n}\n\n/**\n * Spawn a process with the given command and arguments, inheriting stdio.\n *\n * @private\n * @param params - The command, arguments, and working directory.\n * @returns The exit code of the spawned process.\n */\nfunction spawnProcess(params: {\n  readonly cmd: string\n  readonly args: readonly string[]\n  readonly cwd: string\n}): Promise<number> {\n  return proc.spawn(params)\n}\n"],"mappings":"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"}

package/dist/commands/stories.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "maltty";
+
+//#region src/commands/stories.d.ts
+/**
+* Launch the stories viewer TUI for browsing and editing
+* component stories in the terminal.
+*/
+declare const storiesCommand: Command;
+//#endregion
+export { storiesCommand as default };
+//# sourceMappingURL=stories.d.ts.map

package/dist/commands/stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stories.d.ts","names":[],"sources":["../../src/commands/stories.ts"],"mappings":";;;;;AAA6B;;cAkBvB,cAAA,EAAgB,OAAA"}

package/dist/commands/stories.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { StoriesScreen } from "maltty/stories";
+import { screen } from "maltty/ui";
+//#region src/commands/stories.ts
+/**
+* Launch the stories viewer TUI for browsing and editing
+* component stories in the terminal.
+*/
+const storiesCommand = screen({
+	description: "Browse and preview component stories in the terminal",
+	options: z.object({
+		include: z.string().describe("Glob pattern for story files").optional(),
+		out: z.string().describe("Render story to stdout (pass story name, or omit for all)").optional(),
+		check: z.boolean().describe("Validate stories for common issues").default(false)
+	}),
+	exit: "manual",
+	render: StoriesScreen
+});
+//#endregion
+export { storiesCommand as default };
+
+//# sourceMappingURL=stories.js.map

package/dist/commands/stories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stories.js","names":[],"sources":["../../src/commands/stories.ts"],"sourcesContent":["import type { Command } from 'maltty'\nimport { StoriesScreen } from 'maltty/stories'\nimport { screen } from 'maltty/ui'\nimport { z } from 'zod'\n\n/**\n * Options schema for the `maltty stories` command.\n */\nconst options = z.object({\n  include: z.string().describe('Glob pattern for story files').optional(),\n  out: z.string().describe('Render story to stdout (pass story name, or omit for all)').optional(),\n  check: z.boolean().describe('Validate stories for common issues').default(false),\n})\n\n/**\n * Launch the stories viewer TUI for browsing and editing\n * component stories in the terminal.\n */\nconst storiesCommand: Command = screen({\n  description: 'Browse and preview component stories in the terminal',\n  options,\n  exit: 'manual',\n  render: StoriesScreen,\n})\n\nexport default storiesCommand\n"],"mappings":";;;;;;;;AAkBA,MAAM,iBAA0B,OAAO;CACrC,aAAa;CACb,SAZc,EAAE,OAAO;EACvB,SAAS,EAAE,QAAQ,CAAC,SAAS,+BAA+B,CAAC,UAAU;EACvE,KAAK,EAAE,QAAQ,CAAC,SAAS,4DAA4D,CAAC,UAAU;EAChG,OAAO,EAAE,SAAS,CAAC,SAAS,qCAAqC,CAAC,QAAQ,MAAM;EACjF,CAAC;CASA,MAAM;CACN,QAAQ;CACT,CAAC"}

package/dist/config-helpers-pv_2Spux.js

@@ -0,0 +1,15 @@
+//#region src/lib/config-helpers.ts
+/**
+* Extract a MalttyConfig from a load result, falling back to empty defaults.
+*
+* @param result - The result from loadConfig, or null when loading failed.
+* @returns The loaded config or an empty object (all MalttyConfig fields are optional).
+*/
+function extractConfig(result) {
+	if (result) return result.config;
+	return {};
+}
+//#endregion
+export { extractConfig as t };
+
+//# sourceMappingURL=config-helpers-pv_2Spux.js.map

package/dist/config-helpers-pv_2Spux.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-helpers-pv_2Spux.js","names":[],"sources":["../src/lib/config-helpers.ts"],"sourcesContent":["import type { MalttyConfig } from '@maltty/config'\nimport type { LoadConfigResult } from '@maltty/config/utils'\n\n/**\n * Extract a MalttyConfig from a load result, falling back to empty defaults.\n *\n * @param result - The result from loadConfig, or null when loading failed.\n * @returns The loaded config or an empty object (all MalttyConfig fields are optional).\n */\nexport function extractConfig(result: LoadConfigResult | null): MalttyConfig {\n  if (result) {\n    return result.config\n  }\n\n  return {}\n}\n"],"mappings":";;;;;;;AASA,SAAgB,cAAc,QAA+C;AAC3E,KAAI,OACF,QAAO,OAAO;AAGhB,QAAO,EAAE"}