fix: handle empty content and output routing regressions

.changeset/fresh-tomatoes-crash.md

@@ -0,0 +1,8 @@
+---
+"@node-minify/cli": patch
+"@node-minify/core": patch
+"@node-minify/run": patch
+"@node-minify/utils": patch
+---
+
+Fix empty in-memory content handling, benchmark CLI defaults, subprocess close handling, and multi-output routing regressions.

packages/cli/__tests__/cli-benchmark-bin.test.ts

@@ -0,0 +1,49 @@
+/*!
+ * node-minify
+ * Copyright (c) 2011-2026 Rodolphe Stoclin
+ * MIT Licensed
+ */
+
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { describe, expect, test } from "vitest";
+
+const execFileAsync = promisify(execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "../../..");
+const cliEntry = path.join(repoRoot, "packages/cli/src/bin/cli.ts");
+
+describe("cli benchmark command", () => {
+    test("should emit clean JSON and benchmark defaults when compressors are not provided", async () => {
+        const { stdout, stderr } = await execFileAsync(
+            "bun",
+            [
+                cliEntry,
+                "benchmark",
+                "tests/fixtures/es5/fixture-1.js",
+                "--format",
+                "json",
+                "--iterations",
+                "1",
+            ],
+            {
+                cwd: repoRoot,
+            }
+        );
+
+        expect(stderr).toBe("");
+
+        const trimmedStdout = stdout.trim();
+        const parsed = JSON.parse(trimmedStdout) as {
+            files: Array<{
+                results: Array<{ compressor: string }>;
+            }>;
+        };
+
+        expect(
+            parsed.files[0]?.results.map((result) => result.compressor)
+        ).toEqual(["terser", "esbuild", "swc", "oxc"]);
+    }, 60000);
+});

packages/cli/src/bin/cli.ts

@@ -96,32 +96,35 @@ function setupProgram(): Command {
         .option("--brotli", "include brotli size")
         .option("-v, --verbose", "verbose output")
         .action(async (input, options) => {
-            const globalOpts = program.opts();
-            const spinner = ora("Benchmarking...").start();
+            const shouldUseSpinner =
+                options.format !== "json" && !!process.stderr.isTTY;
+            const spinner = shouldUseSpinner
+                ? ora("Benchmarking...").start()
+                : null;
             try {
                 const results = await benchmark({
                     input,
-                    compressors:
-                        options.compressors?.split(",") ||
-                        globalOpts.compressor?.split(","),
+                    compressors: options.compressors?.split(","),
                     iterations: parseInt(options.iterations, 10),
                     format: options.format,
                     output: options.output,
                     includeGzip: !!options.gzip,
                     includeBrotli: !!options.brotli,
-                    type: globalOpts.type,
+                    type: program.opts().type,
                     verbose: !!options.verbose,
                     onProgress: (compressor: string, file: string) => {
-                        spinner.text = `Benchmarking ${compressor} on ${file}...`;
+                        if (spinner) {
+                            spinner.text = `Benchmarking ${compressor} on ${file}...`;
+                        }
                     },
                 });
 
-                spinner.stop();
+                spinner?.stop();
                 const reporter = getReporter(options.format);
                 console.log(reporter(results));
                 process.exit(0);
             } catch (error) {
-                spinner.fail("Benchmark failed");
+                spinner?.fail("Benchmark failed");
                 console.error(error);
                 process.exit(1);
             }

packages/core/__tests__/core.test.ts

@@ -216,6 +216,15 @@ describe("Package: core", async () => {
             expect(min).toBeDefined();
         });
 
+        test("should accept empty string content in memory mode", async () => {
+            const settings: Settings = {
+                compressor: noCompress,
+                content: "",
+            };
+
+            await expect(minify(settings)).resolves.toBe("");
+        });
+
         test("should throw an error if binary does not exist", async () => {
             const settings: Settings = {
                 compressor: "fake" as unknown as Compressor,

packages/core/src/index.ts

@@ -22,6 +22,9 @@ export async function minify<T extends CompressorOptions = CompressorOptions>(
     settings: Settings<T>
 ): Promise<string> {
     const compressorSettings = setup(settings);
-    const method = settings.content ? compressSingleFile : compress;
+    const method =
+        compressorSettings.content !== undefined
+            ? compressSingleFile
+            : compress;
     return await method(compressorSettings);
 }

packages/core/src/setup.ts

@@ -33,8 +33,8 @@ function setup<T extends CompressorOptions = CompressorOptions>(
     } as Settings<T>;
 
     // In memory
-    if (settings.content) {
-        validateMandatoryFields(inputSettings, ["compressor", "content"]);
+    if (settings.content !== undefined) {
+        validateMandatoryFields(inputSettings, ["compressor"]);
         return settings;
     }
 

packages/run/__tests__/run.test.ts

@@ -166,7 +166,7 @@ describe("Package: run", () => {
                 mockStdout.emit("error", new Error("stdout error"));
                 mockStderr.emit("error", new Error("stderr error"));
                 mockStdout.emit("data", Buffer.from("output"));
-                mockChild.emit("exit", 0);
+                mockChild.emit("close", 0);
             });
 
             const result = await promise;
@@ -221,7 +221,7 @@ describe("Package: run", () => {
             setImmediate(() => {
                 mockStdin.emit("error", new Error("stdin error"));
                 mockStdout.emit("data", Buffer.from("output"));
-                mockChild.emit("exit", 0);
+                mockChild.emit("close", 0);
             });
 
             const result = await promise;
@@ -231,6 +231,39 @@ describe("Package: run", () => {
             consoleSpy.mockRestore();
         });
 
+        test("should wait for close before resolving stdout", async () => {
+            const mockChild = new EventEmitter() as ReturnType<
+                typeof childProcess.spawn
+            >;
+            const mockStdin = new EventEmitter();
+            const mockStdout = new EventEmitter();
+            const mockStderr = new EventEmitter();
+
+            Object.assign(mockChild, {
+                stdin: Object.assign(mockStdin, {
+                    end: vi.fn(),
+                }),
+                stdout: mockStdout,
+                stderr: mockStderr,
+                kill: vi.fn(),
+            });
+
+            spy.mockReturnValue(mockChild);
+
+            const promise = runCommandLine({
+                args: ["-jar", "fake.jar"],
+                data: "test",
+            });
+
+            setImmediate(() => {
+                mockChild.emit("exit", 0);
+                mockStdout.emit("data", Buffer.from("delayed-output"));
+                mockChild.emit("close", 0);
+            });
+
+            await expect(promise).resolves.toBe("delayed-output");
+        });
+
         test("should reject when maxBuffer is exceeded", async () => {
             const mockChild = new EventEmitter() as ReturnType<
                 typeof childProcess.spawn

packages/run/src/index.ts

@@ -96,7 +96,7 @@ export async function run({
         child.stdout?.on("error", handleError("child.stdout"));
         child.stderr?.on("error", handleError("child.stderr"));
 
-        child.on("exit", (code: number | null) => {
+        child.on("close", (code: number | null) => {
             if (settled) return;
             settled = true;
             if (timeoutId) clearTimeout(timeoutId);