domflax 0.1.1 → 0.1.4

package/dist/cli.js

@@ -1,23 +1,18 @@
 #!/usr/bin/env node
 import {
-  builtinPatterns,
-  createCssResolver,
-  createJsxBackend,
-  createJsxFrontend,
-  createTailwindResolver
-} from "./chunk-DNHOGPYV.js";
-import {
-  buildSelectorIndex,
-  createSyntheticSink,
-  normalizer,
-  runPasses,
-  syncClassesFromComputed
-} from "./chunk-DWLB7FRR.js";
+  createTransform,
+  destinationFor,
+  isGitClean,
+  planWrites
+} from "./chunk-EVENAJYI.js";
+import "./chunk-3Z5ZWLXX.js";
+import "./chunk-H5KTGI3A.js";
 import {
   __commonJS,
+  __dirname,
   __toESM,
   init_esm_shims
-} from "./chunk-6WVVF6AD.js";
+} from "./chunk-U5GOONKV.js";
 
 // ../../node_modules/sisteransi/src/index.js
 var require_src = __commonJS({
@@ -172,6 +167,14 @@ function toSafety(raw) {
   if (n === 0 || n === 1 || n === 2 || n === 3) return n;
   throw new Error(`domflax: invalid --safety "${raw}" (expected 0, 1, 2 or 3)`);
 }
+function toPositiveInt(raw, flag) {
+  if (raw === void 0) return null;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(`domflax: invalid ${flag} "${raw}" (expected a positive integer)`);
+  }
+  return n;
+}
 function parseInvocation(argv) {
   const { values, positionals } = parseArgs({
     args: argv,
@@ -187,7 +190,9 @@ function parseInvocation(argv) {
       "no-interactive": { type: "boolean", default: false },
       yes: { type: "boolean", short: "y", default: false },
       safety: { type: "string" },
-      "project-root": { type: "string" }
+      "project-root": { type: "string" },
+      "max-memory": { type: "string" },
+      concurrency: { type: "string" }
     }
   });
   const provider = values.provider ?? DEFAULT_PROVIDER;
@@ -206,7 +211,9 @@ function parseInvocation(argv) {
     interactive: values["no-interactive"] !== true && values.yes !== true,
     passes: null,
     safety: toSafety(values.safety),
-    projectRoot: values["project-root"] ?? null
+    projectRoot: values["project-root"] ?? null,
+    maxMemory: toPositiveInt(values["max-memory"], "--max-memory"),
+    concurrency: toPositiveInt(values.concurrency, "--concurrency")
   };
 }
 function shouldPrompt(options, isTty) {
@@ -230,200 +237,203 @@ var USAGE = [
   "  --dangerously-overwrite-source overwrite source in place (needs a clean git tree)",
   "  --no-git-check                 skip the clean-git-tree gate",
   "  --safety <0|1|2|3>             optimization aggressiveness (default: 2)",
+  "  --max-memory <MB>              memory budget; caps pool RAM AND parallelism (default: ~70% free RAM)",
+  "  --concurrency <N>              max parallel workers (still clamped by --max-memory)",
   "  --yes, --no-interactive        never launch the wizard (CI-safe)",
   "",
+  "Many files are processed across CPU cores by a memory-bounded worker pool; small jobs run inline.",
   "With no paths in an interactive terminal, a guided wizard launches."
 ].join("\n");
 
-// ../cli/src/safety.ts
+// ../cli/src/pool.ts
 init_esm_shims();
-import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import * as os from "os";
 import * as path from "path";
-var DISPOSABLE_DIRS = /* @__PURE__ */ new Set(["dist", "build", "out", ".next"]);
-function isDisposablePath(file) {
-  return path.resolve(file).split(path.sep).some((seg) => DISPOSABLE_DIRS.has(seg));
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
+var PER_WORKER_MB = 160;
+var MIN_OLD_GEN_MB = 64;
+function emptyTotals() {
+  return { files: 0, changed: 0, nodesRemoved: 0, classesSaved: 0, bytesSaved: 0 };
 }
-function isGitClean(cwd) {
-  try {
-    const out = execFileSync("git", ["status", "--porcelain"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return out.trim().length === 0;
-  } catch {
-    return false;
-  }
-}
-function planWrites(options, gitClean) {
-  if (options.dangerouslyOverwriteSource) {
-    if (!options.noGitCheck && !gitClean) {
-      return {
-        ok: false,
-        error: "refusing --dangerously-overwrite-source: git working tree is not clean. Commit or stash first, or pass --no-git-check to override."
-      };
-    }
-    return { ok: true, value: { mode: "overwrite-source", outDir: null } };
-  }
-  const outDir = path.resolve(options.out ?? "domflax-out");
-  return { ok: true, value: { mode: "out-dir", outDir } };
-}
-function destinationFor(file, inputRoot, plan) {
-  const absFile = path.resolve(file);
-  if (plan.mode === "overwrite-source") {
-    return { ok: true, value: absFile };
-  }
-  const outDir = plan.outDir;
-  const rel = path.relative(inputRoot, absFile);
-  const safeRel = rel === "" || rel.startsWith("..") || path.isAbsolute(rel) ? path.basename(absFile) : rel;
-  const dest = path.join(outDir, safeRel);
-  if (path.resolve(dest) === absFile && !isDisposablePath(absFile)) {
-    return {
-      ok: false,
-      error: `refusing to overwrite source file ${absFile}: the output path resolves onto the source. Choose a different --out, or pass --dangerously-overwrite-source (with a clean git tree).`
-    };
-  }
-  return { ok: true, value: dest };
+function addStats(totals, stats, changed) {
+  totals.files += 1;
+  if (changed) totals.changed += 1;
+  totals.nodesRemoved += stats.nodesRemoved;
+  totals.classesSaved += stats.classesSaved;
+  totals.bytesSaved += stats.bytesSaved;
 }
-
-// ../cli/src/transform.ts
-init_esm_shims();
-function buildResolver(provider, css, projectRoot) {
-  if (provider === "custom") {
-    return createCssResolver([], { files: css, projectRoot });
-  }
-  return createTailwindResolver({ projectRoot });
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(hi, n));
 }
-function buildPasses(patterns) {
-  const byPhase = /* @__PURE__ */ new Map();
-  for (const p2 of patterns) {
-    const phase = p2.category.split("/", 1)[0] ?? "flatten";
-    let bucket = byPhase.get(phase);
-    if (!bucket) {
-      bucket = [];
-      byPhase.set(phase, bucket);
-    }
-    bucket.push(p2);
-  }
-  const passes = [];
-  for (const [phase, pats] of byPhase) {
-    passes.push({ phase, category: `${phase}/builtin`, patterns: pats });
-  }
-  return passes;
+function computeWorkerCount(options) {
+  const cpus2 = Math.max(1, os.cpus().length);
+  const freeMB = Math.floor(os.freemem() / (1024 * 1024));
+  const budgetMB = Math.max(PER_WORKER_MB, options.maxMemory ?? Math.floor(freeMB * 0.7));
+  const byMemory = Math.max(1, Math.floor(budgetMB / PER_WORKER_MB));
+  const target = options.concurrency ?? Math.max(1, cpus2 - 1);
+  const workers = clamp(Math.min(target, byMemory), 1, byMemory);
+  const perWorkerCapMB = Math.max(MIN_OLD_GEN_MB, Math.floor(budgetMB / workers));
+  return { workers, budgetMB, perWorkerCapMB };
 }
-function selectPatterns(names) {
-  if (names === null) return builtinPatterns;
-  const set = new Set(names);
-  return builtinPatterns.filter((p2) => set.has(p2.name));
+function inlineThreshold(workers) {
+  return Math.max(4, 2 * workers);
 }
-function jsxKindOf(id) {
-  const clean = id.split("?", 1)[0] ?? id;
-  const lower = clean.toLowerCase();
-  if (lower.endsWith(".tsx")) return "tsx";
-  if (lower.endsWith(".jsx")) return "jsx";
-  return null;
+function shouldUsePool(fileCount, plan) {
+  return plan.workers > 1 && fileCount > inlineThreshold(plan.workers);
 }
-function countClassTokens(code) {
-  let total = 0;
-  const re = /\b(?:className|class)\s*=\s*"([^"]*)"/g;
-  let m2;
-  while ((m2 = re.exec(code)) !== null) {
-    total += m2[1].split(/\s+/).filter((t) => t.length > 0).length;
+function moduleDir() {
+  try {
+    return path.dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return typeof __dirname !== "undefined" ? __dirname : process.cwd();
   }
-  return total;
 }
-function bytes(s) {
-  return Buffer.byteLength(s, "utf8");
-}
-function passthroughResult(code) {
-  return {
-    code,
-    changed: false,
-    passthrough: true,
-    stats: {
-      nodesIn: 0,
-      nodesOut: 0,
-      nodesRemoved: 0,
-      classesBefore: 0,
-      classesAfter: 0,
-      classesSaved: 0,
-      bytesBefore: bytes(code),
-      bytesAfter: bytes(code),
-      bytesSaved: 0
-    }
-  };
+function resolveWorkerPath() {
+  const dir = moduleDir();
+  const candidates = [
+    path.join(dir, "worker.cjs"),
+    path.join(dir, "worker.js"),
+    path.join(dir, "..", "dist", "worker.cjs"),
+    path.join(dir, "..", "dist", "worker.js")
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  return candidates[0];
 }
-function createTransform(options) {
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const resolver = buildResolver(options.provider, options.css, projectRoot);
-  const patterns = selectPatterns(options.passes);
-  function prepare(code, id, kind, gate) {
-    const parsed = createJsxFrontend().parse(code, {
-      id,
-      kind,
-      resolver,
-      normalizer,
-      config: {},
-      onDiagnostic: () => {
+function runPool(files, init, plan, onWrote) {
+  const workerPath = resolveWorkerPath();
+  const totals = emptyTotals();
+  const wrote = [];
+  const errors = [];
+  let failures = 0;
+  const budgetBytes = plan.budgetMB * 1024 * 1024;
+  let nextIndex = 0;
+  let completed = 0;
+  const total = files.length;
+  let respawns = 0;
+  const maxRespawns = total + plan.workers + 8;
+  return new Promise((resolve3) => {
+    const handles = /* @__PURE__ */ new Set();
+    const finishIfDone = () => {
+      if (completed < total) return;
+      for (const h2 of handles) {
+        if (!h2.dead) {
+          try {
+            h2.worker.postMessage({ type: "stop" });
+          } catch {
+          }
+          void h2.worker.terminate();
+        }
       }
-    });
-    const doc = parsed.doc;
-    const nodesIn = doc.nodes.size;
-    for (const node of doc.nodes.values()) node.meta.safetyFloor = 3;
-    const ctx = {
-      doc,
-      safetyCeiling: options.safety,
-      normalizer,
-      // Real CSS-selector-safety index from the active resolver (custom-CSS reports combinator /
-      // structural-pseudo coupling; Tailwind has none → null index, behaviour unchanged).
-      selectors: buildSelectorIndex(doc, resolver),
-      resolver,
-      gate
+      handles.clear();
+      resolve3({ totals, failures, wrote, errors });
     };
-    return { doc, ctx, passes: buildPasses(patterns), nodesIn };
-  }
-  function finish(code, optimized, id, nodesIn) {
-    syncClassesFromComputed(optimized, resolver, normalizer);
-    const printed = createJsxBackend().print(
-      optimized,
-      { moduleId: id, ops: [], provenance: /* @__PURE__ */ new Map() },
-      { normalizer, resolver, sink: createSyntheticSink(), eol: "\n", onDiagnostic: () => {
-      } }
-    );
-    const out = printed.code;
-    const nodesOut = optimized.nodes.size;
-    const classesBefore = countClassTokens(code);
-    const classesAfter = countClassTokens(out);
-    return {
-      code: out,
-      changed: out !== code,
-      passthrough: false,
-      stats: {
-        nodesIn,
-        nodesOut,
-        nodesRemoved: Math.max(0, nodesIn - nodesOut),
-        classesBefore,
-        classesAfter,
-        classesSaved: Math.max(0, classesBefore - classesAfter),
-        bytesBefore: bytes(code),
-        bytesAfter: bytes(out),
-        bytesSaved: bytes(code) - bytes(out)
+    const recordFailure = (file, error) => {
+      failures += 1;
+      completed += 1;
+      errors.push({ path: file, error });
+    };
+    const dispatch = (h2) => {
+      if (h2.dead) return;
+      if (nextIndex >= total) {
+        h2.current = null;
+        try {
+          h2.worker.postMessage({ type: "stop" });
+        } catch {
+        }
+        return;
+      }
+      if (process.memoryUsage().rss > budgetBytes) {
+        setTimeout(() => dispatch(h2), 25);
+        return;
+      }
+      const file = files[nextIndex++];
+      h2.current = file;
+      try {
+        h2.worker.postMessage({ type: "file", path: file });
+      } catch {
+        onWorkerDown(h2);
       }
     };
-  }
-  return {
-    resolver,
-    transformFile(code, id) {
-      const kind = jsxKindOf(id);
-      if (kind === null) return passthroughResult(code);
-      const { doc, ctx, passes, nodesIn } = prepare(code, id, kind, "provably-safe");
-      const { doc: optimized } = runPasses(doc, passes, ctx);
-      return finish(code, optimized, id, nodesIn);
-    }
-  };
-}
-function builtinPatternNames() {
-  return builtinPatterns.map((p2) => p2.name);
+    const onMessage = (h2, msg) => {
+      if (msg.type === "ready") {
+        h2.ready = true;
+        dispatch(h2);
+        return;
+      }
+      h2.current = null;
+      if (msg.ok) {
+        addStats(totals, msg.stats, msg.changed);
+        if (msg.wrote) {
+          wrote.push(msg.wrote);
+          onWrote?.(msg.wrote);
+        }
+      } else {
+        failures += 1;
+        errors.push({ path: msg.path, error: msg.error });
+      }
+      completed += 1;
+      if (completed >= total) {
+        finishIfDone();
+        return;
+      }
+      dispatch(h2);
+    };
+    const drainRemaining = (reason) => {
+      while (nextIndex < total) recordFailure(files[nextIndex++], reason);
+      finishIfDone();
+    };
+    const onWorkerDown = (h2) => {
+      if (h2.dead) return;
+      h2.dead = true;
+      handles.delete(h2);
+      const lost = h2.current;
+      h2.current = null;
+      if (lost !== null) recordFailure(lost, "worker crashed while processing this file");
+      void h2.worker.terminate();
+      if (completed >= total) {
+        finishIfDone();
+        return;
+      }
+      if (nextIndex >= total) {
+        if (handles.size === 0) finishIfDone();
+        return;
+      }
+      if (respawns < maxRespawns) {
+        respawns += 1;
+        spawn();
+      } else if (handles.size === 0) {
+        drainRemaining("worker pool exhausted its respawn budget (memory cap too small?)");
+      }
+    };
+    const spawn = () => {
+      let worker;
+      try {
+        worker = new Worker(workerPath, {
+          workerData: init,
+          resourceLimits: { maxOldGenerationSizeMb: plan.perWorkerCapMB }
+        });
+      } catch {
+        if (nextIndex < total) recordFailure(files[nextIndex++], "failed to spawn worker");
+        if (completed >= total) finishIfDone();
+        else if (handles.size === 0 && nextIndex < total) spawn();
+        return;
+      }
+      const h2 = { worker, current: null, ready: false, dead: false };
+      handles.add(h2);
+      worker.on("message", (m2) => onMessage(h2, m2));
+      worker.on("error", () => onWorkerDown(h2));
+      worker.on("exit", (code) => {
+        if (code !== 0) onWorkerDown(h2);
+      });
+    };
+    const initial = Math.min(plan.workers, total);
+    for (let i = 0; i < initial; i++) spawn();
+    if (initial === 0) finishIfDone();
+  });
 }
 
 // ../cli/src/walk.ts
@@ -451,8 +461,8 @@ function walkDir(dir, out) {
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       walkDir(full, out);
-    } else if (entry.isFile() && isSupported(entry.name)) {
-      out.push(full);
+    } else if (entry.isFile()) {
+      if (isSupported(entry.name)) out.push(full);
     }
   }
 }
@@ -490,7 +500,8 @@ function discoverInputs(paths) {
       continue;
     }
     if (stat?.isFile()) {
-      push(p2);
+      if (isSupported(p2)) push(p2);
+      else warnings.push(`unsupported file type, skipped: ${p2}`);
       continue;
     }
     if (hasGlobMagic(p2)) {
@@ -499,9 +510,10 @@ function discoverInputs(paths) {
         warnings.push(`glob not supported on this Node version, skipped: ${p2}`);
         continue;
       }
-      const matches = glob(p2).filter(isSupported);
-      if (matches.length === 0) warnings.push(`no files matched: ${p2}`);
-      for (const m2 of matches) push(m2);
+      const matched = glob(p2);
+      const supported = matched.filter(isSupported);
+      if (supported.length === 0) warnings.push(`no .jsx/.tsx/.html files matched: ${p2}`);
+      for (const m2 of supported) push(m2);
       continue;
     }
     warnings.push(`no such file or directory: ${p2}`);
@@ -1115,15 +1127,17 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([
 ]);
 var COMMON_INPUT_DIRS = ["src", "app", "components", "pages", "lib", "ui", "public"];
 var CSS_FILE_CAP = 200;
+var DEFAULT_CSS_DEPTH = 10;
 function toRelative(root, abs) {
   const rel = path3.relative(root, abs);
   return rel.split(path3.sep).join("/");
 }
-function detectCssFiles(root) {
-  const found = [];
+function detectCssFiles(root, scanRoots = [], maxDepth = DEFAULT_CSS_DEPTH) {
+  const base = path3.resolve(root);
+  const found = /* @__PURE__ */ new Map();
   let capped = false;
-  const walk = (dir) => {
-    if (capped) return;
+  const walk = (dir, depth) => {
+    if (capped || depth > maxDepth) return;
     let entries;
     try {
       entries = fs2.readdirSync(dir, { withFileTypes: true });
@@ -1134,23 +1148,31 @@ function detectCssFiles(root) {
       const full = path3.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS2.has(entry.name)) continue;
-        walk(full);
+        walk(full, depth + 1);
         if (capped) return;
       } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".css")) {
-        found.push(toRelative(root, full));
-        if (found.length >= CSS_FILE_CAP) {
-          capped = true;
-          return;
+        const abs = path3.resolve(full);
+        if (!found.has(abs)) {
+          found.set(abs, toRelative(base, abs));
+          if (found.size >= CSS_FILE_CAP) {
+            capped = true;
+            return;
+          }
         }
       }
     }
   };
-  walk(path3.resolve(root));
-  found.sort((a, b3) => a.localeCompare(b3));
+  walk(base, 0);
+  for (const r2 of scanRoots) {
+    if (capped) break;
+    const abs = path3.resolve(r2);
+    if (abs !== base) walk(abs, 0);
+  }
+  const list = [...found.values()].sort((a, b3) => a.localeCompare(b3));
   if (capped) {
     console.error(`domflax: more than ${CSS_FILE_CAP} CSS files found; showing the first ${CSS_FILE_CAP}.`);
   }
-  return found;
+  return list;
 }
 function detectInputDirs(root) {
   const resolved = path3.resolve(root);
@@ -1232,15 +1254,6 @@ async function runWizard(base) {
   } else if (outputMode === "overwrite") {
     dangerouslyOverwriteSource = true;
   }
-  const allPasses = builtinPatternNames();
-  const passSelection = await fe({
-    message: "Which optimization passes should run?",
-    options: allPasses.map((name) => ({ value: name, label: name })),
-    initialValues: [...allPasses],
-    required: true
-  });
-  if (cancelled(passSelection)) return done();
-  const passes = passSelection;
   const provider = await ve({
     message: "How should class names resolve to styles?",
     options: [
@@ -1253,7 +1266,7 @@ async function runWizard(base) {
   if (cancelled(provider)) return done();
   let css = base.css;
   if (provider === "custom") {
-    const detectedCss = detectCssFiles(root);
+    const detectedCss = detectCssFiles(root, [inputPath]);
     if (detectedCss.length > 0) {
       const picked = await fe({
         message: "Which CSS files should resolve your classes? (all detected files are pre-selected)",
@@ -1281,7 +1294,7 @@ async function runWizard(base) {
     css,
     dryRun,
     dangerouslyOverwriteSource,
-    passes: passes.length === allPasses.length ? null : passes,
+    passes: null,
     safety: base.safety ?? DEFAULT_SAFETY
   };
   function done() {
@@ -1291,13 +1304,6 @@ async function runWizard(base) {
 }
 
 // ../cli/src/index.ts
-function addStats(totals, stats, changed) {
-  totals.files += 1;
-  if (changed) totals.changed += 1;
-  totals.nodesRemoved += stats.nodesRemoved;
-  totals.classesSaved += stats.classesSaved;
-  totals.bytesSaved += stats.bytesSaved;
-}
 function printReport(totals) {
   console.log("");
   console.log("domflax report");
@@ -1307,23 +1313,8 @@ function printReport(totals) {
   console.log(`  classes saved   : ${totals.classesSaved}`);
   console.log(`  bytes saved     : ${totals.bytesSaved}`);
 }
-async function execute(options) {
-  const { files, inputRoot, warnings } = discoverInputs(options.paths);
-  for (const w2 of warnings) console.error(`domflax: ${w2}`);
-  if (files.length === 0) {
-    console.error("domflax: no .jsx/.tsx/.html files found for the given paths");
-    return { exitCode: 1 };
-  }
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const gitClean = options.dangerouslyOverwriteSource && !options.noGitCheck ? isGitClean(projectRoot) : true;
-  const planned = planWrites(options, gitClean);
-  if (!planned.ok) {
-    console.error(`domflax: ${planned.error}`);
-    return { exitCode: 1 };
-  }
-  const plan = planned.value;
+function runInline(files, options, inputRoot, plan, totals) {
   const transform = createTransform(options);
-  const totals = { files: 0, changed: 0, nodesRemoved: 0, classesSaved: 0, bytesSaved: 0 };
   let failures = 0;
   for (const file of files) {
     let code;
@@ -1358,8 +1349,59 @@ async function execute(options) {
       failures += 1;
     }
   }
+  return failures;
+}
+async function execute(options) {
+  const { files, inputRoot, warnings } = discoverInputs(options.paths);
+  for (const w2 of warnings) console.error(`domflax: ${w2}`);
+  if (files.length === 0) {
+    console.error("domflax: no .jsx/.tsx files found for the given paths");
+    return { exitCode: 1 };
+  }
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const gitClean = options.dangerouslyOverwriteSource && !options.noGitCheck ? isGitClean(projectRoot) : true;
+  const planned = planWrites(options, gitClean);
+  if (!planned.ok) {
+    console.error(`domflax: ${planned.error}`);
+    return { exitCode: 1 };
+  }
+  const plan = planned.value;
+  const poolPlan = computeWorkerCount(options);
+  const usePool = !options.dryRun && shouldUsePool(files.length, poolPlan);
+  const totals = emptyTotals();
+  let failures = 0;
+  if (usePool) {
+    const outcome = await runPool(
+      files,
+      { options, inputRoot, plan },
+      poolPlan
+      // Per-file "wrote" lines are collected and printed in deterministic (sorted) order below.
+    );
+    Object.assign(totals, outcome.totals);
+    failures = outcome.failures;
+    for (const { path: p2, error } of outcome.errors) {
+      console.error(`domflax: failed ${path4.relative(process.cwd(), p2) || p2}: ${error}`);
+    }
+    for (const dest of [...outcome.wrote].sort()) {
+      console.log(`domflax: wrote ${path4.relative(process.cwd(), dest) || dest}`);
+    }
+  } else {
+    failures += runInline(files, options, inputRoot, plan, totals);
+  }
+  if (options.dryRun) {
+    console.log("\ndomflax: dry run \u2014 no files were written.");
+  } else if (totals.changed === 0) {
+    console.log(
+      `
+domflax: processed ${totals.files} file${totals.files === 1 ? "" : "s"} \u2014 nothing to optimize (0 changed).`
+    );
+  } else {
+    console.log(
+      `
+domflax: optimized ${totals.changed} of ${totals.files} file${totals.files === 1 ? "" : "s"} (${totals.nodesRemoved} nodes removed, ${totals.classesSaved} classes saved, ${totals.bytesSaved} bytes saved).`
+    );
+  }
   if (options.report) printReport(totals);
-  if (options.dryRun) console.log("\ndomflax: dry run \u2014 no files were written.");
   return { exitCode: failures > 0 ? 1 : 0 };
 }
 async function main(argv = process.argv.slice(2)) {